# logger.setLevel(logging.DEBUG)
#
logger = logging.getLogger(__name__)
-FORMAT = "[%(filename)s:%(lineno)s - %(funcName)s() ] %(message)s"
-logging.basicConfig(format=FORMAT)
class BaseTypes():
.format(type, base_types[type]))
def pack(self, data, kwargs=None):
- logger.debug("Data: {} Format: {}".format(data, self.packer.format))
return self.packer.pack(data)
def unpack(self, data, offset, result=None):
- logger.debug("@ {} Format: {}".format(offset, self.packer.format))
- return self.packer.unpack_from(data, offset)[0]
+ return self.packer.unpack_from(data, offset)[0], self.packer.size
types = {}
self.size = self.packer.size
def pack(self, list, kwargs):
- logger.debug("Data: {}".format(list))
-
+ """Packs a fixed length bytestring. Left-pads with zeros
+ if input data is too short."""
if len(list) > self.num:
raise ValueError('Fixed list length error for "{}", got: {}'
' expected: {}'
self.size = self.packer.size * num
def pack(self, list, kwargs):
- logger.debug("Data: {}".format(list))
-
if len(list) != self.num:
raise ValueError('Fixed list length error, got: {} expected: {}'
.format(len(list), self.num))
def unpack(self, data, offset=0, result=None):
# Return a list of arguments
result = []
+ total = 0
for e in range(self.num):
- x = self.packer.unpack(data, offset)
+ x, size = self.packer.unpack(data, offset)
result.append(x)
- offset += self.packer.size
- return result
+ offset += size
+ total += size
+ return result, total
class VLAList():
def __init__(self, name, field_type, len_field_name, index):
+ self.name = name
self.index = index
self.packer = types[field_type]
self.size = self.packer.size
self.length_field = len_field_name
def pack(self, list, kwargs=None):
- logger.debug("Data: {}".format(list))
if len(list) != kwargs[self.length_field]:
raise ValueError('Variable length error, got: {} expected: {}'
.format(len(list), kwargs[self.length_field]))
# u8 array
if self.packer.size == 1:
- p = BaseTypes('u8', len(list))
- return p.pack(list)
+ return bytearray(list)
for e in list:
b += self.packer.pack(e)
return b
def unpack(self, data, offset=0, result=None):
- logger.debug("Data: {} @ {} Result: {}"
- .format(list, offset, result[self.index]))
# Return a list of arguments
+ total = 0
# u8 array
if self.packer.size == 1:
if result[self.index] == 0:
- return b''
+ return b'', 0
p = BaseTypes('u8', result[self.index])
- r = p.unpack(data, offset)
- return r
+ return p.unpack(data, offset)
r = []
for e in range(result[self.index]):
- x = self.packer.unpack(data, offset)
+ x, size = self.packer.unpack(data, offset)
r.append(x)
- offset += self.packer.size
- return r
+ offset += size
+ total += size
+ return r, total
class VLAList_legacy():
self.size = self.packer.size
def pack(self, list, kwargs=None):
- logger.debug("Data: {}".format(list))
+ if self.packer.size == 1:
+ return bytes(list)
+
b = bytes()
for e in list:
b += self.packer.pack(e)
return b
def unpack(self, data, offset=0, result=None):
+ total = 0
# Return a list of arguments
if (len(data) - offset) % self.packer.size:
raise ValueError('Legacy Variable Length Array length mismatch.')
elements = int((len(data) - offset) / self.packer.size)
r = []
- logger.debug("Legacy VLA: {} elements of size {}"
- .format(elements, self.packer.size))
for e in range(elements):
- x = self.packer.unpack(data, offset)
+ x, size = self.packer.unpack(data, offset)
r.append(x)
offset += self.packer.size
- return r
+ total += size
+ return r, total
class VPPEnumType():
return self.enum[name]
def pack(self, data, kwargs=None):
- logger.debug("Data: {}".format(data))
return types['u32'].pack(data, kwargs)
def unpack(self, data, offset=0, result=None):
- x = types['u32'].unpack(data, offset)
- return self.enum(x)
+ x, size = types['u32'].unpack(data, offset)
+ return self.enum(x), size
class VPPUnionType():
logger.debug('Adding union {}'.format(name))
def pack(self, data, kwargs=None):
- logger.debug("Data: {}".format(data))
for k, v in data.items():
logger.debug("Key: {} Value: {}".format(k, v))
b = self.packers[k].pack(v, kwargs)
- offset = self.size - self.packers[k].size
break
r = bytearray(self.size)
- r[offset:] = b
+ r[:len(b)] = b
return r
def unpack(self, data, offset=0, result=None):
r = []
+ maxsize = 0
for k, p in self.packers.items():
- union_offset = self.size - p.size
- r.append(p.unpack(data, offset + union_offset))
- return self.tuple._make(r)
+ x, size = p.unpack(data, offset)
+ if size > maxsize:
+ maxsize = size
+ r.append(x)
+ return self.tuple._make(r), maxsize
class VPPType():
def pack(self, data, kwargs=None):
if not kwargs:
kwargs = data
- logger.debug("Data: {}".format(data))
b = bytes()
for i, a in enumerate(self.fields):
if a not in data:
- logger.debug("Argument {} not given, defaulting to 0"
- .format(a))
b += b'\x00' * self.packers[i].size
continue
- b += self.packers[i].pack(data[a], kwargs)
+
+ if isinstance(self.packers[i], VPPType):
+ b += self.packers[i].pack(data[a], kwargs[a])
+ else:
+ b += self.packers[i].pack(data[a], kwargs)
return b
def unpack(self, data, offset=0, result=None):
# Return a list of arguments
result = []
+ total = 0
for p in self.packers:
- x = p.unpack(data, offset, result)
+ x, size = p.unpack(data, offset, result)
if type(x) is tuple and len(x) == 1:
x = x[0]
result.append(x)
- offset += p.size
- return self.tuple._make(result)
+ offset += size
+ total += size
+ t = self.tuple._make(result)
+ return t, total
+
+
+class VPPMessage(VPPType):
+ pass
Code Review / vpp.git / blobdiff