Move information about expected binary size of each multiaddr protocol into the codec registry

Avoids the current duplication of information and reduces the number of possible error cases.

Author: ntninja

multiaddr/codec.py

@@ -1,17 +1,28 @@
+# -*- encoding: utf-8 -*-
 from __future__ import absolute_import
 import importlib
 
+import six
 import varint
 
 from .protocols import protocol_with_code
 from .protocols import protocol_with_name
 from .protocols import read_varint_code
 
 
+# These are special sizes
+LENGTH_PREFIXED_VAR_SIZE = -1
+
+
+class NoneCodec:
+	SIZE = 0
+	IS_PATH = False
+
+
 CODEC_CACHE = {}
 def find_codec_by_name(name):
-    if not name:
-        raise ValueError("unknown protocol codec")
+    if name is None:  # Special “do nothing – expect nothing” pseudo-codec
+        return NoneCodec
     codec = CODEC_CACHE.get(name)
     if not codec:
         codec = CODEC_CACHE[name] = importlib.import_module(".codecs.{0}".format(name), __package__)
@@ -34,16 +45,17 @@ def string_to_bytes(string):
         element = sp.pop(0)
         proto = protocol_with_name(element)
         bs.append(varint.encode(proto.code))
-        if proto.size == 0:
+        try:
+            codec = find_codec_by_name(proto.codec)
+        except ImportError as exc:
+            six.raise_from(ValueError("failed to parse %s addr: unknown" % proto.name), exc)
+        if codec.SIZE == 0:
             continue
         if len(sp) < 1:
             raise ValueError(
                 "protocol requires address, none given: %s" % proto.name)
-        if proto.path:
+        if codec.IS_PATH:
             sp = ["/" + "/".join(sp)]
-        if not proto.codec:
-            raise ValueError("failed to parse %s addr: unknown" % proto.name)
-        codec = find_codec_by_name(proto.codec)
         bs.append(codec.to_bytes(proto, sp.pop(0)))
     return b''.join(bs)
 
@@ -56,21 +68,24 @@ def bytes_to_string(buf):
         buf = buf[num_bytes_read:]
         proto = protocol_with_code(code)
         maddr_component += proto.name
-        size = size_for_addr(proto, buf)
-        if size > 0:
+        try:
             codec = find_codec_by_name(proto.codec)
+        except ImportError as exc:
+            six.raise_from(ValueError("failed to parse %s addr: unknown" % proto.name), exc)
+        size = size_for_addr(codec, buf)
+        if size > 0:
             addr = codec.to_string(proto, buf[:size])
-            if not (proto.path and addr[0] == '/'):
+            if not (codec.IS_PATH and addr[0] == '/'):
                 maddr_component += '/'
             maddr_component += addr
         st.append(maddr_component)
         buf = buf[size:]
     return '/'.join(st)
 
 
-def size_for_addr(proto, buf):
-    if proto.size >= 0:
-        return proto.size // 8
+def size_for_addr(codec, buf):
+    if codec.SIZE >= 0:
+        return codec.SIZE // 8
     else:
         size, num_bytes_read = read_varint_code(buf)
         return size + num_bytes_read
@@ -81,7 +96,11 @@ def bytes_split(buf):
     while buf:
         code, num_bytes_read = read_varint_code(buf)
         proto = protocol_with_code(code)
-        size = size_for_addr(proto, buf[num_bytes_read:])
+        try:
+            codec = find_codec_by_name(proto.codec)
+        except ImportError as exc:
+            six.raise_from(ValueError("failed to parse %s addr: unknown" % proto.name), exc)
+        size = size_for_addr(codec, buf[num_bytes_read:])
         length = size + num_bytes_read
         ret.append(buf[:length])
         buf = buf[length:]

multiaddr/codecs/fspath.py

@@ -4,9 +4,14 @@
 import six
 import varint
 
+from ..codec import LENGTH_PREFIXED_VAR_SIZE
 from ..protocols import read_varint_code
 
 
+SIZE = LENGTH_PREFIXED_VAR_SIZE
+IS_PATH = True
+
+
 if hasattr(os, "fsencode") and hasattr(os, "fsdecode"):
     fsencode = os.fsencode
     fsdecode = os.fsdecode

multiaddr/codecs/idna.py

@@ -3,9 +3,14 @@
 import idna
 import varint
 
+from ..codec import LENGTH_PREFIXED_VAR_SIZE
 from ..protocols import read_varint_code
 
 
+SIZE = LENGTH_PREFIXED_VAR_SIZE
+IS_PATH = False
+
+
 def to_bytes(proto, string):
 	bytes = idna.encode(string, uts46=True)
 	size = varint.encode(len(bytes))

