go-mqtt 0.0.1

data/lib/mqtt/sn/packet.rb

@@ -0,0 +1,720 @@
+# encoding: BINARY
+
+module MQTT
+  module SN
+    # Class representing a MQTT::SN Packet
+    # Performs binary encoding and decoding of headers
+    class Packet
+      attr_accessor :duplicate     # Duplicate delivery flag
+      attr_accessor :qos           # Quality of Service level
+      attr_accessor :retain        # Retain flag
+      attr_accessor :request_will  # Request that gateway prompts for Will
+      attr_accessor :clean_session # When true, subscriptions are deleted after disconnect
+      attr_accessor :topic_id_type # One of :normal, :predefined or :short
+
+      DEFAULTS = {}
+
+      # Parse buffer into new packet object
+      def self.parse(buffer)
+        # Parse the fixed header (length and type)
+        length, type_id, body = buffer.unpack('CCa*')
+        length, type_id, body = buffer.unpack('xnCa*') if length == 1
+
+        # Double-check the length
+        if buffer.length != length
+          raise ProtocolException, 'Length of packet is not the same as the length header'
+        end
+
+        packet_class = PACKET_TYPES[type_id]
+        if packet_class.nil?
+          raise ProtocolException, "Invalid packet type identifier: #{type_id}"
+        end
+
+        # Create a new packet object
+        packet = packet_class.new
+        packet.parse_body(body)
+
+        packet
+      end
+
+      # Create a new empty packet
+      def initialize(args = {})
+        update_attributes(self.class::DEFAULTS.merge(args))
+      end
+
+      def update_attributes(attr = {})
+        attr.each_pair do |k, v|
+          send("#{k}=", v)
+        end
+      end
+
+      # Get the identifer for this packet type
+      def type_id
+        PACKET_TYPES.each_pair do |key, value|
+          return key if self.class == value
+        end
+        raise "Invalid packet type: #{self.class}"
+      end
+
+      # Serialise the packet
+      def to_s
+        # Get the packet's variable header and payload
+        body = encode_body
+
+        # Build up the body length field bytes
+        body_length = body.length
+        raise 'MQTT-SN Packet is too big, maximum packet body size is 65531' if body_length > 65_531
+
+        if body_length > 253
+          [0x01, body_length + 4, type_id].pack('CnC') + body
+        else
+          [body_length + 2, type_id].pack('CC') + body
+        end
+      end
+
+      def parse_body(buffer); end
+
+      protected
+
+      def parse_flags(flags)
+        self.duplicate = ((flags & 0x80) >> 7) == 0x01
+        self.qos = (flags & 0x60) >> 5
+        self.qos = -1 if qos == 3
+        self.retain = ((flags & 0x10) >> 4) == 0x01
+        self.request_will = ((flags & 0x08) >> 3) == 0x01
+        self.clean_session = ((flags & 0x04) >> 2) == 0x01
+
+        self.topic_id_type =
+          case (flags & 0x03)
+          when 0x0
+            :normal
+          when 0x1
+            :predefined
+          when 0x2
+            :short
+          end
+      end
+
+      # Get serialisation of packet's body (variable header and payload)
+      def encode_body
+        '' # No body by default
+      end
+
+      def encode_flags
+        flags = 0x00
+        flags += 0x80 if duplicate
+        case qos
+        when -1
+          flags += 0x60
+        when 1
+          flags += 0x20
+        when 2
+          flags += 0x40
+        end
+        flags += 0x10 if retain
+        flags += 0x08 if request_will
+        flags += 0x04 if clean_session
+        case topic_id_type
+        when :normal
+          flags += 0x0
+        when :predefined
+          flags += 0x1
+        when :short
+          flags += 0x2
+        end
+        flags
+      end
+
+      def encode_topic_id
+        if topic_id_type == :short
+          unless topic_id.is_a?(String)
+            raise "topic_id must be an String for type #{topic_id_type}"
+          end
+          (topic_id[0].ord << 8) + topic_id[1].ord
+        else
+          unless topic_id.is_a?(Integer)
+            raise "topic_id must be an Integer for type #{topic_id_type}"
+          end
+          topic_id
+        end
+      end
+
+      def parse_topic_id(topic_id)
+        if topic_id_type == :short
+          int = topic_id.to_i
+          self.topic_id = [(int >> 8) & 0xFF, int & 0xFF].pack('CC')
+        else
+          self.topic_id = topic_id
+        end
+      end
+
+      # Used where a field can either be a Topic Id or a Topic Name
+      # (the Subscribe and Unsubscribe packet types)
+      def encode_topic
+        case topic_id_type
+        when :normal
+          topic_name
+        when :short
+          if topic_name.nil?
+            topic_id
+          else
+            topic_name
+          end
+        when :predefined
+          [topic_id].pack('n')
+        end
+      end
+
+      # Used where a field can either be a Topic Id or a Topic Name
+      # (the Subscribe and Unsubscribe packet types)
+      def parse_topic(topic)
+        case topic_id_type
+        when :normal
+          self.topic_name = topic
+        when :short
+          self.topic_name = topic
+          self.topic_id = topic
+        when :predefined
+          self.topic_id = topic.unpack('n').first
+        end
+      end
+
+      class Advertise < Packet
+        attr_accessor :gateway_id
+        attr_accessor :duration
+
+        DEFAULTS = {
+          :gateway_id => 0x00,
+          :duration => 0
+        }
+
+        def encode_body
+          [gateway_id, duration].pack('Cn')
+        end
+
+        def parse_body(buffer)
+          self.gateway_id, self.duration = buffer.unpack('Cn')
+        end
+      end
+
+      class Searchgw < Packet
+        attr_accessor :radius
+        DEFAULTS = {
+          :radius => 1
+        }
+
+        def encode_body
+          [radius].pack('C')
+        end
+
+        def parse_body(buffer)
+          self.radius, _ignore = buffer.unpack('C')
+        end
+      end
+
+      class Gwinfo < Packet
+        attr_accessor :gateway_id
+        attr_accessor :gateway_address
+        DEFAULTS = {
+          :gateway_id => 0,
+          :gateway_address => nil
+        }
+
+        def encode_body
+          [gateway_id, gateway_address].pack('Ca*')
+        end
+
+        def parse_body(buffer)
+          if buffer.length > 1
+            self.gateway_id, self.gateway_address = buffer.unpack('Ca*')
+          else
+            self.gateway_id, _ignore = buffer.unpack('C')
+            self.gateway_address = nil
+          end
+        end
+      end
+
+      class Connect < Packet
+        attr_accessor :keep_alive
+        attr_accessor :client_id
+
+        DEFAULTS = {
+          :request_will => false,
+          :clean_session => true,
+          :keep_alive => 15
+        }
+
+        # Get serialisation of packet's body
+        def encode_body
+          if @client_id.nil? || @client_id.empty? || @client_id.length > 23
+            raise 'Invalid client identifier when serialising packet'
+          end
+
+          [encode_flags, 0x01, keep_alive, client_id].pack('CCna*')
+        end
+
+        def parse_body(buffer)
+          flags, protocol_id, self.keep_alive, self.client_id = buffer.unpack('CCna*')
+
+          if protocol_id != 0x01
+            raise ProtocolException, "Unsupported protocol ID number: #{protocol_id}"
+          end
+
+          parse_flags(flags)
+        end
+      end
+
+      class Connack < Packet
+        attr_accessor :return_code
+
+        # Get a string message corresponding to a return code
+        def return_msg
+          case return_code
+          when 0x00
+            'Accepted'
+          when 0x01
+            'Rejected: congestion'
+          when 0x02
+            'Rejected: invalid topic ID'
+          when 0x03
+            'Rejected: not supported'
+          else
+            "Rejected: error code #{return_code}"
+          end
+        end
+
+        def encode_body
+          raise 'return_code must be an Integer' unless return_code.is_a?(Integer)
+
+          [return_code].pack('C')
+        end
+
+        def parse_body(buffer)
+          self.return_code = buffer.unpack('C')[0]
+        end
+      end
+
+      class Willtopicreq < Packet
+        # No attributes
+      end
+
+      class Willtopic < Packet
+        attr_accessor :topic_name
+
+        DEFAULTS = {
+          :qos => 0,
+          :retain => false,
+          :topic_name => nil
+        }
+
+        def encode_body
+          if topic_name.nil? || topic_name.empty?
+            ''
+          else
+            [encode_flags, topic_name].pack('Ca*')
+          end
+        end
+
+        def parse_body(buffer)
+          if buffer.length > 1
+            flags, self.topic_name = buffer.unpack('Ca*')
+          else
+            flags, _ignore = buffer.unpack('C')
+            self.topic_name = nil
+          end
+          parse_flags(flags)
+        end
+      end
+
+      class Willmsgreq < Packet
+        # No attributes
+      end
+
+      class Willmsg < Packet
+        attr_accessor :data
+
+        def encode_body
+          data
+        end
+
+        def parse_body(buffer)
+          self.data = buffer
+        end
+      end
+
+      class Register < Packet
+        attr_accessor :id
+        attr_accessor :topic_id
+        attr_accessor :topic_name
+
+        DEFAULTS = {
+          :id => 0x00,
+          :topic_id_type => :normal
+        }
+
+        def encode_body
+          raise 'id must be an Integer' unless id.is_a?(Integer)
+
+          raise 'topic_id must be an Integer' unless topic_id.is_a?(Integer)
+
+          [topic_id, id, topic_name].pack('nna*')
+        end
+
+        def parse_body(buffer)
+          self.topic_id, self.id, self.topic_name = buffer.unpack('nna*')
+        end
+      end
+
+      class Regack < Packet
+        attr_accessor :id
+        attr_accessor :topic_id
+        attr_accessor :return_code
+
+        DEFAULTS = {
+          :id => 0x00,
+          :topic_id => 0x00,
+          :topic_id_type => :normal
+        }
+
+        def encode_body
+          raise 'id must be an Integer' unless id.is_a?(Integer)
+
+          raise 'topic_id must be an Integer' unless topic_id.is_a?(Integer)
+
+          [topic_id, id, return_code].pack('nnC')
+        end
+
+        def parse_body(buffer)
+          self.topic_id, self.id, self.return_code = buffer.unpack('nnC')
+        end
+      end
+
+      class Publish < Packet
+        attr_accessor :topic_id
+        attr_accessor :id
+        attr_accessor :data
+
+        DEFAULTS = {
+          :id => 0x00,
+          :duplicate => false,
+          :qos => 0,
+          :retain => false,
+          :topic_id_type => :normal
+        }
+
+        def encode_body
+          raise 'id must be an Integer' unless id.is_a?(Integer)
+
+          [encode_flags, encode_topic_id, id, data].pack('Cnna*')
+        end
+
+        def parse_body(buffer)
+          flags, topic_id, self.id, self.data = buffer.unpack('Cnna*')
+          parse_flags(flags)
+          parse_topic_id(topic_id)
+        end
+      end
+
+      class Puback < Packet
+        attr_accessor :topic_id
+        attr_accessor :id
+        attr_accessor :return_code
+
+        DEFAULTS = {
+          :id => 0x00,
+          :topic_id => nil,
+          :return_code => 0x00
+        }
+
+        def encode_body
+          raise 'id must be an Integer' unless id.is_a?(Integer)
+
+          raise 'topic_id must be an Integer' unless topic_id.is_a?(Integer)
+
+          [topic_id, id, return_code].pack('nnC')
+        end
+
+        def parse_body(buffer)
+          self.topic_id, self.id, self.return_code = buffer.unpack('nnC')
+        end
+      end
+
+      class Pubcomp < Packet
+        attr_accessor :id
+
+        DEFAULTS = {
+          :id => 0x00
+        }
+
+        def encode_body
+          raise 'id must be an Integer' unless id.is_a?(Integer)
+
+          [id].pack('n')
+        end
+
+        def parse_body(buffer)
+          self.id, _ignore = buffer.unpack('n')
+        end
+      end
+
+      class Pubrec < Packet
+        attr_accessor :id
+
+        DEFAULTS = {
+          :id => 0x00
+        }
+
+        def encode_body
+          raise 'id must be an Integer' unless id.is_a?(Integer)
+
+          [id].pack('n')
+        end
+
+        def parse_body(buffer)
+          self.id, _ignore = buffer.unpack('n')
+        end
+      end
+
+      class Pubrel < Packet
+        attr_accessor :id
+
+        DEFAULTS = {
+          :id => 0x00
+        }
+
+        def encode_body
+          raise 'id must be an Integer' unless id.is_a?(Integer)
+
+          [id].pack('n')
+        end
+
+        def parse_body(buffer)
+          self.id, _ignore = buffer.unpack('n')
+        end
+      end
+
+      class Subscribe < Packet
+        attr_accessor :id
+        attr_accessor :topic_id
+        attr_accessor :topic_name
+
+        DEFAULTS = {
+          :id => 0x00,
+          :topic_id_type => :normal
+        }
+
+        def encode_body
+          raise 'id must be an Integer' unless id.is_a?(Integer)
+
+          [encode_flags, id, encode_topic].pack('Cna*')
+        end
+
+        def parse_body(buffer)
+          flags, self.id, topic = buffer.unpack('Cna*')
+          parse_flags(flags)
+          parse_topic(topic)
+        end
+      end
+
+      class Suback < Packet
+        attr_accessor :id
+        attr_accessor :topic_id
+        attr_accessor :return_code
+
+        DEFAULTS = {
+          :qos => 0,
+          :id => 0x00,
+          :topic_id => 0x00,
+          :topic_id_type => :normal
+        }
+
+        def encode_body
+          raise 'id must be an Integer' unless id.is_a?(Integer)
+
+          [encode_flags, encode_topic_id, id, return_code].pack('CnnC')
+        end
+
+        def parse_body(buffer)
+          flags, topic_id, self.id, self.return_code = buffer.unpack('CnnC')
+          parse_flags(flags)
+          parse_topic_id(topic_id)
+        end
+      end
+
+      class Unsubscribe < Packet
+        attr_accessor :id
+        attr_accessor :topic_id
+        attr_accessor :topic_name
+
+        DEFAULTS = {
+          :id => 0x00,
+          :topic_id_type => :normal
+        }
+
+        def encode_body
+          raise 'id must be an Integer' unless id.is_a?(Integer)
+
+          [encode_flags, id, encode_topic].pack('Cna*')
+        end
+
+        def parse_body(buffer)
+          flags, self.id, topic = buffer.unpack('Cna*')
+          parse_flags(flags)
+          parse_topic(topic)
+        end
+      end
+
+      class Unsuback < Packet
+        attr_accessor :id
+
+        DEFAULTS = {
+          :id => 0x00
+        }
+
+        def encode_body
+          raise 'id must be an Integer' unless id.is_a?(Integer)
+
+          [id].pack('n')
+        end
+
+        def parse_body(buffer)
+          self.id = buffer.unpack('n').first
+        end
+      end
+
+      class Pingreq < Packet
+        # No attributes
+      end
+
+      class Pingresp < Packet
+        # No attributes
+      end
+
+      class Disconnect < Packet
+        attr_accessor :duration
+
+        DEFAULTS = {
+          :duration => nil
+        }
+
+        def encode_body
+          if duration.nil? || duration.zero?
+            ''
+          else
+            [duration].pack('n')
+          end
+        end
+
+        def parse_body(buffer)
+          self.duration = buffer.length == 2 ? buffer.unpack('n').first : nil
+        end
+      end
+
+      class Willtopicupd < Packet
+        attr_accessor :topic_name
+
+        DEFAULTS = {
+          :qos => 0,
+          :retain => false,
+          :topic_name => nil
+        }
+
+        def encode_body
+          if topic_name.nil? || topic_name.empty?
+            ''
+          else
+            [encode_flags, topic_name].pack('Ca*')
+          end
+        end
+
+        def parse_body(buffer)
+          if buffer.length > 1
+            flags, self.topic_name = buffer.unpack('Ca*')
+            parse_flags(flags)
+          else
+            self.topic_name = nil
+          end
+        end
+      end
+
+      class Willtopicresp < Packet
+        attr_accessor :return_code
+
+        DEFAULTS = {
+          :return_code => 0x00
+        }
+
+        def encode_body
+          raise 'return_code must be an Integer' unless return_code.is_a?(Integer)
+
+          [return_code].pack('C')
+        end
+
+        def parse_body(buffer)
+          self.return_code, _ignore = buffer.unpack('C')
+        end
+      end
+
+      class Willmsgupd < Packet
+        attr_accessor :data
+
+        def encode_body
+          data
+        end
+
+        def parse_body(buffer)
+          self.data = buffer
+        end
+      end
+
+      class Willmsgresp < Packet
+        attr_accessor :return_code
+
+        DEFAULTS = {
+          :return_code => 0x00
+        }
+
+        def encode_body
+          raise 'return_code must be an Integer' unless return_code.is_a?(Integer)
+
+          [return_code].pack('C')
+        end
+
+        def parse_body(buffer)
+          self.return_code, _ignore = buffer.unpack('C')
+        end
+      end
+    end
+
+    # An enumeration of the MQTT-SN packet types
+    PACKET_TYPES = {
+      0x00 => MQTT::SN::Packet::Advertise,
+      0x01 => MQTT::SN::Packet::Searchgw,
+      0x02 => MQTT::SN::Packet::Gwinfo,
+      0x04 => MQTT::SN::Packet::Connect,
+      0x05 => MQTT::SN::Packet::Connack,
+      0x06 => MQTT::SN::Packet::Willtopicreq,
+      0x07 => MQTT::SN::Packet::Willtopic,
+      0x08 => MQTT::SN::Packet::Willmsgreq,
+      0x09 => MQTT::SN::Packet::Willmsg,
+      0x0a => MQTT::SN::Packet::Register,
+      0x0b => MQTT::SN::Packet::Regack,
+      0x0c => MQTT::SN::Packet::Publish,
+      0x0d => MQTT::SN::Packet::Puback,
+      0x0e => MQTT::SN::Packet::Pubcomp,
+      0x0f => MQTT::SN::Packet::Pubrec,
+      0x10 => MQTT::SN::Packet::Pubrel,
+      0x12 => MQTT::SN::Packet::Subscribe,
+      0x13 => MQTT::SN::Packet::Suback,
+      0x14 => MQTT::SN::Packet::Unsubscribe,
+      0x15 => MQTT::SN::Packet::Unsuback,
+      0x16 => MQTT::SN::Packet::Pingreq,
+      0x17 => MQTT::SN::Packet::Pingresp,
+      0x18 => MQTT::SN::Packet::Disconnect,
+      0x1a => MQTT::SN::Packet::Willtopicupd,
+      0x1b => MQTT::SN::Packet::Willtopicresp,
+      0x1c => MQTT::SN::Packet::Willmsgupd,
+      0x1d => MQTT::SN::Packet::Willmsgresp
+    }
+  end
+end

data/lib/mqtt/version.rb

@@ -0,0 +1,4 @@
+module MQTT
+  # The version number of the MQTT gem
+  VERSION = '0.0.1'
+end