update protocol codes to match the one from https://github.com/multiformats/multicodec/

Author: zaibon

multiaddr/codec.py

@@ -9,7 +9,7 @@
 from .protocols import P_DCCP
 from .protocols import P_IP4
 from .protocols import P_IP6
-from .protocols import P_IPFS
+from .protocols import P_P2P
 from .protocols import P_ONION
 from .protocols import protocol_with_code
 from .protocols import protocol_with_name
@@ -126,18 +126,18 @@ def address_string_to_bytes(proto, addr_string):
 
         return b''.join([onion_host_bytes,
                          binascii.hexlify(encode_big_endian_16(port))])
-    elif proto.code == P_IPFS:  # ipfs
+    elif proto.code == P_P2P:  # ipfs
         # the address is a varint prefixed multihash string representation
         try:
             mm = base58.b58decode(addr_string)
         except Exception as ex:
-            raise ValueError("failed to parse ipfs addr: %s %s"
+            raise ValueError("failed to parse p2p addr: %s %s"
                              % (addr_string, str(ex)))
         size = code_to_varint(len(mm))
         mm = binascii.hexlify(mm)
         if len(mm) < 10:
             # TODO - port go-multihash so we can do this correctly
-            raise ValueError("invalid IPFS multihash: %s" % mm)
+            raise ValueError("invalid P2P multihash: %s" % mm)
         return b''.join([size, mm])
     else:
         raise ValueError("failed to parse %s addr: unknown" % proto.name)
@@ -157,7 +157,7 @@ def address_bytes_to_string(proto, buf):
         addr = base64.b32encode(addr_bytes).decode('ascii').lower()
         port = str(decode_big_endian_16(port_bytes))
         return ':'.join([addr, port])
-    elif proto.code == P_IPFS:
+    elif proto.code == P_P2P:
         buf = binascii.unhexlify(buf)
         size, num_bytes_read = read_varint_code(buf)
         buf = buf[num_bytes_read:]

multiaddr/protocols.csv

@@ -3,64 +3,63 @@
 import six
 import varint
 
+# source of protocols https://github.com/multiformats/multicodec/blob/master/table.csv#L382
 # replicating table here to:
 # 1. avoid parsing the csv
 # 2. ensuring errors in the csv don't screw up code.
 # 3. changing a number has to happen in two places.
-P_IP4 = 4
-P_TCP = 6
-P_UDP = 17
-P_DCCP = 33
-P_IP6 = 41
-P_IP6ZONE = 42  # rfc4007 IPv6 zone
-P_DNS = 53		# reserved
-P_DNS4 = 54
-P_DNS6 = 55
-P_DNSADDR = 56
-P_SCTP = 132
-P_UDT = 301
-P_UTP = 302
-P_UNIX = 400
-P_P2P = 421		# preferred over /ipfs
-P_IPFS = 421  # backwards compatibility; equivalent to /p2p
-P_ONION = 444
-P_QUIC = 460
-P_HTTP = 480
-P_HTTPS = 443
-P_WS = 477
-P_WSS = 478
-P_P2P_WEBSOCKET_STAR = 479
-P_P2P_WEBRTC_STAR = 275
-P_P2P_WEBRTC_DIRECT = 276
-P_P2P_CIRCUIT = 290
+P_IP4 = 0x04
+P_IP6 = 0x29
+P_IP6ZONE = 0x2A
+P_TCP = 0x06
+P_UDP = 0x0111
+P_DCCP = 0x21
+P_SCTP = 0x84
+P_UDT = 0x012D
+P_UTP = 0x012E
+P_P2P = 0x01A5
+P_HTTP = 0x01E0
+P_HTTPS = 0x01BB
+P_QUIC = 0x01CC
+P_WS = 0x01DD
+P_WSS = 0x01DE
+P_ONION = 0x01BC
+P_P2P_CIRCUIT = 0x0122
+P_DNS = 0x35
+P_DNS4 = 0x36
+P_DNS6 = 0x37
+P_DNSADDR = 0x38
+P_P2P_WEBSOCKET_STAR = 0x01DF
+P_P2P_WEBRTC_STAR = 0x0113
+P_P2P_WEBRTC_DIRECT = 0x0114
+P_UNIX = 0x0190
 
 _CODES = [
     P_IP4,
+    P_IP6,
+    P_IP6ZONE,
     P_TCP,
     P_UDP,
     P_DCCP,
-    P_IP6,
-    P_IP6ZONE,
-    P_DNS,
-    P_DNS4,
-    P_DNS6,
-    P_DNSADDR,
     P_SCTP,
     P_UDT,
     P_UTP,
-    P_UNIX,
     P_P2P,
-    P_IPFS,
-    P_ONION,
-    P_QUIC,
     P_HTTP,
     P_HTTPS,
+    P_QUIC,
     P_WS,
     P_WSS,
+    P_ONION,
+    P_P2P_CIRCUIT,
+    P_DNS,
+    P_DNS4,
+    P_DNS6,
+    P_DNSADDR,
     P_P2P_WEBSOCKET_STAR,
     P_P2P_WEBRTC_STAR,
     P_P2P_WEBRTC_DIRECT,
-    P_P2P_CIRCUIT,
+    P_UNIX,
 ]
 
 
@@ -103,7 +102,7 @@ def __eq__(self, other):
                     self.vcode == other.vcode))
 
     def __ne__(self, other):
