Inside Bitcoin

251        self.nodes[0].addnode(node=ip_port, command='add')
252        self.log.info("Try to add an equivalent ip and check it fails")
253        self.log.debug("(note that OpenBSD doesn't support the IPv4 shorthand notation with omitted zero-bytes)")
254        if platform.system() != "OpenBSD":
255            ip_port2 = "127.1:{}".format(p2p_port(2))
256            assert_raises_rpc_error(-23, "Node already added", self.nodes[0].addnode, node=ip_port2, command='add')
257        self.log.info("Check that the node has indeed been added")
258        added_nodes = self.nodes[0].getaddednodeinfo()
259        assert_equal(len(added_nodes), 1)
260        assert_equal(added_nodes[0]['addednode'], ip_port)
261        self.log.info("Check that filtering by node works")
262        self.nodes[0].addnode(node="11.22.33.44", command='add')
263        first_added_node = self.nodes[0].getaddednodeinfo(node=ip_port)
264        assert_equal(added_nodes, first_added_node)
265        assert_equal(len(self.nodes[0].getaddednodeinfo()), 2)
266        self.log.info("Check that node cannot be added again")
267        assert_raises_rpc_error(-23, "Node already added", self.nodes[0].addnode, node=ip_port, command='add')
268        self.log.info("Check that node can be removed")
269        self.nodes[0].addnode(node=ip_port, command='remove')
270        added_nodes = self.nodes[0].getaddednodeinfo()
271        assert_equal(len(added_nodes), 1)
272        assert_equal(added_nodes[0]['addednode'], "11.22.33.44")
273        self.log.info("Check that an invalid command returns an error")
274        assert_raises_rpc_error(-1, 'addnode "node" "command"', self.nodes[0].addnode, node=ip_port, command='abc')
275        self.log.info("Check that an empty node address returns an error")
276        for command in ['add', 'remove', 'onetry']:
277            assert_raises_rpc_error(-8, "Node address cannot be empty", self.nodes[0].addnode, node="", command=command)
278            assert_raises_rpc_error(-8, "Node address cannot be empty", self.nodes[0].addnode, node=" ", command=command)
279        assert_equal(len(self.nodes[0].getaddednodeinfo()), 1)
280        self.log.info("Check that trying to remove the node again returns an error")
281        assert_raises_rpc_error(-24, "Node could not be removed", self.nodes[0].addnode, node=ip_port, command='remove')
282        self.log.info("Check that a non-existent node returns an error")
283        assert_raises_rpc_error(-24, "Node has not been added", self.nodes[0].getaddednodeinfo, '1.1.1.1')
284
285    def test_service_flags(self):
286        self.log.info("Test service flags")
287        self.nodes[0].add_p2p_connection(P2PInterface(), services=(1 << 4) | (1 << 63))
288        if self.options.v2transport:
289            assert_equal(['UNKNOWN[2^4]', 'P2P_V2', 'UNKNOWN[2^63]'], self.nodes[0].getpeerinfo()[-1]['servicesnames'])
290        else:
291            assert_equal(['UNKNOWN[2^4]', 'UNKNOWN[2^63]'], self.nodes[0].getpeerinfo()[-1]['servicesnames'])
292        self.nodes[0].disconnect_p2ps()
293
294    def test_getnodeaddresses(self):
295        self.log.info("Test getnodeaddresses")
296        self.nodes[0].add_p2p_connection(P2PInterface())
297
298        # Add an IPv6 address to the address manager.
299        ipv6_addr = "1233:3432:2434:2343:3234:2345:6546:4534"
300        self.nodes[0].addpeeraddress(address=ipv6_addr, port=8333)
301
302        # Add 10,000 IPv4 addresses to the address manager. Due to the way bucket
303        # and bucket positions are calculated, some of these addresses will collide.
304        imported_addrs = []
305        for i in range(10000):
306            first_octet = i >> 8
307            second_octet = i % 256
308            a = f"{first_octet}.{second_octet}.1.1"
309            imported_addrs.append(a)
310            self.nodes[0].addpeeraddress(a, 8333)
311
312        # Fetch the addresses via the RPC and test the results.
313        assert_equal(len(self.nodes[0].getnodeaddresses()), 1)  # default count is 1
314        assert_equal(len(self.nodes[0].getnodeaddresses(count=2)), 2)
315        assert_equal(len(self.nodes[0].getnodeaddresses(network="ipv4", count=8)), 8)
316
317        # Maximum possible addresses in AddrMan is 10000. The actual number will
318        # usually be less due to bucket and bucket position collisions.
319        node_addresses = self.nodes[0].getnodeaddresses(0, "ipv4")
320        assert_greater_than(len(node_addresses), 5000)
321        assert_greater_than(10000, len(node_addresses))
322        for a in node_addresses:
323            assert_greater_than(a["time"], 1527811200)  # 1st June 2018
324            assert_equal(a["services"], P2P_SERVICES)
325            assert a["address"] in imported_addrs
326            assert_equal(a["port"], 8333)
327            assert_equal(a["network"], "ipv4")
328
329        # Test the IPv6 address.
330        res = self.nodes[0].getnodeaddresses(0, "ipv6")
331        assert_equal(len(res), 1)
332        assert_equal(res[0]["address"], ipv6_addr)
333        assert_equal(res[0]["network"], "ipv6")
334        assert_equal(res[0]["port"], 8333)
335        assert_equal(res[0]["services"], P2P_SERVICES)
336
337        for network in ["onion", "OnIoN", "i2p", "cjdns"]:
338            assert_equal(self.nodes[0].getnodeaddresses(0, network), [])
339
340        # Test invalid arguments.
341        assert_raises_rpc_error(-8, "Address count out of range", self.nodes[0].getnodeaddresses, -1)
342        for network in ["Foo", "tor"]:
343            assert_raises_rpc_error(-8, f"Network not recognized: {network}", self.nodes[0].getnodeaddresses, 1, network)
344
345    def test_addpeeraddress(self):
346        self.log.info("Test addpeeraddress")
347        # The node has an existing, non-deterministic addrman from a previous test.
348        # Clear it to have a deterministic addrman.
349        self.restart_node(1, ["-checkaddrman=1", "-test=addrman"], clear_addrman=True)
350        node = self.nodes[1]
351
352        self.log.debug("Test that addpeeraddress is a hidden RPC")
353        # It is hidden from general help, but its detailed help may be called directly.
354        assert "addpeeraddress" not in node.help()
355        assert "unknown command: addpeeraddress" not in node.help("addpeeraddress")
356
357        self.log.debug("Test that adding an empty address fails")
358        assert_raises_rpc_error(-30, "Invalid IP address", node.addpeeraddress, address="", port=8333)
359        assert_equal(node.getnodeaddresses(count=0), [])
360
361        self.log.debug("Test that adding a non-IP/hostname fails (no DNS lookup allowed)")
362        assert_raises_rpc_error(-30, "Invalid IP address", node.addpeeraddress, address="not_an_ip", port=8333)
363
364        self.log.debug("Test that non-bool tried fails")
365        assert_raises_rpc_error(-3, "JSON value of type string is not of expected type bool", self.nodes[0].addpeeraddress, address="1.2.3.4", tried="True", port=1234)
366
367        self.log.debug("Test that adding an address with invalid port fails")
368        assert_raises_rpc_error(-1, "JSON integer out of range", self.nodes[0].addpeeraddress, address="1.2.3.4", port=-1)
369        assert_raises_rpc_error(-1, "JSON integer out of range", self.nodes[0].addpeeraddress, address="1.2.3.4", port=65536)
370
371        self.log.debug("Test that adding a valid address to the new table succeeds")
372        assert_equal(node.addpeeraddress(address="1.0.0.0", tried=False, port=8333), {"success": True})
373        addrman = node.getrawaddrman()
374        assert_equal(len(addrman["tried"]), 0)
375        new_table = list(addrman["new"].values())
376        assert_equal(len(new_table), 1)
377        assert_equal(new_table[0]["address"], "1.0.0.0")
378        assert_equal(new_table[0]["port"], 8333)
379
380        self.log.debug("Test that adding an already-present new address to the new and tried tables fails")
381        for value in [True, False]:
382            assert_equal(node.addpeeraddress(address="1.0.0.0", tried=value, port=8333), {"success": False, "error": "failed-adding-to-new"})
383        assert_equal(len(node.getnodeaddresses(count=0)), 1)
384
385        self.log.debug("Test that adding a valid address to the tried table succeeds")
386        assert_equal(node.addpeeraddress(address="1.2.3.4", tried=True, port=8333), {"success": True})
387        addrman = node.getrawaddrman()
388        assert_equal(len(addrman["new"]), 1)
389        tried_table = list(addrman["tried"].values())
390        assert_equal(len(tried_table), 1)
391        assert_equal(tried_table[0]["address"], "1.2.3.4")
392        assert_equal(tried_table[0]["port"], 8333)
393        node.getnodeaddresses(count=0)  # getnodeaddresses re-runs the addrman checks
394
395        self.log.debug("Test that adding an already-present tried address to the new and tried tables fails")
396        for value in [True, False]:
397            assert_equal(node.addpeeraddress(address="1.2.3.4", tried=value, port=8333), {"success": False, "error": "failed-adding-to-new"})
398        assert_equal(len(node.getnodeaddresses(count=0)), 2)
399
400        self.log.debug("Test that adding an address, which collides with the address in tried table, fails")
401        colliding_address = "1.2.5.45"  # grinded address that produces a tried-table collision
402        assert_equal(node.addpeeraddress(address=colliding_address, tried=True, port=8333), {"success": False, "error": "failed-adding-to-tried"})
403        # When adding an address to the tried table, it's first added to the new table.
404        # As we fail to move it to the tried table, it remains in the new table.
405        addrman_info = node.getaddrmaninfo()
406        assert_equal(addrman_info["all_networks"]["tried"], 1)
407        assert_equal(addrman_info["all_networks"]["new"], 2)
408
409        self.log.debug("Test that adding an another address to the new table succeeds")
410        assert_equal(node.addpeeraddress(address="2.0.0.0", port=8333), {"success": True})
411        addrman_info = node.getaddrmaninfo()
412        assert_equal(addrman_info["all_networks"]["tried"], 1)
413        assert_equal(addrman_info["all_networks"]["new"], 3)
414        node.getnodeaddresses(count=0)  # getnodeaddresses re-runs the addrman checks
415
416    def test_sendmsgtopeer(self):
417        node = self.nodes[0]
418
419        self.restart_node(0)
420        # we want to use a p2p v1 connection here in order to ensure
421        # a peer id of zero (a downgrade from v2 to v1 would lead
422        # to an increase of the peer id)
423        self.connect_nodes(0, 1, peer_advertises_v2=False)
424
425        self.log.info("Test sendmsgtopeer")
426        self.log.debug("Send a valid message")
427        msg_bytes_before = node.getpeerinfo()[0]["bytesrecv_per_msg"]["pong"]
428
429        with self.nodes[1].assert_debug_log(expected_msgs=["received: addr"]):
430            node.sendmsgtopeer(peer_id=0, msg_type="addr", msg="FFFFFF")
431            node.ping()
432            self.wait_until(lambda: node.getpeerinfo()[0]["bytesrecv_per_msg"]["pong"] > msg_bytes_before)
433
434        self.log.debug("Test error for sending to non-existing peer")
435        assert_raises_rpc_error(-1, "Error: Could not send message to peer", node.sendmsgtopeer, peer_id=100, msg_type="addr", msg="FF")
436
437        self.log.debug("Test that zero-length msg_type is allowed")
438        node.sendmsgtopeer(peer_id=0, msg_type="addr", msg="")
439
440        self.log.debug("Test error for msg_type that is too long")
441        assert_raises_rpc_error(-8, "Error: msg_type too long, max length is 12", node.sendmsgtopeer, peer_id=0, msg_type="long_msg_type", msg="FF")
442
443        self.log.debug("Test that unknown msg_type is allowed")
444        node.sendmsgtopeer(peer_id=0, msg_type="unknown", msg="FF")
445
446        self.log.debug("Test that empty msg is allowed")
447        node.sendmsgtopeer(peer_id=0, msg_type="addr", msg="FF")
448
449        self.log.debug("Test that oversized messages are allowed, but get us disconnected")
450        zero_byte_string = b'\x00' * 4000001
451        node.sendmsgtopeer(peer_id=0, msg_type="addr", msg=zero_byte_string.hex())
452        self.wait_until(lambda: len(self.nodes[0].getpeerinfo()) == 0, timeout=10)
453
454    def test_getaddrmaninfo(self):
455        self.log.info("Test getaddrmaninfo")
456        self.restart_node(1, extra_args=["-cjdnsreachable", "-test=addrman"], clear_addrman=True)
457        node = self.nodes[1]
458        seed_addrman(node)
459
460        expected_network_count = {
461            'all_networks': {'new': 4, 'tried': 4, 'total': 8},
462            'ipv4': {'new': 1, 'tried': 1, 'total': 2},
463            'ipv6': {'new': 1, 'tried': 1, 'total': 2},
464            'onion': {'new': 0, 'tried': 2, 'total': 2},
465            'i2p': {'new': 1, 'tried': 0, 'total': 1},
466            'cjdns': {'new': 1, 'tried': 0, 'total': 1},
467        }
468
469        self.log.debug("Test that count of addresses in addrman match expected values")
470        res = node.getaddrmaninfo()
471        for network, count in expected_network_count.items():
472            assert_equal(res[network]['new'], count['new'])
473            assert_equal(res[network]['tried'], count['tried'])
474            assert_equal(res[network]['total'], count['total'])
475
476    def test_getrawaddrman(self):
477        self.log.info("Test getrawaddrman")
478        self.restart_node(1, extra_args=["-cjdnsreachable", "-test=addrman"], clear_addrman=True)
479        node = self.nodes[1]
480        self.addr_time = int(time.time())
481        node.setmocktime(self.addr_time)
482        seed_addrman(node)
483
484        self.log.debug("Test that getrawaddrman is a hidden RPC")
485        # It is hidden from general help, but its detailed help may be called directly.
486        assert "getrawaddrman" not in node.help()
487        assert "unknown command: getrawaddrman" not in node.help("getrawaddrman")
488
489        def check_addr_information(result, expected):
490            """Utility to compare a getrawaddrman result entry with an expected entry"""
491            assert_equal(result["address"], expected["address"])
492            assert_equal(result["port"], expected["port"])
493            assert_equal(result["services"], expected["services"])
494            assert_equal(result["network"], expected["network"])
495            assert_equal(result["source"], expected["source"])
496            assert_equal(result["source_network"], expected["source_network"])
497            assert_equal(result["time"], self.addr_time)
498
499        def check_getrawaddrman_entries(expected):
500            """Utility to compare a getrawaddrman result with expected addrman contents"""