def cache_message(data, message_id, sender_id, recipient_id, message_type=None, direction=None): if _Debug: lg.args(_DebugLevel, message_id=message_id, sender_id=sender_id, recipient_id=recipient_id, message_type=message_type) if message_type == 'private_message': if not my_keys.is_key_registered(sender_id): sender_idurl = global_id.glob2idurl(sender_id) known_ident = identitycache.FromCache(sender_idurl) if not known_ident: lg.warn('sender identity %r was not cached, not possible to store message locally' % sender_idurl) return False if not my_keys.register_key(sender_id, known_ident.getPublicKey()): lg.err('failed to register known public key of the sender: %r' % sender_id) return False if not my_keys.is_key_registered(recipient_id): recipient_idurl = global_id.glob2idurl(recipient_id) known_ident = identitycache.FromCache(recipient_idurl) if not known_ident: lg.warn('recipient identity %r was not cached, not possible to store message locally' % recipient_idurl) return False if not my_keys.register_key(recipient_id, known_ident.getPublicKey()): lg.err('failed to register known public key of the recipient: %r' % recipient_id) return False return store_message(data, message_id, sender_id, recipient_id, message_type, direction) if message_type == 'group_message' or message_type == 'personal_message': if not my_keys.is_key_registered(recipient_id): lg.err('failed to cache %r because recipient key %r was not registered' % (message_type, recipient_id, )) return False return store_message(data, message_id, sender_id, recipient_id, message_type, direction) raise Exception('unexpected message type: %r' % message_type)
def audit_private_key(key_id, untrusted_idurl, timeout=10): """ Be sure remote user posses given private key. I need to posses the public key to be able to audit. I will generate a random string, encrypt it with given key public key and send encrypted string to him. He will decrypt and send me back original string. Returns Deferred object. """ if _Debug: lg.out(_DebugLevel, 'key_ring.audit_private_key testing %s from %s' % (key_id, untrusted_idurl)) result = Deferred() recipient_id_obj = identitycache.FromCache(untrusted_idurl) if not recipient_id_obj: lg.warn('not found "%s" in identity cache' % untrusted_idurl) result.errback(Exception('not found "%s" in identity cache' % untrusted_idurl)) return result key_alias, creator_idurl = my_keys.split_key_id(key_id) if not key_alias or not creator_idurl: lg.warn('wrong key_id') result.errback(Exception('wrong key_id')) return result private_test_sample = key.NewSessionKey() if untrusted_idurl == creator_idurl and key_alias == 'master': lg.warn('doing audit of master key (private part) of remote user') private_test_encrypted_sample = recipient_id_obj.encrypt(private_test_sample) else: if not my_keys.is_key_registered(key_id): lg.warn('unknown key: "%s"' % key_id) result.errback(Exception('unknown key: "%s"' % key_id)) return result private_test_encrypted_sample = my_keys.encrypt(key_id, private_test_sample) json_payload = { 'key_id': key_id, 'audit': { 'public_sample': '', 'private_sample': base64.b64encode(private_test_encrypted_sample), } } raw_payload = serialization.DictToBytes(json_payload, values_to_text=True) block = encrypted.Block( BackupID=key_id, Data=raw_payload, SessionKey=key.NewSessionKey(), # encrypt data using public key of recipient EncryptKey=lambda inp: recipient_id_obj.encrypt(inp), ) encrypted_payload = block.Serialize() p2p_service.SendAuditKey( remote_idurl=recipient_id_obj.getIDURL(), encrypted_payload=encrypted_payload, packet_id=key_id, timeout=timeout, callbacks={ commands.Ack(): lambda response, info: _on_audit_private_key_response(response, info, key_id, untrusted_idurl, private_test_sample, result), commands.Fail(): lambda response, info: result.errback(Exception(response)), None: lambda pkt_out: result.errback(Exception('timeout')), # timeout }, ) return result
def push_contact(idurl): global _Contacts global _PingDelayDict global _CurrentDelay ident = identitycache.FromCache(idurl) if ident is None: lg.err('"%s" not in the cache' % idurl) return None http_contact = ident.getProtoContact('http') if http_contact is None: if _Debug: lg.out( _DebugLevel * 2, 'http_node.add_contact SKIP "%s" : no http contacts found in identity' % idurl) return None _, host, port, _ = nameurl.UrlParse(http_contact) new_item = False if idurl in _Contacts: new_item = True _Contacts[idurl] = (host, port) _PingDelayDict[idurl] = _CurrentDelay if new_item: if _Debug: lg.out( _DebugLevel, 'http_node.add_contact ADDED "%s" on %s:%s' % (idurl, host, port)) else: if _Debug: lg.out( _DebugLevel, 'http_node.add_contact UPDATED "%s" on %s:%s' % (idurl, host, port)) return idurl
def get_contact_identity(idurl): """ The Main Method Here - return identity object for given ID or None if not found. Only valid contacts for packets will be signed by local identity, suppliers, customers. """ if idurl is None: return None idurl = id_url.field(idurl) if idurl.to_bin() == my_id.getLocalID().to_bin(): return my_id.getLocalIdentity() # if is_supplier(idurl): # return identitycache.FromCache(idurl) # if is_customer(idurl): # return identitycache.FromCache(idurl) # if is_correspondent(idurl): # return identitycache.FromCache(idurl) if identitycache.HasKey(idurl): # lg.warn("who is %s ?" % nameurl.GetName(idurl)) return identitycache.FromCache(idurl) lg.warn("%s is NOT FOUND IN CACHE" % idurl) # TODO: # this is not correct: # need to check if other contacts is fine - if internet is turned off we can get lots of fails ... return None
def get_customer_identity(idurl): """ If ``idurl`` is in customers list, return its identity object. """ if is_customer(idurl): return identitycache.FromCache(idurl) return None
def get_supplier_identity(idurl): """ Return peer's identity if he is in suppliers list. """ if is_supplier(idurl): return identitycache.FromCache(idurl) return None
def encrypt(self, message_body, encrypt_session_func=None): if _Debug: lg.args(_DebugLevel, encrypt_session_func=encrypt_session_func, recipient=self.recipient) new_sessionkey = key.NewSessionKey(session_key_type=key.SessionKeyType()) if not encrypt_session_func: if my_keys.is_key_registered(self.recipient): if _Debug: lg.dbg(_DebugLevel, 'with registered key %r' % self.recipient) encrypt_session_func = lambda inp: my_keys.encrypt(self.recipient, inp) if not encrypt_session_func: glob_id = global_id.NormalizeGlobalID(self.recipient) if glob_id['key_alias'] == 'master': if glob_id['idurl'] == my_id.getIDURL(): lg.warn('making encrypted message addressed to me ?') encrypt_session_func = lambda inp: my_keys.encrypt('master', inp) else: remote_identity = identitycache.FromCache(glob_id['idurl']) if not remote_identity: raise Exception('remote identity is not cached yet, not able to encrypt the message') if _Debug: lg.dbg(_DebugLevel, 'with remote identity public key %r' % glob_id['idurl']) encrypt_session_func = remote_identity.encrypt else: own_key = global_id.MakeGlobalID(idurl=my_id.getIDURL(), key_alias=glob_id['key_alias']) if my_keys.is_key_registered(own_key): if _Debug: lg.dbg(_DebugLevel, 'with registered key (found by alias) %r' % own_key) encrypt_session_func = lambda inp: my_keys.encrypt(own_key, inp) if not encrypt_session_func: raise Exception('can not find key for given recipient') self.encrypted_session = encrypt_session_func(new_sessionkey) self.encrypted_body = key.EncryptWithSessionKey(new_sessionkey, message_body, session_key_type=key.SessionKeyType()) return self.encrypted_session, self.encrypted_body
def get_correspondent_identity(idurl): """ Return peer's identity if he is in the correspondents list. """ if is_correspondent(idurl): return identitycache.FromCache(idurl) return ''
def _on_audit_public_key_response(response, info, key_id, untrusted_idurl, test_sample, result): try: response_sample = base64.b64decode(response.Payload) except: lg.exc() result.callback(False) return False key_alias, creator_idurl = my_keys.split_key_id(key_id) if creator_idurl == untrusted_idurl and key_alias == 'master': recipient_id_obj = identitycache.FromCache(creator_idurl) if not recipient_id_obj: lg.warn('not found "%s" in identity cache' % creator_idurl) result.errback(Exception('not found "%s" in identity cache' % creator_idurl)) return result orig_sample = recipient_id_obj.encrypt(test_sample) else: orig_sample = my_keys.encrypt(key_id, test_sample) if response_sample == orig_sample: if _Debug: lg.out(_DebugLevel, 'key_ring._on_audit_public_key_response : %s on %s' % (key_id, untrusted_idurl, )) lg.out(_DebugLevel, ' is OK !!!!!!!!!!!!!!!!!!!!!!!!!') result.callback(True) return True lg.warn('key %s on %s is not OK' % (key_id, untrusted_idurl, )) result.callback(False) return False
def encrypt(self, message_body, encrypt_session_func=None): new_sessionkey = key.NewSessionKey() if not encrypt_session_func: if my_keys.is_key_registered(self.recipient): if _Debug: lg.out(_DebugLevel, 'message.PrivateMessage.encrypt with "%s" key' % self.recipient) encrypt_session_func = lambda inp: my_keys.encrypt(self.recipient, inp) if not encrypt_session_func: glob_id = global_id.ParseGlobalID(self.recipient) if glob_id['key_alias'] == 'master': if glob_id['idurl'] == my_id.getLocalID(): lg.warn('making private message addressed to me ???') if _Debug: lg.out(_DebugLevel, 'message.PrivateMessage.encrypt with "master" key') encrypt_session_func = lambda inp: my_keys.encrypt('master', inp) else: remote_identity = identitycache.FromCache(glob_id['idurl']) if not remote_identity: raise Exception('remote identity is not cached yet, not able to encrypt the message') if _Debug: lg.out(_DebugLevel, 'message.PrivateMessage.encrypt with remote identity public key') encrypt_session_func = remote_identity.encrypt else: own_key = global_id.MakeGlobalID(idurl=my_id.getLocalID(), key_alias=glob_id['key_alias']) if my_keys.is_key_registered(own_key): if _Debug: lg.out(_DebugLevel, 'message.PrivateMessage.encrypt with "%s" key' % own_key) encrypt_session_func = lambda inp: my_keys.encrypt(own_key, inp) if not encrypt_session_func: raise Exception('can not find key for given recipient') self.encrypted_session = encrypt_session_func(new_sessionkey) self.encrypted_body = key.EncryptWithSessionKey(new_sessionkey, message_body) return self.encrypted_session, self.encrypted_body
def get_correspondent_identity(idurl): """ Return peer's identity if he is in the correspondents list. """ if is_correspondent(idurl): idurl = strng.to_bin(idurl.strip()) return identitycache.FromCache(idurl) return None
def get_supplier_identity(idurl): """ Return peer's identity if he is in suppliers list. """ if is_supplier(idurl): idurl = strng.to_bin(idurl.strip()) return identitycache.FromCache(idurl) return None
def get_customer_identity(idurl): """ If ``idurl`` is in customers list, return its identity object. """ if is_customer(idurl): idurl = strng.to_bin(idurl.strip()) return identitycache.FromCache(idurl) return None
def doStartListening(self, *args, **kwargs): """ Action method. """ try: _, info = args[0] self.router_proto_host = (info.proto, info.host) except: try: s = config.conf().getString('services/proxy-transport/current-router').strip() _, router_proto, router_host = s.split(' ') self.router_proto_host = (router_proto, strng.to_bin(router_host), ) except: lg.exc() self.router_identity = identitycache.FromCache(self.router_idurl) config.conf().setString('services/proxy-transport/current-router', '%s %s %s' % ( strng.to_text(self.router_idurl), strng.to_text(self.router_proto_host[0]), strng.to_text(self.router_proto_host[1]), )) current_identity = my_id.getLocalIdentity().serialize() previous_identity = ReadMyOriginalIdentitySource() if previous_identity: lg.warn('my original identity is not empty, SKIP overwriting') lg.out(2, '\nPREVIOUS ORIGINAL IDENTITY:\n%s\n' % current_identity) else: WriteMyOriginalIdentitySource(current_identity) lg.warn('current identity was stored as my-original-identity') self.request_service_packet_id = [] callback.insert_inbox_callback(0, self._on_inbox_packet_received) if contact_status.isKnown(self.router_idurl): contact_status.A(self.router_idurl).addStateChangedCallback( self._on_router_contact_status_connected, newstate='CONNECTED') contact_status.A(self.router_idurl).addStateChangedCallback( self._on_router_contact_status_offline, newstate='OFFLINE') active_router_sessions = gateway.find_active_session(info.proto, info.host) if active_router_sessions: self.router_connection_info = { 'id': active_router_sessions[0].id, 'index': active_router_sessions[0].index, 'proto': info.proto, 'host': info.host, 'idurl': self.router_idurl, 'global_id': global_id.UrlToGlobalID(self.router_idurl), } active_router_session_machine = automat.objects().get(self.router_connection_info['index'], None) if active_router_session_machine: active_router_session_machine.addStateChangedCallback( self._on_router_session_disconnected, oldstate='CONNECTED') lg.info('connected to proxy router and set active session: %s' % self.router_connection_info) else: lg.err('not found proxy router session state machine: %s' % self.router_connection_info['index']) else: lg.err('active connection with proxy router at %s:%s was not found' % (info.proto, info.host, )) if _Debug: lg.out(2, 'proxy_receiver.doStartListening !!!!!!! router: %s at %s://%s' % ( self.router_idurl, self.router_proto_host[0], self.router_proto_host[1]))
def transfer_key(key_id, trusted_idurl, include_private=False, include_signature=False, timeout=10, result=None): """ Actually sending given key to remote user. """ if _Debug: lg.out(_DebugLevel, 'key_ring.transfer_key %s -> %s' % (key_id, trusted_idurl)) if not result: result = Deferred() recipient_id_obj = identitycache.FromCache(trusted_idurl) if not recipient_id_obj: lg.warn('not found "%s" in identity cache' % trusted_idurl) result.errback(Exception('not found "%s" in identity cache' % trusted_idurl)) return result key_alias, creator_idurl = my_keys.split_key_id(key_id) if not key_alias or not creator_idurl: lg.warn('wrong key_id') result.errback(Exception('wrong key_id')) return result if not my_keys.is_key_registered(key_id): lg.warn('unknown key: "%s"' % key_id) result.errback(Exception('unknown key: "%s"' % key_id)) return result key_object = my_keys.key_obj(key_id) try: key_json = my_keys.make_key_info( key_object, key_id=key_id, include_private=include_private, include_signature=include_signature, ) except Exception as exc: lg.exc() result.errback(exc) return result key_data = serialization.DictToBytes(key_json, values_to_text=True) block = encrypted.Block( BackupID=key_id, Data=key_data, SessionKey=key.NewSessionKey(session_key_type=key.SessionKeyType()), SessionKeyType=key.SessionKeyType(), # encrypt data using public key of recipient EncryptKey=lambda inp: recipient_id_obj.encrypt(inp), ) encrypted_key_data = block.Serialize() p2p_service.SendKey( remote_idurl=recipient_id_obj.getIDURL(), encrypted_key_data=encrypted_key_data, packet_id=key_id, callbacks={ commands.Ack(): lambda response, info: _on_transfer_key_response(response, info, key_id, result), commands.Fail(): lambda response, info: _on_transfer_key_response(response, info, key_id, result), None: lambda pkt_out: _on_transfer_key_response(None, None, key_id, result), }, timeout=timeout, ) return result
def send_message(json_data, recipient_global_id, packet_id=None, timeout=None): """ Send command.Message() packet to remote peer. Returns Deferred (if remote_idurl was not cached yet) or outbox packet object. """ global _LastUserPingTime global _PingTrustIntervalSeconds if not packet_id: packet_id = packetid.UniqueID() lg.out( 4, "message.send_message to %s with PackteID=%s" % (recipient_global_id, packet_id)) remote_idurl = global_id.GlobalUserToIDURL(recipient_global_id) if not remote_idurl: return fail(Exception('invalid recipient')) ret = Deferred() if remote_idurl not in _LastUserPingTime: is_expired = True else: is_expired = time.time( ) - _LastUserPingTime[remote_idurl] > _PingTrustIntervalSeconds remote_identity = identitycache.FromCache(remote_idurl) if is_expired or remote_identity is None or not online_status.isOnline( remote_idurl): d = propagate.PingContact(remote_idurl, timeout=timeout or 5) d.addCallback(lambda response_tuple: on_ping_success( response_tuple, remote_idurl)) d.addCallback( lambda response_tuple: do_send_message(json_data, recipient_global_id, packet_id, timeout, result_defer=ret)) d.addErrback(lambda err: on_message_failed(remote_idurl, json_data, recipient_global_id, packet_id, None, None, result_defer=ret)) return ret try: do_send_message(json_data, recipient_global_id, packet_id, timeout, ret) except Exception as exc: lg.warn(str(exc)) on_message_failed( remote_idurl, json_data, recipient_global_id, packet_id, None, None, ) ret.errback(exc) return ret
def do_send_message(json_data, recipient_global_id, packet_id, message_ack_timeout, result_defer=None, fire_callbacks=True): global _OutgoingMessageCallbacks remote_idurl = global_id.GlobalUserToIDURL(recipient_global_id, as_field=False) if not remote_idurl: raise Exception('invalid recipient') remote_identity = identitycache.FromCache(remote_idurl) if not remote_identity: raise Exception('remote identity object not exist in cache') message_body = serialization.DictToBytes( json_data, pack_types=True, encoding='utf-8', ) if _Debug: lg.out(_DebugLevel, "message.do_send_message to %s with %d bytes message ack_timeout=%s" % ( recipient_global_id, len(message_body), message_ack_timeout)) try: private_message_object = PrivateMessage(recipient=recipient_global_id) private_message_object.encrypt(message_body) except: lg.exc() raise Exception('message encryption failed') payload = private_message_object.serialize() if _Debug: lg.out(_DebugLevel, " payload is %d bytes, remote idurl is %s" % (len(payload), remote_idurl)) callbacks = {} if message_ack_timeout: callbacks = { commands.Ack(): lambda response, info: on_message_delivered( remote_idurl, json_data, recipient_global_id, packet_id, response, info, result_defer, ), commands.Fail(): lambda response, info: on_message_failed( remote_idurl, json_data, recipient_global_id, packet_id, response, info, result_defer=result_defer, error='fail received'), None: lambda pkt_out: on_message_failed( remote_idurl, json_data, recipient_global_id, packet_id, None, None, result_defer=result_defer, error='timeout', ), 'failed': lambda pkt_out, errmsg: on_message_failed( remote_idurl, json_data, recipient_global_id, packet_id, None, None, result_defer=result_defer, error=errmsg, ), } result, outpacket = p2p_service.SendMessage( remote_idurl=remote_idurl, packet_id=packet_id, payload=payload, callbacks=callbacks, response_timeout=message_ack_timeout, ) if fire_callbacks: try: for cp in _OutgoingMessageCallbacks: cp(json_data, private_message_object, remote_identity, outpacket, result) except: lg.exc() raise Exception('failed sending message') return result
def fetch(list_ids): """ Request a list of identity files. """ lg.out(6, "propagate.fetch identities for %d users" % len(list_ids)) dl = [] for url in list_ids: if url: if not identitycache.FromCache(url): dl.append(identitycache.scheduleForCaching(url)) return DeferredList(dl, consumeErrors=True)
def _nodes_lookup_finished(self, idurls): if _Debug: lg.out(_DebugLevel, 'broadcasters_finder._nodes_lookup_finished : %r' % idurls) for idurl in idurls: ident = identitycache.FromCache(idurl) remoteprotos = set(ident.getProtoOrder()) myprotos = set(my_id.getLocalIdentity().getProtoOrder()) if len(myprotos.intersection(remoteprotos)) > 0: self.automat('found-one-user', idurl) return self.automat('users-not-found')
def transfer_private_key(key_id, idurl): if _Debug: lg.out(_DebugLevel, 'key_ring.transfer_private_key %s -> %s' % (key_id, idurl)) result = Deferred() recipient_id_obj = identitycache.FromCache(idurl) if not recipient_id_obj: lg.warn('not found "%s" in identity cache' % idurl) result.errback(Exception('not found "%s" in identity cache' % idurl)) return result key_alias, creator_idurl = my_keys.split_key_id(key_id) if not key_alias or not creator_idurl: lg.warn('wrong key_id') result.errback(Exception('wrong key_id')) return result key_object = my_keys.known_keys().get(key_id) if key_object is None: lg.warn('unknown key: "%s"' % key_id) result.errback(Exception('unknown key: "%s"' % key_id)) return result key_json = { 'key_id': key_id, 'alias': key_alias, 'creator': creator_idurl, 'fingerprint': str(key_object.fingerprint()), 'type': str(key_object.type()), 'ssh_type': str(key_object.sshType()), 'size': str(key_object.size()), 'public': str(key_object.public().toString('openssh')), 'private': str(key_object.toString('openssh')), } key_data = json.dumps(key_json) block = encrypted.Block( BackupID=key_id, Data=key_data, SessionKey=key.NewSessionKey(), # encrypt data using public key of recipient EncryptKey=lambda inp: recipient_id_obj.encrypt(inp), ) encrypted_key_data = block.Serialize() p2p_service.SendKey( remote_idurl=recipient_id_obj.getIDURL(), encrypted_key_data=encrypted_key_data, packet_id=key_id, callbacks={ commands.Ack(): lambda response, info: result.callback(response), commands.Fail(): lambda response, info: result.errback(Exception(response)), }, ) return result
def _nodes_lookup_finished(self, idurls): # TODO: this is still under construction - so I am using this node for tests # idurls = ['http://veselin-p2p.ru/bitdust_vps1000_k.xml', ] if _Debug: lg.out(_DebugLevel, 'accountants_finder._nodes_lookup_finished : %r' % idurls) for idurl in idurls: ident = identitycache.FromCache(idurl) remoteprotos = set(ident.getProtoOrder()) myprotos = set(my_id.getLocalIdentity().getProtoOrder()) if len(myprotos.intersection(remoteprotos)) > 0: self.automat('found-one-user', idurl) return self.automat('users-not-found')
def doUpdateRouterID(self, *args, **kwargs): """ Action method. """ newpacket, _ = args[0] newxml = newpacket.Payload newidentity = identity.identity(xmlsrc=newxml) cachedidentity = identitycache.FromCache(self.router_idurl) if self.router_idurl != newidentity.getIDURL(): lg.warn('router idurl is unrecognized from response %r != %r' % (self.router_idurl, newidentity.getIDURL(), )) return if newidentity.serialize() != cachedidentity.serialize(): lg.warn('cached identity is not same, router identity changed') self.router_identity = newidentity
def doUpdateRouterID(self, arg): """ Action method. """ newpacket, _ = arg newxml = newpacket.Payload newidentity = identity.identity(xmlsrc=newxml) cachedidentity = identitycache.FromCache(self.router_idurl) if self.router_idurl != newidentity.getIDURL(): lg.warn('router_idurl != newidentity.getIDURL()') return if newidentity.serialize() != cachedidentity.serialize(): lg.warn('cached identity is not same, router identity changed') self.router_identity = newidentity
def fetch(list_ids, refresh_cache=False): """ Request a list of identity files. """ if _Debug: lg.out(_DebugLevel, "propagate.fetch %d identities" % len(list_ids)) dl = [] for url in list_ids: if not url: continue if identitycache.FromCache(url) and not refresh_cache: continue dl.append(identitycache.immediatelyCaching(id_url.to_original(url))) return DeferredList(dl, consumeErrors=True)
def doStartListening(self, *args, **kwargs): """ Action method. """ try: _, info, active_router_session_machine = args[0] self.router_proto_host = (info.proto, info.host) except: try: # TODO: move that setting to separate file s = config.conf().getString('services/proxy-transport/current-router').strip() _, router_proto, router_host = s.split(' ') self.router_proto_host = (router_proto, strng.to_bin(router_host), ) except: lg.exc() self.router_identity = identitycache.FromCache(self.router_idurl) if _Debug: lg.args(_DebugLevel, router_idurl=self.router_idurl) config.conf().setString('services/proxy-transport/current-router', '%s %s %s' % ( strng.to_text(self.router_idurl), strng.to_text(self.router_proto_host[0]), strng.to_text(self.router_proto_host[1]), )) current_identity = my_id.getLocalIdentity().serialize(as_text=True) previous_identity = ReadMyOriginalIdentitySource() if previous_identity: lg.err('my original identity is not empty, SKIP overwriting') if _Debug: lg.out(_DebugLevel, 'PREVIOUS ORIGINAL IDENTITY:\n%s\n' % previous_identity) WriteMyOriginalIdentitySource(current_identity) lg.info('copy of my current identity was stored as my "original" identity') self.request_service_packet_id = [] callback.insert_inbox_callback(0, self._on_inbox_packet_received) if online_status.isKnown(self.router_idurl): online_status.add_online_status_listener_callback( idurl=self.router_idurl, callback_method=self._on_router_contact_status_connected, newstate='CONNECTED', ) online_status.add_online_status_listener_callback( idurl=self.router_idurl, callback_method=self._on_router_contact_status_offline, newstate='OFFLINE', ) active_router_session_machine.addStateChangedCallback(self._on_router_session_disconnected, oldstate='CONNECTED') lg.info('router %s is connected at %s://%s' % (self.router_idurl, self.router_proto_host[0], self.router_proto_host[1], )) my_id.rebuildLocalIdentity()
def _on_nodes_lookup_finished(self, idurls, attempts): if _Debug: lg.out(_DebugLevel, 'proxy_receiver._on_nodes_lookup_finished : %r' % idurls) for idurl in idurls: ident = identitycache.FromCache(idurl) remoteprotos = set(ident.getProtoOrder()) myprotos = set(my_id.getLocalIdentity().getProtoOrder()) if len(myprotos.intersection(remoteprotos)) > 0: self.possible_router_idurl = id_url.field(idurl) if _Debug: lg.out(_DebugLevel, 'proxy_receiver._on_nodes_lookup_finished found : %r' % self.possible_router_idurl) self.automat('found-one-node', self.possible_router_idurl) return if attempts > 0: self._find_random_node(attempts-1) else: self.automat('nodes-not-found')
def _finish_verification(res): if _Debug: lg.out(4, 'proxy_interface._finish_verification') try: cached_id = identitycache.FromCache(proxy_receiver.GetRouterIDURL()) if not cached_id: if _Debug: lg.out(4, ' returning False: router identity is not cached') res.callback(False) return False if not proxy_receiver.GetRouterIdentity(): if _Debug: lg.out(4, ' returning False : router identity is None or router is not ready yet') return True if cached_id.serialize() != proxy_receiver.GetRouterIdentity().serialize(): if _Debug: lg.out(4, 'proxy_interface.verify_contacts return False: cached copy is different') lg.out(20, '\n%s\n' % cached_id.serialize()) lg.out(20, '\n%s\n' % proxy_receiver.GetRouterIdentity().serialize()) res.callback(False) return router_contacts = proxy_receiver.GetRouterIdentity().getContactsByProto() if len(router_contacts) != id_obj.getContactsNumber(): if _Debug: lg.out(4, ' returning False: router contacts is different') res.callback(False) return False for proto, contact in id_obj.getContactsByProto().items(): if proto not in list(router_contacts.keys()): if _Debug: lg.out(4, ' returning False: [%s] is not present in router contacts' % proto) res.callback(False) return False if router_contacts[proto] != contact: if _Debug: lg.out(4, ' returning False: [%s] contact is different in router id' % proto) res.callback(False) return False if _Debug: lg.out(4, ' returning True : my contacts and router contacts is same') res.callback(True) return True except: lg.exc() res.callback(True) return True
def _nodes_lookup_finished(self, idurls): if _Debug: lg.out(_DebugLevel, 'p2p_service_seeker._nodes_lookup_finished : %r' % idurls) found_idurls = [] for idurl in idurls: if idurl in self.exclude_nodes: continue if idurl in found_idurls: continue ident = identitycache.FromCache(idurl) remoteprotos = set(ident.getProtoOrder()) myprotos = set(my_id.getLocalIdentity().getProtoOrder()) if len(myprotos.intersection(remoteprotos)) > 0: found_idurls.append(idurl) if found_idurls: self.automat('found-users', found_idurls) else: self.automat('users-not-found')
def _nodes_lookup_finished(self, idurls): if _Debug: lg.out(_DebugLevel, 'broadcasters_finder._nodes_lookup_finished : %r' % idurls) if not idurls: self.automat('users-not-found') return # if driver.is_on('service_proxy_transport'): # current_router_idurl = config.conf().getString('services/proxy-transport/current-router', '').strip() # if current_router_idurl and current_router_idurl in idurls: # idurls.remove(current_router_idurl) for idurl in idurls: ident = identitycache.FromCache(idurl) remoteprotos = set(ident.getProtoOrder()) myprotos = set(my_id.getLocalIdentity().getProtoOrder()) if len(myprotos.intersection(remoteprotos)) > 0: self.automat('found-one-user', idurl) return self.automat('users-not-found')
def doStartListening(self, arg): """ Action method. """ try: _, info = arg self.router_proto_host = (info.proto, info.host) except: try: s = config.conf().getString( 'services/proxy-transport/current-router').strip() _, router_proto, router_host = s.split(' ') self.router_proto_host = (router_proto, router_host) except: lg.exc() self.router_identity = identitycache.FromCache(self.router_idurl) config.conf().setString( 'services/proxy-transport/current-router', '%s %s %s' % (self.router_idurl, self.router_proto_host[0], self.router_proto_host[1])) current_identity = my_id.getLocalIdentity().serialize() previous_identity = ReadMyOriginalIdentitySource() if previous_identity: lg.warn('my original identity is not empty, SKIP overwriting') lg.out(2, '\nPREVIOUS ORIGINAL IDENTITY:\n%s\n' % current_identity) else: WriteMyOriginalIdentitySource(current_identity) lg.warn('current identity was stored as my-original-identity') self.request_service_packet_id = [] callback.insert_inbox_callback(0, self._on_inbox_packet_received) if contact_status.isKnown(self.router_idurl): contact_status.A(self.router_idurl).addStateChangedCallback( self._on_router_contact_status_connected, newstate='CONNECTED') contact_status.A(self.router_idurl).addStateChangedCallback( self._on_router_contact_status_offline, newstate='OFFLINE') if _Debug: lg.out( 2, 'proxy_receiver.doStartListening !!!!!!! router: %s at %s://%s' % (self.router_idurl, self.router_proto_host[0], self.router_proto_host[1]))