mqtt-ccutrer 1.0.0

data/lib/mqtt/proxy.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+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 => e
+            logger.error e.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/mqtt/sn/packet.rb

@@ -0,0 +1,714 @@
+# encoding: BINARY
+# frozen_string_literal: true
+
+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 = {}.freeze
+
+      # 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
+        raise ProtocolException, 'Length of packet is not the same as the length header' if buffer.length != length
+
+        packet_class = PACKET_TYPES[type_id]
+        raise ProtocolException, "Invalid packet type identifier: #{type_id}" if packet_class.nil?
+
+        # 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 instance_of?(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
+          raise "topic_id must be an String for type #{topic_id_type}" unless topic_id.is_a?(String)
+
+          (topic_id[0].ord << 8) + topic_id[1].ord
+        else
+          raise "topic_id must be an Integer for type #{topic_id_type}" unless topic_id.is_a?(Integer)
+
+          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.unpack1('n')
+        end
+      end
+
+      class Advertise < Packet
+        attr_accessor :gateway_id
+        attr_accessor :duration
+
+        DEFAULTS = {
+          gateway_id: 0x00,
+          duration: 0
+        }.freeze
+
+        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
+        }.freeze
+
+        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, :gateway_address
+
+        DEFAULTS = {
+          gateway_id: 0,
+          gateway_address: nil
+        }.freeze
+
+        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
+        }.freeze
+
+        # 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*')
+
+          raise ProtocolException, "Unsupported protocol ID number: #{protocol_id}" if protocol_id != 0x01
+
+          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.unpack1('C')
+        end
+      end
+
+      class Willtopicreq < Packet
+        # No attributes
+      end
+
+      class Willtopic < Packet
+        attr_accessor :topic_name
+
+        DEFAULTS = {
+          qos: 0,
+          retain: false,
+          topic_name: nil
+        }.freeze
+
+        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
+        }.freeze
+
+        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
+        }.freeze
+
+        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
+        }.freeze
+
+        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
+        }.freeze
+
+        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
+        }.freeze
+
+        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
+        }.freeze
+
+        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
+        }.freeze
+
+        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
+        }.freeze
+
+        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
+        }.freeze
+
+        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
+        }.freeze
+
+        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
+        }.freeze
+
+        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.unpack1('n')
+        end
+      end
+
+      class Pingreq < Packet
+        # No attributes
+      end
+
+      class Pingresp < Packet
+        # No attributes
+      end
+
+      class Disconnect < Packet
+        attr_accessor :duration
+
+        DEFAULTS = {
+          duration: nil
+        }.freeze
+
+        def encode_body
+          if duration.nil? || duration.zero?
+            ''
+          else
+            [duration].pack('n')
+          end
+        end
+
+        def parse_body(buffer)
+          self.duration = buffer.length == 2 ? buffer.unpack1('n') : nil
+        end
+      end
+
+      class Willtopicupd < Packet
+        attr_accessor :topic_name
+
+        DEFAULTS = {
+          qos: 0,
+          retain: false,
+          topic_name: nil
+        }.freeze
+
+        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
+        }.freeze
+
+        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
+        }.freeze
+
+        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
+    }.freeze
+  end
+end