Add support for UNIX protocol (#32)

* Add codec for protocol `unix`

And add the attribute `path` in `Protocol`, to identify if a protocol is
a path protocol.

* Fix `bytes_to_string` and `addr_bytes_to_string`

- Fix `addr_bytes_to_string` to remove the size prefix correctly
- Fix `bytes_to_string` to handle the protocol Path correctly

* Fix `value_for_protocol` to support UNIX

And add the tests for UNIX protocol

* flake8

* Fix bug in value_for_protocol

When there is only one layer of path protocols like UNIX,
`Multiaddr("/unix/studio").value_for_protocol(P_UNIX)` gives "studio",
which is wrong.

* Add test for invalid path of protocol

Author: mhchia

multiaddr/codec.py

@@ -1,7 +1,6 @@
 import base58
 import base64
 import binascii
-import six
 
 from netaddr import IPAddress
 
@@ -16,6 +15,7 @@
 from .protocols import P_SCTP
 from .protocols import P_TCP
 from .protocols import P_UDP
+from .protocols import P_UNIX
 from .protocols import read_varint_code
 
 
@@ -40,6 +40,8 @@ def string_to_bytes(string):
         if len(sp) < 1:
             raise ValueError(
                 "protocol requires address, none given: %s" % proto.name)
+        if proto.path:
+            sp = ["/" + "/".join(sp)]
         bs.append(address_string_to_bytes(proto, sp.pop(0)))
     return b''.join(bs)
 
@@ -48,14 +50,18 @@ def bytes_to_string(buf):
     st = ['']  # start with empty string so we get a leading slash on join()
     buf = binascii.unhexlify(buf)
     while buf:
+        maddr_component = ""
         code, num_bytes_read = read_varint_code(buf)
         buf = buf[num_bytes_read:]
         proto = protocol_with_code(code)
-        st.append(proto.name)
+        maddr_component += proto.name
         size = size_for_addr(proto, buf)
         if size > 0:
             addr = address_bytes_to_string(proto, binascii.hexlify(buf[:size]))
-            st.append(addr)
+            if not (proto.path and addr[0] == '/'):
+                maddr_component += '/'
+            maddr_component += addr
+        st.append(maddr_component)
         buf = buf[size:]
     return '/'.join(st)
 
@@ -149,6 +155,10 @@ def address_string_to_bytes(proto, addr_string):
             # TODO - port go-multihash so we can do this correctly
             raise ValueError("invalid P2P multihash: %s" % mm)
         return b''.join([size, mm])
+    elif proto.code == P_UNIX:
+        addr_string_bytes = addr_string.encode("ascii")
+        size = code_to_varint(len(addr_string_bytes))
+        return b''.join([size, binascii.hexlify(addr_string_bytes)])
     else:
         raise ValueError("failed to parse %s addr: unknown" % proto.name)
 
@@ -179,6 +189,10 @@ def address_bytes_to_string(proto, buf):
         if len(buf) != size:
             raise ValueError("inconsistent lengths")
         return base58.b58encode(buf).decode()
+    elif proto.code == P_UNIX:
+        buf = binascii.unhexlify(buf)
+        size, num_bytes_read = read_varint_code(buf)
+        return buf[num_bytes_read:].decode('ascii')
     raise ValueError("unknown protocol")
 
 

multiaddr/multiaddr.py

@@ -5,7 +5,6 @@
 from .codec import size_for_addr
 from .codec import string_to_bytes
 from .codec import bytes_to_string
-from .codec import protocol_with_name
 from .protocols import protocol_with_code
 from .protocols import read_varint_code
 
@@ -117,13 +116,16 @@ def value_for_protocol(self, code):
         """Return the value (if any) following the specified protocol."""
         from .util import split
 
-        if isinstance(code, str):
-            protocol = protocol_with_name(code)
-            code = protocol.code
+        if not isinstance(code, int):
+            raise ValueError("code type should be `int`, code={}".format(code))
 
         for sub_addr in split(self):
-            if sub_addr.protocols()[0].code == code:
+            protocol = sub_addr.protocols()[0]
+            if protocol.code == code:
+                # e.g. if `sub_addr=/unix/123`, then `addr_parts=['', 'unix', '123']`
                 addr_parts = str(sub_addr).split("/")
+                if protocol.path:
+                    return "/" + "/".join(addr_parts[2:])
                 if len(addr_parts) > 3:
                     raise ValueError("Unknown Protocol format")
                 elif len(addr_parts) == 3:

multiaddr/protocols.py

@@ -73,9 +73,10 @@ class Protocol(object):
         "size",   # int (-1 indicates a length-prefixed variable size)
         "name",   # string
         "vcode",  # bytes
+        "path",   # bool (True indicates a path protocol (eg unix, http))
     ]
 
