add tests, indexing and bugfixed

Author: Firanel

ber.lua

@@ -19,14 +19,21 @@ local Types = {
   NULL = 5,
   SEQUENCE = 16,
   SET = 17,
+  IA5String = 22,
+  DATE = 31,
+  TIME_OF_DAY = 32,
+  DATE_TIME = 33,
+  DURATION = 34,
+  OID_IRI = 35,
+  RELATIVE_OID_IRI = 36,
 }
 
 local constructedOnly = {
-  ["8"] = true,
-  ["11"] = true,
-  ["16"] = true,
-  ["17"] = true,
-  ["29"] = true,
+  [8] = true,
+  [11] = true,
+  [16] = true,
+  [17] = true,
+  [29] = true,
 }
 
 
@@ -72,25 +79,32 @@ end
 
 
 
-local function encode(value)
+local function encode(value, forceIdentifier)
+  local ident = forceIdentifier and function(o)
+    local t = {}
+    for k, v in pairs(o) do t[k] = v end
+    for k, v in pairs(forceIdentifier) do t[k] = v end
+    return identifier(t)
+  end or identifier
+
   local mt = getmetatable(value)
   local tober = mt and mt.__tober
   if tober then
     if type(tober) == "function" then
-      return encode(tober(value))
+      return encode(tober(value), forceIdentifier)
     else
-      return encode(tober)
+      return encode(tober, forceIdentifier)
     end
   end
 
   local t = type(value)
 
   if t == "nil" then
-    return identifier{type = Types.NULL} .. length(0)
+    return ident{type = Types.NULL} .. length(0)
   elseif t == "number" then
     if math.floor(value) == value then
       local len = bytesRequired(value)
-      local res = identifier{type = Types.INTEGER} .. length(len)
+      local res = ident{type = Types.INTEGER} .. length(len)
       if len > 0 then
         res = res .. string.pack(">i"..len, value)
       end
@@ -99,36 +113,49 @@ local function encode(value)
       error("Not implemented")
     end
   elseif t == "string" then
