#! /usr/bin/env python3 import hashlib, random, socket, sys, threading, time DEFAULT_PORT = 62039 class Peer: def __init__(self, ipv6, port, lifetime_counter): self.ipv6 = ipv6 self.port = port self.lifetime_counter = lifetime_counter self.partner = None def get_address(self): return self.ipv6, self.port def __str__(self): return describe(self.ipv6, self.port) class Node: def __init__(self, node_socket, peers): self.lock = threading.Lock() self.node_socket = node_socket self.peers = peers self.incoming_heartbeats = [] self.partners = [] def add_heartbeat(self, address): with self.lock: self.incoming_heartbeats.append(address) def add_partner(self, address): with self.lock: self.partners.append(address) def get_events(self): with self.lock: heartbeats = self.incoming_heartbeats partners = self.partners self.incoming_heartbeats = [] self.partners = [] return heartbeats, partners def describe(ipv6, port): if port == DEFAULT_PORT: return ipv6 return f"[{ipv6}]:{port}" def log(msg): time_info = time.strftime("%d.%m.%Y %H:%M:%S") print(f"[{time_info}] {msg}") def parse_address(addr_str): if addr_str.startswith("["): closing = addr_str.find("]:") if closing == -1: raise Exception(f"Not a valid address: {addr_str}") ipv6 = addr_str[1:closing] port = int(addr_str[closing+2:]) else: ipv6 = addr_str port = DEFAULT_PORT return Peer(ipv6, port, 10) def wait_until(target_time): duration = target_time - time.time() if duration > 0: time.sleep(duration) def empty_transaction_list_hash(): current_hash = 32 * b"\0" for _ in range(1024): entry = current_hash + 44 * b"\0" current_hash = hashlib.sha256(entry).digest() return current_hash def send_heartbeat(node, peer): protocol_version = 2 * b"\0" capable_version = 2 * b"\0" msg_type = b"\0" difficulty_sum = 32 * b"\0" hash_value = empty_transaction_list_hash() if peer.partner is None: partner_ipv6 = 16 * b"\0" partner_port = 2 * b"\0" else: partner_ipv6 = socket.inet_pton(socket.AF_INET6, peer.partner.ipv6) partner_port = peer.partner.port.to_bytes(2, "big") heartbeat_msg = protocol_version + capable_version + msg_type + \ difficulty_sum + hash_value + partner_ipv6 + partner_port node.node_socket.sendto(heartbeat_msg, (peer.ipv6, peer.port)) def define_partnership(peers): peers_to_pair = [peer for peer in peers if peer.lifetime_counter >= 8] random.shuffle(peers_to_pair) pairing_count = len(peers_to_pair) // 2 for pair_idx in range(pairing_count): peers_to_pair[2*pair_idx].partner = peers_to_pair[2*pair_idx+1] peers_to_pair[2*pair_idx+1].partner = peers_to_pair[2*pair_idx] # in case of an odd count, the last one will remain without partner if pairing_count % 2 == 1: peers_to_pair[-1].partner = None def heartbeat(node): while True: heartbeats, partners = node.get_events() heartbeats = set(heartbeats) partners = set(partners) peerlist_update = False for peer in node.peers: address = peer.get_address() if address in heartbeats: peer.lifetime_counter = 10 heartbeats.remove(address) else: peer.lifetime_counter -= 1 if peer.lifetime_counter < 0: log(f"Removing {peer} from the list (no contact)") peerlist_update = True if address in partners: partners.remove(address) # cleaning up inactives node.peers = [peer for peer in node.peers if peer.lifetime_counter >= 0] # adding new peers that contacted me for new_peer in (heartbeats - partners): peer = Peer(new_peer[0], new_peer[1], 10) log(f"Adding peer {peer} to the list (It connected on its own)") node.peers.append(peer) peerlist_update = True # adding partners for new_peer in partners: peer = Peer(new_peer[0], new_peer[1], 3) log(f"Adding peer {peer} to the list (Got it as \"partner\" from another peer)") node.peers.append(peer) peerlist_update = True peer_count = len(node.peers) if peerlist_update: if peer_count == 1: log(f"There is now 1 peer in my list.") else: log(f"There are now {peer_count} peers in my list.") start_time = time.time() define_partnership(node.peers) for i, peer in enumerate(node.peers): wait_until(start_time + 60 * (i+1) / peer_count) send_heartbeat(node, peer) def receiver(node): while True: msg, addr = node.node_socket.recvfrom(4096) sender = describe(addr[0], addr[1]) msg_len = len(msg) if msg_len < 4: log("Got a udp message from {sender} that was too short.") continue version = int.from_bytes(msg[0:2], "big") if version != 0: log(f"Got a udp message of version {version} from {sender}, but only version 0 is supported.") continue if msg_len < 5: log(f"Got a udp message from {sender} that was too short. (missing type field)") continue msg_type = msg[4] if msg_type == 0: # heartbeat if msg_len != 87: log(f"Got a heartbeat message of wrong length ({msg_len} bytes from {sender}, but expected 87 bytes)") continue # register heartbeat of the sender node.add_heartbeat(addr[0:2]) partner_info = msg[69:87] if partner_info != 18 * b"\0": # register the partner that was sent along partner_ip = socket.inet_ntop(socket.AF_INET6, partner_info[0:16]) partner_port = int.from_bytes(partner_info[16:18], "big") node.add_partner((partner_ip, partner_port)) else: log(f"Got a udp message of unknown type from {sender}. (type {msg_type})") def main(): address_arguments = sys.argv[1:] peers = [parse_address(argument) for argument in address_arguments] node_socket = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM) try: node_socket.bind(("::", DEFAULT_PORT)) except OSError as e: if e.errno == 98: node_socket.bind(("::", 0)) port = node_socket.getsockname()[1] log(f"Default port {DEFAULT_PORT} is in use, listening on port {port} instead.") else: raise e log("Node is ready") node = Node(node_socket, peers) heartbeat_thread = threading.Thread(target = heartbeat, args = (node,)) receiving_thread = threading.Thread(target = receiver, args = (node,)) heartbeat_thread.start() receiving_thread.start() heartbeat_thread.join() receiving_thread.join() if __name__ == '__main__': main()