-    def __init__(self, code, size, name, vcode):
+    def __init__(self, code, size, name, vcode, path=False):
         if not isinstance(code, six.integer_types):
             raise ValueError("code must be an integer")
         if not isinstance(size, six.integer_types):
@@ -84,6 +85,8 @@ def __init__(self, code, size, name, vcode):
             raise ValueError("name must be a string")
         if not isinstance(vcode, six.binary_type):
             raise ValueError("vcode must be binary")
+        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)
@@ -94,21 +97,25 @@ def __init__(self, code, size, name, vcode):
         self.size = size
         self.name = name
         self.vcode = vcode
+        self.path = path
 
     def __eq__(self, other):
         return all((self.code == other.code,
                     self.size == other.size,
                     self.name == other.name,
-                    self.vcode == other.vcode))
+                    self.vcode == other.vcode,
+                    self.path == other.path))
 
     def __ne__(self, other):
         return not self == other
 
     def __repr__(self):
-        return "Protocol(code={code}, name='{name}', size={size})".format(
+        return "Protocol(code={code}, name='{name}', size={size}, path={path})".format(
             code=self.code,
             size=self.size,
-            name=self.name)
+            name=self.name,
+            path=self.path,
+        )
 
 
 def code_to_varint(num):
@@ -169,7 +176,7 @@ def read_varint_code(buf):
     Protocol(P_P2P_WEBRTC_STAR, 0, 'p2p-webrtc-star', code_to_varint(P_P2P_WEBRTC_STAR)),
     Protocol(P_P2P_WEBRTC_DIRECT, 0, 'p2p-webrtc-direct', code_to_varint(P_P2P_WEBRTC_DIRECT)),
     Protocol(P_P2P_CIRCUIT, 0, 'p2p-circuit', code_to_varint(P_P2P_CIRCUIT)),
-    Protocol(P_UNIX, LENGTH_PREFIXED_VAR_SIZE, 'unix', code_to_varint(P_UNIX)),
+    Protocol(P_UNIX, LENGTH_PREFIXED_VAR_SIZE, 'unix', code_to_varint(P_UNIX), path=True),
 ]
 
 _names_to_protocols = dict((proto.name, proto) for proto in PROTOCOLS)

tests/test_codec.py

@@ -51,7 +51,7 @@ def test_size_for_addr(proto, buf, expected):
       b'\x06\x10\xe1']),
 ])
 def test_bytes_split(buf, expected):
-    assert  bytes_split(buf) == expected
+    assert bytes_split(buf) == expected
 
 
 @pytest.mark.parametrize("proto, buf, expected", ADDR_BYTES_MAP_STR_TEST_DATA)
@@ -85,11 +85,12 @@ def test_string_to_bytes_value_error(string):
 
 
 class DummyProtocol(Protocol):
-    def __init__(self, code, size, name, vcode):
+    def __init__(self, code, size, name, vcode, path=False):
         self.code = code
         self.size = size
         self.name = name
         self.vcode = vcode
+        self.path = path
 
 
 @pytest.mark.parametrize("proto, address", [

tests/test_multiaddr.py

@@ -12,6 +12,7 @@
 from multiaddr.protocols import P_UTP
 from multiaddr.protocols import P_TCP
 from multiaddr.protocols import P_UDP
+from multiaddr.protocols import P_UNIX
 from multiaddr.util import split
 from multiaddr.util import join
 
@@ -41,7 +42,10 @@
      "/ip4/127.0.0.1/tcp/jfodsajfidosajfoidsa",
      "/ip4/127.0.0.1/tcp",
      "/ip4/127.0.0.1/p2p",
-     "/ip4/127.0.0.1/p2p/tcp"])
+     "/ip4/127.0.0.1/p2p/tcp",
+     "/unix",
+     "/ip4/1.2.3.4/tcp/80/unix",
+     "/ip4/127.0.0.1/tcp/9090/http/p2p-webcrt-direct"])
 def test_invalid(addr_str):
     with pytest.raises(ValueError):
         Multiaddr(addr_str)
