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]))