multiaddr/codecs/ip4.py

@@ -6,6 +6,10 @@
 from ..util import packed_net_bytes_to_int
 
 
+SIZE = 32
+IS_PATH = False
+
+
 def to_bytes(proto, string):
 	try:
 		return netaddr.IPAddress(string, version=4).packed

multiaddr/codecs/ip6.py

@@ -6,6 +6,10 @@
 from ..util import packed_net_bytes_to_int
 
 
+SIZE = 128
+IS_PATH = False
+
+
 def to_bytes(proto, string):
 	try:
 		return netaddr.IPAddress(string, version=6).packed

multiaddr/codecs/onion.py

@@ -5,6 +5,10 @@
 import six
 
 
+SIZE = 96
+IS_PATH = False
+
+
 def to_bytes(proto, string):
 	addr = string.split(":")
 	if len(addr) != 2:

multiaddr/codecs/p2p.py

@@ -4,9 +4,14 @@
 import six
 import varint
 
+from ..codec import LENGTH_PREFIXED_VAR_SIZE
 from ..protocols import read_varint_code
 
 
+SIZE = LENGTH_PREFIXED_VAR_SIZE
+IS_PATH = False
+
+
 def to_bytes(proto, string):
 	# the address is a base58-encoded string
 	try:

multiaddr/codecs/uint16be.py

@@ -4,6 +4,10 @@
 import six
 
 
+SIZE = 16
+IS_PATH = False
+
+
 def to_bytes(proto, string):
 	try:
 		return struct.pack('>H', int(string, 10))

multiaddr/multiaddr.py

@@ -3,6 +3,7 @@
 
 import six
 
+from .codec import find_codec_by_name
 from .codec import size_for_addr
 from .codec import string_to_bytes
 from .codec import bytes_to_string
@@ -93,9 +94,13 @@ def protocols(self):
         while buf:
             code, num_bytes_read = read_varint_code(buf)
             proto = protocol_with_code(code)
+            try:
+                codec = find_codec_by_name(proto.codec)
+            except ImportError as exc:
+                six.raise_from(ValueError("failed to parse %s addr: unknown" % proto.name), exc)
             protos.append(proto)
             buf = buf[num_bytes_read:]
-            size = size_for_addr(proto, buf)
+            size = size_for_addr(codec, buf)
             buf = buf[size:]
         return protos
 

multiaddr/protocols.py

@@ -63,62 +63,64 @@
 ]
 
 
-# These are special sizes
-LENGTH_PREFIXED_VAR_SIZE = -1
-
+find_codec_by_name = None
 
 class Protocol(object):
     __slots__ = [
         "code",   # int
-        "size",   # int (-1 indicates a length-prefixed variable size)
         "name",   # string
-        "vcode",  # bytes
         "codec",  # string
-        "path",   # bool (True indicates a path protocol (eg unix, http))
     ]
 
-    def __init__(self, code, size, name, codec=None, path=False):
+    def __init__(self, code, name, codec):
         if not isinstance(code, six.integer_types):
             raise ValueError("code must be an integer")
-        if not isinstance(size, six.integer_types):
-            raise ValueError("size must be an integer")
         if not isinstance(name, six.string_types):
             raise ValueError("name must be a string")
-        if not isinstance(codec, six.string_types) and codec is not None:
+        if not isinstance(codec, six.string_types) and not codec is None:
             raise ValueError("codec must be a string or None")
-        if not isinstance(path, bool):
-            raise ValueError("path must be a boolean")
 
         if code not in _CODES and code != 0:
             raise ValueError("Invalid code '%d'" % code)
 
-        if size < -1 or size > 128:
-            raise ValueError("Invalid size")
         self.code = code
-        self.size = size
         self.name = name
-        self.vcode = varint.encode(code)
         self.codec = codec
-        self.path = path
+
+    @property
+    def size(self):
+        global find_codec_by_name
+        if find_codec_by_name is None:
+            from .codec import find_codec_by_name
+
+        return find_codec_by_name(self.codec).SIZE
+
+    @property
+    def path(self):
+        global find_codec_by_name
+        if find_codec_by_name is None:
+            from .codec import find_codec_by_name
+
+        return find_codec_by_name(self.codec).IS_PATH
+
+    @property
+    def vcode(self):
+        return varint.encode(self.code)
 
     def __eq__(self, other):
         return all((self.code == other.code,
-                    self.size == other.size,
                     self.name == other.name,
-                    self.vcode == other.vcode,
                     self.codec == other.codec,
                     self.path == other.path))
 
     def __ne__(self, other):
         return not self == other
 
     def __repr__(self):