@@ -71,11 +75,12 @@ def test_invalid(addr_str):
      "/tcp/1234/https",
      "/p2p/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC/tcp/1234",
      "/ip4/127.0.0.1/udp/1234",
-     "/ip4/127.0.0.1/udp/0",
-     "/ip4/127.0.0.1/tcp/1234",
-     "/ip4/127.0.0.1/tcp/1234/",
-     "/ip4/127.0.0.1/p2p/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC",
-     "/ip4/127.0.0.1/p2p/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC/tcp/1234"])  # nopep8
+     "/ip4/127.0.0.1/p2p/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC/tcp/1234",
+     "/unix/a/b/c/d/e",
+     "/unix/stdio",
+     "/ip4/1.2.3.4/tcp/80/unix/a/b/c/d/e/f",
+     "/ip4/127.0.0.1/p2p/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC/tcp/1234/unix/stdio",
+     "/ip4/127.0.0.1/tcp/9090/http/p2p-webrtc-direct"])  # nopep8
 def test_valid(addr_str):
     ma = Multiaddr(addr_str)
     assert str(ma) == addr_str.rstrip("/")
@@ -207,6 +212,13 @@ def test_get_value():
     assert_value_for_proto(a, P_UDP, "12345")
     assert_value_for_proto(a, P_UTP, "")
 
+    a = Multiaddr("/ip4/0.0.0.0/unix/a/b/c/d")  # ending in a path one.
+    assert_value_for_proto(a, P_IP4, "0.0.0.0")
+    assert_value_for_proto(a, P_UNIX, "/a/b/c/d")
+
+    a = Multiaddr("/unix/studio")
+    assert_value_for_proto(a, P_UNIX, "/studio")  # only a path.
+
 
 def test_bad_initialization_no_params():
     with pytest.raises(TypeError):
@@ -238,6 +250,12 @@ def test_get_value_too_many_fields_protocol(monkeypatch):
         a.value_for_protocol(P_UDP)
 
 
+def test_value_for_protocol_argument_wrong_type():
+    a = Multiaddr("/ip4/127.0.0.1/udp/1234")
+    with pytest.raises(ValueError):
+        a.value_for_protocol('str123')
+
+
 def test_multi_addr_str_corruption():
     a = Multiaddr("/ip4/127.0.0.1/udp/1234")
     a._bytes = b"047047047"

tests/test_protocols.py

@@ -21,7 +21,8 @@ def valid_params():
     return {'code': protocols.P_IP4,
             'size': 32,
             'name': 'ipb4',
-            'vcode': protocols.code_to_varint(protocols.P_IP4)}
+            'vcode': protocols.code_to_varint(protocols.P_IP4),
+            'path': False}
 
 
 def test_valid(valid_params):
@@ -59,6 +60,13 @@ def test_invalid_vcode(valid_params, invalid_vcode):
         protocols.Protocol(**valid_params)
 
 
+@pytest.mark.parametrize("invalid_path", [123, '123', 0.123])
+def test_invalid_path(valid_params, invalid_path):
+    valid_params['path'] = invalid_path
+    with pytest.raises(ValueError):
+        protocols.Protocol(**valid_params)
+
+
 @pytest.mark.parametrize("name", ["foo-str", u"foo-u"])
 def test_valid_names(valid_params, name):
     valid_params['name'] = name
@@ -152,7 +160,7 @@ def test_add_protocol_twice(patch_protocols, valid_params):
 
 def test_protocol_repr():
     proto = protocols.protocol_with_name('ip4')
-    assert "Protocol(code=4, name='ip4', size=32)" == repr(proto)
+    assert "Protocol(code=4, name='ip4', size=32, path=False)" == repr(proto)
 
 
 @pytest.mark.parametrize("buf", [