def handler(node, src_id, msg):
# Is this a response to our request?
try:
msg = OrderedDict(msg)
# Not a UNL response.
if msg[u"type"] != u"unl_response":
_log.debug("unl response: type !=")
return
# Invalid UNL.
their_unl = UNL(value=msg[u"unl"]).deconstruct()
if their_unl is None:
_log.debug("unl response:their unl !=")
return
# Invalid signature.
if not verify_signature(msg, wif, their_node_id):
_log.debug("unl response: their sig")
return
# Everything passed: fire callback.
d.callback(msg[u"unl"])
# Remove this callback.
node.remove_message_handler(handler)
except (ValueError, KeyError) as e:
_log.debug(str(e))
_log.debug("Protocol: invalid JSON")
def process_unl_requests(node, src_id, msg):
unl = node._data_transfer.net.unl.value
try:
msg = OrderedDict(msg)
# Not a UNL request.
if msg[u"type"] != u"unl_request":
return
# Check signature.
their_node_id = address_to_node_id(msg[u"requester"])
if not verify_signature(msg, node.get_key(), their_node_id):
return
# Response.
response = sign(OrderedDict(
{
u"type": u"unl_response",
u"requestee": node.get_address(),
u"unl": unl
}
), node.get_key())
# Send response.
node.relay_message(their_node_id, response.items())
except (ValueError, KeyError) as e:
global _log
_log.debug(str(e))
_log.debug("Protocol: invalid JSON")
def handler(node, msg):
# Is this a response to our request?
try:
msg = util.list_to_ordered_dict(msg)
# Not a UNL response.
if msg[u"type"] != u"unl_response":
_log.debug("unl response: type !=")
return
# Invalid UNL.
their_unl = UNL(value=msg[u"unl"]).deconstruct()
if their_unl is None:
_log.debug("unl response:their unl !=")
return
# Invalid signature.
if not verify_signature(msg, wif, their_node_id):
_log.debug("unl response: their sig")
return
# Everything passed: fire callback.
d.callback(msg[u"unl"])
# Remove this callback.
node.remove_message_handler(handler)
except (ValueError, KeyError):
_log.debug("unl response:val or key er")
pass # not a unl response
def handle_requests(node, msg):
_log.debug("In handle requests")
# Check message type.
msg = list_to_ordered_dict(msg)
if msg[u"type"] != u"test_bandwidth_request":
_log.debug("req: Invalid request")
return -1
# Drop request if test already active.
if self.test_node_unl is not None:
_log.debug("req: test already active")
return -2
# Check they got our node unl right.
our_unl = self.transfer.net.unl.value
if our_unl != msg[u"test_node_unl"]:
_log.debug("req: they got our node unl wrong")
return -3
# Check sig.
src_node_id = parse_node_id_from_unl(msg[u"requester"])
if not verify_signature(msg, self.wif, src_node_id):
_log.debug("req: Invalid sig")
return -4
# Build response.
res = OrderedDict([
(u"type", u"test_bandwidth_response"),
(u"timestamp", time.time()),
(u"requestee", our_unl),
(u"request", msg)
])
# Sign response
res = sign(res, self.wif)
# Save their node ID!
self.test_node_unl = msg[u"requester"]
# Add accept handler for bandwidth tests.
accept_handler = build_accept_handler(self, msg)
self.add_handler("accept", accept_handler)
# Add start handler.
start_handler = build_start_handler(self, msg)
self.add_handler("start", start_handler)
# Set start time.
self.start_time = time.time()
# Save data id.
self.data_id = msg[u"data_id"]
# Send request back to source.
res = ordered_dict_to_list(res)
self.api.repeat_relay_message(src_node_id, res)
_log.debug("req: got request")
return res
def process_unl_requests(node, msg):
_log.debug("In process unl requests: ")
_log.debug(msg)
unl = node._data_transfer.net.unl.value
_log.debug(unl)
try:
msg = list_to_ordered_dict(msg)
# Not a UNL request.
if msg[u"type"] != u"unl_request":
_log.debug("unl req: invalid type")
_log.debug(msg[u"type"])
return
# Check signature.
their_node_id = address_to_node_id(msg[u"requester"])
if not verify_signature(msg, node.get_key(), their_node_id):
_log.debug("unl req: invalid sig")
return
# Response.
response = sign(OrderedDict(
{
u"type": u"unl_response",
u"requestee": node.get_address(),
u"unl": unl
}
), node.get_key())
# Send response.
response = ordered_dict_to_list(response)
node.repeat_relay_message(their_node_id, response)
except (ValueError, KeyError):
_log.debug("val err or key err")
pass # not a unl request
def handle_responses(node, msg):
# Check message type.
msg = list_to_ordered_dict(msg)
if msg[u"type"] != u"test_bandwidth_response":
_log.debug("res: Invalid response")
return -1
# Transfer already active.
if self.test_node_unl is not None:
_log.debug("res: transfer already active")
return -2
# Check we sent the request.
req = msg[u"request"]
_log.debug(req)
# Check node IDs match.
if req[u"test_node_unl"] != msg[u"requestee"]:
_log.debug("res: node ids don't match")
return -4
# Check signature.
valid_sig = verify_signature(
msg[u"request"],
self.wif,
self.api.get_id()
)
# Quit if sig is invalid.
if not valid_sig:
_log.debug("res: our request sig was invalid")
return -3
# Check their sig.
src_node_id = parse_node_id_from_unl(msg[u"requestee"])
if not verify_signature(msg, self.wif, src_node_id):
_log.debug("res: their sig did not match")
return -5
# Set active node ID.
self.test_node_unl = msg[u"requestee"]
# Register accept handler.
accept_handler = build_accept_handler(self, req)
self.add_handler("accept", accept_handler)
# Register start handler.
start_handler = build_start_handler(self, req)
self.add_handler("start", start_handler)
# Send upload request to remote host!
contract_id = self.transfer.data_request(
"download",
req[u"data_id"],
req[u"file_size"],
req[u"test_node_unl"]
)
# Fire error.
def errback(ret):
if self.active_test is not None:
self.active_test.errback(ret)
self.reset_state()
# Register error handler for transfer.
self.transfer.defers[contract_id].addErrback(errback)
# Build completion handler.
completion_handler = build_completion_handler(
self,
req,
accept_handler
)
# Register completion handler.
self.add_handler("complete", completion_handler)
_log.debug("res: got response")
