def _do_send_identity_to_router(self, identity_source, failed_event):
try:
identity_obj = identity.identity(xmlsrc=identity_source)
except:
lg.exc()
return
if _Debug:
lg.out(_DebugLevel, 'proxy_receiver._do_send_identity_to_router to %s' % self.router_idurl)
lg.out(_DebugLevel, ' contacts=%r, sources=%r' % (
identity_obj.contacts, identity_obj.getSources(as_originals=True)))
newpacket = signed.Packet(
Command=commands.Identity(),
OwnerID=my_id.getIDURL(),
CreatorID=my_id.getIDURL(),
PacketID=('proxy_receiver:%s' % packetid.UniqueID()),
Payload=identity_obj.serialize(),
RemoteID=self.router_idurl,
)
packet_out.create(
newpacket,
wide=True,
callbacks={
commands.Ack(): lambda response, info: self.automat('ack-received', (response, info)),
commands.Fail(): lambda x: self.automat(failed_event),
None: lambda pkt_out: self.automat('ack-timeout', pkt_out),
'failed': lambda pkt_out, error_message: self.automat('sending-failed', (pkt_out, error_message)),
},
keep_alive=True,
response_timeout=30,
)
def _do_send_identity_to_router(self, identity_source, failed_event):
try:
identity_obj = identity.identity(xmlsrc=identity_source)
except:
lg.exc()
return
if _Debug:
lg.out(_DebugLevel, 'proxy_receiver.doSendMyIdentity to %s' % self.router_idurl)
lg.out(_DebugLevel, ' contacts=%s, sources=%s' % (identity_obj.contacts, identity_obj.sources))
newpacket = signed.Packet(
commands.Identity(),
my_id.getLocalID(),
my_id.getLocalID(),
commands.Identity(),
identity_source,
self.router_idurl,
)
packet_out.create(
newpacket,
wide=True,
callbacks={
commands.Ack(): lambda response, info: self.automat('ack-received', (response, info)),
commands.Fail(): lambda x: self.automat(failed_event),
},
keep_alive=True,
)
def _do_send_request_service(self, *args, **kwargs):
if len(self.request_service_packet_id) >= 10:
if _Debug:
lg.warn('too many service requests to %r' % self.router_idurl)
self.automat('service-refused', *args, **kwargs)
return
orig_identity = config.conf().getData('services/proxy-transport/my-original-identity').strip()
if not orig_identity:
orig_identity = my_id.getLocalIdentity().serialize(as_text=True)
service_info = {
'name': 'service_proxy_server',
'payload': {
'identity': orig_identity,
},
}
newpacket = signed.Packet(
commands.RequestService(),
my_id.getIDURL(),
my_id.getIDURL(),
packetid.UniqueID(),
serialization.DictToBytes(service_info, values_to_text=True),
self.router_idurl,
)
packet_out.create(
newpacket,
wide=False,
callbacks={
commands.Ack(): self._on_request_service_ack,
commands.Fail(): self._on_request_service_fail,
None: lambda pkt_out: self.automat('request-timeout', pkt_out),
},
response_timeout=30,
)
self.request_service_packet_id.append(newpacket.PacketID)
def _do_send_request_service(self, *args, **kwargs):
if len(self.request_service_packet_id) >= 3:
if _Debug:
lg.warn('too many service requests to %r' % self.router_idurl)
self.automat('service-refused', *args, **kwargs)
return
orig_identity = config.conf().getData('services/proxy-transport/my-original-identity').strip()
if not orig_identity:
orig_identity = my_id.getLocalIdentity().serialize()
service_info = {
'name': 'service_proxy_server',
'payload': {
'identity': strng.to_text(orig_identity),
},
}
service_info_raw = json.dumps(service_info)
newpacket = signed.Packet(
commands.RequestService(),
my_id.getLocalID(),
my_id.getLocalID(),
packetid.UniqueID(),
service_info_raw,
self.router_idurl,
)
packet_out.create(newpacket, wide=False, callbacks={
commands.Ack(): self._on_request_service_ack,
commands.Fail(): self._on_request_service_fail,
},)
self.request_service_packet_id.append(newpacket.PacketID)
def doSendRequestService(self, arg):
"""
Action method.
"""
if len(self.request_service_packet_id) >= 3:
if _Debug:
lg.warn('too many service requests to %s' % self.router_idurl)
self.automat('service-refused', arg)
return
service_info = 'service_proxy_server \n'
orig_identity = config.conf().getData('services/proxy-transport/my-original-identity').strip()
if not orig_identity:
orig_identity = my_id.getLocalIdentity().serialize()
service_info += orig_identity
# for t in gateway.transports().values():
# service_info += '%s://%s' % (t.proto, t.host)
# service_info += ' '
newpacket = signed.Packet(
commands.RequestService(),
my_id.getLocalID(),
my_id.getLocalID(),
packetid.UniqueID(),
service_info,
self.router_idurl,)
packet_out.create(newpacket, wide=False, callbacks={
commands.Ack(): self._on_request_service_ack,
commands.Fail(): self._on_request_service_fail},)
self.request_service_packet_id.append(newpacket.PacketID)
def doSendRequestService(self, arg):
"""
Action method.
"""
if len(self.request_service_packet_id) >= 3:
if _Debug:
lg.warn('too many service requests to %s' % self.router_idurl)
self.automat('service-refused', arg)
return
service_info = 'service_proxy_server \n'
orig_identity = config.conf().getData(
'services/proxy-transport/my-original-identity').strip()
if not orig_identity:
orig_identity = my_id.getLocalIdentity().serialize()
service_info += orig_identity
# for t in gateway.transports().values():
# service_info += '%s://%s' % (t.proto, t.host)
# service_info += ' '
newpacket = signed.Packet(
commands.RequestService(),
my_id.getLocalID(),
my_id.getLocalID(),
packetid.UniqueID(),
service_info,
self.router_idurl,
)
packet_out.create(
newpacket,
wide=False,
callbacks={
commands.Ack(): self._on_request_service_ack,
commands.Fail(): self._on_request_service_fail
},
)
self.request_service_packet_id.append(newpacket.PacketID)
def doSendMyIdentity(self, *args, **kwargs):
"""
Action method.
"""
global _KnownChannels
self.ping_attempts += 1
if self.fake_identity:
identity_object = self.fake_identity
else:
identity_object = my_id.getLocalIdentity()
if not identity_object.Valid():
raise Exception('can not use invalid identity for ping')
if self.channel_counter:
packet_id = '%s:%d:%d:%s' % (self.channel, _KnownChannels[self.channel], self.ping_attempts, packetid.UniqueID())
else:
packet_id = '%s:%d:%s' % (self.channel, self.ping_attempts, packetid.UniqueID())
ping_packet = signed.Packet(
Command=commands.Identity(),
OwnerID=my_id.getIDURL(),
CreatorID=my_id.getIDURL(),
PacketID=packet_id,
Payload=strng.to_bin(identity_object.serialize()),
RemoteID=self.remote_idurl,
)
if self.skip_outbox:
packet_out.create(
outpacket=ping_packet,
wide=True,
response_timeout=self.ack_timeout,
callbacks={
commands.Ack(): lambda response, info: self.automat('ack-received', response=response, info=info),
commands.Fail(): lambda response, info: self.automat('fail-received', response=response, info=info),
None: lambda pkt_out: self.automat('ack-timeout', pkt_out),
},
keep_alive=self.keep_alive,
)
else:
gateway.outbox(
outpacket=ping_packet,
wide=True,
response_timeout=self.ack_timeout,
callbacks={
commands.Ack(): lambda response, info: self.automat('ack-received', response=response, info=info),
commands.Fail(): lambda response, info: self.automat('fail-received', response=response, info=info),
None: lambda pkt_out: self.automat('ack-timeout', pkt_out),
},
keep_alive=self.keep_alive,
)
if _Debug:
lg.args(_DebugLevel, packet_id=packet_id, remote_idurl=self.remote_idurl, ping_attempts=self.ping_attempts)
def doSendCancelService(self, arg):
"""
Action method.
"""
newpacket = signed.Packet(
commands.CancelService(),
my_id.getLocalID(),
my_id.getLocalID(),
packetid.UniqueID(),
'service_proxy_server',
self.router_idurl,)
packet_out.create(newpacket, wide=True, callbacks={
commands.Ack(): self._on_request_service_ack,
commands.Fail(): self._on_request_service_fail},)
def doSendCancelService(self, *args, **kwargs):
"""
Action method.
"""
newpacket = signed.Packet(
commands.CancelService(),
my_id.getIDURL(),
my_id.getIDURL(),
packetid.UniqueID(),
serialization.DictToBytes({'name': 'service_proxy_server', }),
self.router_idurl,
)
packet_out.create(newpacket, wide=True, callbacks={
commands.Ack(): self._on_request_service_ack,
commands.Fail(): self._on_request_service_fail,
})
def on_outbox_packet(outpacket,
wide,
callbacks,
target=None,
route=None,
response_timeout=None,
keep_alive=True):
"""
"""
started_packets = packet_out.search_similar_packets(outpacket)
if started_packets:
for active_packet, active_item in started_packets:
if callbacks:
for command, cb in callbacks.items():
active_packet.set_callback(command, cb)
lg.warn(
'skip creating new outbox packet because found similar packet: %r'
% active_packet)
return active_packet
pkt_out = packet_out.create(outpacket, wide, callbacks, target, route,
response_timeout, keep_alive)
# if _Debug and lg.is_debug(_DebugLevel):
# monitoring()
control.request_update([('packet', outpacket.PacketID)])
return pkt_out
def doForwardInboxPacket(self, arg):
"""
Action method.
"""
# encrypt with proxy_receiver()'s key and sent to man behind my proxy
receiver_idurl, newpacket, info = arg
route_info = self.routes.get(receiver_idurl, None)
if not route_info:
lg.warn('route with %s not found for inbox packet: %s' % (receiver_idurl, newpacket))
return
hosts = route_info['address']
if len(hosts) == 0:
lg.warn('route with %s do not have actual info about the host, use identity contacts instead' % receiver_idurl)
hosts = route_info['contacts']
if len(hosts) == 0:
lg.warn('has no known contacts for route with %s' % receiver_idurl)
return
receiver_proto, receiver_host = hosts[0]
publickey = route_info['publickey']
src = ''
src += newpacket.Serialize()
block = encrypted.Block(
my_id.getLocalID(),
'routed incoming data',
0,
key.NewSessionKey(),
key.SessionKeyType(),
True,
src,
EncryptFunc=lambda inp: key.EncryptStringPK(publickey, inp))
routed_packet = signed.Packet(
commands.Relay(),
newpacket.OwnerID,
my_id.getLocalID(),
newpacket.PacketID,
block.Serialize(),
receiver_idurl)
pout = packet_out.create(
newpacket,
wide=False,
callbacks={},
route={
'packet': routed_packet,
'proto': receiver_proto,
'host': receiver_host,
'remoteid': receiver_idurl,
'description': ('Relay_%s[%s]_%s' % (
newpacket.Command, newpacket.PacketID,
nameurl.GetName(receiver_idurl)))})
if _Debug:
lg.out(_DebugLevel, '<<<Relay-IN %s %s:%s' % (
str(newpacket), info.proto, info.host,))
lg.out(_DebugLevel, ' sent to %s://%s with %d bytes in %s' % (
receiver_proto, receiver_host, len(src), pout))
del src
del block
del newpacket
del routed_packet
def doSendCancelService(self, arg):
"""
Action method.
"""
service_info = {
'name': 'service_proxy_server',
}
service_info_raw = json.dumps(service_info)
newpacket = signed.Packet(
commands.CancelService(),
my_id.getLocalID(),
my_id.getLocalID(),
packetid.UniqueID(),
service_info_raw,
self.router_idurl, )
packet_out.create(newpacket, wide=True, callbacks={
commands.Ack(): self._on_request_service_ack,
commands.Fail(): self._on_request_service_fail,
},)
def doForwardOutboxPacket(self, arg):
"""
Action method.
"""
# decrypt with my key and send to outside world
newpacket, info = arg
block = encrypted.Unserialize(newpacket.Payload)
if block is None:
lg.out(2, 'proxy_router.doForwardOutboxPacket ERROR reading data from %s' % newpacket.RemoteID)
return
try:
session_key = key.DecryptLocalPK(block.EncryptedSessionKey)
padded_data = key.DecryptWithSessionKey(session_key, block.EncryptedData)
inpt = cStringIO.StringIO(padded_data[:int(block.Length)])
sender_idurl = inpt.readline().rstrip('\n')
receiver_idurl = inpt.readline().rstrip('\n')
wide = inpt.readline().rstrip('\n')
wide = wide == 'wide'
except:
lg.out(2, 'proxy_router.doForwardOutboxPacket ERROR reading data from %s' % newpacket.RemoteID)
lg.exc()
try:
inpt.close()
except:
pass
return
route = self.routes.get(sender_idurl, None)
if not route:
inpt.close()
lg.warn('route with %s not found' % (sender_idurl))
p2p_service.SendFail(newpacket, 'route not exist', remote_idurl=sender_idurl)
return
data = inpt.read()
inpt.close()
routed_packet = signed.Unserialize(data)
if not routed_packet:
lg.out(2, 'proxy_router.doForwardOutboxPacket ERROR unserialize packet from %s' % newpacket.RemoteID)
return
# send the packet directly to target
pout = packet_out.create(routed_packet, wide=wide, callbacks={}, target=receiver_idurl,)
# gateway.outbox(routed_packet, wide=wide)
if _Debug:
lg.out(_DebugLevel, '>>>Relay-OUT %d bytes from %s at %s://%s :' % (
len(data), nameurl.GetName(sender_idurl), info.proto, info.host,))
lg.out(_DebugLevel, ' routed to %s : %s' % (nameurl.GetName(receiver_idurl), pout))
del block
del data
del padded_data
del route
del inpt
del session_key
del routed_packet
def doSendMyIdentity(self, arg):
"""
Action method.
"""
identity_source = config.conf().getData('services/proxy-transport/my-original-identity').strip()
if identity_source:
if _Debug:
lg.out(_DebugLevel, 'proxy_receiver.doSendMyIdentity use my previously stored identity')
else:
identity_source = my_id.getLocalIdentity().serialize()
cur_contacts = my_id.getLocalIdentity().getContacts()
if _Debug:
lg.out(_DebugLevel, 'proxy_receiver.doSendMyIdentity using my current identity, contacts=%s' % cur_contacts)
newpacket = signed.Packet(
commands.Identity(), my_id.getLocalID(),
my_id.getLocalID(), 'identity',
identity_source, self.router_idurl,
)
packet_out.create(newpacket, wide=True, callbacks={
commands.Ack(): lambda response, info: self.automat('ack-received', (response, info)),
commands.Fail(): lambda x: self.automat('nodes-not-found')
})
def on_outbox_packet(outpacket, wide, callbacks, target=None, route=None):
"""
"""
started_packets = packet_out.search_similar_packets(outpacket)
if started_packets:
for active_packet, active_item in started_packets:
if callbacks:
for command, cb in callbacks.items():
active_packet.set_callback(command, cb)
return active_packet
pkt_out = packet_out.create(outpacket, wide, callbacks, target, route)
if _Debug and lg.is_debug(_DebugLevel):
monitoring()
control.request_update([('packet', outpacket.PacketID)])
return pkt_out
def on_outbox_packet(outpacket, wide, callbacks, target=None, route=None):
"""
"""
started_packets = packet_out.search_similar_packets(outpacket)
if started_packets:
for active_packet, active_item in started_packets:
if callbacks:
for command, cb in callbacks.items():
active_packet.set_callback(command, cb)
return active_packet
pkt_out = packet_out.create(outpacket, wide, callbacks, target, route)
if _Debug and lg.is_debug(_DebugLevel):
monitoring()
control.request_update([("packet", outpacket.PacketID)])
return pkt_out
def _do_forward_outbox_packet(self, outpacket_info_tuple):
"""
This packet addressed to me but contain routed data to be transferred to another node.
I will decrypt with my private key and send to outside world further.
"""
newpacket, info = outpacket_info_tuple
block = encrypted.Unserialize(newpacket.Payload)
if block is None:
lg.out(
2,
'proxy_router.doForwardOutboxPacket ERROR reading data from %s'
% newpacket.RemoteID)
return
try:
session_key = key.DecryptLocalPrivateKey(block.EncryptedSessionKey)
padded_data = key.DecryptWithSessionKey(session_key,
block.EncryptedData)
inpt = BytesIO(padded_data[:int(block.Length)])
# see proxy_sender.ProxySender : _on_first_outbox_packet() for sending part
json_payload = serialization.BytesToDict(inpt.read(),
keys_to_text=True)
inpt.close()
sender_idurl = json_payload['f'] # from
receiver_idurl = json_payload['t'] # to
wide = json_payload['w'] # wide
routed_data = json_payload['p'] # payload
except:
lg.out(
2,
'proxy_router.doForwardOutboxPacket ERROR reading data from %s'
% newpacket.RemoteID)
lg.exc()
try:
inpt.close()
except:
pass
return
route = self.routes.get(sender_idurl, None)
if not route:
inpt.close()
lg.warn('route with %s not found' % (sender_idurl))
p2p_service.SendFail(newpacket,
'route not exist',
remote_idurl=sender_idurl)
return
routed_packet = signed.Unserialize(routed_data)
if not routed_packet or not routed_packet.Valid():
lg.out(
2,
'proxy_router.doForwardOutboxPacket ERROR unserialize packet from %s'
% newpacket.RemoteID)
return
# send the packet directly to target user_id
# we pass not callbacks because all response packets from this call will be also re-routed
pout = packet_out.create(
routed_packet,
wide=wide,
callbacks={},
target=receiver_idurl,
)
if _Debug:
lg.out(
_DebugLevel,
'>>>Relay-IN-OUT %d bytes from %s at %s://%s :' % (
len(routed_data),
nameurl.GetName(sender_idurl),
info.proto,
info.host,
))
lg.out(
_DebugLevel, ' routed to %s : %s' %
(nameurl.GetName(receiver_idurl), pout))
del block
del routed_data
del padded_data
del route
del inpt
del session_key
del routed_packet
def _do_forward_inbox_packet(self, *args, **kwargs):
# encrypt with proxy_receiver()'s key and sent to man behind my proxy
receiver_idurl, newpacket, info = args[0]
route_info = self.routes.get(receiver_idurl, None)
if not route_info:
lg.warn('route with %s not found for inbox packet: %s' %
(receiver_idurl, newpacket))
return
hosts = route_info['address']
if len(hosts) == 0:
lg.warn(
'route with %s do not have actual info about the host, use identity contacts instead'
% receiver_idurl)
hosts = route_info['contacts']
if len(hosts) == 0:
lg.warn('has no known contacts for route with %s' % receiver_idurl)
return
if len(hosts) > 1:
lg.warn('found more then one channel with receiver %s : %r' % (
receiver_idurl,
hosts,
))
receiver_proto, receiver_host = strng.to_bin(
hosts[0][0]), strng.to_bin(hosts[0][1])
publickey = route_info['publickey']
block = encrypted.Block(
CreatorID=my_id.getLocalID(),
BackupID='routed incoming data',
BlockNumber=0,
SessionKey=key.NewSessionKey(),
SessionKeyType=key.SessionKeyType(),
LastBlock=True,
Data=newpacket.Serialize(),
EncryptKey=lambda inp: key.EncryptOpenSSHPublicKey(publickey, inp),
)
raw_data = block.Serialize()
routed_packet = signed.Packet(
commands.Relay(),
newpacket.OwnerID,
my_id.getLocalID(),
newpacket.PacketID,
raw_data,
receiver_idurl,
)
pout = packet_out.create(
newpacket,
wide=False,
callbacks={},
route={
'packet':
routed_packet,
'proto':
receiver_proto,
'host':
receiver_host,
'remoteid':
receiver_idurl,
'description':
('Relay_%s[%s]_%s' % (newpacket.Command, newpacket.PacketID,
nameurl.GetName(receiver_idurl))),
},
)
if _Debug:
lg.out(
_DebugLevel, '<<<Relay-IN-OUT %s %s:%s' % (
str(newpacket),
info.proto,
info.host,
))
lg.out(
_DebugLevel, ' sent to %s://%s with %d bytes in %s' %
(receiver_proto, receiver_host, len(raw_data), pout))
del raw_data
del block
del newpacket
del routed_packet
def _on_first_outbox_packet(self,
outpacket,
wide,
callbacks,
target=None,
route=None,
response_timeout=None,
keep_alive=True):
"""
Will be called first for every outgoing packet.
Must to return None if that packet should be send normal way.
Otherwise will create another "routerd" packet instead and return it.
"""
if not driver.is_on('service_proxy_transport'):
if _Debug:
lg.out(
_DebugLevel,
'proxy_sender._on_first_outbox_packet SKIP because service_proxy_transport is not started'
)
return None
if proxy_receiver.A() and proxy_receiver.A().state != 'LISTEN':
if _Debug:
lg.out(
_DebugLevel,
'proxy_sender._on_first_outbox_packet DELLAYED because proxy_receiver state is not LISTEN yet'
)
return self._add_pending_packet(outpacket, wide, callbacks)
router_idurl = proxy_receiver.GetRouterIDURL()
router_identity_obj = proxy_receiver.GetRouterIdentity()
router_proto_host = proxy_receiver.GetRouterProtoHost()
router_proto, router_host = router_proto_host
publickey = router_identity_obj.publickey
my_original_identity_src = proxy_receiver.ReadMyOriginalIdentitySource(
)
if not router_idurl or not router_identity_obj or not router_proto_host or not my_original_identity_src:
if _Debug:
lg.out(
_DebugLevel,
'proxy_sender._on_first_outbox_packet SKIP because remote router not ready'
)
return self._add_pending_packet(outpacket, wide, callbacks)
if outpacket.RemoteID == router_idurl:
if _Debug:
lg.out(
_DebugLevel,
'proxy_sender._on_first_outbox_packet SKIP, packet addressed to router and must be sent in a usual way'
)
return None
try:
raw_data = outpacket.Serialize()
except:
lg.exc('failed to Serialize %s' % outpacket)
return None
# see proxy_router.ProxyRouter : doForwardOutboxPacket() for receiving part
json_payload = {
'f': my_id.getLocalID(), # from
't': outpacket.RemoteID, # to
'w': wide, # wide
'p': raw_data, # payload
}
raw_bytes = serialization.DictToBytes(json_payload)
block = encrypted.Block(
CreatorID=my_id.getLocalID(),
BackupID='routed outgoing data',
BlockNumber=0,
SessionKey=key.NewSessionKey(),
SessionKeyType=key.SessionKeyType(),
LastBlock=True,
Data=raw_bytes,
EncryptKey=lambda inp: key.EncryptOpenSSHPublicKey(publickey, inp),
)
block_encrypted = block.Serialize()
newpacket = signed.Packet(
commands.Relay(),
outpacket.OwnerID,
my_id.getLocalID(),
outpacket.PacketID,
block_encrypted,
router_idurl,
)
routed_packet = packet_out.create(
outpacket,
wide=wide,
callbacks=callbacks,
route={
'packet':
newpacket,
# pointing "newpacket" to another node
'proto':
router_proto,
'host':
router_host,
'remoteid':
router_idurl,
'description':
'Relay_%s[%s]_%s' % (outpacket.Command, outpacket.PacketID,
nameurl.GetName(router_idurl)),
},
response_timeout=response_timeout,
keep_alive=keep_alive,
)
self.event('outbox-packet-sent', (outpacket, newpacket, routed_packet))
if _Debug:
lg.out(_DebugLevel, '>>>Relay-OUT %s' % str(outpacket))
lg.out(
_DebugLevel, ' sent to %s://%s with %d bytes' %
(router_proto, router_host, len(block_encrypted)))
del raw_bytes
del block
del newpacket
del outpacket
del router_identity_obj
del router_idurl
del router_proto_host
return routed_packet
def _on_first_outbox_packet(self, outpacket, wide, callbacks, target=None, route=None, response_timeout=None, keep_alive=True):
"""
Will be called first for every outgoing packet.
Must return `None` if that packet should be send normal way.
Otherwise will create another "routed" packet instead and return it.
"""
if not driver.is_on('service_proxy_transport'):
if _Debug:
lg.out(_DebugLevel, 'proxy_sender._on_first_outbox_packet SKIP sending %r because service_proxy_transport is not started yet' % outpacket)
return None
if not proxy_receiver.A():
if _Debug:
lg.out(_DebugLevel, 'proxy_sender._on_first_outbox_packet SKIP sending %r because proxy_receiver() not exist' % outpacket)
return None
if outpacket.Command == commands.Identity() and outpacket.CreatorID == my_id.getLocalID():
if proxy_receiver.GetPossibleRouterIDURL() and proxy_receiver.GetPossibleRouterIDURL().to_bin() == outpacket.RemoteID.to_bin():
if network_connector.A().state is 'DISCONNECTED':
if _Debug:
lg.out(_DebugLevel, 'proxy_sender._on_first_outbox_packet SKIP sending %r because network_connector() is DISCONNECTED' % outpacket)
return None
if network_connector.A().state is 'CONNECTED':
lg.warn('sending %r to "possible" proxy router %r' % (outpacket, proxy_receiver.GetPossibleRouterIDURL()))
pkt_out = packet_out.create(outpacket, wide, callbacks, target, route, response_timeout, keep_alive)
return pkt_out
if _Debug:
lg.out(_DebugLevel, 'proxy_sender._on_first_outbox_packet SKIP sending %r, network_connector() have transition state' % outpacket)
return None
if proxy_receiver.A().state != 'LISTEN':
if _Debug:
lg.out(_DebugLevel, 'proxy_sender._on_first_outbox_packet DELLAYED %r because proxy_receiver state is not LISTEN yet' % outpacket)
return self._add_pending_packet(outpacket, wide, callbacks)
router_idurl = proxy_receiver.GetRouterIDURL()
router_identity_obj = proxy_receiver.GetRouterIdentity()
router_proto_host = proxy_receiver.GetRouterProtoHost()
router_proto, router_host = router_proto_host
publickey = router_identity_obj.publickey
my_original_identity_src = proxy_receiver.ReadMyOriginalIdentitySource()
if not router_idurl or not router_identity_obj or not router_proto_host or not my_original_identity_src:
if _Debug:
lg.out(_DebugLevel, 'proxy_sender._on_first_outbox_packet SKIP because remote router not ready')
return self._add_pending_packet(outpacket, wide, callbacks)
if outpacket.RemoteID.to_bin() == router_idurl.to_bin():
if _Debug:
lg.out(_DebugLevel, 'proxy_sender._on_first_outbox_packet SKIP, packet addressed to router and must be sent in a usual way')
return None
try:
raw_data = outpacket.Serialize()
except:
lg.exc('failed to Serialize %s' % outpacket)
return None
# see proxy_router.ProxyRouter : doForwardOutboxPacket() for receiving part
json_payload = {
'f': my_id.getLocalID().to_bin(), # from
't': outpacket.RemoteID.to_bin(), # to
'w': wide, # wide
'p': raw_data, # payload
}
if not json_payload['t']:
raise ValueError('receiver idurl was not set')
raw_bytes = serialization.DictToBytes(json_payload)
block = encrypted.Block(
CreatorID=my_id.getLocalID(),
BackupID='routed outgoing data',
BlockNumber=0,
SessionKey=key.NewSessionKey(session_key_type=key.SessionKeyType()),
SessionKeyType=key.SessionKeyType(),
LastBlock=True,
Data=raw_bytes,
EncryptKey=lambda inp: key.EncryptOpenSSHPublicKey(publickey, inp),
)
block_encrypted = block.Serialize()
newpacket = signed.Packet(
Command=commands.Relay(),
OwnerID=outpacket.OwnerID,
CreatorID=my_id.getLocalID(),
PacketID=outpacket.PacketID,
Payload=block_encrypted,
RemoteID=router_idurl,
)
routed_packet = packet_out.create(
outpacket,
wide=wide,
callbacks=callbacks,
route={
'packet': newpacket,
# pointing "newpacket" to another node
'proto': router_proto,
'host': router_host,
'remoteid': router_idurl,
'description': 'Relay_%s[%s]_%s' % (outpacket.Command, outpacket.PacketID, nameurl.GetName(router_idurl)),
},
response_timeout=response_timeout,
keep_alive=keep_alive,
)
self.event('outbox-packet-sent', (outpacket, newpacket, routed_packet))
if _Debug:
lg.out(_DebugLevel, '>>>Relay-OUT %s' % str(outpacket))
lg.out(_DebugLevel, ' sent to %s://%s with %d bytes' % (
router_proto, router_host, len(block_encrypted)))
if _PacketLogFileEnabled:
lg.out(0, '\033[0;49;36mRELAY OUT %s(%s) with %s bytes from %s to %s via %s\033[0m' % (
outpacket.Command, outpacket.PacketID, len(raw_bytes),
global_id.UrlToGlobalID(outpacket.CreatorID), global_id.UrlToGlobalID(outpacket.RemoteID),
global_id.UrlToGlobalID(router_idurl), ),
log_name='packet', showtime=True,)
del raw_bytes
del block
del newpacket
del outpacket
del router_identity_obj
del router_idurl
del router_proto_host
return routed_packet
def _on_outbox_packet(self, outpacket, wide, callbacks, target=None, route=None):
"""
"""
if not driver.is_started('service_proxy_transport'):
if _Debug:
lg.out(_DebugLevel, 'proxy_sender._on_outbox_packet skip because service_proxy_transport is not started')
return None
if proxy_receiver.A() and proxy_receiver.A().state != 'LISTEN':
return self._add_pending_packet(outpacket, wide, callbacks)
router_idurl = proxy_receiver.GetRouterIDURL()
router_identity_obj = proxy_receiver.GetRouterIdentity()
router_proto_host = proxy_receiver.GetRouterProtoHost()
router_proto, router_host = router_proto_host
publickey = router_identity_obj.publickey
my_original_identity_src = proxy_receiver.ReadMyOriginalIdentitySource()
if not router_idurl or not router_identity_obj or not router_proto_host or not my_original_identity_src:
return self._add_pending_packet(outpacket, wide, callbacks)
if outpacket.RemoteID == router_idurl:
if _Debug:
lg.out(_DebugLevel, 'proxy_sender._on_outbox_packet skip, packet addressed to router and must be sent in a usual way')
return None
src = ''
src += my_id.getLocalID() + '\n'
src += outpacket.RemoteID + '\n'
src += 'wide\n' if wide else '\n'
src += outpacket.Serialize()
block = encrypted.Block(
my_id.getLocalID(),
'routed outgoing data',
0,
key.NewSessionKey(),
key.SessionKeyType(),
True,
src,
EncryptFunc=lambda inp: key.EncryptStringPK(publickey, inp))
block_encrypted = block.Serialize()
newpacket = signed.Packet(
commands.Relay(),
outpacket.OwnerID,
my_id.getLocalID(),
outpacket.PacketID,
block_encrypted,
router_idurl)
result_packet = packet_out.create(
outpacket,
wide=wide,
callbacks=callbacks,
route={
'packet': newpacket,
'proto': router_proto,
'host': router_host,
'remoteid': router_idurl,
'description': 'Relay_%s[%s]_%s' % (outpacket.Command, outpacket.PacketID, nameurl.GetName(router_idurl)),
})
self.event('outbox-packet-sent', (outpacket, newpacket, result_packet))
if _Debug:
lg.out(_DebugLevel, '>>>Relay-OUT %s' % str(outpacket))
lg.out(_DebugLevel, ' sent to %s://%s with %d bytes' % (
router_proto, router_host, len(block_encrypted)))
del src
del block
del newpacket
del outpacket
del router_identity_obj
del router_idurl
del router_proto_host
return result_packet
def _on_outbox_packet(self, outpacket, wide, callbacks, target=None, route=None, response_timeout=None, keep_alive=True):
"""
"""
if not driver.is_on('service_proxy_transport'):
if _Debug:
lg.out(_DebugLevel, 'proxy_sender._on_outbox_packet SKIP because service_proxy_transport is not started')
return None
if proxy_receiver.A() and proxy_receiver.A().state != 'LISTEN':
if _Debug:
lg.out(_DebugLevel, 'proxy_sender._on_outbox_packet SKIP because proxy_receiver state is not LISTEN')
return self._add_pending_packet(outpacket, wide, callbacks)
router_idurl = proxy_receiver.GetRouterIDURL()
router_identity_obj = proxy_receiver.GetRouterIdentity()
router_proto_host = proxy_receiver.GetRouterProtoHost()
router_proto, router_host = router_proto_host
publickey = router_identity_obj.publickey
my_original_identity_src = proxy_receiver.ReadMyOriginalIdentitySource()
if not router_idurl or not router_identity_obj or not router_proto_host or not my_original_identity_src:
if _Debug:
lg.out(_DebugLevel, 'proxy_sender._on_outbox_packet SKIP because remote router not ready')
return self._add_pending_packet(outpacket, wide, callbacks)
if outpacket.RemoteID == router_idurl:
if _Debug:
lg.out(_DebugLevel, 'proxy_sender._on_outbox_packet SKIP, packet addressed to router and must be sent in a usual way')
return None
try:
raw_data = outpacket.Serialize()
except:
lg.exc('failed to Serialize %s' % outpacket)
return None
src = ''
src += my_id.getLocalID() + '\n'
src += outpacket.RemoteID + '\n'
src += 'wide\n' if wide else '\n'
src += raw_data
block = encrypted.Block(
my_id.getLocalID(),
'routed outgoing data',
0,
key.NewSessionKey(),
key.SessionKeyType(),
True,
src,
EncryptKey=lambda inp: key.EncryptOpenSSHPublicKey(publickey, inp))
block_encrypted = block.Serialize()
newpacket = signed.Packet(
commands.Relay(),
outpacket.OwnerID,
my_id.getLocalID(),
outpacket.PacketID,
block_encrypted,
router_idurl,
)
result_packet = packet_out.create(
outpacket,
wide=wide,
callbacks=callbacks,
route={
'packet': newpacket,
'proto': router_proto,
'host': router_host,
'remoteid': router_idurl,
'description': 'Relay_%s[%s]_%s' % (outpacket.Command, outpacket.PacketID, nameurl.GetName(router_idurl)),
},
response_timeout=response_timeout,
keep_alive=keep_alive,
)
self.event('outbox-packet-sent', (outpacket, newpacket, result_packet))
if _Debug:
lg.out(_DebugLevel, '>>>Relay-OUT %s' % str(outpacket))
lg.out(_DebugLevel, ' sent to %s://%s with %d bytes' % (
router_proto, router_host, len(block_encrypted)))
del src
del block
del newpacket
del outpacket
del router_identity_obj
del router_idurl
del router_proto_host
return result_packet
def doForwardOutboxPacket(self, arg):
"""
Action method.
"""
# decrypt with my key and send to outside world
newpacket, info = arg
block = encrypted.Unserialize(newpacket.Payload)
if block is None:
lg.out(
2,
'proxy_router.doForwardOutboxPacket ERROR reading data from %s'
% newpacket.RemoteID)
return
try:
session_key = key.DecryptLocalPrivateKey(block.EncryptedSessionKey)
padded_data = key.DecryptWithSessionKey(session_key,
block.EncryptedData)
inpt = cStringIO.StringIO(padded_data[:int(block.Length)])
sender_idurl = inpt.readline().rstrip('\n')
receiver_idurl = inpt.readline().rstrip('\n')
wide = inpt.readline().rstrip('\n')
wide = wide == 'wide'
except:
lg.out(
2,
'proxy_router.doForwardOutboxPacket ERROR reading data from %s'
% newpacket.RemoteID)
lg.exc()
try:
inpt.close()
except:
pass
return
route = self.routes.get(sender_idurl, None)
if not route:
inpt.close()
lg.warn('route with %s not found' % (sender_idurl))
p2p_service.SendFail(newpacket,
'route not exist',
remote_idurl=sender_idurl)
return
data = inpt.read()
inpt.close()
routed_packet = signed.Unserialize(data)
if not routed_packet:
lg.out(
2,
'proxy_router.doForwardOutboxPacket ERROR unserialize packet from %s'
% newpacket.RemoteID)
return
# send the packet directly to target user_id
# we pass not callbacks because all response packets from this call will be also re-routed
pout = packet_out.create(
routed_packet,
wide=wide,
callbacks={},
target=receiver_idurl,
)
# gateway.outbox(routed_packet, wide=wide)
if _Debug:
lg.out(
_DebugLevel, '>>>Relay-OUT %d bytes from %s at %s://%s :' % (
len(data),
nameurl.GetName(sender_idurl),
info.proto,
info.host,
))
lg.out(
_DebugLevel, ' routed to %s : %s' %
(nameurl.GetName(receiver_idurl), pout))
del block
del data
del padded_data
del route
del inpt
del session_key
del routed_packet
def _on_first_outbox_packet(self,
outpacket,
wide,
callbacks,
target=None,
route=None,
response_timeout=None,
keep_alive=True):
"""
Will be called first for every outgoing packet.
Must return `None` if that packet should be sent in a normal way.
Otherwise will create another "routed" packet instead and return it.
"""
if not driver.is_on('service_proxy_transport'):
if _Debug:
lg.out(
_DebugLevel,
'proxy_sender._on_first_outbox_packet SKIP sending %r because service_proxy_transport is not started yet'
% outpacket)
return None
if not proxy_receiver.A():
if _Debug:
lg.out(
_DebugLevel,
'proxy_sender._on_first_outbox_packet SKIP sending %r because proxy_receiver() not exist'
% outpacket)
return None
if outpacket.Command == commands.Identity(
) and outpacket.CreatorID == my_id.getIDURL():
if proxy_receiver.GetPossibleRouterIDURL(
) and proxy_receiver.GetPossibleRouterIDURL().to_bin(
) == outpacket.RemoteID.to_bin():
if network_connector.A().state == 'DISCONNECTED':
if _Debug:
lg.out(
_DebugLevel,
'proxy_sender._on_first_outbox_packet SKIP sending %r because network_connector() is DISCONNECTED'
% outpacket)
return None
if network_connector.A().state == 'CONNECTED':
lg.warn(
'sending %r to "possible" proxy router %r' %
(outpacket, proxy_receiver.GetPossibleRouterIDURL()))
pkt_out = packet_out.create(outpacket, wide, callbacks,
target, route,
response_timeout, keep_alive)
return pkt_out
if _Debug:
lg.out(
_DebugLevel,
'proxy_sender._on_first_outbox_packet SKIP sending %r, network_connector() have transition state'
% outpacket)
return None
if proxy_receiver.A().state != 'LISTEN':
if _Debug:
lg.out(
_DebugLevel,
'proxy_sender._on_first_outbox_packet DELLAYED %r because proxy_receiver state is not LISTEN yet'
% outpacket)
return self._do_add_pending_packet(outpacket, callbacks, wide,
response_timeout, keep_alive)
return self._do_send_packet_to_router(
outpacket=outpacket,
callbacks=callbacks,
wide=wide,
keep_alive=keep_alive,
response_timeout=response_timeout,
)
def doForwardInboxPacket(self, arg):
"""
Action method.
"""
# encrypt with proxy_receiver()'s key and sent to man behind my proxy
receiver_idurl, newpacket, info = arg
route_info = self.routes.get(receiver_idurl, None)
if not route_info:
lg.warn('route with %s not found for inbox packet: %s' %
(receiver_idurl, newpacket))
return
hosts = route_info['address']
if len(hosts) == 0:
lg.warn(
'route with %s do not have actual info about the host, use identity contacts instead'
% receiver_idurl)
hosts = route_info['contacts']
if len(hosts) == 0:
lg.warn('has no known contacts for route with %s' % receiver_idurl)
return
receiver_proto, receiver_host = hosts[0]
publickey = route_info['publickey']
src = ''
src += newpacket.Serialize()
block = encrypted.Block(
my_id.getLocalID(),
'routed incoming data',
0,
key.NewSessionKey(),
key.SessionKeyType(),
True,
src,
EncryptKey=lambda inp: key.EncryptOpenSSHPublicKey(publickey, inp))
routed_packet = signed.Packet(commands.Relay(), newpacket.OwnerID,
my_id.getLocalID(), newpacket.PacketID,
block.Serialize(), receiver_idurl)
pout = packet_out.create(newpacket,
wide=False,
callbacks={},
route={
'packet':
routed_packet,
'proto':
receiver_proto,
'host':
receiver_host,
'remoteid':
receiver_idurl,
'description':
('Relay_%s[%s]_%s' %
(newpacket.Command, newpacket.PacketID,
nameurl.GetName(receiver_idurl)))
})
if _Debug:
lg.out(
_DebugLevel, '<<<Relay-IN %s %s:%s' % (
str(newpacket),
info.proto,
info.host,
))
lg.out(
_DebugLevel, ' sent to %s://%s with %d bytes in %s' %
(receiver_proto, receiver_host, len(src), pout))
del src
del block
del newpacket
del routed_packet
def _do_send_packet_to_router(self,
outpacket,
callbacks,
wide,
response_timeout,
keep_alive,
is_retry=False):
router_idurl = proxy_receiver.GetRouterIDURL()
router_identity_obj = proxy_receiver.GetRouterIdentity()
router_proto_host = proxy_receiver.GetRouterProtoHost()
router_proto, router_host = router_proto_host
publickey = router_identity_obj.publickey
my_original_identity_src = proxy_receiver.ReadMyOriginalIdentitySource(
)
if not router_idurl or not router_identity_obj or not router_proto_host or not my_original_identity_src:
if _Debug:
lg.out(
_DebugLevel,
'proxy_sender._do_send_packet_to_router SKIP because router not ready yet'
)
return self._do_add_pending_packet(outpacket, callbacks, wide,
response_timeout, keep_alive)
if outpacket.RemoteID.to_bin() == router_idurl.to_bin():
if _Debug:
lg.out(
_DebugLevel,
'proxy_sender._do_send_packet_to_router SKIP, packet addressed to router and must be sent in a usual way'
)
return None
try:
raw_data = outpacket.Serialize()
except:
lg.exc('failed to Serialize %s' % outpacket)
return None
# see proxy_router.ProxyRouter : doForwardOutboxPacket() for receiving part
json_payload = {
'f': my_id.getIDURL().to_bin(), # from
't': outpacket.RemoteID.to_bin(), # to
'p': raw_data, # payload
'w': wide, # wide
'i': response_timeout,
'a': keep_alive,
'r': is_retry,
}
if not json_payload['t']:
raise ValueError('receiver idurl was not set')
raw_bytes = serialization.DictToBytes(json_payload)
block = encrypted.Block(
CreatorID=my_id.getIDURL(),
BackupID='routed outgoing data',
BlockNumber=0,
SessionKey=key.NewSessionKey(
session_key_type=key.SessionKeyType()),
SessionKeyType=key.SessionKeyType(),
LastBlock=True,
Data=raw_bytes,
EncryptKey=lambda inp: key.EncryptOpenSSHPublicKey(publickey, inp),
)
block_encrypted = block.Serialize()
newpacket = signed.Packet(
Command=commands.RelayOut(),
OwnerID=outpacket.OwnerID,
CreatorID=my_id.getIDURL(),
PacketID=outpacket.PacketID,
Payload=block_encrypted,
RemoteID=router_idurl,
)
if response_timeout is not None:
# must give some extra time for the proxy re-routing
response_timeout += 10.0
routed_packet = packet_out.create(
outpacket=outpacket,
wide=False,
callbacks={},
route={
'packet':
newpacket,
# pointing "newpacket" to router node
'proto':
router_proto,
'host':
router_host,
'remoteid':
router_idurl,
'description':
'RelayOut_%s[%s]_%s' % (outpacket.Command, outpacket.PacketID,
nameurl.GetName(router_idurl)),
},
response_timeout=response_timeout,
keep_alive=True,
)
for command, cb_list in callbacks.items():
if isinstance(cb_list, list):
for cb in cb_list:
routed_packet.set_callback(command, cb)
else:
routed_packet.set_callback(command, cb_list)
if not is_retry:
_key = (
outpacket.Command,
outpacket.PacketID,
outpacket.RemoteID.to_bin(),
)
self.sent_packets[_key] = (
routed_packet,
outpacket,
)
self.event('relay-out', (outpacket, newpacket, routed_packet))
if _Debug:
lg.out(
_DebugLevel,
'>>>Relay-OUT %s sent to %s://%s with %d bytes, timeout=%r' % (
str(outpacket),
router_proto,
router_host,
len(block_encrypted),
response_timeout,
))
if _PacketLogFileEnabled:
lg.out(
0,
'\033[0;49;36mRELAY OUT %s(%s) with %s bytes from %s to %s via %s\033[0m'
% (
outpacket.Command,
outpacket.PacketID,
len(raw_bytes),
global_id.UrlToGlobalID(outpacket.CreatorID),
global_id.UrlToGlobalID(outpacket.RemoteID),
global_id.UrlToGlobalID(router_idurl),
),
log_name='packet',
showtime=True,
)
del raw_bytes
del block
del newpacket
del outpacket
del router_identity_obj
del router_idurl
del router_proto_host
return routed_packet
