def check_remote_peers(self): '''Check the peers list we got from a remote peer. Each update is expected to be of the form: [ip_addr, hostname, ['v1.0', 't51001', 's51002']] Call add_peer if the remote doesn't appear to know about us. ''' try: real_names = [' '.join([u[1]] + u[2]) for u in self.remote_peers] peers = [ Peer.from_real_name(real_name, str(self.peer)) for real_name in real_names ] except Exception: self.log_error('bad server.peers.subscribe response') return self.peer_mgr.add_peers(peers) # Announce ourself if not present. Don't if disabled, we # are a non-public IP address, or to ourselves. if not self.peer_mgr.env.peer_announce: return if self.peer in self.peer_mgr.myselves: return my = self.peer_mgr.my_clearnet_peer() if not my or not my.is_public: return for peer in my.matches(peers): if peer.tcp_port == my.tcp_port and peer.ssl_port == my.ssl_port: return self.log_info('registering ourself with server.add_peer') self.send_request(self.on_add_peer, 'server.add_peer', [my.features])
def on_peers_subscribe(self, request): '''Handle the response to the peers.subcribe message.''' if not self.is_good(request, list): return # Check the peers list we got from a remote peer. # Each is expected to be of the form: # [ip_addr, hostname, ['v1.0', 't51001', 's51002']] # Call add_peer if the remote doesn't appear to know about us. raw_peers = request.result() try: real_names = [' '.join([u[1]] + u[2]) for u in raw_peers] peers = [ Peer.from_real_name(real_name, str(self.peer)) for real_name in real_names ] except Exception: self.bad('bad server.peers.subscribe response') return features = self.peer_mgr.features_to_register(self.peer, peers) if features: self.logger.info(f'registering ourself with "server.add_peer"') self.send_request('server.add_peer', [features], self.on_add_peer, timeout=self.timeout) else: self.maybe_close()
def on_add_peer(self, features, source): '''Add peers from an incoming connection.''' peers = Peer.peers_from_features(features, source) if peers: self.log_info('add_peer request received from {}' .format(peers[0].host)) self.add_peers(peers, check_ports=True) return bool(peers)
def import_peers(self): '''Import hard-coded peers from a file or the coin defaults.''' self.add_peers(self.myselves) coin_peers = self.env.coin.PEERS # Add the hard-coded ones peers = [Peer.from_real_name(real_name, 'coins.py') for real_name in coin_peers] self.add_peers(peers, limit=None)
def rpc_add_peer(self, real_name): '''Add a peer. real_name: a real name, as would appear on IRC ''' peer = Peer.from_real_name(real_name, 'RPC') self.peer_mgr.add_peers([peer]) return "peer '{}' added".format(real_name)
def import_peers(self): '''Import hard-coded peers from a file or the coin defaults.''' self.add_peers(self.myselves) coin_peers = self.env.coin.PEERS self.onion_peers = [ Peer.from_real_name(rn, 'coins.py') for rn in coin_peers if '.onion ' in rn ] # If we don't have many peers in the peers file, add # hard-coded ones self.read_peers_file() if len(self.peers) < 5: peers = [ Peer.from_real_name(real_name, 'coins.py') for real_name in coin_peers ] self.add_peers(peers, limit=None)
def on_add_peer(self, features, source): '''Add peers from an incoming connection.''' peers = Peer.peers_from_features(features, source) if peers: hosts = [peer.host for peer in peers] self.log_info('add_peer request from {} for {}' .format(source, ', '.join(hosts))) self.add_peers(peers, check_ports=True) return bool(peers)
def import_peers(self): '''Import hard-coded peers from a file or the coin defaults.''' self.add_peers(self.myselves) # Add the hard-coded ones unless only returning self if self.env.peer_discovery != self.env.PD_SELF: coin_peers = self.env.coin.PEERS peers = [Peer.from_real_name(real_name, 'coins.py') for real_name in coin_peers] self.add_peers(peers, limit=None)
def read_peers_file(self): try: with util.open_file(PEERS_FILE, create=True) as f: data = f.read(-1).decode() except Exception as e: self.logger.error('error reading peers file {}'.format(e)) else: if data: version, items = ast.literal_eval(data) if version == 1: peers = [Peer.deserialize(item) for item in items] self.add_peers(peers, source='peers file', limit=None)
def peers_from_env(env): '''Return a list of peers from the environment settings.''' hosts = {identity.host: {'tcp_port': identity.tcp_port, 'ssl_port': identity.ssl_port} for identity in env.identities} features = { 'hosts': hosts, 'pruning': None, 'server_version': version.VERSION, 'protocol_min': version.PROTOCOL_MIN, 'protocol_max': version.PROTOCOL_MAX, 'genesis_hash': env.coin.GENESIS_HASH, } return [Peer(ident.host, features, 'env') for ident in env.identities]
def read_peers_file(self): try: with util.open_file(PEERS_FILE, create=True) as f: data = f.read(-1).decode() except Exception as e: self.logger.error('error reading peers file {}'.format(e)) else: if data: version, items = ast.literal_eval(data) if version == 1: peers = [] for item in items: if 'last_connect' in item: item['last_good'] = item.pop('last_connect') try: peers.append(Peer.deserialize(item)) except Exception: pass self.add_peers(peers, source='peers file', limit=None)
def __init__(self, env, controller): super().__init__() # Initialise the Peer class Peer.DEFAULT_PORTS = env.coin.PEER_DEFAULT_PORTS self.env = env self.controller = controller self.loop = controller.loop # Our clearnet and Tor Peers, if any self.myselves = [Peer(ident.host, env.server_features(), 'env') for ident in env.identities] self.retry_event = asyncio.Event() # Peers have one entry per hostname. Once connected, the # ip_addr property is either None, an onion peer, or the # IP address that was connected to. Adding a peer will evict # any other peers with the same host name or IP address. self.peers = set() self.permit_onion_peer_time = time.time() self.proxy_tried_event = asyncio.Event() self.detect_proxy_event = asyncio.Event() self.proxy = None
async def on_add_peer(self, features, source_info): '''Add a peer (but only if the peer resolves to the source).''' if not source_info: self.log_info('ignored add_peer request: no source info') return False source = source_info[0] peers = Peer.peers_from_features(features, source) if not peers: self.log_info('ignored add_peer request: no peers given') return False # Just look at the first peer, require it peer = peers[0] host = peer.host if peer.is_tor: permit = self.permit_new_onion_peer() reason = 'rate limiting' else: try: infos = await self.loop.getaddrinfo(host, 80, type=socket.SOCK_STREAM) except socket.gaierror: permit = False reason = 'address resolution failure' else: permit = any(source == info[-1][0] for info in infos) reason = 'source-destination mismatch' if permit: self.log_info('accepted add_peer request from {} for {}'.format( source, host)) self.add_peers([peer], check_ports=True) else: self.log_warning( 'rejected add_peer request from {} for {} ({})'.format( source, host, reason)) return permit
def __init__(self): self.user = '******' Peer.__init__(self)
def add_irc_peer(self, nick, real_name): '''Add an IRC peer.''' peer = Peer.from_real_name(real_name, '{}'.format(nick)) self.add_peers([peer])
#!/usr/bin/python3 from lib.peer import Peer alice = Peer('alice') alice.start()
def clone(db, args): address = args[0] newPeer = Peer(address) newPeer.clone() os.remove(log) print 'Done.'
#!/usr/bin/python3 from lib.peer import Peer bob = Peer('bob') bob.start()
def push(args): address = args[0] newPeer = Peer(address) newPeer.push()
def clone(db,args): address = args[0] newPeer = Peer(address) newPeer.clone() os.remove(log) print 'Done.'
def pull(args): address = args[0] newPeer = Peer(address) newPeer.pull()