X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvpp-api%2Fpython%2Fvpp_papi%2Fvpp_serializer.py;h=d62e3a4a57a56163a8918124312f90a10a3de335;hb=8006c6a;hp=7f5c5ace2dc877abb0918b1258d33b0acb3c26b9;hpb=a7564e8004fd6d9a63eb0605f752f27a71403645;p=vpp.git diff --git a/src/vpp-api/python/vpp_papi/vpp_serializer.py b/src/vpp-api/python/vpp_papi/vpp_serializer.py index 7f5c5ace2dc..d62e3a4a57a 100644 --- a/src/vpp-api/python/vpp_papi/vpp_serializer.py +++ b/src/vpp-api/python/vpp_papi/vpp_serializer.py @@ -17,6 +17,10 @@ import struct import collections from enum import IntEnum import logging +from . import vpp_format +import ipaddress +import sys +import socket # # Set log-level in application by doing e.g.: @@ -25,111 +29,185 @@ import logging # logger = logging.getLogger(__name__) +if sys.version[0] == '2': + def check(d): type(d) is dict +else: + def check(d): type(d) is dict or type(d) is bytes -class BaseTypes(): + +def conversion_required(data, field_type): + if check(data): + return False + try: + if type(data).__name__ in vpp_format.conversion_table[field_type]: + return True + except KeyError: + return False + + +def conversion_packer(data, field_type): + t = type(data).__name__ + return types[field_type].pack(vpp_format. + conversion_table[field_type][t](data)) + + +def conversion_unpacker(data, field_type): + if field_type not in vpp_format.conversion_unpacker_table: + return data + return vpp_format.conversion_unpacker_table[field_type](data) + + +class BaseTypes(object): def __init__(self, type, elements=0): base_types = {'u8': '>B', + 'string': '>s', 'u16': '>H', 'u32': '>I', 'i32': '>i', 'u64': '>Q', 'f64': '>d', + 'bool': '>?', 'header': '>HI'} - if elements > 0 and type == 'u8': + if elements > 0 and (type == 'u8' or type == 'string'): self.packer = struct.Struct('>%ss' % elements) else: self.packer = struct.Struct(base_types[type]) self.size = self.packer.size - logger.debug('Adding {} with format: {}' - .format(type, base_types[type])) def pack(self, data, kwargs=None): - logger.debug("Data: {} Format: {}".format(data, self.packer.format)) + if not data: # Default to zero if not specified + data = 0 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] + def unpack(self, data, offset, result=None, ntc=False): + return self.packer.unpack_from(data, offset)[0], self.packer.size + + +class String(object): + def __init__(self): + self.name = 'string' + self.size = 1 + self.length_field_packer = BaseTypes('u32') + + def pack(self, list, kwargs=None): + if not list: + return self.length_field_packer.pack(0) + b"" + return self.length_field_packer.pack(len(list)) + list.encode('utf8') + + def unpack(self, data, offset=0, result=None, ntc=False): + length, length_field_size = self.length_field_packer.unpack(data, + offset) + if length == 0: + return b'', 0 + p = BaseTypes('u8', length) + x, size = p.unpack(data, offset + length_field_size) + x2 = x.split(b'\0', 1)[0] + return (x2.decode('utf8'), size + length_field_size) + +types = {'u8': BaseTypes('u8'), 'u16': BaseTypes('u16'), + 'u32': BaseTypes('u32'), 'i32': BaseTypes('i32'), + 'u64': BaseTypes('u64'), 'f64': BaseTypes('f64'), + 'bool': BaseTypes('bool'), 'string': String()} -types = {} -types['u8'] = BaseTypes('u8') -types['u16'] = BaseTypes('u16') -types['u32'] = BaseTypes('u32') -types['i32'] = BaseTypes('i32') -types['u64'] = BaseTypes('u64') -types['f64'] = BaseTypes('f64') +def vpp_get_type(name): + try: + return types[name] + except KeyError: + return None -class FixedList_u8(): + +class VPPSerializerValueError(ValueError): + pass + + +class FixedList_u8(object): def __init__(self, name, field_type, num): self.name = name self.num = num self.packer = BaseTypes(field_type, num) self.size = self.packer.size + self.field_type = field_type - def pack(self, list, kwargs): + def pack(self, data, kwargs=None): """Packs a fixed length bytestring. Left-pads with zeros if input data is too short.""" - logger.debug("Data: {}".format(list)) + if not data: + return b'\x00' * self.size - if len(list) > self.num: - raise ValueError('Fixed list length error for "{}", got: {}' - ' expected: {}' - .format(self.name, len(list), self.num)) - return self.packer.pack(list) + if len(data) > self.num: + raise VPPSerializerValueError( + 'Fixed list length error for "{}", got: {}' + ' expected: {}' + .format(self.name, len(data), self.num)) - def unpack(self, data, offset=0, result=None): + return self.packer.pack(data) + + def unpack(self, data, offset=0, result=None, ntc=False): if len(data[offset:]) < self.num: - raise ValueError('Invalid array length for "{}" got {}' - ' expected {}' - .format(self.name, len(data), self.num)) + raise VPPSerializerValueError( + 'Invalid array length for "{}" got {}' + ' expected {}' + .format(self.name, len(data[offset:]), self.num)) + if self.field_type == 'string': + s = self.packer.unpack(data, offset) + s2 = s[0].split(b'\0', 1)[0] + return (s2.decode('utf-8'), self.num) return self.packer.unpack(data, offset) -class FixedList(): +class FixedList(object): def __init__(self, name, field_type, num): self.num = num self.packer = types[field_type] self.size = self.packer.size * num + self.name = name + self.field_type = field_type 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)) + raise VPPSerializerValueError( + 'Fixed list length error, got: {} expected: {}' + .format(len(list), self.num)) b = bytes() for e in list: b += self.packer.pack(e) return b - def unpack(self, data, offset=0, result=None): + def unpack(self, data, offset=0, result=None, ntc=False): # 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, ntc=ntc) result.append(x) - offset += self.packer.size - return result + offset += size + total += size + return result, total -class VLAList(): +class VLAList(object): def __init__(self, name, field_type, len_field_name, index): + self.name = name + self.field_type = field_type 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 not list: + return b"" if len(list) != kwargs[self.length_field]: - raise ValueError('Variable length error, got: {} expected: {}' - .format(len(list), kwargs[self.length_field])) + raise VPPSerializerValueError( + 'Variable length error, got: {} expected: {}' + .format(len(list), kwargs[self.length_field])) b = bytes() # u8 array + if self.packer.size == 1: return bytearray(list) @@ -137,25 +215,24 @@ class VLAList(): 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])) + def unpack(self, data, offset=0, result=None, ntc=False): # 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, ntc=ntc) r = [] for e in range(result[self.index]): - x = self.packer.unpack(data, offset) + x, size = self.packer.unpack(data, offset, ntc=ntc) r.append(x) - offset += self.packer.size - return r + offset += size + total += size + return r, total class VLAList_legacy(): @@ -164,8 +241,6 @@ 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) @@ -174,22 +249,23 @@ class VLAList_legacy(): b += self.packer.pack(e) return b - def unpack(self, data, offset=0, result=None): + def unpack(self, data, offset=0, result=None, ntc=False): + total = 0 # Return a list of arguments if (len(data) - offset) % self.packer.size: - raise ValueError('Legacy Variable Length Array length mismatch.') + raise VPPSerializerValueError( + '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, ntc=ntc) r.append(x) offset += self.packer.size - return r + total += size + return r, total -class VPPEnumType(): +class VPPEnumType(object): def __init__(self, name, msgdef): self.size = types['u32'].size e_hash = {} @@ -202,21 +278,22 @@ class VPPEnumType(): e_hash[ename] = evalue self.enum = IntEnum(name, e_hash) types[name] = self - logger.debug('Adding enum {}'.format(name)) def __getattr__(self, name): return self.enum[name] + def __nonzero__(self): + return True + def pack(self, data, kwargs=None): - logger.debug("Data: {}".format(data)) - return types['u32'].pack(data, kwargs) + return types['u32'].pack(data) - def unpack(self, data, offset=0, result=None): - x = types['u32'].unpack(data, offset) - return self.enum(x) + def unpack(self, data, offset=0, result=None, ntc=False): + x, size = types['u32'].unpack(data, offset) + return self.enum(x), size -class VPPUnionType(): +class VPPUnionType(object): def __init__(self, name, msgdef): self.name = name self.size = 0 @@ -230,7 +307,8 @@ class VPPUnionType(): f_type, f_name = f if f_type not in types: logger.debug('Unknown union type {}'.format(f_type)) - raise ValueError('Unknown message type {}'.format(f_type)) + raise VPPSerializerValueError( + 'Unknown message type {}'.format(f_type)) fields.append(f_name) size = types[f_type].size self.packers[f_name] = types[f_type] @@ -240,28 +318,70 @@ class VPPUnionType(): types[name] = self self.tuple = collections.namedtuple(name, fields, rename=True) - logger.debug('Adding union {}'.format(name)) + # Union of variable length? def pack(self, data, kwargs=None): - logger.debug("Data: {}".format(data)) + if not data: + return b'\x00' * self.size + 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): + def unpack(self, data, offset=0, result=None, ntc=False): 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, ntc=ntc) + if size > maxsize: + maxsize = size + r.append(x) + return self.tuple._make(r), maxsize + + +class VPPTypeAlias(object): + def __init__(self, name, msgdef): + self.name = name + t = vpp_get_type(msgdef['type']) + if not t: + raise ValueError() + if 'length' in msgdef: + if msgdef['length'] == 0: + raise ValueError() + if msgdef['type'] == 'u8': + self.packer = FixedList_u8(name, msgdef['type'], + msgdef['length']) + self.size = self.packer.size + else: + self.packer = FixedList(name, msgdef['type'], msgdef['length']) + else: + self.packer = t + self.size = t.size + types[name] = self + + def pack(self, data, kwargs=None): + if data and conversion_required(data, self.name): + try: + return conversion_packer(data, self.name) + # Python 2 and 3 raises different exceptions from inet_pton + except(OSError, socket.error, TypeError): + pass + + return self.packer.pack(data, kwargs) -class VPPType(): + def unpack(self, data, offset=0, result=None, ntc=False): + t, size = self.packer.unpack(data, offset, result, ntc=ntc) + if not ntc: + return conversion_unpacker(t, self.name), size + return t, size + + +class VPPType(object): # Set everything up to be able to pack / unpack def __init__(self, name, msgdef): self.name = name @@ -281,13 +401,14 @@ class VPPType(): self.fieldtypes.append(f_type) if f_type not in types: logger.debug('Unknown type {}'.format(f_type)) - raise ValueError('Unknown message type {}'.format(f_type)) + raise VPPSerializerValueError( + 'Unknown message type {}'.format(f_type)) if len(f) == 3: # list list_elements = f[2] if list_elements == 0: p = VLAList_legacy(f_name, f_type) self.packers.append(p) - elif f_type == 'u8': + elif f_type == 'u8' or f_type == 'string': p = FixedList_u8(f_name, f_type, list_elements) self.packers.append(p) size += p.size @@ -296,10 +417,9 @@ class VPPType(): self.packers.append(p) size += p.size elif len(f) == 4: # Variable length list - # Find index of length field - length_index = self.fields.index(f[3]) - p = VLAList(f_name, f_type, f[3], length_index) - self.packers.append(p) + length_index = self.fields.index(f[3]) + p = VLAList(f_name, f_type, f[3], length_index) + self.packers.append(p) else: self.packers.append(types[f_type]) size += types[f_type].size @@ -307,36 +427,51 @@ class VPPType(): self.size = size self.tuple = collections.namedtuple(name, self.fields, rename=True) types[name] = self - logger.debug('Adding type {}'.format(name)) 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 + # Try one of the format functions + if data and conversion_required(data, self.name): + return conversion_packer(data, self.name) + + for i, a in enumerate(self.fields): + if data and type(data) is not dict and a not in data: + raise VPPSerializerValueError( + "Invalid argument: {} expected {}.{}". + format(data, self.name, a)) + + # Defaulting to zero. + if not data or a not in data: # Default to 0 + arg = None + kwarg = None # No default for VLA + else: + arg = data[a] + kwarg = kwargs[a] if a in kwargs else None if isinstance(self.packers[i], VPPType): - b += self.packers[i].pack(data[a], kwargs[a]) + b += self.packers[i].pack(arg, kwarg) else: - b += self.packers[i].pack(data[a], kwargs) + b += self.packers[i].pack(arg, kwargs) + return b - def unpack(self, data, offset=0, result=None): + def unpack(self, data, offset=0, result=None, ntc=False): # 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, ntc) 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) + if not ntc: + t = conversion_unpacker(t, self.name) + return t, total class VPPMessage(VPPType):