coap 0.0.16 → 0.1.0

data/lib/core/coap/block.rb

@@ -0,0 +1,98 @@
+module CoRE
+  module CoAP
+    class Block
+      VALID_SIZE = [16, 32, 64, 128, 256, 512, 1024].freeze
+      MAX_NUM = (1048576 - 1).freeze
+
+      attr_reader :num, :more, :size
+
+      def initialize(*args)
+        if args.size == 1
+          @encoded = args.first.to_i
+        else
+          @decoded = []
+          self.num, self.more, self.size = args
+          @decoded = [self.num, self.more, self.size]
+        end
+
+        self
+      end
+
+      def chunk(data)
+        data[@size * @num, @size]
+      end
+
+      def chunk_count(data)
+        return 0 if data.nil? || data.empty?
+        i = data.size % self.size == 0 ? 0 : 1
+        data.size / self.size + i
+      end
+
+      def chunkify(data)
+        Block.chunkify(data, self.size)
+      end
+
+      def decode
+        if @encoded == 0
+          @decoded = [0, false, 16]
+        else
+          @decoded = [@encoded >> 4, (@encoded & 8) == 8, 16 << (@encoded & 7)]
+        end
+
+        self.num, self.more, self.size = @decoded
+
+        self
+      end
+
+      def encode
+        @encoded = @num << 4 | (@more ? 1 : 0) << 3 | CoAP.number_of_bits_up_to(@size) - 4
+      end
+
+      def included_by?(body)
+        return true if self.num == 0 && (body.nil? || body.empty?)
+        self.num < chunk_count(body)
+      end
+
+      def last?(data)
+        return true if data.nil? || data.empty?
+        self.num == chunk_count(data) - 1
+      end
+
+      def more=(v)
+        if @num > MAX_NUM
+          raise ArgumentError, 'num MUST be < 1048576'
+        end
+
+        @more = !!v
+        @decoded[1] = @more
+      end
+
+      def more?(data)
+        return false if data.nil? || data.empty?
+        data.bytesize > (self.num + 1) * self.size
+      end
+
+      def num=(v)
+        @num = v.to_i
+        @decoded[0] = @num
+      end
+
+      def set_more!(body)
+        self.more = self.more?(body)
+      end
+
+      def size=(v)
+        unless VALID_SIZE.include?(v.to_i)
+          raise ArgumentError, 'size MUST be power of 2 between 16 and 1024.'
+        end
+
+        @size = v.to_i
+        @decoded[2] = @size
+      end
+
+      def self.chunkify(data, size)
+        data.bytes.each_slice(size).map { |c| c.pack('C*') }
+      end
+    end
+  end
+end

data/lib/core/coap/client.rb

