Bitmessage/PyBitmessage-2024-12-19
Archived
2
0
Fork 0
Code Issues 168 Pull Requests 52 Actions Packages Projects Releases 5 Wiki Activity

Merge pull request #22 from jaicis/fix#5

Browse Source 
Formatting commits
This commit is contained in:
lakshyacis 2020-01-10 20:22:11 +05:30 committed by GitHub
commit cb8541ea96
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 7 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
src/network/bmproto.py
View File

@ -105,20 +105,11 @@ class BMProto(AdvancedDispatcher, ObjectTracker):
count += 1
if self.command == 'verack'.encode():
addr_verack += 1
# print('the addr_verack count are -{}'.format(addr_verack))
if self.command == 'version'.encode():
addr_version += 1
# print('the addr_version count are -{}'.format(addr_version))
if self.command == 'addr'.encode():
addr_count += 1
# print('the addr_count count are -{}'.format(addr_count))
if self.magic != 0xE9BEB4D9:
# skip 1 byte in order to sync
# in the advancedispatched and length commend's
# escape the 1 length
self.set_state("bm_header", length=1)
self.bm_proto_reset()
logger.debug('Bad magic')
@ -186,7 +177,6 @@ class BMProto(AdvancedDispatcher, ObjectTracker):
self.set_state("close")
return False
if retval:
# print('if retval is true and inside the if ')
self.set_state("bm_header", length=self.payloadLength)
self.bm_proto_reset()
# else assume the command requires a different state to follow
@ -451,7 +441,7 @@ class BMProto(AdvancedDispatcher, ObjectTracker):
if self.object.inventoryHash in Inventory() and Dandelion().hasHash(self.object.inventoryHash):
Dandelion().removeHash(self.object.inventoryHash, "cycle detection")
[self.object.inventoryHash] = (
Inventory()[self.object.inventoryHash] = (
self.object.objectType, self.object.streamNumber,
memoryview(self.payload[objectOffset:]), self.object.expiresTime,
memoryview(self.object.tag)
@ -539,7 +529,6 @@ class BMProto(AdvancedDispatcher, ObjectTracker):
return False
def bm_command_version(self):
# print('inside the bmproto ')
"""
Incoming version.
Parse and log, remember important things, like streams, bitfields, etc.
@ -624,9 +613,6 @@ class BMProto(AdvancedDispatcher, ObjectTracker):
return False
if self.destination in connectionpool.BMConnectionPool().inboundConnections:
try:
# print('+++++++++++++++++++++++++++')
# print('self destination host -{}'.format(self.destination.host))
# print('++++++++++++++++++++++++++++++')
if not protocol.checkSocksIP(self.destination.host):
self.append_write_buf(protocol.assembleErrorMessage(
errorText="Too many connections from your IP."

36
src/network/connectionpool.py
View File

@ -195,7 +195,6 @@ class BMConnectionPool(object):
port = int(BMConfigParser().safeGet("bitmessagesettings", "port"))
# correct port even if it changed
ls = TCPServer(host=bind, port=port)
print('inside the startListening method')
self.listeningSockets[ls.destination] = ls
def startUDPSocket(self, bind=None):
@ -344,21 +343,6 @@ class BMConnectionPool(object):
except socket.error as e:
if e.errno == errno.ENETUNREACH:
continue
# # print('++++++++++++++++++++++++++++++++++++++++++')
# # print('self.inboundConnections.values()-{}'.format(self.inboundConnections.values()))
# # print('self.outboundConnections.values() -{}'.format(self.outboundConnections.values()))
# # print('+++++++++++++++++++++++++++++++++++++++++++')
# else:
# # for i in (
# # list(self.inboundConnections.values()) +
# # list(self.outboundConnections.values())
# # ):
# for i in (
# [inboundConnections for inboundConnections in self.inboundConnections.values()] +
# [inboundConnections for inboundConnections in self.outboundConnections.values()]
# ):
self._lastSpawned = time.time()
else:
for i in self.connections():
@ -377,7 +361,6 @@ class BMConnectionPool(object):
self.startListening(bind)
logger.info('Listening for incoming connections.')
if False:
# self.udpSockets :- {'0.0.0.0': <network.udp.UDPSocket connected at 0x7f95cce7d7b8>}
if BMConfigParser().safeGet('network', 'bind') == '':
self.startUDPSocket()
else:
@ -407,15 +390,6 @@ class BMConnectionPool(object):
reaper = []
# # for i in (
# # list(self.inboundConnections.values()) +
# # list(self.outboundConnections.values())
# # ):
# for i in (
# [inboundConnections for inboundConnections in self.inboundConnections.values()] +
# [outboundConnections for outboundConnections in self.outboundConnections.values()]
# ):
for i in self.connections():
minTx = time.time() - 20
if i.fullyEstablished:
@ -427,17 +401,7 @@ class BMConnectionPool(object):
i.close_reason = "Timeout (%is)" % (
time.time() - i.lastTx)
i.set_state("close")
# for i in (
# list(self.inboundConnections.values()) +
# list(self.outboundConnections.values()) +
# list(self.listeningSockets.values()) +
# list(self.udpSockets.values())
# ):
for i in (
# [inboundConnections for inboundConnections in self.inboundConnections.values()] +
# [outboundConnections for outboundConnections in self.outboundConnections.values()] +
# [listeningSockets for listeningSockets in self.listeningSockets.values()] +
# [udpSockets for udpSockets in self.udpSockets.values()]
self.connections() +
[listeningSockets for listeningSockets in self.listeningSockets.values()] +
[udpSockets for udpSockets in self.udpSockets.values()]

8
src/network/dandelion.py
View File

@ -118,14 +118,6 @@ class Dandelion(object):
except AttributeError:
pass
# for k, v in iter({
# k: v for k, v in iter([hasmap for hasamp in self.hashMap.items()])
# if v.child is None
# }).items():
# self.hashMap[k] = Stem(
# connection, v.stream, self.poissonTimeout())
# invQueue.put((v.stream, k, v.child))
def maybeRemoveStem(self, connection):
"""
Remove current connection from the stem list (called e.g. when

7
src/network/downloadthread.py
View File

@ -41,13 +41,6 @@ class DownloadThread(StoppableThread):
def run(self):
while not self._stopped:
requested = 0
# Choose downloading peers randomly
# connections = [
# x for x in
# list(BMConnectionPool().inboundConnections.values()) +
# list(BMConnectionPool().outboundConnections.values())
# if x.fullyEstablished]
connections = BMConnectionPool().establishedConnections()
helper_random.randomshuffle(connections)
requestChunk = max(int(

6
src/network/httpd.py
View File

@ -130,10 +130,7 @@ class HTTPServer(asyncore.dispatcher):
pair = self.accept()
if pair is not None:
sock, _ = pair
# print 'Incoming connection from %s' % repr(addr)
self.connections += 1
# if self.connections % 1000 == 0:
# print "Processed %i connections, active %i" % (self.connections, len(asyncore.socket_map))
HTTPRequestHandler(sock)
@ -149,10 +146,7 @@ class HTTPSServer(HTTPServer):
pair = self.accept()
if pair is not None:
sock, _ = pair
# print 'Incoming connection from %s' % repr(addr)
self.connections += 1
# if self.connections % 1000 == 0:
# print "Processed %i connections, active %i" % (self.connections, len(asyncore.socket_map))
HTTPSRequestHandler(sock)

10
src/network/randomtrackingdict.py
View File

@ -14,10 +14,12 @@ class RandomTrackingDict(object):
"""
Dict with randomised order and tracking.
Keeps a track of how many items have been requested from the dict, and timeouts. Resets after all objects have been
retrieved and timed out. The main purpose of this isn't as much putting related code together as performance
optimisation and anonymisation of downloading of objects from other peers. If done using a standard dict or array,
it takes too much CPU (and looks convoluted). Randomisation helps with anonymity.
Keeps a track of how many items have been requested from the dict, and timeouts.
Resets after all objects have been retrieved and timed out.
The main purpose of this isn't as much putting related code together
as performance optimisation and anonymisation of downloading of objects from other peers.
If done using a standard dict or array, it takes too much CPU (and looks convoluted).
Randomisation helps with anonymity.
"""
# pylint: disable=too-many-instance-attributes
maxPending = 10

22
src/network/stats.py
View File

@ -19,21 +19,6 @@ currentSentSpeed = 0
def connectedHostsList():
"""List of all the connected hosts"""
# retval = []
# # for i in list(BMConnectionPool().inboundConnections.values()) + \
# # list(BMConnectionPool().outboundConnections.values()):
# outBoundConnections = [outConnection for outConnection in BMConnectionPool().outboundConnections.values()]
# inBoundConnections = [inConnection for inConnection in BMConnectionPool().inboundConnections.values()]
# for i in outBoundConnections+inBoundConnections:
# if not i.fullyEstablished:
# continue
# try:
# retval.append(i)
# except AttributeError:
# pass
# return retval
return BMConnectionPool().establishedConnections()
@ -81,11 +66,4 @@ def pendingDownload():
def pendingUpload():
"""Getting pending uploads"""
# tmp = {}
# for connection in BMConnectionPool().inboundConnections.values() + \
# BMConnectionPool().outboundConnections.values():
# for k in connection.objectsNewToThem.keys():
# tmp[k] = True
# This probably isn't the correct logic so it's disabled
# return len(tmp)
return 0

4
src/network/tcp.py
View File

@ -94,8 +94,6 @@ class TCPConnection(BMProto, TLSDispatcher):
self.network_group = protocol.network_group(self.destination.host)
ObjectTracker.__init__(self) # pylint: disable=non-parent-init-called
self.bm_proto_reset()
# print('--------------tcp------------------')
# from network import stats
self.set_state("bm_header", expectBytes=protocol.Header.size)
def antiIntersectionDelay(self, initial=False):
@ -152,7 +150,6 @@ class TCPConnection(BMProto, TLSDispatcher):
))
self.antiIntersectionDelay(True)
self.fullyEstablished = True
# print('inside the set_connection_fully_established in tcp file')
if self.isOutbound:
knownnodes.increaseRating(self.destination)
Dandelion().maybeAddStem(self)
@ -380,7 +377,6 @@ class TCPServer(AdvancedDispatcher):
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.set_reuse_addr()
for attempt in range(50):
print('inside the attempt of line 371')
try:
if attempt > 0:
logger.warning('Failed to bind on port %s', port)

8
src/network/tls.py
View File

@ -68,7 +68,6 @@ class TLSDispatcher(AdvancedDispatcher):
self.isSSL = False
def state_tls_init(self):
# print()
"""Prepare sockets for TLS handshake"""
# pylint: disable=attribute-defined-outside-init
self.isSSL = True
@ -95,9 +94,7 @@ class TLSDispatcher(AdvancedDispatcher):
ciphers=self.ciphers, do_handshake_on_connect=False)
self.sslSocket.setblocking(0)
self.want_read = self.want_write = True
# print('before tls file python 98 state are :- {}'.format(self.state))
self.set_state("tls_handshake")
# print('after tls file python 100 state are :- {}'.format(self.state))
return False
# if hasattr(self.socket, "context"):
# self.socket.context.set_ecdh_curve("secp256k1")
@ -186,23 +183,18 @@ class TLSDispatcher(AdvancedDispatcher):
return
def tls_handshake(self):
# print('inside the tls_handshake')
"""Perform TLS handshake and handle its stages"""
# wait for flush
if self.write_buf:
return False
# Perform the handshake.
try:
# print "handshaking (internal)"
self.sslSocket.do_handshake()
except ssl.SSLError as err:
# print "%s:%i: handshake fail" % (self.destination.host, self.destination.port)
self.want_read = self.want_write = False
if err.args[0] == ssl.SSL_ERROR_WANT_READ:
# print "want read"
self.want_read = True
if err.args[0] == ssl.SSL_ERROR_WANT_WRITE:
# print "want write"
self.want_write = True
if not (self.want_write or self.want_read):
raise

4
src/network/udp.py
View File

@ -65,19 +65,15 @@ class UDPSocket(BMProto): # pylint: disable=too-many-instance-attributes
# only addr (peer discovery), error and object are implemented
def bm_command_getdata(self):
# return BMProto.bm_command_getdata(self)
return True
def bm_command_inv(self):
# return BMProto.bm_command_inv(self)
return True
def bm_command_addr(self):
addresses = self._decode_addr()
# only allow peer discovery from private IPs in order to avoid
# attacks from random IPs on the internet
# if not self.local:
# return True
self.local = True
remoteport = False
for seenTime, stream, services, ip, port in addresses: