coap 0.0.16 → 0.1.0

data/lib/coap/coap.rb

@@ -1,273 +0,0 @@
-# coapmessage.rb
-# Copyright (C) 2010..2013 Carsten Bormann <cabo@tzi.org>
-
-module CoAP
-  BIN = Encoding::BINARY
-  UTF8 = Encoding::UTF_8
-
-  class << self
-    def empty_buffer
-      ''.encode(BIN)
-    end
-
-    def invert_into_hash(a)
-      a.each_with_index.each_with_object({}) { |k, h| h[k[0]] = k[1] if k[0] }
-    end
-
-    # Arrays that describe a specific option type:
-    # [default value, length range, repeatable?, decoder, encoder]
-
-    # we only care about presence or absence, always empty
-    def presence_once
-      [false, (0..0), false,
-       ->(a) { true },
-       ->(v) { v ? [''] : [] }
-      ]
-    end
-
-    # token-style, goedelized in o256 here
-    def o256_once(min, max, default = nil)
-      [default, (min..max), false,
-       ->(a) { o256_decode(a[0]) },
-       ->(v) { v == default ? [] : [o256_encode(v)] }
-      ]
-    end
-
-    def o256_many(min, max)   # unused
-      [nil, (min..max), true,
-       ->(a) { a.map { |x| o256_decode(x) } },
-       ->(v) { Array(v).map { |x| o256_encode(x) } }
-      ]
-    end
-
-    # vlb as in core-coap Annex A
-    def uint_once(min, max, default = nil)
-      [default, (min..max), false,
-       ->(a) { vlb_decode(a[0]) },
-       ->(v) { v == default ? [] : [vlb_encode(v)] }
-      ]
-    end
-
-    def uint_many(min, max)
-      [nil, (min..max), true,
-       ->(a) { a.map { |x| vlb_decode(x) } },
-       ->(v) { Array(v).map { |x| vlb_encode(x) } }
-      ]
-    end
-
-    # Any other opaque byte sequence
-    def opaq_once(min, max, default = nil)
-      [default, (min..max), false,
-       ->(a) { a[0] },
-       ->(v) { v == default ? [] : Array(v) }
-      ]
-    end
-
-    def opaq_many(min, max)
-      [nil, (min..max), true,
-       ->(a) { a },
-       ->(v) { Array(v) }
-      ]
-    end
-
-    # same, but interpreted as UTF-8
-    def str_once(min, max, default = nil)
-      [default, (min..max), false,
-       ->(a) { a[0].force_encoding('utf-8') }, # XXX needed?
-       ->(v) { v == default ? [] : Array(v) }
-      ]
-    end
-
-    def str_many(min, max)
-      [nil, (min..max), true,
-       ->(a) { a.map { |s| s.force_encoding('utf-8') } }, # XXX needed?
-       ->(v) { Array(v) }
-      ]
-    end
-  end
-
-  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)
-
-  # for now, keep 19
-  #      TOKEN_ON = -1             # handled specially
-  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
-
-  class << self
-    def critical?(option)
-      oi = OPTIONS_I[option] # this is really an option name symbol
-      if oi
-        option = oi[0]          # -> to option number
-      end
-      option.odd?
-    end
-
-    def unsafe?(option)
-      oi = OPTIONS_I[option] # this is really an option name symbol
-      if oi
-        option = oi[0]          # -> to option number
-      end
-      option & 2 == 2
-    end
-
-    def no_cache_key?(option)
-      oi = OPTIONS_I[option] # this is really an option name symbol
-      if oi
-        option = oi[0]          # -> to option number
-      end
-      option & 0x1e == 0x1c
-    end
-
-    # The variable-length binary (vlb) numbers defined in CoRE-CoAP Appendix A.
-    def vlb_encode(n)
-      # on = n
-      n = Integer(n)
-      fail ArgumentError, "Can't encode negative number #{n}" if n < 0
-      v = empty_buffer
-      while n > 0
-        v << (n & 0xFF)
-        n >>= 8
-      end
-      v.reverse!
-      # warn "Encoded #{on} as #{v.inspect}"
-      v
-    end
-
-    def vlb_decode(s)
-      n = 0
-      s.each_byte do |b|
-        n <<= 8
-        n += b
-      end
-      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]
-    end
-
-    def scheme_and_authority_encode(host, port)
-      unless host =~ /\[.*\]/
-        host = "[#{host}]" if host =~ /:/
-      end
-      scheme_and_authority = "coap://#{host}"
-      port = Integer(port)
-      scheme_and_authority << ":#{port}" unless port == 5683
-      scheme_and_authority
-    end
-
-    def scheme_and_authority_decode(s)
-      if s =~ %r{\A(?:coap://)((?:\[|%5B)([^\]]*)(?:\]|%5D)|([^:/]*))(:(\d+))?(/.*)?\z}i
-        host = Regexp.last_match[2] || Regexp.last_match[3]       # should check syntax...
-        port = Regexp.last_match[5] || 5683
-        [host, port.to_i, Regexp.last_match[6]]
-      end
-    end
-
-    UNRESERVED = 'A-Za-z0-9\\-\\._~' # ALPHA / DIGIT / "-" / "." / "_" / "~"
-    SUB_DELIM = "!$&'()*+,;=" # "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
-    PATH_UNENCODED = "#{UNRESERVED}#{SUB_DELIM}:@"
-    PATH_ENCODED_RE = /[^#{PATH_UNENCODED}]/mn
-    def path_encode(uri_elements)
-      '/' << uri_elements.map do |el|
-        el.dup.force_encoding(BIN).gsub(PATH_ENCODED_RE) { |x| '%%%02X' % x.ord }
-      end.join('/')
-    end
-
-    SUB_DELIM_NO_AMP = SUB_DELIM.gsub('&', '')
-    QUERY_UNENCODED = "#{UNRESERVED}#{SUB_DELIM_NO_AMP}:@/?"
-    QUERY_ENCODED_RE = /[^#{QUERY_UNENCODED}]/mn
-    def query_encode(query_elements)
-      if query_elements.empty?
-        ''
-      else
-        '?' << query_elements.map do |el|
-          el.dup.force_encoding(BIN).gsub(QUERY_ENCODED_RE) { |x| '%%%02X' % x.ord }
-        end.join('&')
-      end
-    end
-
-    def percent_decode(el)
-      el.gsub(/%(..)/) { Regexp.last_match[1].to_i(16).chr(BIN) }.force_encoding(UTF8)
-    end
-
-    def path_decode(path)
-      a = path.split('/', -1)     # needs -1 to avoid eating trailing slashes!
-      return a if a.empty?
-      fail ArgumentError, 'path #{path.inspect} did not start with /' unless a[0] == ''
-      return [] if a[1] == '' # special case for "/"
-      a[1..-1].map do |el|
-        percent_decode(el)
-      end
-    end
-
-    def query_decode(query)
-      return [] if query.empty?
-      fail ArgumentError, 'query #{query.inspect} did not start with ?' unless query[0] == '?'
-      a = query.split('&', -1).map do |el|
-        el.gsub(/%(..)/) { Regexp.last_match[1].to_i(16).chr(BIN) }.force_encoding(UTF8)
-      end
-      a[0] = a[0][1..-1]      # remove "?"
-      a
-    end
-
-    # Shortcut: CoRE::CoAP::parse == CoRE::CoAP::Message.parse
-    def parse(*args)
-      Message.parse(*args)
-    end
-  end
-end

data/lib/coap/message.rb

@@ -1,187 +0,0 @@
-# coapmessage.rb
-# Copyright (C) 2010..2013 Carsten Bormann <cabo@tzi.org>
-
-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 = args.pop.dup
-        tt = h.delete(:tt) || args.shift
-        mcode = h.delete(:mcode) || args.shift
-        case mcode
-        when Integer then mcode = METHODS[mcode] || [mcode >> 5, mcode & 0x1f]
-        when Float then 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 # no payload = empty payload
-        fail 'CoRE::CoAPMessage.new: hash or all args' unless args.empty?
-        super(1, tt, mcode, mid, h, payload)
-      else
-        super
-      end
-    end
-
-    def mcode_readable
-      case mcode
-      when Array
-        "#{mcode[0]}.#{"%02d" % mcode[1]}"
-      else
-        mcode.to_s
-      end
-    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
-        fail "[#{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
-      fail 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
-        fail 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
-          fail 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[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
-
-    def self.decode_options_and_put_together(b1, tt, mcode, mid, options, payload)
-      # check and decode option values
-      decoded_options = DEFAULTING_OPTIONS.dup
-      options.each_pair do |k, v|
-        if oinfo = OPTIONS[k]
-          oname, _, minmax, repeatable, decoder, _ = *oinfo
-          repeatable or v.size <= 1 or
-            fail ArgumentError, "repeated unrepeatable option #{oname}"
-          v.each do |v1|
-            unless minmax === v1.bytesize
-              fail 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 prepare_options
-      prepared_options = {}
-      options.each do |k, v|
-        # puts "k = #{k.inspect}, oinfo_i = #{OPTIONS_I[k].inspect}"
-        if oinfo_i = OPTIONS_I[k]
-          onum, oname, defv, minmax, rep, _, encoder = *oinfo_i
-          prepared_options[onum] = a = encoder.call(v)
-          rep or a.size <= 1 or fail "repeated option #{oname} #{a.inspect}"
-          a.each do |v1|
-            unless minmax === v1.bytesize
-              fail ArgumentError, "#{v1.inspect} out of #{minmax} for #{oname}"
-            end
-          end
-        else
-          fail ArgumentError, "#{k.inspect}: unknown option" unless Integer === k
-          prepared_options[k] = Array(v) # store raw option
-        end
-      end
-      prepared_options
-    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 to_wire
-      # check and encode option values
-      prepared_options = prepare_options
-      # puts "prepared_options: #{prepared_options}"
-
-      token = (prepared_options.delete(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|
-        fail "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(BIN)         # value
-        end
-
-      end
-
-      if payload != ''
-        result << 0xFF
-        result << payload.dup.force_encoding(BIN)
-      end
-      result
-    end
-  end
-end