coap 0.0.16 → 0.1.0

data/lib/core/coap/fsm.rb

@@ -0,0 +1,82 @@
+module CoRE
+  module CoAP
+    class FSM
+      # CoAP Message Layer FSM
+      # https://tools.ietf.org/html/draft-ietf-lwig-coap-01#section-2.5.2
+      class Message
+        include Celluloid::FSM
+
+        default_state :closed
+
+        # Receive CON
+        #   Send ACK (accept) -> :closed
+        state :ack_pending, to: [:closed]
+
+        # Sending and receiving
+        #   Send NON (unreliable_send)
+        #   Receive NON
+        #   Receive ACK
+        #   Receive CON -> :ack_pending
+        #   Send CON (reliable_send) -> :reliable_tx
+        state :closed, to: [:reliable_tx, :ack_pending]
+
+        # Send CON
+        #   Retransmit until
+        #     Failure
+        #       Timeout (fail) -> :closed
+        #       Receive matching RST (fail) -> :closed
+        #       Cancel (cancel) -> :closed
+        #     Success
+        #       Receive matching ACK, NON (rx) -> :closed
+        #       Receive matching CON (rx) -> :ack_pending
+        state :reliable_tx, to: [:closed, :ack_pending]
+      end
+
+      # CoAP Client Request/Response Layer FSM
+      # https://tools.ietf.org/html/draft-ietf-lwig-coap-01#section-2.5.1
+      class Client
+        include Celluloid::FSM
+
+        default_state :idle
+
+        # Idle
+        #   Outgoing request ((un)reliable_send) -> :waiting
+        state :idle, to: [:waiting]
+
+        # Waiting for response
+        #   Response received (accept, rx) -> :idle
+        #   Failure (fail) -> :idle
+        #   Cancel (cancel) -> :idle
+        state :waiting, to: [:idle]
+      end
+
+      # CoAP Server Request/Response Layer FSM
+      # https://tools.ietf.org/html/draft-ietf-lwig-coap-01#section-2.5.1
+      class Server
+        include Celluloid::FSM
+
+        default_state :idle
+
+        # Idle
+        #   On NON (rx) -> :separate
+        #   On CON (rx) -> :serving
+        state :idle, to: [:separate, :serving]
+
+        # Separate
+        #   Respond ((un)reliable_send) -> :idle
+        state :separate, to: [:idle]
+
+        # Serving
+        #   Respond (accept) -> :idle
+        #   Empty ACK (accept) -> :separate
+        state :serving, to: [:idle, :separate]
+      end
+
+      attr_reader :fsm
+
+      def initialize
+        @fsm = FSM::Message.new
+      end
+    end
+  end
+end

data/lib/core/coap/message.rb

