X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvpp-api%2Fpython%2Fvpp_papi%2Fvpp_serializer.py;h=443dd83ba68854271cdbf96590cdaacb59045e4b;hb=33a58171e;hp=418c0243402bfedde012588045c5697e1917393f;hpb=413f4a5b2123c1625d615315db293a080078482b;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 418c0243402..443dd83ba68 100644
--- a/src/vpp-api/python/vpp_papi/vpp_serializer.py
+++ b/src/vpp-api/python/vpp_papi/vpp_serializer.py
@@ -12,15 +12,24 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-
-import struct
 import collections
-from enum import IntEnum
 import logging
-from . import vpp_format
-import ipaddress
-import sys
 import socket
+import struct
+import sys
+
+if sys.version_info <= (3, 4):
+    from aenum import IntEnum  # noqa: F401
+else:
+    from enum import IntEnum  # noqa: F401
+
+if sys.version_info <= (3, 6):
+    from aenum import IntFlag  # noqa: F401
+else:
+
+    from enum import IntFlag  # noqa: F401
+
+from . import vpp_format  # noqa: E402
 
 #
 # Set log-level in application by doing e.g.:
@@ -30,9 +39,10 @@ import socket
 logger = logging.getLogger(__name__)
 
 if sys.version[0] == '2':
-    check = lambda d: type(d) is dict
+    def check(d): type(d) is dict
 else:
-    check = lambda d: type(d) is dict or type(d) is bytes
+    def check(d): type(d) is dict or type(d) is bytes
+
 
 def conversion_required(data, field_type):
     if check(data):
@@ -57,14 +67,17 @@ def conversion_unpacker(data, field_type):
 
 
 class BaseTypes(object):
-    def __init__(self, type, elements=0):
+    def __init__(self, type, elements=0, options=None):
         base_types = {'u8': '>B',
+                      'i8': '>b',
                       'string': '>s',
                       'u16': '>H',
+                      'i16': '>h',
                       'u32': '>I',
                       'i32': '>i',
                       'u64': '>Q',
-                      'f64': '>d',
+                      'i64': '>q',
+                      'f64': '=d',
                       'bool': '>?',
                       'header': '>HI'}
 
@@ -73,10 +86,18 @@ class BaseTypes(object):
         else:
             self.packer = struct.Struct(base_types[type])
         self.size = self.packer.size
+        self.options = options
+
+    def __call__(self, args):
+        self.options = args
+        return self
 
     def pack(self, data, kwargs=None):
         if not data:  # Default to zero if not specified
-            data = 0
+            if self.options and 'default' in self.options:
+                data = self.options['default']
+            else:
+                data = 0
         return self.packer.pack(data)
 
     def unpack(self, data, offset, result=None, ntc=False):
@@ -84,31 +105,52 @@ class BaseTypes(object):
 
 
 class String(object):
-    def __init__(self):
-        self.name = 'string'
+    def __init__(self, name, num, options):
+        self.name = name
+        self.num = num
         self.size = 1
         self.length_field_packer = BaseTypes('u32')
+        self.limit = options['limit'] if 'limit' in options else num
+        self.fixed = True if num else False
+        if self.fixed and not self.limit:
+            raise VPPSerializerValueError(
+                "Invalid argument length for: {}, {} maximum {}".
+                format(list, len(list), self.limit))
 
     def pack(self, list, kwargs=None):
         if not list:
+            if self.fixed:
+                return b"\x00" * self.limit
             return self.length_field_packer.pack(0) + b""
-        return self.length_field_packer.pack(len(list)) + list.encode('utf8')
+        if self.limit and len(list) > self.limit - 1:
+            raise VPPSerializerValueError(
+                "Invalid argument length for: {}, {} maximum {}".
+                format(list, len(list), self.limit - 1))
+        if self.fixed:
+            return list.encode('ascii').ljust(self.limit, b'\x00')
+        return self.length_field_packer.pack(len(list)) + list.encode('ascii')
 
     def unpack(self, data, offset=0, result=None, ntc=False):
+        if self.fixed:
+            p = BaseTypes('u8', self.num)
+            s = p.unpack(data, offset)
+            s2 = s[0].split(b'\0', 1)[0]
+            return (s2.decode('ascii'), self.num)
+
         length, length_field_size = self.length_field_packer.unpack(data,
                                                                     offset)
         if length == 0:
-            return b'', 0
+            return '', 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)
+        #x2 = x.split(b'\0', 1)[0]
+        return (x.decode('ascii', errors='replace'), 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()}
+         'bool': BaseTypes('bool'), 'string': String}
 
 
 def vpp_get_type(name):
@@ -130,6 +172,10 @@ class FixedList_u8(object):
         self.size = self.packer.size
         self.field_type = field_type
 
