stubbfel/blob2wireshark
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

further implementation for create dissector template

Browse Source
This commit is contained in:
stubbfel
2017-06-21 01:37:02 +02:00
parent 457cab3b60
commit 8db67e3e5a
2 changed files with 288 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

148
src/b2ws-plugin/b2ws_snippet.lua
View File

@@ -33,7 +33,7 @@ function b2ws_create_field_object(name, type, type_suffix)
end
end
end
return {["name"] = b2ws_trim(name), ["type"] = ws_type_name, ["bit_size"] = bit_size, ["bit_mask"] = bit_mask, ["offset"] = 0, ["array_number"] = array_number}
return {["name"] = b2ws_trim(name), ["type"] = ws_type_name, ["bit_size"] = bit_size, ["bit_mask"] = bit_mask, ["array_number"] = array_number}
end
function b2ws_create_struct_object(name)
@@ -43,6 +43,7 @@ end
function b2ws_parse_struct(struct_string)
local struct_name, field_list = string.match(b2ws_trim(struct_string), "struct%s+(%g+)%s*{(.*)}")
struct_object = b2ws_create_struct_object(struct_name)
local tmp_bit_size = 0
for key_index, field_string in next, b2ws_string_split(field_list, ";")
do
local trim_filed_string = b2ws_trim(field_string)
@@ -51,14 +52,34 @@ function b2ws_parse_struct(struct_string)
if type_suffix == nil then
type_suffix = ""
end
struct_object.fields[key_index] = b2ws_create_field_object(field_name, type_name, type_suffix)
local tmp_field_object = b2ws_create_field_object(field_name, type_name, type_suffix)
struct_object.fields[key_index] = tmp_field_object
tmp_bit_size = tmp_bit_size + tmp_field_object.bit_size
end
end
if tmp_bit_size % 8 ~= 0 then
tmp_bit_size = tmp_bit_size + 8
end
struct_object.size = tmp_bit_size / 8
return struct_object
end
next_proto_template = [[-- {field_name} Layer
{field_name}_layer = Proto("{field_name}_layer", "{field_name} layer")
function {field_name}_layer.dissector(buffer, packet_info, tree)
{field_name}_layer_tree = tree:add({field_name}_layer, buffer(0, buffer:len()))
end
]]
next_proto_dissector_call = [[Dissector.get("{field_name}_layer"):call(buffer({struct_size}, buffer:len() - {struct_size}):tvb(), packet_info, tree)]]
proto_template = [[-- {struct_name} Layer
{struct_name}_layer = Proto("{struct_name}_layer", "{struct_name} layer")
local {struct_name}_layer_fields = {struct_name}_layer.fields
{field_declarations}
function {struct_name}_layer.dissector(buffer, packet_info, tree)
@@ -66,14 +87,129 @@ function {struct_name}_layer.dissector(buffer, packet_info, tree)
{field_definitions}
end]]
field_declaration_template = [===[{struct_name}_layer_fields.{field_name} = ProtoField.{fiel_type}("{struct_name}_layer_fields.{field_name}", "{field_name}", {base_type}, nil--[[valuestring]], {bit_mask}, {field_name} description})]===]
field_declaration_template = [===[{struct_name}_layer_fields.{field_name} = ProtoField.{field_type}("{struct_name}_layer_fields.{field_name}", "{field_name}", {base_type}, nil--[[valuestring]], {bit_mask}, {field_name} description})]===]
field_definition_template = [[
local {field_name}_value = buffer({field_start},{field_end}):{to_method}()
{struct_name}_layer_tree:add({struct_name}_layer_fields.{field_name}, buffer({field_start}, {field_end}), {field_name}_value)]]
local {field_name}_value = buffer(current_offset, {field_end}):{to_method}()
{struct_name}_layer_tree:add({struct_name}_layer_fields.{field_name}, buffer(current_offset, {field_end}), {field_name}_value)
current_offset = current_offset + {field_end}]]
first_field_definition_template = [[
local {field_name}_value = buffer(0, {field_end}):{to_method}()
{struct_name}_layer_tree:add({struct_name}_layer_fields.{field_name}, buffer(0, {field_end}), {field_name}_value)
local current_offset = {field_end}]]
last_field_definition_template = [[
local {field_name}_value = buffer(current_offset, {field_end}):{to_method}()
{struct_name}_layer_tree:add({struct_name}_layer_fields.{field_name}, buffer(current_offset, {field_end}), {field_name}_value)]]
pad_lef_template = "0x%0{pad_count}x"
function b2ws_create_dissector_next_layer_snippet(field_object, template_string)
return template_string:gsub("{field_name}", field_object.name)
end
function b2ws_create_dissector_call_snippet(struct_object, field_object, template_string)
local result_template = template_string:gsub("{field_name}", field_object.name)
return result_template:gsub("{struct_size}", struct_object.size)
end
function b2ws_create_dissector_fields_definition_snippet(struct_object, field_object, template_string)
local result_template = template_string:gsub("{struct_name}", struct_object.name)
result_template = result_template:gsub("{field_name}", field_object.name)
local bit_size = field_object.bit_size
local array_number = field_object.array_number
if bit_size == 0 then
result_template = result_template:gsub("{field_end}", "buffer:len() - current_offset")
else
if bit_size % 8 ~= 0 then
bit_size = bit_size + 8
end
local byte_size = bit_size / 8
if array_number == nil or tonumber(array_number) ~= nil then
if field_object.bit_mask ~= nil then
byte_size = tonumber(string.match(field_object.type, "(%d+)")) / 8
end
result_template = result_template:gsub("{field_end}", string.match(byte_size, "(%d+)"))
else
result_template = result_template:gsub("{field_end}", string.match(byte_size, "(%d+)") .. " * " .. array_number .. "_value")
end
end
if array_number== nil then
result_template = result_template:gsub("{to_method}", "le_uint")
else
result_template = result_template:gsub("{to_method}", "bytes")
end
return result_template
end
function b2ws_create_dissector_fields_declaration_snippet(struct_object, field_object, template_string)
local result_template = template_string:gsub("{struct_name}", struct_object.name)
result_template = result_template:gsub("{field_name}", field_object.name)
local field_type = field_object.type
if field_object.array_number == nil then
result_template = result_template:gsub("{field_type}", field_type)
else
result_template = result_template:gsub("{field_type}", "bytes")
end
if b2ws_string_starts(field_type, "u") or field_object.array_number ~= nil then
result_template = result_template:gsub("{base_type}", "base.HEX")
else
result_template = result_template:gsub("{base_type}", "base.DEC")
end
local bit_mask = field_object.bit_mask
if bit_mask == nil then
bit_mask = "nil"
else
local size_string = string.match(field_type, "(%d+)")
local bit_size = string.match(tonumber(size_string) / 4, "(%d+)")
bit_mask = string.format( pad_lef_template:gsub("{pad_count}", bit_size), bit_mask)
end
return result_template:gsub("{bit_mask}", bit_mask)
end
function b2ws_create_dissector_fields_snippet(struct_object, template_string)
return template_string
local field_list = struct_object.fields
local field_declarations_string = ""
local field_definitions_string = "\n"
local tmp_bit_size = 0
local field_list_len = #field_list
local field_object = nil
local tmp_field_definition_template = first_field_definition_template
if field_list_len > 1 then
field_object = field_list[1]
field_declarations_string = field_declarations_string .. b2ws_create_dissector_fields_declaration_snippet(struct_object, field_object, field_declaration_template) .. "\n"
field_definitions_string = field_definitions_string .. b2ws_create_dissector_fields_definition_snippet(struct_object, field_object, tmp_field_definition_template) .. "\n"
tmp_field_definition_template = field_definition_template
if field_list_len > 2 then
for key_index = 2, field_list_len - 1
do
field_object = field_list[key_index]
field_declarations_string = field_declarations_string .. b2ws_create_dissector_fields_declaration_snippet(struct_object, field_object, field_declaration_template) .. "\n"
field_definitions_string = field_definitions_string .. b2ws_create_dissector_fields_definition_snippet(struct_object, field_object, tmp_field_definition_template) .. "\n"
end
end
end
local pre_template = ""
field_object = field_list[field_list_len]
if field_object.bit_size == 0 then
pre_template = b2ws_create_dissector_next_layer_snippet(field_object, next_proto_template) .. "\n"
field_definitions_string = field_definitions_string .. b2ws_create_dissector_call_snippet(struct_object, field_object, next_proto_dissector_call)
else
field_declarations_string = field_declarations_string .. b2ws_create_dissector_fields_declaration_snippet(struct_object, field_object, field_declaration_template)
field_definitions_string = field_definitions_string .. b2ws_create_dissector_fields_definition_snippet(struct_object, field_object, last_field_definition_template)
end
local result_template_string = template_string:gsub("{field_declarations}", field_declarations_string)
result_template_string = result_template_string:gsub("{field_definitions}", field_definitions_string:gsub("\n", "\n\t"))
return pre_template .. result_template_string
end
function b2ws_create_dissector_layer_snippet(struct_object, template_string)