@@ -0,0 +1,314 @@
+# encoding: utf-8
+
+module CoRE
+  module CoAP
+    # CoAP client library
+    class Client
+      attr_accessor :max_payload, :host, :port
+
+      # @param  options   Valid options are (all optional): max_payload
+      #                   (maximum payload size, default 256), max_retransmit
+      #                   (maximum retransmission count, default 4),
+      #                   recv_timeout (timeout for ACK responses, default: 2),
+      #                   host (destination host), post (destination port,
+      #                   default 5683).
+      def initialize(options = {})
+        @max_payload = options[:max_payload] || 256
+
+        @host = options[:host]
+        @port = options[:port] || CoAP::PORT
+
+        @options = options
+
+        @logger = CoAP.logger
+      end
+
+      # Enable DTLS socket.
+      def use_dtls
+        require 'CoDTLS'
+        @options[:socket] = CoDTLS::SecureSocket
+        self
+      end
+
+      # GET
+      #
+      # @param  path      Path
+      # @param  host      Destination host
+      # @param  port      Destination port
+      # @param  payload   Payload
+      # @param  options   Options
+      #
+      # @return CoAP::Message
+      def get(*args)
+        client(:get, *args)
+      end
+
+      # GET by URI
+      #
+      # @param  uri       URI
+      # @param  payload   Payload
+      # @param  options   Options
+      #
+      # @return CoAP::Message
+      def get_by_uri(uri, *args)
+        get(*decode_uri(uri), *args)
+      end
+
+      # POST
+      #
+      # @param  host      Destination host
+      # @param  port      Destination port
+      # @param  path      Path
+      # @param  payload   Payload
+      # @param  options   Options
+      #
+      # @return CoAP::Message
+      def post(*args)
+        client(:post, *args)
+      end
+
+      # POST by URI
+      #
+      # @param  uri       URI
+      # @param  payload   Payload
+      # @param  options   Options
+      #
+      # @return CoAP::Message
+      def post_by_uri(uri, *args)
+        post(*decode_uri(uri), *args)
+      end
+
+      # PUT
+      #
+      # @param  host      Destination host
+      # @param  port      Destination port
+      # @param  path      Path
+      # @param  payload   Payload
+      # @param  options   Options
+      #
+      # @return CoAP::Message
+      def put(*args)
+        client(:put, *args)
+      end
+
+      # PUT by URI
+      #
+      # @param  uri       URI
+      # @param  payload   Payload
+      # @param  options   Options
+      #
+      # @return CoAP::Message
+      def put_by_uri(uri, *args)
+        put(*decode_uri(uri), *args)
+      end
+
+      # DELETE
+      #
+      # @param  host      Destination host
+      # @param  port      Destination port
+      # @param  path      Path
+      # @param  payload   Payload
+      # @param  options   Options
+      #
+      # @return CoAP::Message
+      def delete(*args)
+        client(:delete, *args)
+      end
+
+      # DELETE by URI
+      #
+      # @param  uri       URI
+      # @param  payload   Payload
+      # @param  options   Options
+      #
+      # @return CoAP::Message
+      def delete_by_uri(uri, *args)
+        delete(*decode_uri(uri), *args)
+      end
+
+      # OBSERVE
+      #
+      # @param  host      Destination host
+      # @param  port      Destination port
+      # @param  path      Path
+      # @param  callback  Method to call with the observe data. Must provide
+      #                   arguments payload and socket.
+      # @param  payload   Payload
+      # @param  options   Options
+      #
+      # @return CoAP::Message
+      def observe(path, host, port, callback, payload = nil, options = {})
+        options[:observe] = 0
+        client(:get, path, host, port, payload, options, callback)
+      end
+
+      # OBSERVE by URI
+      #
+      # @param  uri       URI
+      # @param  callback  Method to call with the observe data. Must provide
+      #                   arguments payload and socket.
+      # @param  payload   Payload
+      # @param  options   Options
+      #
+      # @return CoAP::Message
+      def observe_by_uri(uri, *args)
+        observe(*decode_uri(uri), *args)
+      end
+
+      private
+
+      def client(method, path, host = nil, port = nil, payload = nil, options = {}, observe_callback = nil)
+        # Set host and port only one time on multiple requests
+        host.nil? ? (host = @host unless @host.nil?) : @host = host
+        port.nil? ? (port = @port unless @port.nil?) : @port = port
+
+        path, query = path.split('?')
+
+        validate_arguments!(host, port, path, payload)
+
+        szx = 2 ** CoAP.number_of_bits_up_to(@max_payload)
+
+        # Initialize block2 with payload size.
+        block2 = Block.new(0, false, szx)
+
+        # Initialize block1.
+        block1 = if options[:block1].nil?
+          Block.new(0, false, szx)
+        else
+          Block.new(options[:block1]).decode
+        end
+
+        # Initialize chunks if payload size > max_payload.
+        if !payload.nil? && payload.bytesize > @max_payload
+          chunks = Block.chunkify(payload, @max_payload)
+        else
+          chunks = [payload]
+        end
+
+        # Create CoAP message struct.
+        message = initialize_message(method, path, query, payload)
+        message.mid = options.delete(:mid) if options[:mid]
+
+        # Set message type to non if chosen in global or local options.
+        if options.delete(:tt) == :non || @options.delete(:tt) == :non
+          message.tt = :non
+        end
+
+        # If more than 1 chunk, we need to use block1.
+        if !payload.nil? && chunks.size > 1
+          # Increase block number.
+          block1.num += 1 unless options[:block1].nil?
+
+          # More chunks?
+          if chunks.size > block1.num + 1
+            block1.more = true
+            message.options.delete(:block2)
+          else
+            block1.more = false
+          end
+
+          # Set final payload.
+          message.payload = chunks[block1.num]
+
+          # Set block1 message option.
+          message.options[:block1] = block1.encode
+        end
+
+        # Preserve user options.
+        message.options[:block2] = options[:block2] unless options[:block2] == nil
+        message.options[:observe] = options[:observe] unless options[:observe] == nil
+        message.options.merge!(options)
+
+        log_message(:sending_message, message)
+
+        # Wait for answer and retry sending message if timeout reached.
+        @transmission, recv_parsed = Transmission.request(message, host, port, @options)
+
+        log_message(:received_message, recv_parsed)
+
+        # Payload is not fully transmitted.
+        # TODO Get rid of nasty recursion.
+        if block1.more
+          return client(method, path, host, port, payload, message.options)
+        end
+
+        # Test for more block2 payload.
+        block2 = Block.new(recv_parsed.options[:block2]).decode
+
+        if block2.more
+          block2.num += 1
+
+          options.delete(:block1) # end block1
+          options[:block2] = block2.encode
+
+          local_recv_parsed = client(method, path, host, port, nil, options)
+
+          unless local_recv_parsed.nil?
+            recv_parsed.payload << local_recv_parsed.payload
+          end
+        end
+
+        # Do we need to observe?
+        if recv_parsed.options[:observe]
+          CoAP::Observer.new.observe(recv_parsed, observe_callback, @transmission)
+        end
+
+        recv_parsed
+      end
+
+      private
+
+      # Decode CoAP URIs.
+      def decode_uri(uri)
+        uri = CoAP.scheme_and_authority_decode(uri.to_s)
+
+        @logger.debug 'URI decoded: ' + uri.inspect
+        fail ArgumentError, 'Invalid URI' if uri.nil?
+
+        uri
+      end
+
+      def initialize_message(method, path, query = nil, payload = nil)
+        mid   = SecureRandom.random_number(0xffff)
+        token = SecureRandom.random_number(0xff)
+
+        options = {
+          uri_path: CoAP.path_decode(path),
+          token: token
+        }
+
+        unless query.nil?
+          options[:uri_query] = CoAP.query_decode(query)
+        end
+
+        Message.new(:con, method, mid, payload, options)
+      end
+
+      # Log message to debug log.
+      def log_message(text, message)
+        @logger.debug '### ' + text.to_s.upcase.gsub('_', ' ')
+        @logger.debug message.inspect
+        @logger.debug message.to_s.hexdump if $DEBUG
+      end
+
+      # Raise ArgumentError exceptions on wrong client method arguments.
+      def validate_arguments!(host, port, path, payload)
+        if host.nil? || host.empty?
+          fail ArgumentError, 'Argument «host» missing.'
+        end
+
+        if port.nil? || !port.is_a?(Integer)
+          fail ArgumentError, 'Argument «port» missing or not an Integer.'
+        end
+
+        if path.nil? || path.empty?
+          fail ArgumentError, 'Argument «path» missing.'
+        end
+
+        if !payload.nil? && (payload.empty? || !payload.is_a?(String))
+          fail ArgumentError, 'Argument «payload» must be a non-emtpy String'
+        end
+      end
+    end
+  end
+end