-        return not (self == other)
+        return not self == other
 
     def __repr__(self):
         return "Protocol(code={code}, name='{name}', size={size})".format(
@@ -159,9 +158,7 @@ def read_varint_code(buf):
     Protocol(P_SCTP, 16, 'sctp', code_to_varint(P_SCTP)),
     Protocol(P_UDT, 0, 'udt', code_to_varint(P_UDT)),
     Protocol(P_UTP, 0, 'utp', code_to_varint(P_UTP)),
-    Protocol(P_UNIX, LENGTH_PREFIXED_VAR_SIZE, 'unix', code_to_varint(P_UNIX)),
-    Protocol(P_P2P,	LENGTH_PREFIXED_VAR_SIZE, 'p2p', code_to_varint(P_P2P)),
-    Protocol(P_IPFS, LENGTH_PREFIXED_VAR_SIZE, 'ipfs', code_to_varint(P_IPFS)),
+    Protocol(P_P2P, LENGTH_PREFIXED_VAR_SIZE, 'p2p', code_to_varint(P_P2P)),
     Protocol(P_ONION, 96, 'onion', code_to_varint(P_ONION)),
     Protocol(P_QUIC, 0, 'quic', code_to_varint(P_QUIC)),
     Protocol(P_HTTP, 0, 'http', code_to_varint(P_HTTP)),
@@ -172,6 +169,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)),
 ]
 
 _names_to_protocols = dict((proto.name, proto) for proto in PROTOCOLS)

multiaddr/protocols.py

@@ -20,38 +20,38 @@
     (_names_to_protocols['tcp'], b'abcd', '43981'),
     (_names_to_protocols['onion'], b'9a18087306369043091f04d2',
      'timaq4ygg2iegci7:1234'),
