em-mqtt-sn 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 89cbe9cba1cf7a7b09bf5bef4ec54c47a2953f4d
+  data.tar.gz: 5e1138b972b3ac617062a9dadfb2e6afffac34b2
+SHA512:
+  metadata.gz: ab1388f070cc1860fc8d73d30e3e1a5d33d9b1aafecaf369086b731ca710d7382cc1042500193e1e5e688fbfda41a186af8e0ce2a1d9578e67620a8a81de1372
+  data.tar.gz: bc7dabab0a5596af64424fedb78e785449518bddc5eeea86a1a4a4a5eb3298155a4537a2b79cebeada9b3f78633f66366710ed0d14d55b0ddc73602993d1257a

data/LICENSE.md

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+=====================
+
+Copyright (c) Nicholas J Humfrey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/NEWS.md

@@ -0,0 +1,14 @@
+EventMachine MQTT-SN NEWS
+=========================
+
+Version 0.0.2 (2015-03-03)
+--------------------------
+
+* Renamed gem from mqtts to mqtt-sn.
+* Fixes for new version of MQTT gem
+
+
+Version 0.0.1 (2013-04-20)
+--------------------------
+
+* Initial Release.

data/README.md

@@ -0,0 +1,54 @@
+ruby-em-mqtt-sn
+===============
+
+This gem adds MQTT-SN (MQTT For Sensor Networks) protocol support to EventMachine,
+an event-processing library for Ruby.
+
+It also includes a MQTT-SN gateway, to connect MQTT-SN clients to a standard [MQTT] server.
+
+    Usage: em-mqtt-sn-gateway [options]
+
+    Options:
+      -D, --debug                  turn on debug logging
+      -a, --address [HOST]         bind to HOST address (default: 0.0.0.0)
+      -p, --port [PORT]            UDP port number to run on (default: 1883)
+      -A, --server-address [HOST]  MQTT server address to connect to (default: 127.0.0.1)
+      -P, --server-port [PORT]     MQTT server port to connect to (default: 1883)
+      -h, --help                   show this message
+          --version                show version
+
+
+Example
+-------
+
+    $ sudo gem install em-mqtt-sn
+    $ em-mqtt-sn-gateway -A test.mosquitto.org
+    I, [2013-04-20T12:08:56.850572 #29588]  INFO -- : Starting MQTT-SN gateway on UDP 0.0.0.0:1883
+    I, [2013-04-20T12:08:56.850646 #29588]  INFO -- : Server address test.mosquitto.org:1883
+    I, [2013-04-20T12:09:00.577446 #29588]  INFO -- : mqtt-sn-tools-29710 is now connected
+    I, [2013-04-20T12:09:00.578032 #29588]  INFO -- : mqtt-sn-tools-29710 subscribing to 'test'
+    I, [2013-04-20T12:09:00.601937 #29588]  INFO -- : mqtt-sn-tools-29710 recieved publish to 'test'
+    I, [2013-04-20T12:09:07.770269 #29588]  INFO -- : mqtt-sn-tools-29713 is now connected
+    I, [2013-04-20T12:09:07.770733 #29588]  INFO -- : mqtt-sn-tools-29713 publishing to 'test'
+    I, [2013-04-20T12:09:07.783940 #29588]  INFO -- : mqtt-sn-tools-29710 recieved publish to 'test'
+    I, [2013-04-20T12:09:22.815726 #29588]  INFO -- : Disconnected: mqtt-sn-tools-29713
+
+
+License
+-------
+
+The em-mqtt-sn gem is licensed under the terms of the MIT license.
+See the file LICENSE for details.
+
+
+Contact
+-------
+
+* Author:    Nicholas J Humfrey
+* Email:     njh@aelius.com
+* Twitter:   [@njh]
+* Home Page: http://www.aelius.com/njh/
+
+
+[MQTT]:                     http://mqtt.org/
+[@njh]:                     http://twitter.com/njh

data/bin/em-mqtt-sn-gateway

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", 'lib')))
+require 'em/mqtt-sn'
+
+EventMachine::MQTTSN::Gateway.new(ARGV).run

data/lib/em/mqtt-sn.rb

@@ -0,0 +1,25 @@
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..')))
+
+require 'eventmachine'
+require 'logger'
+require 'em/mqtt'
+
+module EventMachine::MQTTSN
+
+  DEFAULT_HOST = 'localhost'
+  DEFAULT_PORT = 1883
+
+  class Exception < Exception
+  end
+
+  class ProtocolException < MQTT::Exception
+  end
+
+  require "em/mqtt-sn/version"
+
+  autoload :ServerConnection,  'em/mqtt-sn/server_connection'
+  autoload :Gateway,           'em/mqtt-sn/gateway'
+  autoload :GatewayHandler,    'em/mqtt-sn/gateway_handler'
+  autoload :Packet,            'em/mqtt-sn/packet'
+
+end

data/lib/em/mqtt-sn/gateway.rb

@@ -0,0 +1,81 @@
+require 'optparse'
+
+class EventMachine::MQTTSN::Gateway
+  attr_accessor :local_address
+  attr_accessor :local_port
+  attr_accessor :server_address
+  attr_accessor :server_port
+  attr_accessor :logger
+
+  def initialize(args=[])
+    # Set defaults
+    self.local_address = "0.0.0.0"
+    self.local_port = EventMachine::MQTTSN::DEFAULT_PORT
+    self.server_address = "127.0.0.1"
+    self.server_port = MQTT::DEFAULT_PORT
+    self.logger = Logger.new(STDOUT)
+    self.logger.level = Logger::INFO
+    parse(args) unless args.empty?
+  end
+
+  def parse(args)
+    OptionParser.new("", 28, '  ') do |opts|
+      opts.banner = "Usage: #{File.basename $0} [options]"
+
+      opts.separator ""
+      opts.separator "Options:"
+
+      opts.on("-D", "--debug", "turn on debug logging") do
+        self.logger.level = Logger::DEBUG
+      end
+
+      opts.on("-a", "--address [HOST]", "bind to HOST address (default: #{local_address})") do |address|
+        self.local_address = address
+      end
+
+      opts.on("-p", "--port [PORT]", "UDP port number to run on (default: #{local_port})") do |port|
+        self.local_port = port
+      end
+
+      opts.on("-A", "--server-address [HOST]", "MQTT server address to connect to (default: #{server_address})") do |address|
+        self.server_address = address
+      end
+
+      opts.on("-P", "--server-port [PORT]", "MQTT server port to connect to (default: #{server_port})") do |port|
+        self.server_port = port
+      end
+
+      opts.on_tail("-h", "--help", "show this message") do
+        puts opts
+        exit
+      end
+
+      opts.on_tail("--version", "show version") do
+        puts EventMachine::MQTTSN::VERSION
+        exit
+      end
+
+      opts.parse!(args)
+    end
+  end
+
+  def run
+    EventMachine.run do
+      # hit Control + C to stop
+      Signal.trap("INT")  { EventMachine.stop }
+      Signal.trap("TERM") { EventMachine.stop }
+
+      logger.info("Starting MQTT-SN gateway on UDP #{local_address}:#{local_port}")
+      logger.info("MQTT server address #{server_address}:#{server_port}")
+      EventMachine.open_datagram_socket(
+        local_address,
+        local_port,
+        EventMachine::MQTTSN::GatewayHandler,
+        :logger => logger,
+        :server_address => server_address,
+        :server_port => server_port
+      )
+    end
+  end
+
+end

data/lib/em/mqtt-sn/gateway_handler.rb

@@ -0,0 +1,216 @@
+#
+# There is only a single instance of GatewayHandler which
+# processes UDP packets from all MQTT-SN clients.
+#
+
+class EventMachine::MQTTSN::GatewayHandler < EventMachine::Connection
+  attr_reader :logger
+  attr_reader :connections
+  attr_reader :server_address
+  attr_reader :server_port
+
+  def initialize(attr)
+    @connections = {}
+    attr.each_pair do |k,v|
+      instance_variable_set("@#{k}", v)
+    end
+
+    # Run the cleanup task periodically
+    EventMachine.add_periodic_timer(10) { cleanup }
+  end
+
+  # UDP packet received by gateway
+  def receive_data(data)
+    packet = EventMachine::MQTTSN::Packet.parse(data)
+    unless packet.nil?
+      process_packet(get_peername, packet)
+    end
+  end
+
+  # Incoming packet received from client
+  def process_packet(peername, packet)
+    logger.debug("Received MQTT-SN: #{packet.class}")
+
+    if packet.class == EventMachine::MQTTSN::Packet::Connect
+      connect(peername, packet)
+    else
+      connection = @connections[peername]
+      unless connection.nil? or !connection.connected?
+        case packet
+          when EventMachine::MQTTSN::Packet::Register
+            register(connection, packet)
+          when EventMachine::MQTTSN::Packet::Publish
+            publish(connection, packet)
+          when EventMachine::MQTTSN::Packet::Subscribe
+            subscribe(connection, packet)
+          when EventMachine::MQTTSN::Packet::Pingreq
+            connection.send_packet MQTT::Packet::Pingreq.new
+          when EventMachine::MQTTSN::Packet::Pingresp
+            connection.send_packet MQTT::Packet::Pingresp.new
+          when EventMachine::MQTTSN::Packet::Disconnect
+            disconnect(connection)
+          else
+            logger.warn("Unable to handle MQTT-SN packet of type: #{packet.class}")
+        end
+      else
+        logger.warn("Received MQTT-SN packet of type: #{packet.class} while not connected")
+      end
+    end
+  end
+
+  # CONNECT received from client - establish connection to server
+  def connect(peername, packet)
+    # If connection already exists, disconnect first
+    if @connections.has_key?(peername)
+      logger.warn("Received CONNECT while already connected")
+      @connections[peername].disconnect
+    end
+
+    # Create a TCP connection to the server
+    client_port, client_address = Socket.unpack_sockaddr_in(peername)
+    connection = EventMachine::connect(
+      server_address, server_port,
+      EventMachine::MQTTSN::ServerConnection,
+      self, client_address, client_port
+    )
+
+    # Store the client ID
+    connection.client_id = packet.client_id
+
+    # Send a MQTT connect packet to the server
+    connection.send_packet MQTT::Packet::Connect.new(
+      :client_id => packet.client_id,
+      :keep_alive => packet.keep_alive,
+      :clean_session => packet.clean_session
+    )
+
+    # Add the connection to the table
+    @connections[peername] = connection
+  end
+
+  # Handle a MQTT packet coming back from the server
+  def relay_from_server(connection, packet)
+    logger.debug("Received MQTT: #{packet.inspect}")
+    case packet
+      when MQTT::Packet::Connack
+        # FIXME: re-map the return code
+        mqttsn_packet = EventMachine::MQTTSN::Packet::Connack.new(
+          :return_code => packet.return_code
+        )
+        if packet.return_code == 0
+          logger.info("#{connection.client_id} is now connected")
+        else
+          logger.info("#{connection.client_id} failed to connect: #{packet.return_msg}")
+        end
+      when MQTT::Packet::Suback
+        # Check that it is a response to a request we made
+        request = connection.remove_from_pending(packet.id)
+        if request
+          logger.debug("#{connection.client_id} now subscribed to '#{request.topic_name}'")
+          topic_id_type, topic_id = connection.get_topic_id(request.topic_name)
+          mqttsn_packet = EventMachine::MQTTSN::Packet::Suback.new(
+            :topic_id_type => topic_id_type,
+            :topic_id => topic_id,
+            :qos => packet.granted_qos.first,
+            :id => packet.id,
+            :return_code => 0x00
+          )
+        else
+          logger.warn("Received Suback from server for something we didn't request: #{packet.inspect}")
+        end
+      when MQTT::Packet::Publish
+        logger.info("#{connection.client_id} recieved publish to '#{packet.topic}'")
+        # FIXME: send register if this is a new topic
+        topic_id_type, topic_id = connection.get_topic_id(packet.topic)
+        mqttsn_packet = EventMachine::MQTTSN::Packet::Publish.new(
+          :duplicate => packet.duplicate,
+          :qos => packet.qos,
+          :retain => packet.retain,
+          :topic_id_type => topic_id_type,
+          :topic_id => topic_id,
+          :id => packet.id,
+          :data => packet.payload
+        )
+      when MQTT::Packet::Pingreq
+        mqttsn_packet = EventMachine::MQTTSN::Packet::Pingreq.new
+      when MQTT::Packet::Pingresp
+        mqttsn_packet = EventMachine::MQTTSN::Packet::Pingresp.new
+      else
+        logger.warn("Unable to handle MQTT packet of type: #{packet.class}")
+    end
+
+    unless mqttsn_packet.nil?
+      send_datagram(mqttsn_packet.to_s, connection.client_address, connection.client_port)
+    end
+  end
+
+  # REGISTER received from client
+  def register(connection, packet)
+    regack = EventMachine::MQTTSN::Packet::Regack.new(
+      :topic_id_type => :normal,
+      :id => packet.id
+    )
+
+    topic_id_type, topic_id = connection.get_topic_id(packet.topic_name)
+    unless topic_id.nil?
+      regack.return_code = 0x00   # Accepted
+      regack.topic_id = topic_id
+    else
+       regack.return_code = 0x02  # Rejected: invalid topic ID
+    end
+    send_data(regack.to_s)
+  end
+
+  # PUBLISH received from client - pass it on to the server
+  def publish(connection, packet)
+    if packet.topic_id_type == :short
+      topic_name = packet.topic_id
+    elsif packet.topic_id_type == :normal
+      topic_name = connection.get_topic_name(packet.topic_id)
+    end
+
+    if topic_name
+      logger.info("#{connection.client_id} publishing to '#{topic_name}'")
+      connection.send_packet MQTT::Packet::Publish.new(
+        :topic => topic_name,
+        :payload => packet.data,
+        :retain => packet.retain,
+        :qos => packet.qos
+      )
+    else
+      # FIXME: disconnect?
+      logger.warn("Invalid topic ID: #{packet.topic_id}")
+    end
+  end
+
+  # SUBSCRIBE received from client - pass it on to the server
+  def subscribe(connection, packet)
+    logger.info("#{connection.client_id} subscribing to '#{packet.topic_name}'")
+    mqtt_packet = MQTT::Packet::Subscribe.new(
+      :id => packet.id,
+      :topics => packet.topic_name
+    )
+    connection.add_to_pending(packet)
+    connection.send_packet(mqtt_packet)
+  end
+
+  # Disconnect client from server
+  def disconnect(connection)
+    if connection.connected?
+      logger.info("Disconnected: #{connection.client_id}")
+      mqttsn_packet = EventMachine::MQTTSN::Packet::Disconnect.new
+      send_datagram(mqttsn_packet.to_s, connection.client_address, connection.client_port)
+      connection.disconnect
+    end
+  end
+
+  # Periodic task to cleanup dead connections
+  def cleanup
+    connections.each_pair do |key,connection|
+      unless connection.connected?
+        logger.debug("Destroying connection: #{connection.client_id}")
+        @connections.delete(key)
+      end
+    end
+  end
+end

data/lib/em/mqtt-sn/packet.rb

@@ -0,0 +1,348 @@
+module EventMachine::MQTTSN
+
+  # Class representing a MQTTSN 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 "Packet too big"
+      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
+      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
+        (topic_id[0].ord << 8) + topic_id[1].ord
+      else
+        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
+
+    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
+        [return_code].pack('C')
+      end
+
+      def parse_body(buffer)
+        self.return_code = buffer.unpack('C')[0]
+      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
+        [encode_topic_id, id, topic_name].pack('nna*')
+      end
+
+      def parse_body(buffer)
+        topic_id, self.id, self.topic_name = buffer.unpack('nna*')
+        parse_topic_id(topic_id)
+      end
+    end
+
+    class Regack < Packet
+      attr_accessor :id
+      attr_accessor :topic_id
+      attr_accessor :return_code
+
+      DEFAULTS = {
+        :id => 0x00,
+        :topic_id_type => :normal
+      }
+
+      def encode_body
+        [encode_topic_id, id, return_code].pack('nnC')
+      end
+
+      def parse_body(buffer)
+        topic_id, self.id, self.return_code = buffer.unpack('nnC')
+        parse_topic_id(topic_id)
+      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
+        [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 Subscribe < Packet
+      attr_accessor :id
+      attr_accessor :topic_id
+      attr_accessor :topic_name
+
+      DEFAULTS = {
+        :id => 0x00,
+        :topic_id_type => :normal
+      }
+
+      def encode_body
+        [encode_flags, id, topic_name].pack('Cna*')
+      end
+
+      def parse_body(buffer)
+        flags, self.id, self.topic_name = buffer.unpack('Cna*')
+        parse_flags(flags)
+      end
+    end
+
+    class Suback < Packet
+      attr_accessor :id
+      attr_accessor :topic_id
+      attr_accessor :return_code
+
+      DEFAULTS = {
+        :qos => 0,
+        :id => 0x00,
+        :topic_id_type => :normal
+      }
+
+      def encode_body
+        [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 Pingreq < Packet
+      # No attributes
+    end
+
+    class Pingresp < Packet
+      # No attributes
+    end
+
+    class Disconnect < Packet
+      # No attributes
+    end
+
+  end
+
+
+  # An enumeration of the MQTT-SN packet types
+  PACKET_TYPES = {
+#       0x00 => EventMachine::MQTTSN::Packet::Advertise,
+#       0x01 => EventMachine::MQTTSN::Packet::Searchgw,
+#       0x02 => EventMachine::MQTTSN::Packet::Gwinfo,
+      0x04 => EventMachine::MQTTSN::Packet::Connect,
+      0x05 => EventMachine::MQTTSN::Packet::Connack,
+#       0x06 => EventMachine::MQTTSN::Packet::Willtopicreq,
+#       0x07 => EventMachine::MQTTSN::Packet::Willtopic,
+#       0x08 => EventMachine::MQTTSN::Packet::Willmsgreq,
+#       0x09 => EventMachine::MQTTSN::Packet::Willmsg,
+      0x0a => EventMachine::MQTTSN::Packet::Register,
+      0x0b => EventMachine::MQTTSN::Packet::Regack,
+      0x0c => EventMachine::MQTTSN::Packet::Publish,
+#       0x0d => EventMachine::MQTTSN::Packet::Puback,
+#       0x0e => EventMachine::MQTTSN::Packet::Pubcomp,
+#       0x0f => EventMachine::MQTTSN::Packet::Pubrec,
+#       0x10 => EventMachine::MQTTSN::Packet::Pubrel,
+      0x12 => EventMachine::MQTTSN::Packet::Subscribe,
+      0x13 => EventMachine::MQTTSN::Packet::Suback,
+#       0x14 => EventMachine::MQTTSN::Packet::Unsubscribe,
+#       0x15 => EventMachine::MQTTSN::Packet::Unsuback,
+      0x16 => EventMachine::MQTTSN::Packet::Pingreq,
+      0x17 => EventMachine::MQTTSN::Packet::Pingresp,
+      0x18 => EventMachine::MQTTSN::Packet::Disconnect,
+#       0x1a => EventMachine::MQTTSN::Packet::Willtopicupd,
+#       0x1b => EventMachine::MQTTSN::Packet::Willtopicresp,
+#       0x1c => EventMachine::MQTTSN::Packet::Willmsgupd,
+#       0x1d => EventMachine::MQTTSN::Packet::Willmsgresp,
+  }
+
+end