data/lib/core/coap/coap.rb

@@ -0,0 +1,26 @@
+# coapmessage.rb
+# Copyright (C) 2010..2013 Carsten Bormann <cabo@tzi.org>
+
+module CoRE
+  module CoAP
+    extend Utility
+
+    include Coding
+    include Options
+
+    EMPTY = empty_buffer.freeze
+
+    TTYPES = [:con, :non, :ack, :rst]
+    TTYPES_I = invert_into_hash(TTYPES)
+
+    METHODS = [nil, :get, :post, :put, :delete]
+    METHODS_I = invert_into_hash(METHODS)
+
+    PORT = 5683
+
+    # Shortcut: CoRE::CoAP::parse == CoRE::CoAP::Message.parse
+    def self.parse(*args)
+      Message.parse(*args)
+    end
+  end
+end

data/lib/core/coap/coding.rb

@@ -0,0 +1,146 @@
+# coapmessage.rb
+# Copyright (C) 2010..2013 Carsten Bormann <cabo@tzi.org>
+
+module CoRE
+  module CoAP
+    module Coding
+      BIN  = Encoding::BINARY
+      UTF8 = Encoding::UTF_8
+
+      UNRESERVED = '\w\-\.~' # Alphanumerics, '_', '-', '.', '~'
+      SUB_DELIM = "!$&'()*+,;="
+      SUB_DELIM_NO_AMP = SUB_DELIM.delete('&')
+
+      PATH_UNENCODED = "#{UNRESERVED}#{SUB_DELIM}:@"
+      PATH_ENCODED_RE = /[^#{PATH_UNENCODED}]/mn
+
+      QUERY_UNENCODED = "#{UNRESERVED}#{SUB_DELIM_NO_AMP}:@/?"
+      QUERY_ENCODED_RE = /[^#{QUERY_UNENCODED}]/mn
+
+      # Also extend on include.
+      def self.included(base)
+        base.send :extend, Coding
+      end
+
+      # The variable-length binary (vlb) numbers defined in CoRE-CoAP Appendix A.
+      def vlb_encode(n)
+        n = Integer(n)
+        v = empty_buffer
+
+        if n < 0
+          raise ArgumentError, "Can't encode negative number #{n}."
+        end
+
+        while n > 0
+          v << (n & 0xFF)
+          n >>= 8
+        end
+
+        v.reverse!
+      end
+
+      def vlb_decode(s)
+        n = 0
+        s.each_byte { |b| n <<= 8; n += b }
+        n
+      end
+
+      # Byte strings lexicographically goedelized as numbers (one+256 coding)
+      def o256_encode(num)
+        str = empty_buffer
+
+        while num > 0
+          num -= 1
+          str << (num & 0xFF)
+          num >>= 8
+        end
+
+        str.reverse
+      end
+
+      def o256_decode(str)
+        num = 0
+
+        str.each_byte do |b|
+          num <<= 8
+          num += b + 1
+        end
+
+        num
+      end
+
+      # n must be 2**k
+      # Returns k
+      def number_of_bits_up_to(n)
+#       Math.frexp(n-1)[1]
+        Math.log2(n).floor
+      end
+
+      def scheme_and_authority_encode(host, port)
+        unless host =~ /\[.*\]/
+          host = "[#{host}]" if host =~ /:/
+        end
+
+        port = Integer(port)
+
+        scheme_and_authority = "coap://#{host}"
+        scheme_and_authority << ":#{port}" unless port == CoAP::PORT
+        scheme_and_authority
+      end
+
+      def scheme_and_authority_decode(s)
+        if s =~ %r{\A(?:coap://)((?:\[|%5B)([^\]]*)(?:\]|%5D)|([^:/]*))(:(\d+))?(/.*)?\z}i
+          host = $2 || $3       # Should check syntax...
+          port = $5 || CoAP::PORT
+          [$6, host, port.to_i]
+        end
+      end
+
+      def path_encode(uri_elements)
+        return '/' if uri_elements.nil? || uri_elements.empty?
+        '/' + uri_elements.map { |el| uri_encode_element(el, PATH_ENCODED_RE) }.join('/')
+      end
+
+      def query_encode(query_elements)
+        return '' if query_elements.nil? || query_elements.empty?
+        '?' + query_elements.map { |el| uri_encode_element(el, QUERY_ENCODED_RE) }.join('&')
+      end
+
+      def uri_encode_element(el, re)
+        el.dup.force_encoding(BIN).gsub(re) { |x| "%%%02X" % x.ord }
+      end
+
+      def percent_decode(el)
+        el.gsub(/%(..)/) { $1.to_i(16).chr(BIN) }.force_encoding(UTF8)
+      end
+
+      def path_decode(path)
+        # Needs -1 to avoid eating trailing slashes!
+        a = path.split('/', -1) 
+
+        return a if a.empty?
+
+        if a[0] != ''
+          raise ArgumentError, "Path #{path.inspect} not starting with /"
+        end
+
+        # Special case for '/'
+        return [] if a[1] == '' 
+
+        a[1..-1].map { |el| percent_decode(el) }
+      end
+
+      def query_decode(query)
+        return [] if query.empty?
+
+        query = query[1..-1] if query[0] == '?'
+
+        a = query.split('&', -1).map do |el|
+          el.gsub(/%(..)/) { $1.to_i(16).chr(BIN) }.force_encoding(UTF8)
+        end
+
+        a
+      end
+    end
+  end
+end