@@ -0,0 +1,203 @@
+# coapmessage.rb
+# Copyright (C) 2010..2013 Carsten Bormann <cabo@tzi.org>
+
+module CoRE
+  module CoAP
+    class Message < Struct.new(:ver, :tt, :mcode, :mid, :options, :payload)
+      def initialize(*args) # convenience: .new(tt?, mcode?, mid?, payload?, hash?)
+        if args.size < 6
+          h = {}
+          h = args.pop.dup if args.last.is_a? Hash
+
+          tt = h.delete(:tt) || args.shift
+
+          mcode = h.delete(:mcode) || args.shift
+
+          # TODO Allow later setting of mcode by Float.
+          case mcode
+            when Integer
+              mcode = METHODS[mcode] || [mcode >> 5, mcode & 0x1f]
+            when Float
+              mcode = [mcode.to_i, (mcode * 100 % 100).round] # Accept 2.05 and such
+          end
+
+          mid = h.delete(:mid) || args.shift
+
+          payload = h.delete(:payload) || args.shift || EMPTY
+
+          unless args.empty?
+            raise 'CoRE::CoAP::Message.new: Either specify Hash or all arguments.'
+          end
+
+          super(1, tt, mcode, mid, h, payload)
+        else
+          super
+        end
+      end
+
+      def klausify(n)
+        if n < 13
+          [n, '']
+        else
+          n -= 13
+          if n < 256
+            [13, [n].pack("C")]
+          else
+            [14, [n-256].pack("n")]
+          end
+        end
+      end
+
+      def mcode_readable
+        return "#{mcode[0]}.#{"%02d" % mcode[1]}" if mcode.is_a? Array
+        mcode.to_s
+      end
+
+      def prepare_options
+        prepared_options = {}
+        options.each do |k, v|
+          if oinfo_i = CoAP::OPTIONS_I[k]
+            onum, oname, defv, minmax, rep, _, encoder = *oinfo_i
+            prepared_options[onum] = a = encoder.call(v)
+            rep or a.size <= 1 or raise "repeated option #{oname} #{a.inspect}"
+            a.each do |v1|
+              unless minmax === v1.bytesize
+                raise ArgumentError, "#{v1.inspect} out of #{minmax} for #{oname}"
+              end
+            end
+          else
+            raise ArgumentError, "#{k.inspect}: unknown option" unless Integer === k
+            prepared_options[k] = Array(v) # store raw option
+          end
+        end
+        prepared_options
+      end
+
+      def to_s
+        path  = CoAP.path_encode(self.options[:uri_path])
+        query = CoAP.query_encode(self.options[:uri_query])
+
+        [mcode_readable, path, query].join(' ')
+      end
+
+      def to_wire
+        # check and encode option values
+        prepared_options = prepare_options
+        # puts "prepared_options: #{prepared_options}"
+
+        token = (prepared_options.delete(CoAP::TOKEN_ON) || [nil])[0] || ''
+        puts "TOKEN: #{token.inspect}" unless token
+
+        b1 = 0x40 | TTYPES_I[tt] << 4 | token.bytesize
+        b2 = METHODS_I[mcode] || (mcode[0] << 5) + mcode[1]
+        result = [b1, b2, mid].pack("CCn")
+        result << token
+
+        # stuff options in packet
+        onumber = 0
+        num_encoded_options = 0
+        prepared_options.keys.sort.each do |k|
+          raise "Bad Option Type #{k.inspect}" unless Integer === k && k >= 0
+          a = prepared_options[k]
+          a.each do |v|
+            # result << frob(k, v)
+            odelta = k - onumber
+            onumber = k
+
+            odelta1, odelta2 = klausify(odelta)
+            odelta1 <<= 4
+
+            length1, length2 = klausify(v.bytesize)
+            result << [odelta1 | length1].pack("C")
+            result << odelta2
+            result << length2
+            result << v.dup.force_encoding(CoAP::BIN)         # value
+          end
+        end
+
+        if payload != '' && !payload.nil?
+          result << 0xFF
+          result << payload.dup.force_encoding(CoAP::BIN)
+        end
+
+        result
+      end
+
+      def self.decode_options_and_put_together(b1, tt, mcode, mid, options, payload)
+        # check and decode option values
+        decoded_options = CoAP::DEFAULTING_OPTIONS.dup
+        options.each_pair do |k, v|
+          if oinfo = CoAP::OPTIONS[k]
+            oname, _, minmax, repeatable, decoder, _ = *oinfo
+            repeatable or v.size <= 1 or
+              raise ArgumentError, "repeated unrepeatable option #{oname}"
+            v.each do |v1|
+              unless minmax === v1.bytesize
+                raise ArgumentError, "#{v1.inspect} out of #{minmax} for #{oname}"
+              end
+            end
+            decoded_options[oname] = decoder.call(v)
+          else
+            decoded_options[k] = v # we don't know what that is -- keep it in raw
+          end
+        end
+
+        new(b1, tt, mcode, mid, Hash[decoded_options], payload) # XXX: why Hash[] again?
+      end
+
+      def self.deklausify(d, dpos, len)
+        case len
+        when 0..12
+          [len, dpos]
+        when 13
+          [d.getbyte(dpos) + 13, dpos += 1]
+        when 14
+          [d.byteslice(dpos, 2).unpack("n")[0] + 269, dpos += 2]
+        else
+          raise "[#{d.inspect}] Bad delta/length nibble #{len} at #{dpos}"
+        end
+      end
+      
+      def self.parse(d)
+        # dpos keeps our current position in parsing d
+        b1, mcode, mid = d.unpack("CCn"); dpos = 4
+        toklen = b1 & 0xf
+        token = d.byteslice(dpos, toklen); dpos += toklen
+        b1 >>= 4
+        tt = TTYPES[b1 & 0x3]
+        b1 >>= 2
+        raise ArgumentError, "unknown CoAP version #{b1}" unless b1 == 1
+        mcode = METHODS[mcode] || [mcode>>5, mcode&0x1F]
+
+        # collect options
+        onumber = 0             # current option number
+        options = Hash.new { |h, k| h[k] = [] }
+        dlen = d.bytesize
+        while dpos < dlen
+          tl1 = d.getbyte(dpos); dpos += 1
+          raise ArgumentError, "option is not there at #{dpos} with oc #{orig_numopt}" unless tl1 # XXX
+
+          break if tl1 == 0xff
+
+          odelta, dpos = deklausify(d, dpos, tl1 >> 4)
+          olen, dpos = deklausify(d, dpos, tl1 & 0xF)
+
+          onumber += odelta
+
+          if dpos + olen > dlen
+            raise ArgumentError, "#{olen}-byte option at #{dpos} -- not enough data in #{dlen} total"
+          end
+
+          oval = d.byteslice(dpos, olen); dpos += olen
+          options[onumber] << oval
+        end
+
+        options[CoAP::TOKEN_ON] = [token] if token != ''
+        
+        # d.bytesize = more than all the rest...
+        decode_options_and_put_together(b1, tt, mcode, mid, options,
+                                        d.byteslice(dpos, d.bytesize))
+      end
+    end
+  end
+end

