mqtt 0.3.1 → 0.4.0

data/lib/mqtt/packet.rb

@@ -368,7 +368,7 @@ module MQTT
         end
         body += encode_string(@topic)
         body += encode_short(@id) unless qos == 0
-        body += payload.to_s.force_encoding('ASCII-8BIT')
+        body += payload.to_s.dup.force_encoding('ASCII-8BIT')
         return body
       end
 
@@ -780,9 +780,9 @@ module MQTT
 
       # Set one or more topic filters for the Subscribe packet
       # The topics parameter should be one of the following:
-      # * String: subscribe to one topic with QOS 0
-      # * Array: subscribe to multiple topics with QOS 0
-      # * Hash: subscribe to multiple topics where the key is the topic and the value is the QOS level
+      # * String: subscribe to one topic with QoS 0
+      # * Array: subscribe to multiple topics with QoS 0
+      # * Hash: subscribe to multiple topics where the key is the topic and the value is the QoS level
       #
       # For example:
       #   packet.topics = 'a/b'
@@ -877,7 +877,7 @@ module MQTT
         super(ATTR_DEFAULTS.merge(args))
       end
 
-      # Set the granted QOS value for each of the topics that were subscribed to
+      # Set the granted QoS value for each of the topics that were subscribed to
       # Can either be an integer or an array or integers.
       def return_codes=(value)
         if value.is_a?(Array)
@@ -892,7 +892,7 @@ module MQTT
       # Get serialisation of packet's body
       def encode_body
         if @return_codes.empty?
-          raise "no granted QOS given when serialising packet"
+          raise "no granted QoS given when serialising packet"
         end
         body = encode_short(@id)
         return_codes.each { |qos| body += encode_bytes(qos) }

data/lib/mqtt/patches/string_encoding.rb

@@ -24,6 +24,10 @@ class Encoding
   def to_s
     @name
   end
+  
+  def name
+    @name
+  end
 
   UTF_8 = Encoding.new("UTF-8")
   ASCII_8BIT = Encoding.new("ASCII-8BIT")

data/lib/mqtt/sn/packet.rb

@@ -0,0 +1,763 @@
+# encoding: BINARY
+
+module MQTT::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*')
+      if length == 1
+        length,type_id,body = buffer.unpack('xnCa*')
+      end
+
+      # Double-check the length
+      if buffer.length != length
+        raise ProtocolException.new("Length of packet is not the same as the length header")
+      end
+
+      packet_class = PACKET_TYPES[type_id]
+      if packet_class.nil?
+        raise ProtocolException.new("Invalid packet type identifier: #{type_id}")
+      end
+
+      # Create a new packet object
+      packet = packet_class.new
+      packet.parse_body(body)
+
+      return 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 = self.encode_body
+
+      # Build up the body length field bytes
+      body_length = body.length
+      if body_length > 65531
+        raise "MQTT-SN Packet is too big, maximum packet body size is 65531"
+      elsif 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 self.qos == 3
+      self.retain = ((flags & 0x10) >> 4) == 0x01
+      self.request_will = ((flags & 0x08) >> 3) == 0x01
+      self.clean_session = ((flags & 0x04) >> 2) == 0x01
+      case (flags & 0x03)
+        when 0x0
+          self.topic_id_type = :normal
+        when 0x1
+          self.topic_id_type = :predefined
+        when 0x2
+          self.topic_id_type = :short
+        else
+          self.topic_id_type = nil
+      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
+      return 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
+          unless topic_name.nil?
+            topic_name
+          else
+            topic_id
+          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? or @client_id.length < 1 or @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.new("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
+        unless return_code.is_a?(Integer)
+          raise "return_code must be an Integer"
+        end
+
+        [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? or 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
+        unless id.is_a?(Integer)
+          raise "id must be an Integer"
+        end
+
+        unless topic_id.is_a?(Integer)
+          raise "topic_id must be an Integer"
+        end
+
+        [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
+        unless id.is_a?(Integer)
+          raise "id must be an Integer"
+        end
+
+        unless topic_id.is_a?(Integer)
+          raise "topic_id must be an Integer"
+        end
+
+        [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
+        unless id.is_a?(Integer)
+          raise "id must be an Integer"
+        end
+
+        [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
+        unless id.is_a?(Integer)
+          raise "id must be an Integer"
+        end
+
+        unless topic_id.is_a?(Integer)
+          raise "topic_id must be an Integer"
+        end
+
+        [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
+        unless id.is_a?(Integer)
+          raise "id must be an Integer"
+        end
+
+        [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
+        unless id.is_a?(Integer)
+          raise "id must be an Integer"
+        end
+
+        [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
+        unless id.is_a?(Integer)
+          raise "id must be an Integer"
+        end
+
+        [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
+        unless id.is_a?(Integer)
+          raise "id must be an Integer"
+        end
+
+        [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
+        unless id.is_a?(Integer)
+          raise "id must be an Integer"
+        end
+
+        [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
+        unless id.is_a?(Integer)
+          raise "id must be an Integer"
+        end
+
+        [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
+        unless id.is_a?(Integer)
+          raise "id must be an Integer"
+        end
+
+        [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? or duration == 0
+          ''
+        else
+          [duration].pack('n')
+        end
+      end
+
+      def parse_body(buffer)
+        if buffer.length == 2
+          self.duration = buffer.unpack('n').first
+        else
+          self.duration = nil
+        end
+      end
+    end
+
+    class Willtopicupd < Packet
+      attr_accessor :topic_name
+
+      DEFAULTS = {
+        :qos => 0,
+        :retain => false,
+        :topic_name => nil
+      }
+
+      def encode_body
+        if topic_name.nil? or 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
+        unless return_code.is_a?(Integer)
+          raise "return_code must be an Integer"
+        end
+
+        [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
+        unless return_code.is_a?(Integer)
+          raise "return_code must be an Integer"
+        end
+
+        [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