158
tests/src/test_b2ws_snippet.lua
View File

@@ -6,7 +6,6 @@ local loaded_test_code = assert(loadfile("../../src/b2ws-plugin/b2ws_snippet.lua
loaded_test_code()
-- Unit testing starts
local lu = require('luaunit')
TestSnippet = {} --class
@@ -16,7 +15,6 @@ TestSnippet = {} --class
lu.assertEquals(fieldObject.type, 'bar')
lu.assertEquals(fieldObject.bit_size, nil)
lu.assertEquals(fieldObject.bit_mask, nil)
lu.assertEquals(fieldObject.offset, 0)
lu.assertEquals(fieldObject.array_number, nil)
local structObject = b2ws_create_struct_object("bla ")
@@ -31,7 +29,6 @@ TestSnippet = {} --class
lu.assertEquals(fieldObject.type, 'uint8')
lu.assertEquals(fieldObject.bit_size, 8)
lu.assertEquals(fieldObject.bit_mask, nil)
lu.assertEquals(fieldObject.offset, 0)
lu.assertEquals(fieldObject.array_number, nil)
fieldObject = b2ws_create_field_object("foo3", "uint16", "[ ]")
@@ -39,7 +36,6 @@ TestSnippet = {} --class
lu.assertEquals(fieldObject.type, 'uint16')
lu.assertEquals(fieldObject.bit_size, 0)
lu.assertEquals(fieldObject.bit_mask, nil)
lu.assertEquals(fieldObject.offset, 0)
lu.assertEquals(fieldObject.array_number, "")
fieldObject = b2ws_create_field_object("foo3-1", "uint16", "[]")
@@ -47,7 +43,6 @@ TestSnippet = {} --class
lu.assertEquals(fieldObject.type, 'uint16')
lu.assertEquals(fieldObject.bit_size, 0)
lu.assertEquals(fieldObject.bit_mask, nil)
lu.assertEquals(fieldObject.offset, 0)
lu.assertEquals(fieldObject.array_number, "")
fieldObject = b2ws_create_field_object("foo4", "int16", "[3]")
@@ -55,7 +50,6 @@ TestSnippet = {} --class
lu.assertEquals(fieldObject.type, 'int16')
lu.assertEquals(fieldObject.bit_size, 48)
lu.assertEquals(fieldObject.bit_mask, nil)
lu.assertEquals(fieldObject.offset, 0)
lu.assertEquals(fieldObject.array_number, "3")
fieldObject = b2ws_create_field_object("foo5", "int16", "[foo]")
@@ -63,7 +57,6 @@ TestSnippet = {} --class
lu.assertEquals(fieldObject.type, 'int16')
lu.assertEquals(fieldObject.bit_size, 16)
lu.assertEquals(fieldObject.bit_mask, nil)
lu.assertEquals(fieldObject.offset, 0)
lu.assertEquals(fieldObject.array_number, "foo")
fieldObject = b2ws_create_field_object("foo6", "uint32", ":0-15")
@@ -71,7 +64,6 @@ TestSnippet = {} --class
lu.assertEquals(fieldObject.type, 'uint32')
lu.assertEquals(fieldObject.bit_size, 16)
lu.assertEquals(fieldObject.bit_mask, 0x0000ffff)
lu.assertEquals(fieldObject.offset, 0)
lu.assertEquals(fieldObject.array_number, nil)
fieldObject = b2ws_create_field_object("foo6-1", "uint32", ":8-23")
@@ -79,7 +71,6 @@ TestSnippet = {} --class
lu.assertEquals(fieldObject.type, 'uint32')
lu.assertEquals(fieldObject.bit_size, 16)
lu.assertEquals(fieldObject.bit_mask, 0x00ffff00)
lu.assertEquals(fieldObject.offset, 0)
lu.assertEquals(fieldObject.array_number, nil)
fieldObject = b2ws_create_field_object("foo6-2", "uint32", ":24-31")
@@ -87,7 +78,6 @@ TestSnippet = {} --class
lu.assertEquals(fieldObject.type, 'uint32')
lu.assertEquals(fieldObject.bit_size, 8)
lu.assertEquals(fieldObject.bit_mask, 0xff000000)
lu.assertEquals(fieldObject.offset, 0)
lu.assertEquals(fieldObject.array_number, nil)
end
@@ -99,7 +89,7 @@ TestSnippet = {} --class
int16_t bla; int32_t bla; int64_t bla;
} "]])
lu.assertEquals(structObject.name, 'foo')
lu.assertEquals(structObject.size, -1)
lu.assertEquals(structObject.size, 22)
lu.assertEquals(structObject.fields[1].name, 'bla_count')
lu.assertEquals(structObject.fields[1].type, 'uint8')
lu.assertEquals(structObject.fields[2].name, 'bla')
@@ -116,9 +106,63 @@ TestSnippet = {} --class
local structObject = b2ws_parse_struct([[" struct foo
{ uint8 bla_count; uint16_t bla[bla_count];
uint32_t foo:0-15; int64_t bar[]; int8_t bla[3];
int16_t bla; int32_t bla; int64_t bla;
int16_t bla; int32_t bla; int64_t bar[];
} "]])
result_template = b2ws_create_dissector_snippet(structObject)
local result_template = b2ws_create_dissector_snippet(structObject)
local expected_result = [===[-- bar Layer
bar_layer = Proto("bar_layer", "bar layer")
function bar_layer.dissector(buffer, packet_info, tree)
bar_layer_tree = tree:add(bar_layer, buffer(0, buffer:len()))
end
-- foo Layer
foo_layer = Proto("foo_layer", "foo layer")
local foo_layer_fields = foo_layer.fields
foo_layer_fields.bla_count = ProtoField.uint8("foo_layer_fields.bla_count", "bla_count", base.HEX, nil--[[valuestring]], nil, bla_count description})
foo_layer_fields.bla = ProtoField.bytes("foo_layer_fields.bla", "bla", base.HEX, nil--[[valuestring]], nil, bla description})
foo_layer_fields.foo = ProtoField.uint32("foo_layer_fields.foo", "foo", base.HEX, nil--[[valuestring]], 0x0000ffff, foo description})
foo_layer_fields.bar = ProtoField.bytes("foo_layer_fields.bar", "bar", base.HEX, nil--[[valuestring]], nil, bar description})
foo_layer_fields.bla = ProtoField.bytes("foo_layer_fields.bla", "bla", base.HEX, nil--[[valuestring]], nil, bla description})
foo_layer_fields.bla = ProtoField.int16("foo_layer_fields.bla", "bla", base.DEC, nil--[[valuestring]], nil, bla description})
foo_layer_fields.bla = ProtoField.int32("foo_layer_fields.bla", "bla", base.DEC, nil--[[valuestring]], nil, bla description})
function foo_layer.dissector(buffer, packet_info, tree)
foo_layer_tree = tree:add(foo_layer, buffer(0, 14.0))
local bla_count_value = buffer(0, 1):le_uint()
foo_layer_tree:add(foo_layer_fields.bla_count, buffer(0, 1), bla_count_value)
local current_offset = 1
local bla_value = buffer(current_offset, 2 * bla_count_value):bytes()
foo_layer_tree:add(foo_layer_fields.bla, buffer(current_offset, 2 * bla_count_value), bla_value)
current_offset = current_offset + 2 * bla_count_value
local foo_value = buffer(current_offset, 4):le_uint()
foo_layer_tree:add(foo_layer_fields.foo, buffer(current_offset, 4), foo_value)
current_offset = current_offset + 4
local bar_value = buffer(current_offset, buffer:len() - current_offset):bytes()
foo_layer_tree:add(foo_layer_fields.bar, buffer(current_offset, buffer:len() - current_offset), bar_value)
current_offset = current_offset + buffer:len() - current_offset
local bla_value = buffer(current_offset, 3):bytes()
foo_layer_tree:add(foo_layer_fields.bla, buffer(current_offset, 3), bla_value)
current_offset = current_offset + 3
local bla_value = buffer(current_offset, 2):le_uint()
foo_layer_tree:add(foo_layer_fields.bla, buffer(current_offset, 2), bla_value)
current_offset = current_offset + 2
local bla_value = buffer(current_offset, 4):le_uint()
foo_layer_tree:add(foo_layer_fields.bla, buffer(current_offset, 4), bla_value)
current_offset = current_offset + 4
Dissector.get("bar_layer"):call(buffer(14.0, buffer:len() - 14.0):tvb(), packet_info, tree)
end
]===]
lu.assertEquals(result_template:gsub("%s", ""), expected_result:gsub("%s", ""))
-- print(result_template)
end
@@ -129,9 +173,95 @@ TestSnippet = {} --class
int16_t bla; int32_t bla; int64_t bla;
} "]])
result_template = b2ws_create_dissector_layer_snippet(structObject, "{struct_size}bla \n\t{struct_name}_bar{struct_size}\n{struct_name}:{struct_name}{struct_size}")
lu.assertEquals(result_template, "-1bla \n\tfoo_bar-1\nfoo:foo-1")
lu.assertEquals(result_template, "22.0bla \n\tfoo_bar22.0\nfoo:foo22.0")
end
function TestSnippet:testCreateFunctionDeclaration()
local test_field_declaration_template = [===[{struct_name}_layer_fields.{field_name} = ProtoField.{field_type}("{struct_name}_layer_fields.{field_name}", "{field_name}", {base_type}, nil--[[valuestring]], {bit_mask}, {field_name} description})]===]
local structObject = b2ws_create_struct_object("bla ")
structObject.fields[1] = fieldObject
lu.assertEquals(structObject.name, 'bla')
local fieldObject = b2ws_create_field_object("foo2", "uint8_t", "")
local result_string = b2ws_create_dissector_fields_declaration_snippet(structObject, fieldObject, test_field_declaration_template)
lu.assertEquals(result_string,
"bla_layer_fields.foo2 = ProtoField.uint8(\"bla_layer_fields.foo2\", \"foo2\", base.HEX, nil--[[valuestring]], nil, foo2 description})")
fieldObject = b2ws_create_field_object("foo3", "uint16", "[ ]")
result_string = b2ws_create_dissector_fields_declaration_snippet(structObject, fieldObject, test_field_declaration_template)
lu.assertEquals(result_string,
"bla_layer_fields.foo3 = ProtoField.bytes(\"bla_layer_fields.foo3\", \"foo3\", base.HEX, nil--[[valuestring]], nil, foo3 description})")
fieldObject = b2ws_create_field_object("foo3-1", "uint16", "[]")
result_string = b2ws_create_dissector_fields_declaration_snippet(structObject, fieldObject, test_field_declaration_template)
lu.assertEquals(result_string,
"bla_layer_fields.foo3-1 = ProtoField.bytes(\"bla_layer_fields.foo3-1\", \"foo3-1\", base.HEX, nil--[[valuestring]], nil, foo3-1 description})")
fieldObject = b2ws_create_field_object("foo4", "int16", "")
result_string = b2ws_create_dissector_fields_declaration_snippet(structObject, fieldObject, test_field_declaration_template)
lu.assertEquals(result_string,
"bla_layer_fields.foo4 = ProtoField.int16(\"bla_layer_fields.foo4\", \"foo4\", base.DEC, nil--[[valuestring]], nil, foo4 description})")
fieldObject = b2ws_create_field_object("foo5", "int16", "[foo]")
result_string = b2ws_create_dissector_fields_declaration_snippet(structObject, fieldObject, test_field_declaration_template)
lu.assertEquals(result_string,
"bla_layer_fields.foo5 = ProtoField.bytes(\"bla_layer_fields.foo5\", \"foo5\", base.HEX, nil--[[valuestring]], nil, foo5 description})")
fieldObject = b2ws_create_field_object("foo6", "uint32", ":0-15")
result_string = b2ws_create_dissector_fields_declaration_snippet(structObject, fieldObject, test_field_declaration_template)
lu.assertEquals(result_string,
"bla_layer_fields.foo6 = ProtoField.uint32(\"bla_layer_fields.foo6\", \"foo6\", base.HEX, nil--[[valuestring]], 0x0000ffff, foo6 description})")
fieldObject = b2ws_create_field_object("foo6-1", "int32", ":8-23")
result_string = b2ws_create_dissector_fields_declaration_snippet(structObject, fieldObject, test_field_declaration_template)
lu.assertEquals(result_string,
"bla_layer_fields.foo6-1 = ProtoField.int32(\"bla_layer_fields.foo6-1\", \"foo6-1\", base.DEC, nil--[[valuestring]], 0x00ffff00, foo6-1 description})")
end
function TestSnippet:testCreateFunctionDefinition()
local test_field_declaration_template = [[local {field_name}_value = buffer(0,{field_end}):{to_method}()
{struct_name}_layer_tree:add({struct_name}_layer_fields.{field_name}, buffer(0, {field_end}), {field_name}_value)]]
local structObject = b2ws_create_struct_object("bla ")
structObject.fields[1] = fieldObject
lu.assertEquals(structObject.name, 'bla')
local fieldObject = b2ws_create_field_object("foo2", "uint8_t", "")
local result_string = b2ws_create_dissector_fields_definition_snippet(structObject, fieldObject, test_field_declaration_template)
lu.assertEquals(result_string,
"local foo2_value = buffer(0,1):le_uint()\nbla_layer_tree:add(bla_layer_fields.foo2, buffer(0, 1), foo2_value)")
fieldObject = b2ws_create_field_object("foo3", "uint16", "[ ]")
result_string = b2ws_create_dissector_fields_definition_snippet(structObject, fieldObject, test_field_declaration_template)
lu.assertEquals(result_string,
"local foo3_value = buffer(0,buffer:len() - current_offset):bytes()\nbla_layer_tree:add(bla_layer_fields.foo3, buffer(0, buffer:len() - current_offset), foo3_value)")
fieldObject = b2ws_create_field_object("foo33", "uint16", "[3]")
result_string = b2ws_create_dissector_fields_definition_snippet(structObject, fieldObject, test_field_declaration_template)
lu.assertEquals(result_string,
"local foo33_value = buffer(0,6):bytes()\nbla_layer_tree:add(bla_layer_fields.foo33, buffer(0, 6), foo33_value)")
fieldObject = b2ws_create_field_object("foo4", "int16", "")
local result_string = b2ws_create_dissector_fields_definition_snippet(structObject, fieldObject, test_field_declaration_template)
lu.assertEquals(result_string,
"local foo4_value = buffer(0,2):le_uint()\nbla_layer_tree:add(bla_layer_fields.foo4, buffer(0, 2), foo4_value)")
fieldObject = b2ws_create_field_object("foo5", "int16", "[foo]")
result_string = b2ws_create_dissector_fields_definition_snippet(structObject, fieldObject, test_field_declaration_template)
lu.assertEquals(result_string,
"local foo5_value = buffer(0,2 * foo_value):bytes()\nbla_layer_tree:add(bla_layer_fields.foo5, buffer(0, 2 * foo_value), foo5_value)")
fieldObject = b2ws_create_field_object("foo6", "uint32", ":0-15")
result_string = b2ws_create_dissector_fields_definition_snippet(structObject, fieldObject, test_field_declaration_template)
lu.assertEquals(result_string,
"local foo6_value = buffer(0,4):le_uint()\nbla_layer_tree:add(bla_layer_fields.foo6, buffer(0, 4), foo6_value)")
fieldObject = b2ws_create_field_object("foo6-1", "int32", ":8-23")
result_string = b2ws_create_dissector_fields_definition_snippet(structObject, fieldObject, test_field_declaration_template)
lu.assertEquals(result_string,
"local foo6-1_value = buffer(0,4):le_uint()\nbla_layer_tree:add(bla_layer_fields.foo6-1, buffer(0, 4), foo6-1_value)")
end
-- class TestSnippet