data/lib/core/coap/observer.rb

@@ -0,0 +1,40 @@
+module CoRE
+  module CoAP
+    class Observer
+      MAX_OBSERVE_OPTION_VALUE = 8_388_608
+
+      def initialize
+        @logger = CoAP.logger
+      end
+
+      def observe(message, callback, socket)
+        n = message.options[:observe]
+
+        callback.call(socket, message)
+
+        # This does not seem to be able to cope with concurrency.
+        loop do
+          answer = socket.receive(timeout: 0)
+
+          next unless answer.options[:observe]
+
+          if update?(n, answer.options[:observe])
+            callback.call(socket, answer)
+          end
+        end
+      end
+
+      private
+
+      def update?(old, new)
+        if new > old
+          new - old < MAX_OBSERVE_OPTION_VALUE
+        elsif new < old
+          old - new > MAX_OBSERVE_OPTION_VALUE
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/core/coap/options.rb

@@ -0,0 +1,44 @@
+module CoRE
+  module CoAP
+    module Options
+      extend Types
+
+      TOKEN_ON = 19
+
+      # 14 => :user, default, length range, replicable?, decoder, encoder
+      OPTIONS = { # name      minlength, maxlength, [default]    defined where:
+         1 => [:if_match,       *o256_many(0, 8)],     # core-coap-12
+         3 => [:uri_host,       *str_once(1, 255)],    # core-coap-12
+         4 => [:etag,           *o256_many(1, 8)],     # core-coap-12 !! once in rp
+         5 => [:if_none_match,  *presence_once],       # core-coap-12
+         6 => [:observe,        *uint_once(0, 3)],     # core-observe-07
+         7 => [:uri_port,       *uint_once(0, 2)],     # core-coap-12
+         8 => [:location_path,  *str_many(0, 255)],    # core-coap-12
+        11 => [:uri_path,       *str_many(0, 255)],    # core-coap-12
+        12 => [:content_format, *uint_once(0, 2)],     # core-coap-12
+        14 => [:max_age,        *uint_once(0, 4, 60)], # core-coap-12
+        15 => [:uri_query,      *str_many(0, 255)],    # core-coap-12
+        17 => [:accept,         *uint_once(0, 2)],     # core-coap-18!
+        TOKEN_ON => [:token,    *o256_once(1, 8, 0)],  # core-coap-12 -> opaq_once(1, 8, EMPTY)
+        20 => [:location_query, *str_many(0, 255)],    # core-coap-12
+        23 => [:block2,         *uint_once(0, 3)],     # core-block-10
+        27 => [:block1,         *uint_once(0, 3)],     # core-block-10
+        28 => [:size2,          *uint_once(0, 4)],     # core-block-10
+        35 => [:proxy_uri,      *str_once(1, 1034)],   # core-coap-12
+        39 => [:proxy_scheme,   *str_once(1, 255)],    # core-coap-13
+        60 => [:size1,          *uint_once(0, 4)],     # core-block-10
+      }
+
+      # :user => 14, :user, def, range, rep, deco, enco
+      OPTIONS_I =
+        Hash[OPTIONS.map { |k, v| [v[0], [k, *v]] }]
+
+      DEFAULTING_OPTIONS = 
+        Hash[
+          OPTIONS 
+            .map { |k, v| [v[0].freeze, v[1].freeze] }
+            .select { |k, v| v }
+        ].freeze
+    end
+  end
+end