-        return "Protocol(code={code}, name='{name}', size={size}, codec={codec!r}, path={path})".format(
+        return "Protocol(code={code!r}, name={name!r}, codec={codec!r})".format(
             code=self.code,
-            size=self.size,
             name=self.name,
             codec=self.codec,
-            path=self.path,
         )
 
 
@@ -147,31 +149,31 @@ def read_varint_code(buf):
 
 # Protocols is the list of multiaddr protocols supported by this module.
 PROTOCOLS = [
-    Protocol(P_IP4, 32, 'ip4', 'ip4'),
-    Protocol(P_TCP, 16, 'tcp', 'uint16be'),
-    Protocol(P_UDP, 16, 'udp', 'uint16be'),
-    Protocol(P_DCCP, 16, 'dccp', 'uint16be'),
-    Protocol(P_IP6, 128, 'ip6', 'ip6'),
-    Protocol(P_IP6ZONE,	LENGTH_PREFIXED_VAR_SIZE, 'ip6zone'),
-    Protocol(P_DNS, LENGTH_PREFIXED_VAR_SIZE, 'dns', 'idna'),
-    Protocol(P_DNS4, LENGTH_PREFIXED_VAR_SIZE, 'dns4', 'idna'),
-    Protocol(P_DNS6, LENGTH_PREFIXED_VAR_SIZE, 'dns6', 'idna'),
-    Protocol(P_DNSADDR,	LENGTH_PREFIXED_VAR_SIZE, 'dnsaddr', 'idna'),
-    Protocol(P_SCTP, 16, 'sctp', 'uint16be'),
-    Protocol(P_UDT, 0, 'udt'),
-    Protocol(P_UTP, 0, 'utp'),
-    Protocol(P_P2P, LENGTH_PREFIXED_VAR_SIZE, 'p2p', 'p2p'),
-    Protocol(P_ONION, 96, 'onion', 'onion'),
-    Protocol(P_QUIC, 0, 'quic'),
-    Protocol(P_HTTP, 0, 'http'),
-    Protocol(P_HTTPS, 0, 'https'),
-    Protocol(P_WS, 0, 'ws'),
-    Protocol(P_WSS, 0, 'wss'),
-    Protocol(P_P2P_WEBSOCKET_STAR, 0, 'p2p-websocket-star'),
-    Protocol(P_P2P_WEBRTC_STAR, 0, 'p2p-webrtc-star'),
-    Protocol(P_P2P_WEBRTC_DIRECT, 0, 'p2p-webrtc-direct'),
-    Protocol(P_P2P_CIRCUIT, 0, 'p2p-circuit'),
-    Protocol(P_UNIX, LENGTH_PREFIXED_VAR_SIZE, 'unix', 'fspath', path=True),
+    Protocol(P_IP4, 'ip4', 'ip4'),
+    Protocol(P_TCP, 'tcp', 'uint16be'),
+    Protocol(P_UDP, 'udp', 'uint16be'),
+    Protocol(P_DCCP, 'dccp', 'uint16be'),
+    Protocol(P_IP6, 'ip6', 'ip6'),
+    Protocol(P_IP6ZONE, 'ip6zone', '?'),
+    Protocol(P_DNS, 'dns', 'idna'),
+    Protocol(P_DNS4, 'dns4', 'idna'),
+    Protocol(P_DNS6, 'dns6', 'idna'),
+    Protocol(P_DNSADDR, 'dnsaddr', 'idna'),
+    Protocol(P_SCTP, 'sctp', 'uint16be'),
+    Protocol(P_UDT, 'udt', None),
+    Protocol(P_UTP, 'utp', None),
+    Protocol(P_P2P, 'p2p', 'p2p'),
+    Protocol(P_ONION, 'onion', 'onion'),
+    Protocol(P_QUIC, 'quic', None),
+    Protocol(P_HTTP, 'http', None),
+    Protocol(P_HTTPS, 'https', None),
+    Protocol(P_WS, 'ws', None),
+    Protocol(P_WSS, 'wss', None),
+    Protocol(P_P2P_WEBSOCKET_STAR, 'p2p-websocket-star', None),
+    Protocol(P_P2P_WEBRTC_STAR, 'p2p-webrtc-star', None),
+    Protocol(P_P2P_WEBRTC_DIRECT, 'p2p-webrtc-direct', None),
+    Protocol(P_P2P_CIRCUIT, 'p2p-circuit', None),
+    Protocol(P_UNIX, 'unix', 'fspath'),
 ]
 
 _names_to_protocols = dict((proto.name, proto) for proto in PROTOCOLS)