diff --git a/src/network/bmproto.py b/src/network/bmproto.py index 099dc358..698f6df9 100644 --- a/src/network/bmproto.py +++ b/src/network/bmproto.py @@ -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." diff --git a/src/network/connectionpool.py b/src/network/connectionpool.py index 719c798c..bbb09d7e 100644 --- a/src/network/connectionpool.py +++ b/src/network/connectionpool.py @@ -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': } 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()] diff --git a/src/network/dandelion.py b/src/network/dandelion.py index ec9384e5..34654c2e 100644 --- a/src/network/dandelion.py +++ b/src/network/dandelion.py @@ -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 diff --git a/src/network/downloadthread.py b/src/network/downloadthread.py index 6e1f9ca8..0ed89f9c 100644 --- a/src/network/downloadthread.py +++ b/src/network/downloadthread.py @@ -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( diff --git a/src/network/httpd.py b/src/network/httpd.py index 1679f864..b92adbd7 100644 --- a/src/network/httpd.py +++ b/src/network/httpd.py @@ -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) diff --git a/src/network/randomtrackingdict.py b/src/network/randomtrackingdict.py index c5c460b4..1e81d3ad 100644 --- a/src/network/randomtrackingdict.py +++ b/src/network/randomtrackingdict.py @@ -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 diff --git a/src/network/stats.py b/src/network/stats.py index 8ce18226..caab3c19 100644 --- a/src/network/stats.py +++ b/src/network/stats.py @@ -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 diff --git a/src/network/tcp.py b/src/network/tcp.py index 586dedd6..5cf96c6d 100644 --- a/src/network/tcp.py +++ b/src/network/tcp.py @@ -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) diff --git a/src/network/tls.py b/src/network/tls.py index 08969227..040f5e4f 100644 --- a/src/network/tls.py +++ b/src/network/tls.py @@ -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 diff --git a/src/network/udp.py b/src/network/udp.py index d3421806..6f796331 100644 --- a/src/network/udp.py +++ b/src/network/udp.py @@ -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: