qubitro-mqtt 0.0.1

data/lib/qubitro-mqtt/patches/string_encoding.rb

@@ -0,0 +1,33 @@
+# Monkey patch to add stubbed string encoding functions to Ruby 1.8
+
+class String
+    def force_encoding(encoding)
+      @encoding = encoding
+      self
+    end
+  
+    def encoding
+      @encoding ||= Encoding::ASCII_8BIT
+    end
+  
+    def encode(encoding)
+      new = dup
+      new.force_encoding(encoding)
+    end
+  end
+  
+  class Encoding
+    attr_reader :name
+  
+    def initialize(name)
+      @name = name
+    end
+  
+    def to_s
+      @name
+    end
+  
+    UTF_8 = Encoding.new('UTF-8')
+    ASCII_8BIT = Encoding.new('ASCII-8BIT')
+  end
+  

data/lib/qubitro-mqtt/proxy.rb

@@ -0,0 +1,116 @@
+module MQTT
+    # Class for implementing a proxy to filter/mangle MQTT packets.
+    class Proxy
+      # Address to bind listening socket to
+      attr_reader :local_host
+  
+      # Port to bind listening socket to
+      attr_reader :local_port
+  
+      # Address of upstream server to send packets upstream to
+      attr_reader :server_host
+  
+      # Port of upstream server to send packets upstream to.
+      attr_reader :server_port
+  
+      # Time in seconds before disconnecting an idle connection
+      attr_reader :select_timeout
+  
+      # Ruby Logger object to send informational messages to
+      attr_reader :logger
+  
+      # A filter Proc for packets coming from the client (to the server).
+      attr_writer :client_filter
+  
+      # A filter Proc for packets coming from the server (to the client).
+      attr_writer :server_filter
+  
+      # Create a new MQTT Proxy instance.
+      #
+      # Possible argument keys:
+      #
+      #  :local_host      Address to bind listening socket to.
+      #  :local_port      Port to bind listening socket to.
+      #  :server_host     Address of upstream server to send packets upstream to.
+      #  :server_port     Port of upstream server to send packets upstream to.
+      #  :select_timeout  Time in seconds before disconnecting a connection.
+      #  :logger          Ruby Logger object to send informational messages to.
+      #
+      # NOTE: be careful not to connect to yourself!
+      def initialize(args = {})
+        @local_host = args[:local_host] || '0.0.0.0'
+        @local_port = args[:local_port] || MQTT::DEFAULT_PORT
+        @server_host = args[:server_host]
+        @server_port = args[:server_port] || 18_830
+        @select_timeout = args[:select_timeout] || 60
+  
+        # Setup a logger
+        @logger = args[:logger]
+        if @logger.nil?
+          @logger = Logger.new(STDOUT)
+          @logger.level = Logger::INFO
+        end
+  
+        # Default is not to have any filters
+        @client_filter = nil
+        @server_filter = nil
+  
+        # Create TCP server socket
+        @server = TCPServer.open(@local_host, @local_port)
+        @logger.info "MQTT::Proxy listening on #{@local_host}:#{@local_port}"
+      end
+  
+      # Start accepting connections and processing packets.
+      def run
+        loop do
+          # Wait for a client to connect and then create a thread for it
+          Thread.new(@server.accept) do |client_socket|
+            logger.info "Accepted client: #{client_socket.peeraddr.join(':')}"
+            server_socket = TCPSocket.new(@server_host, @server_port)
+            begin
+              process_packets(client_socket, server_socket)
+            rescue Exception => exp
+              logger.error exp.to_s
+            end
+            logger.info "Disconnected: #{client_socket.peeraddr.join(':')}"
+            server_socket.close
+            client_socket.close
+          end
+        end
+      end
+  
+      private
+  
+      def process_packets(client_socket, server_socket)
+        loop do
+          # Wait for some data on either socket
+          selected = IO.select([client_socket, server_socket], nil, nil, @select_timeout)
+  
+          # Timeout
+          raise 'Timeout in select' if selected.nil?
+  
+          # Iterate through each of the sockets with data to read
+          if selected[0].include?(client_socket)
+            packet = MQTT::Packet.read(client_socket)
+            logger.debug "client -> <#{packet.type_name}>"
+            packet = @client_filter.call(packet) unless @client_filter.nil?
+            unless packet.nil?
+              server_socket.write(packet)
+              logger.debug "<#{packet.type_name}> -> server"
+            end
+          elsif selected[0].include?(server_socket)
+            packet = MQTT::Packet.read(server_socket)
+            logger.debug "server -> <#{packet.type_name}>"
+            packet = @server_filter.call(packet) unless @server_filter.nil?
+            unless packet.nil?
+              client_socket.write(packet)
+              logger.debug "<#{packet.type_name}> -> client"
+            end
+          else
+            logger.error 'Problem with select: socket is neither server or client'
+          end
+        end
+      end
+    end
+  end
+  

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

@@ -0,0 +1,721 @@
+# 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
+