data/lib/core/coap/registry.rb

@@ -0,0 +1,32 @@
+module CoRE
+  module CoAP
+    module Registry
+      REGISTRY_PATH = File.join(File.dirname(__FILE__), 'registry').freeze
+
+      def self.load_yaml(registry)
+        registry = "#{registry}.yml"
+        YAML.load_file(File.join(REGISTRY_PATH, registry))
+      end
+
+      CONTENT_FORMATS = load_yaml(:content_formats).freeze
+      CONTENT_FORMATS_INVERTED = CONTENT_FORMATS.invert.freeze
+
+      def self.convert_content_format(cf)
+        if cf.is_a? String
+          CONTENT_FORMATS_INVERTED[cf] || without_charset(cf)
+        else
+          CONTENT_FORMATS[cf]
+        end
+      end
+
+      private
+
+      def self.without_charset(cf)
+        cf = cf.split(';').first
+        CONTENT_FORMATS_INVERTED.select { |k| k =~ /^#{cf}/ }.first[1]
+      rescue NoMethodError
+        nil
+      end
+    end
+  end
+end

data/lib/core/coap/registry/content_formats.yml

@@ -0,0 +1,7 @@
+0:  'text/plain; charset=utf-8'
+40: 'application/link-format'
+41: 'application/xml'
+42: 'application/octet-stream'
+47: 'application/exi'
+50: 'application/json'
+60: 'application/cbor'

data/lib/core/coap/resolver.rb

@@ -0,0 +1,17 @@
+module CoRE
+  module CoAP
+    class Resolver
+      def self.address(host)
+        a = if ENV['IPv4'].nil?
+          IPv6FavorResolv.getaddress(host).to_s
+        else
+          Resolv.getaddress(host).to_s
+        end
+
+        raise Resolv::ResolvError if a.empty?
+
+        a
+      end
+    end
+  end
+end

data/lib/core/coap/transmission.rb

@@ -0,0 +1,165 @@
+module CoRE
+  module CoAP
+    # Socket abstraction.
+    class Transmission
+      DEFAULT_RECV_TIMEOUT = 2
+
+      attr_accessor :max_retransmit, :recv_timeout
+      attr_reader :address_family, :socket
+
+      def initialize(options = {})
+        @max_retransmit   = options[:max_retransmit] || 4
+        @recv_timeout     = options[:recv_timeout]   || DEFAULT_RECV_TIMEOUT
+        @socket           = options[:socket]
+
+        @retransmit       = if options[:retransmit].nil?
+                              true
+                            else
+                              !!options[:retransmit]
+                            end
+
+        if @socket
+          @socket_class   = @socket.class
+          @address_family = @socket.addr.first
+        else
+          @socket_class   = options[:socket_class]   || Celluloid::IO::UDPSocket
+          @address_family = options[:address_family] || Socket::AF_INET6
+          @socket         = @socket_class.new(@address_family)
+        end
+
+        # http://lists.apple.com/archives/darwin-kernel/2014/Mar/msg00012.html
+        if OS.osx? && ipv6?
+          ifname  = Socket.if_up?('en1') ? 'en1' : 'en0'
+          ifindex = Socket.if_nametoindex(ifname)
+
+          s = @socket.to_io rescue @socket
+          s.setsockopt(:IPPROTO_IPV6, :IPV6_MULTICAST_IF, [ifindex].pack('i_'))
+        end
+
+        @socket
+      end
+
+      def ipv6?
+        @address_family == Socket::AF_INET6
+      end
+
+      # Receive from socket and return parsed CoAP message. (ACK is sent on CON
+      # messages.)
+      def receive(options = {})
+        retry_count = options[:retry_count] || 0
+        timeout = (options[:timeout] || @recv_timeout) ** (retry_count + 1)
+
+        mid   = options[:mid]
+        flags = mid.nil? ? 0 : Socket::MSG_PEEK
+
+        data = Timeout.timeout(timeout) do
+          @socket.recvfrom(1152, flags)
+        end
+
+        answer = CoAP.parse(data[0].force_encoding('BINARY'))
+
+        if mid == answer.mid
+          Timeout.timeout(1) { @socket.recvfrom(1152) }
+        end
+
+        return if answer.nil?
+
+        if answer.tt == :con
+          message = Message.new(:ack, 0, answer.mid, nil,
+            {token: answer.options[:token]})
+
+          send(message, data[1][3])
+        end
+
+        answer
+      end
+
+      # Send +message+ (retransmit if necessary) and wait for answer. Returns
+      # answer.
+      def request(message, host, port = CoAP::PORT)
+        retry_count = 0
+        retransmit = @retransmit && message.tt == :con
+
+        begin
+          send(message, host, port)
+          response = receive(retry_count: retry_count, mid: message.mid)
+        rescue Timeout::Error
+          raise unless retransmit
+
+          retry_count += 1
+
+          if retry_count > @max_retransmit
+            raise "Maximum retransmission count of #{@max_retransmit} reached."
+          end
+
+          retry unless message.tt == :non
+        end
+
+        if seperate?(response)
+          response = receive(timeout: 10, mid: message.mid)
+        end
+
+        response
+      end
+
+      # Send +message+.
+      def send(message, host, port = CoAP::PORT)
+        message = message.to_wire if message.respond_to?(:to_wire)
+
+        # In MRI and Rubinius, the Socket::MSG_DONTWAIT option is 64.
+        # It is not defined by JRuby.
+        # TODO Is it really necessary?
+        @socket.send(message, 64, host, port)
+      end
+
+      private
+
+      # Check if answer is seperated.
+      def seperate?(response)
+        r = response
+        r.tt == :ack && r.payload.empty? && r.mcode == [0, 0]
+      end
+
+      class << self
+        # Return Transmission instance with socket matching address family.
+        def from_host(host, options = {})
+          if IPAddr.new(host).ipv6? 
+            new(options)
+          else
+            new(options.merge(address_family: Socket::AF_INET))
+          end
+        # MRI throws IPAddr::InvalidAddressError, JRuby an ArgumentError
+        rescue ArgumentError
+          host = Resolver.address(host)
+          retry
+        end
+
+        # Instanciate matching Transmission and send message.
+        def send(*args)
+          invoke(:send, *args)
+        end
+
+        # Instanciate matching Transmission and perform request.
+        def request(*args)
+          invoke(:request, *args)
+        end
+
+        private
+
+        # Instanciate matching Transmission and invoke +method+ on instance.
+        def invoke(method, *args)
+          options = {}
+          options = args.pop if args.last.is_a? Hash
+
+          if options[:socket]
+            transmission = Transmission.new(options)
+          else
+            transmission = from_host(args[1], options)
+          end
+
+          [transmission, transmission.__send__(method, *args)]
+        end
+      end
+    end
+  end
+end