-    (_names_to_protocols['ipfs'],
+    (_names_to_protocols['p2p'],
      b'221220d52ebb89d85b02a284948203a62ff28389c57c9f42beec4ec20db76a68911c0b',
      'QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC'),
 ]
 
 BYTES_MAP_STR_TEST_DATA = [
-    ("/ip4/127.0.0.1/udp/1234", b'047f0000011104d2'),
+    ("/ip4/127.0.0.1/udp/1234", b'047f000001910204d2'),
     ("/ip4/127.0.0.1/tcp/4321", b'047f0000010610e1'),
     ("/ip4/127.0.0.1/udp/1234/ip4/127.0.0.1/tcp/4321",
-     b'047f0000011104d2047f0000010610e1')
+     b'047f000001910204d2047f0000010610e1')
 ]
 
 
 @pytest.mark.parametrize("proto, buf, expected", [
     (_names_to_protocols['https'], b'\x01\x02\x03', 0),
     (_names_to_protocols['ip4'], b'\x01\x02\x03', 4),
-    (_names_to_protocols['ipfs'], b'\x40\x50\x60\x51', 65),
+    (_names_to_protocols['p2p'], b'\x40\x50\x60\x51', 65),
 ])
 def test_size_for_addr(proto, buf, expected):
     assert size_for_addr(proto, buf) == expected
 
 
 @pytest.mark.parametrize("buf, expected", [
     # "/ip4/127.0.0.1/udp/1234/ip4/127.0.0.1/tcp/4321"
-    (b'047f0000011104d2047f0000010610e1',
+    (b'047f000001910204d2047f0000010610e1',
      [b'\x04\x7f\x00\x00\x01',
-      b'\x11\x04\xd2',
+      b'\x91\x02\04\xd2',
       b'\x04\x7f\x00\x00\x01',
       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)
@@ -103,7 +103,7 @@ def __init__(self, code, size, name, vcode):
     (_names_to_protocols['onion'], 'timaq4ygg2iegci7:a'),
     (_names_to_protocols['onion'], 'timaq4ygg2iegci7:0'),
     (_names_to_protocols['onion'], 'timaq4ygg2iegci7:71234'),
-    (_names_to_protocols['ipfs'], '15230d52ebb89d85b02a284948203a'),
+    (_names_to_protocols['p2p'], '15230d52ebb89d85b02a284948203a'),
 ])
 def test_address_string_to_bytes_value_error(proto, address):
     with pytest.raises(ValueError):
@@ -112,7 +112,7 @@ def test_address_string_to_bytes_value_error(proto, address):
 
 @pytest.mark.parametrize("proto, buf", [
     (DummyProtocol(234, 32, 'test', b'123'), b'0a0b0c0d'),
-    (_names_to_protocols['ipfs'], b'15230d52ebb89d85b02a284948203a'),
+    (_names_to_protocols['p2p'], b'15230d52ebb89d85b02a284948203a'),
     (_names_to_protocols['tcp'], b'ffffffff')
 ])
 def test_address_bytes_to_string_value_error(proto, buf):

tests/test_codec.py

@@ -8,7 +8,7 @@
 from multiaddr.protocols import protocols_with_string
 from multiaddr.protocols import P_IP4
 from multiaddr.protocols import P_IP6
-from multiaddr.protocols import P_IPFS
+from multiaddr.protocols import P_P2P
 from multiaddr.protocols import P_UTP
 from multiaddr.protocols import P_TCP
 from multiaddr.protocols import P_UDP
@@ -40,8 +40,8 @@
      "/ip4/127.0.0.1/udp",
      "/ip4/127.0.0.1/tcp/jfodsajfidosajfoidsa",
      "/ip4/127.0.0.1/tcp",
-     "/ip4/127.0.0.1/ipfs",
-     "/ip4/127.0.0.1/ipfs/tcp"])
+     "/ip4/127.0.0.1/p2p",
+     "/ip4/127.0.0.1/p2p/tcp"])
 def test_invalid(addr_str):
     with pytest.raises(ValueError):
         Multiaddr(addr_str)
@@ -63,19 +63,19 @@ def test_invalid(addr_str):
      "/sctp/1234",
      "/udp/65535",
      "/tcp/65535",
-     "/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC",
+     "/p2p/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC",
      "/udp/1234/sctp/1234",
      "/udp/1234/udt",
      "/udp/1234/utp",
      "/tcp/1234/http",
      "/tcp/1234/https",
-     "/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC/tcp/1234",
+     "/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/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC",
-     "/ip4/127.0.0.1/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC/tcp/1234"])  # nopep8
+     "/ip4/127.0.0.1/p2p/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC",
+     "/ip4/127.0.0.1/p2p/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC/tcp/1234"])  # nopep8
 def test_valid(addr_str):
     ma = Multiaddr(addr_str)
     assert str(ma) == addr_str.rstrip("/")
@@ -184,14 +184,14 @@ def assert_value_for_proto(multi, proto, expected):
 def test_get_value():
     ma = Multiaddr(
         "/ip4/127.0.0.1/utp/tcp/5555/udp/1234/utp/"
-        "ipfs/QmbHVEEepCi7rn7VL7Exxpd2Ci9NNB6ifvqwhsrbRMgQFP")
+        "p2p/QmbHVEEepCi7rn7VL7Exxpd2Ci9NNB6ifvqwhsrbRMgQFP")
 
     assert_value_for_proto(ma, P_IP4, "127.0.0.1")
     assert_value_for_proto(ma, P_UTP, "")
     assert_value_for_proto(ma, P_TCP, "5555")
     assert_value_for_proto(ma, P_UDP, "1234")
     assert_value_for_proto(
-        ma, P_IPFS, "QmbHVEEepCi7rn7VL7Exxpd2Ci9NNB6ifvqwhsrbRMgQFP")
+        ma, P_P2P, "QmbHVEEepCi7rn7VL7Exxpd2Ci9NNB6ifvqwhsrbRMgQFP")
 
     with pytest.raises(ProtocolNotFoundException):
         ma.value_for_protocol(P_IP6)