+    def __call__(self, args):
+        self.options = args
+        return self
+
     def pack(self, data, kwargs=None):
         """Packs a fixed length bytestring. Left-pads with zeros
         if input data is too short."""
@@ -150,10 +196,6 @@ class FixedList_u8(object):
                 '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)
 
 
@@ -165,6 +207,10 @@ class FixedList(object):
         self.name = name
         self.field_type = field_type
 
+    def __call__(self, args):
+        self.options = args
+        return self
+
     def pack(self, list, kwargs):
         if len(list) != self.num:
             raise VPPSerializerValueError(
@@ -196,6 +242,10 @@ class VLAList(object):
         self.size = self.packer.size
         self.length_field = len_field_name
 
+    def __call__(self, args):
+        self.options = args
+        return self
+
     def pack(self, list, kwargs=None):
         if not list:
             return b""
@@ -239,6 +289,10 @@ class VLAList_legacy():
         self.packer = types[field_type]
         self.size = self.packer.size
 
+    def __call__(self, args):
+        self.options = args
+        return self
+
     def pack(self, list, kwargs=None):
         if self.packer.size == 1:
             return bytes(list)
@@ -267,28 +321,37 @@ class VLAList_legacy():
 class VPPEnumType(object):
     def __init__(self, name, msgdef):
         self.size = types['u32'].size
+        self.enumtype = 'u32'
         e_hash = {}
         for f in msgdef:
             if type(f) is dict and 'enumtype' in f:
                 if f['enumtype'] != 'u32':
-                    raise NotImplementedError
+                    self.size = types[f['enumtype']].size
+                    self.enumtype = f['enumtype']
                 continue
             ename, evalue = f
             e_hash[ename] = evalue
-        self.enum = IntEnum(name, e_hash)
+        self.enum = IntFlag(name, e_hash)
         types[name] = self
 
+    def __call__(self, args):
+        self.options = args
+        return self
+
     def __getattr__(self, name):
         return self.enum[name]
 
-    def __nonzero__(self):
+    def __bool__(self):
         return True
 
+    if sys.version[0] == '2':
+        __nonzero__ = __bool__
+
     def pack(self, data, kwargs=None):
-        return types['u32'].pack(data)
+        return types[self.enumtype].pack(data)
 
     def unpack(self, data, offset=0, result=None, ntc=False):
-        x, size = types['u32'].unpack(data, offset)
+        x, size = types[self.enumtype].unpack(data, offset)
         return self.enum(x), size
 
 
@@ -318,6 +381,10 @@ class VPPUnionType(object):
         types[name] = self
         self.tuple = collections.namedtuple(name, fields, rename=True)
 
+    def __call__(self, args):
+        self.options = args
+        return self
+
     # Union of variable length?
     def pack(self, data, kwargs=None):
         if not data:
@@ -363,6 +430,10 @@ class VPPTypeAlias(object):
 
         types[name] = self
 
+    def __call__(self, args):
+        self.options = args
+        return self
+
     def pack(self, data, kwargs=None):
         if data and conversion_required(data, self.name):
             try:
@@ -402,31 +473,51 @@ class VPPType(object):
                 logger.debug('Unknown type {}'.format(f_type))
                 raise VPPSerializerValueError(
                     'Unknown message type {}'.format(f_type))
-            if len(f) == 3:  # list
+
+            fieldlen = len(f)
+            options = [x for x in f if type(x) is dict]
+            if len(options):
+                self.options = options[0]
+                fieldlen -= 1
+            else:
+                self.options = {}
+            if fieldlen == 3:  # list
                 list_elements = f[2]
                 if list_elements == 0:
-                    p = VLAList_legacy(f_name, f_type)
+                    if f_type == 'string':
+                        p = String(f_name, 0, self.options)
+                    else:
+                        p = VLAList_legacy(f_name, f_type)
                     self.packers.append(p)
-                elif f_type == 'u8' or f_type == 'string':
+                elif f_type == 'u8':
                     p = FixedList_u8(f_name, f_type, list_elements)
                     self.packers.append(p)
                     size += p.size
+                elif f_type == 'string':
+                    p = String(f_name, list_elements, self.options)
+                    self.packers.append(p)
+                    size += p.size
                 else:
                     p = FixedList(f_name, f_type, list_elements)
                     self.packers.append(p)
                     size += p.size
-            elif len(f) == 4:  # Variable length list
+            elif fieldlen == 4:  # Variable length list
                 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
+                p = types[f_type](self.options)
+                self.packers.append(p)
+                size += p.size
 
         self.size = size
         self.tuple = collections.namedtuple(name, self.fields, rename=True)
         types[name] = self
 
+    def __call__(self, args):
+        self.options = args
+        return self
+
     def pack(self, data, kwargs=None):
         if not kwargs:
             kwargs = data