-    return identifier{type = Types.OCTET_STRING} .. length(#value) .. value
+    return ident{type = Types.OCTET_STRING} .. length(#value) .. value
   elseif t == "boolean" then
-    return identifier{type = Types.BOOLEAN} .. length(1) .. string.char(value and 1 or 0)
+    return ident{type = Types.BOOLEAN} .. length(1) .. string.char(value and 0xff or 0)
   elseif t == "table" then
     if value[1] then
-      local res = {}
+      local children = {}
       for i, v in ipairs(value) do
-        res[i] = encode(v)
+        children[i] = v
+        value[i] = nil
       end
-      res = table.concat(res, "")
-      return identifier{type = Types.SEQUENCE} .. length(#res) .. res
-    else
-      if value.constructed == nil and constructedOnly[value.type] then
-        value.constructed = true
-      end
-      if value.constructed and value.children then
-        value.data = encode(value.children)
-        value.length = #value.data
+      value.children = children
+      if not value.type then
+        value.type = Types.SEQUENCE
       end
+    end
 
-      if not value.length then
-        if not value.data then
-          value.data = ""
-          value.length = 0
-        else
-          value.length = #value.data
+    if value.constructed == nil and constructedOnly[value.type] then
+      value.constructed = true
+    end
+    if value.constructed and value.children then
+      local res = {}
+      if value.index then
+        for i, v in ipairs(value.children) do
+          res[i] = encode(v, {class = 2, type = i - 1})
+        end
+      else
+        for i, v in ipairs(value.children) do
+          res[i] = encode(v)
         end
       end
-      return identifier(value) .. length(value.length) .. value.data
+      value.data = table.concat(res, "")
+      value.length = #value.data
+    end
+
+    if not value.length then
+      if not value.data then
+        value.data = ""
+        value.length = 0
+      else
+        value.length = #value.data
+      end
     end
+    return ident(value) .. length(value.length) .. value.data
   else
     error("Type not supported: "..t)
   end
@@ -138,7 +165,7 @@ end
 
 local function decode(value, cursor, maxDepth)
   local i = cursor or 1 -- Cursor
-  depth = (depth or math.maxinteger) - 1
+  maxDepth = (maxDepth or math.maxinteger) - 1
 
   -- Identifier octets
 
@@ -219,4 +246,5 @@ return {
   decode = decode,
   identifier = identifier,
   length = length,
+  Types = Types,
 }

readme.md

@@ -71,6 +71,17 @@ assert(ber.encode {"hello", 42} == ber.encode {
 })
 ```
 
+Tables with numbered indices may also contain BerObject properties:
+```lua
+assert(ber.encode {
+  type = ber.Types.SET,
+  1, 2, 3
+} == ber.encode {
+  type = ber.Types.SET,
+  children = {1, 2, 3}
+})
+```
+
 If `constructed` is true and `children` is set, `encode` will first encode children and use the result as the data.
 ```lua
 ber.encode {
@@ -84,6 +95,25 @@ ber.encode {
 }
 ```
 
+Constructed types may set `index` to `true` to auto index children:
+```lua
+assert(ber.encode {
+  index = true,
+  1, 2
+} == ber.encode {
+  {
+    class = 2,
+    type = 0,
+    data = string.byte(1)
+  },
+  {
+    class = 2,
+    type = 1,
+    data = string.byte(2)
+  }
+})
+```
+
 The metatable index `__tober` can be used to customize encoding, by providing an encodable value
 or a function returning an encodable value.
 ```lua

test.lua

@@ -1,6 +1,8 @@
 local ber = require "ber"
 
 
+-- Utils
+
 
 local function toHex(str)
   return str:gsub(".", function (s) return string.format("%02x ", string.byte(s)) end)
@@ -12,25 +14,132 @@ local function pprint(t)
   end
 end
 
+function recursive_compare(t1,t2)
+  -- Use usual comparison first.
+  if t1==t2 then return true end
+  -- We only support non-default behavior for tables
+  if (type(t1)~="table") then return false end
+  -- They better have the same metatables
+  local mt1 = getmetatable(t1)
+  local mt2 = getmetatable(t2)
+  if( not recursive_compare(mt1,mt2) ) then return false end
+
+  -- Check each key-value pair
+  -- We have to do this both ways in case we miss some.
+  -- TODO: Could probably be smarter and not check those we've
+  -- already checked though!
+  for k1,v1 in pairs(t1) do
+    local v2 = t2[k1]
+    if( not recursive_compare(v1,v2) ) then
+      print("Diff", k1, v1, v2)
+      return false
+    end
+  end
+  for k2,v2 in pairs(t2) do
+    local v1 = t1[k2]
+    if( not recursive_compare(v1,v2) ) then
+      print("Diff", k2, v1, v2)
+      return false
+    end
+  end
 
-
-print "Testing..."
+  return true
+end
 
 
+-- Tests
 
-local str = "Hello world!"
 
-assert(ber.decode(ber.encode(str)).data == str)
+print "Testing..."
 
-print(toHex(ber.encode(str)))
-print(ber.encode(str))
-pprint(ber.decode(ber.encode(str)))
 
-print(toHex(ber.encode(0x1234)))
-pprint(ber.decode(ber.encode(0x40)))
-print(ber.decode(ber.encode(0x40)).data)
 
-print(toHex(ber.encode{"hello", 4660, false}))
+-- Examples
+
+
+-- "Maggie", 4, true
+local result = "\x31\x0e\x16\x06\x4d\x61\x67\x67\x69\x65\x02\x01\x04\x01\x01\xFF"
+assert(result == ber.encode {
+  type = ber.Types.SET,
+  {
+    type = ber.Types.IA5String,
+    data = "Maggie"
+  }, 4, true
+})
+
+-- Tag long form
+result = "\x1F\x22\x05\x31\x30\x30\x30\x59"
+assert(result == ber.encode {
+  type = ber.Types.DURATION,
+  data = "1000Y"
+})
+
+-- Sequence indexing
+result = "\x30\x10\x80\x08\x62\x69\x67\x20\x68\x65\x61\x64\x81\x01\x02\x82\x01\x1A"
+assert(result == ber.encode {
+  index = true,
+  "\x62\x69\x67\x20\x68\x65\x61\x64",
+  2,
+  26,
+})
+
+
+
+-- Internal tests
+
+
+-- string
+assert(recursive_compare(
+  ber.decode(ber.encode "test"),
+  {
+    class = 0,
+    constructed = false,
+    type = 4,
+    length = 4,
+    data = "test",
+  }
+))
+
+-- Sequence
+local tmp = ber.encode "a" .. ber.encode "b"
+assert(recursive_compare(
+  ber.decode(ber.encode {"a", "b"}),
+  {
+    class = 0,
+    constructed = true,
+    type = ber.Types.SEQUENCE,
+    length = #tmp,
+    data = tmp,
+    children = {{
+      class = 0,
+      constructed = false,
+      type = 4,
+      length = 1,
+      data = "a",
+    }, {
+      class = 0,
+      constructed = false,
+      type = 4,
+      length = 1,
+      data = "b",
+    }}
+  }
+))
+
+-- metamethod
+tmp = setmetatable({name = "steve"}, {
+    __tober = function (this) return string.format("Hello %s!", this.name) end
+})
+assert(recursive_compare(
+  ber.decode(ber.encode(tmp)),
+  {
+    class = 0,
+    constructed = false,
+    type = 4,
+    length = 12,
+    data = "Hello steve!"
+  }
+))