def _query_encoder(query):
"""@see encode"""
query_dict = {
"q": query.rpctype,
"a": {
"id": basic_coder.encode_network_id(query._from)
}
}
# Perform specific rpc encoding
if query.rpctype == 'ping':
pass
elif query.rpctype == 'find_node':
query_dict['a']['target'] = (basic_coder.encode_network_id(
query.target_id))
elif query.rpctype == 'get_peers':
query_dict['a']['info_hash'] = (basic_coder.encode_network_id(
query.target_id))
elif query.rpctype == 'announce_peer':
query_dict['a']['token'] = basic_coder.ltob(query.token)
# Try encoding the port, to see if it is within range
basic_coder.encode_port(query.port)
query_dict['a']['port'] = query.port
query_dict['a']['info_hash'] = (basic_coder.encode_network_id(
query.target_id))
else:
raise _ProtocolFormatError()
return query_dict
def __init__(self,
node_id=None,
address=None,
last_updated=None,
totalrtt=None,
successcount=None,
failcount=None):
# TODO make check interface.Don't use the encoding funcs directlly
# So we don't crash here.
basic_coder.encode_address(address)
basic_coder.encode_network_id(node_id)
# Network information
self.node_id = node_id
self.address = address
# Statistical information
if last_updated is None:
self.last_updated = time.time()
self.totalrtt = 0
self.successcount = 0
self.failcount = 0
else:
self.last_updated = last_updated
self.totalrtt = totalrtt
self.successcount = successcount
self.failcount = failcount
def __init__(self, node_id, address):
# Verify the node_id and address are in the proper format
basic_coder.encode_address(address)
basic_coder.encode_network_id(node_id)
# Network information
self.node_id = node_id
self.address = address
# Statistical information
self.last_updated = time.time()
self.totalrtt = 0
self.successcount = 0
self.failcount = 0
def __init__(self, routing_table_class=TreeRoutingTable,
node_id=None, _reactor=None):
if node_id is None:
node_id = random.getrandbits(constants.id_size)
# Verify the node_id is valid
basic_coder.encode_network_id(node_id)
KRPC_Sender.__init__(self, routing_table_class, node_id, _reactor)
# Datastore is used for storing peers on torrents
self._datastore = defaultdict(set)
self._token_generator = _TokenGenerator()
def __init__(self, node_id, address):
# Verify the node_id and address are in the proper format
basic_coder.encode_address(address)
basic_coder.encode_network_id(node_id)
# Network information
self.node_id = node_id
self.address = address
# Statistical information
# TODO make this time format human readable
self.last_updated = time.time()
self.totalrtt = 0
self.successcount = 0
self.failcount = 0
def _get_hash(self, query, address, secret):
"""
Create the hash code for the given query/address/secret combination
"""
node_id = query._from
infohash = query.target_id
hash = self.hash_constructor()
# The hash code relies on the querying node's ID,
# the target infohash of the query, the address of
# the querier, and a secret that changes every
# constants._secret_timeout seconds
hash.update(basic_coder.encode_network_id(node_id))
hash.update(basic_coder.encode_network_id(infohash))
hash.update(basic_coder.encode_address(address))
hash.update(secret)
# Return the hash as a number rather than a string
numeric_hash_value = basic_coder.btol(hash.digest())
return numeric_hash_value
def __init__(self, node_id=None, address=None, last_updated=None, totalrtt=None, successcount=None, failcount=None):
# TODO make check interface.Don't use the encoding funcs directlly
# So we don't crash here.
basic_coder.encode_address(address)
basic_coder.encode_network_id(node_id)
# Network information
self.node_id = node_id
self.address = address
# Statistical information
if last_updated is None:
self.last_updated = time.time()
self.totalrtt = 0
self.successcount = 0
self.failcount = 0
else:
self.last_updated = last_updated
self.totalrtt = totalrtt
self.successcount = successcount
self.failcount = failcount
def _response_encoder(response):
"""@see encode"""
resp_dict = {"r": {"id": basic_coder.encode_network_id(response._from)}}
if response.nodes is not None:
encoded_nodes = [contact.encode_node(node) for node in response.nodes]
resp_dict['r']['nodes'] = "".join(encoded_nodes)
if response.peers is not None:
encoded_peers = map(basic_coder.encode_address, response.peers)
resp_dict['r']['values'] = encoded_peers
if response.token is not None:
resp_dict['r']['token'] = basic_coder.ltob(response.token)
return resp_dict
def encode_node(node):
"""
Encodes the given node into a network string
The format of the network string is specified in the
BitTorrent DHT extension specification
@see DHTBot/references/README for the DHT BEP
"""
return "%s%s" % (basic_coder.encode_network_id(
node.node_id), basic_coder.encode_address(node.address))
def _response_encoder(response):
"""@see encode"""
resp_dict = {"r": {"id": basic_coder.encode_network_id(response._from)}}
if response.nodes is not None:
encoded_nodes = [contact.encode_node(node) for node in response.nodes]
resp_dict['r']['nodes'] = "".join(encoded_nodes)
if response.peers is not None:
encoded_peers = map(basic_coder.encode_address, response.peers)
resp_dict['r']['values'] = encoded_peers
if response.token is not None:
resp_dict['r']['token'] = basic_coder.ltob(response.token)
return resp_dict
def encode_node(node):
"""
Encodes the given node into a network string
The format of the network string is specified in the
BitTorrent DHT extension specification
@see DHTBot/references/README for the DHT BEP
"""
return "%s%s" % (basic_coder.encode_network_id(node.node_id),
basic_coder.encode_address(node.address))
def _query_encoder(query):
"""@see encode"""
query_dict = {"q": query.rpctype,
"a": { "id": basic_coder.encode_network_id(query._from)}}
# Perform specific rpc encoding
if query.rpctype == 'ping':
pass
elif query.rpctype == 'find_node':
query_dict['a']['target'] = (
basic_coder.encode_network_id(query.target_id))
elif query.rpctype == 'get_peers':
query_dict['a']['info_hash'] = (
basic_coder.encode_network_id(query.target_id))
elif query.rpctype == 'announce_peer':
query_dict['a']['token'] = basic_coder.ltob(query.token)
# Try encoding the port, to see if it is within range
basic_coder.encode_port(query.port)
query_dict['a']['port'] = query.port
query_dict['a']['info_hash'] = (
basic_coder.encode_network_id(query.target_id))
else:
raise _ProtocolFormatError()
return query_dict
def test_encode_network_id_validIDs(self):
self.assertEquals("\x00" * 20, encode_network_id(0))
self.assertEquals("\xff" * 20, encode_network_id(2**160 - 1))
def test_encode_network_id_validIDs(self):
self.assertEquals("\x00" * 20, encode_network_id(0))
self.assertEquals("\xff" * 20, encode_network_id(2**160 - 1))
