From ec618d9d1a198d1e7216101f2aff1bd8d011c3fd Mon Sep 17 00:00:00 2001 From: "jai.s" Date: Mon, 27 Jan 2020 21:41:46 +0530 Subject: [PATCH] Solved sending message issues --- src/class_objectProcessor.py | 8 +-- src/class_singleWorker.py | 92 +++++++++-------------------------- src/class_sqlThread.py | 1 - src/inventory.py | 3 -- src/network/bmobject.py | 2 +- src/network/bmproto.py | 55 ++++----------------- src/network/downloadthread.py | 2 +- src/network/invthread.py | 1 - src/network/tcp.py | 27 +++++----- src/proofofwork.py | 9 ---- src/storage/sqlite.py | 39 ++------------- 11 files changed, 54 insertions(+), 185 deletions(-) diff --git a/src/class_objectProcessor.py b/src/class_objectProcessor.py index f7930dce..6a832aa7 100644 --- a/src/class_objectProcessor.py +++ b/src/class_objectProcessor.py @@ -141,7 +141,7 @@ class objectProcessor(threading.Thread): if bytes(data[readPosition:]) in shared.ackdataForWhichImWatching: logger.info('This object is an acknowledgement bound for me.') - del shared.ackdataForWhichImWatching[data[readPosition:]] + del shared.ackdataForWhichImWatching[bytes(data[readPosition:])] sqlExecute( 'UPDATE sent SET status=?, lastactiontime=?' ' WHERE ackdata=?', @@ -234,7 +234,6 @@ class objectProcessor(threading.Thread): logger.debug( 'the tag requested in this getpubkey request is: %s', hexlify(requestedTag)) - # import pdb;pdb.set_trace() if bytes(requestedTag) in shared.myAddressesByTag: myAddress = shared.myAddressesByTag[bytes(requestedTag)] @@ -441,15 +440,12 @@ class objectProcessor(threading.Thread): return # Let us try to decrypt the pubkey - print("TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT#################################################", tag) toAddress, _ = state.neededPubkeys[bytes(tag)] #check with py2 - # import pdb;pdb.set_trace() - if protocol.decryptAndCheckPubkeyPayload(bytes(data), toAddress) == \ + if protocol.decryptAndCheckPubkeyPayload(bytes(data), toAddress) == \ 'successful': # At this point we know that we have been waiting on this # pubkey. This function will command the workerThread # to start work on the messages that require it. - print("decryptAndCheckPubkeyPayload completed#########################################################") self.possibleNewPubkey(toAddress) # Display timing data diff --git a/src/class_singleWorker.py b/src/class_singleWorker.py index 486308d7..f6494198 100644 --- a/src/class_singleWorker.py +++ b/src/class_singleWorker.py @@ -224,6 +224,7 @@ class singleWorker(StoppableThread): if log_time: start_time = time.time() trialValue, nonce = proofofwork.run(target, initialHash) + print("nonce calculated value#############################", nonce) self.logger.info( '%s Found proof of work %s Nonce: %s', log_prefix, trialValue, nonce @@ -679,7 +680,6 @@ class singleWorker(StoppableThread): """Send a message-type object (assemble the object, perform PoW and put it to the inv announcement queue)""" # pylint: disable=too-many-nested-blocks # Reset just in case - # import pdb;pdb.set_trace() sqlExecute( '''UPDATE sent SET status='msgqueued' ''' ''' WHERE status IN ('doingpubkeypow', 'doingmsgpow')''') @@ -690,7 +690,6 @@ class singleWorker(StoppableThread): ''' and folder LIKE '%sent%' ''') # while we have a msg that needs some work for row in queryreturn: - print(row, "rowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowv") toaddress, fromaddress, subject, message, \ ackdata, status, TTL, retryNumber, encoding = row # toStatus @@ -732,7 +731,6 @@ class singleWorker(StoppableThread): toaddress ) # If we have the needed pubkey in the pubkey table already, - print("sendmsg line no 734#####################################################################") if queryreturn != []: # set the status of this msg to doingmsgpow sqlExecute( @@ -753,7 +751,6 @@ class singleWorker(StoppableThread): ) # We don't have the needed pubkey in the pubkeys table already. else: - print("sendmsg line no 756#####################################################################") if toAddressVersionNumber <= 3: toTag = '' else: @@ -763,16 +760,14 @@ class singleWorker(StoppableThread): ).digest()).digest()[32:] if toaddress in state.neededPubkeys or \ toTag in state.neededPubkeys: - print("sendmsg line no 766#####################################################################") # We already sent a request for the pubkey sqlExecute( '''UPDATE sent SET status='awaitingpubkey', ''' ''' sleeptill=? WHERE toaddress=? ''' ''' AND status='msgqueued' ''', - int(10), + int(time.time()) + 2.5 * 24 * 60 * 60, toaddress ) - print("sendmsg line no 774#####################################################################") queues.UISignalQueue.put(( 'updateSentItemStatusByToAddress', ( toaddress, @@ -780,11 +775,9 @@ class singleWorker(StoppableThread): "MainWindow", "Encryption key was requested earlier.")) )) - print("sendmsg line no 783#####################################################################") # on with the next msg on which we can do some work continue else: - print("sendmsg line no 785#####################################################################") # We have not yet sent a request for the pubkey needToRequestPubkey = True # If we are trying to send to address @@ -812,7 +805,6 @@ class singleWorker(StoppableThread): highlevelcrypto.makeCryptor( hexlify(privEncryptionKey)) ) - for value in Inventory().by_type_and_tag(1, toTag): # if valid, this function also puts it # in the pubkeys table. @@ -858,7 +850,6 @@ class singleWorker(StoppableThread): self.requestPubKey(toaddress) # on with the next msg on which we can do some work continue - print("sendmsg line no 856#####################################################################") # At this point we know that we have the necessary pubkey # in the pubkeys table. TTL *= 2**retryNumber @@ -867,10 +858,8 @@ class singleWorker(StoppableThread): # add some randomness to the TTL TTL = int(TTL + helper_random.randomrandrange(-300, 300)) embeddedTime = int(time.time() + TTL) - print("sendmsg line no 870#####################################################################") # if we aren't sending this to ourselves or a chan if not BMConfigParser().has_section(toaddress): - print("sendmsg line no 873#####################################################################") shared.ackdataForWhichImWatching[ackdata] = 0 queues.UISignalQueue.put(( 'updateSentItemStatusByAckdata', ( @@ -878,22 +867,23 @@ class singleWorker(StoppableThread): tr._translate( "MainWindow", "Looking up the receiver\'s public key")) - )) + )) self.logger.info('Sending a message.') - self.logger.debug( - 'First 150 characters of message: %s', - repr(message[:150]) - ) + # self.logger.debug( + # 'First 150 characters of message: %s', + # repr(message[:150]) + # ) # Let us fetch the recipient's public key out of # our database. If the required proof of work difficulty # is too hard then we'll abort. + queryreturn = sqlQuery( 'SELECT transmitdata FROM pubkeys WHERE address=?', toaddress) for row in queryreturn: # pylint: disable=redefined-outer-name pubkeyPayload, = row - + # The pubkey message is stored with the following items # all appended: # -address version @@ -917,7 +907,7 @@ class singleWorker(StoppableThread): # if receiver is a mobile device who expects that their # address RIPE is included unencrypted on the front of - # the message.. + # the message.. if protocol.isBitSetWithinBitfield(behaviorBitfield, 30): # if we are Not willing to include the receiver's # RIPE hash on the message.. @@ -954,9 +944,8 @@ class singleWorker(StoppableThread): pubEncryptionKeyBase256 = pubkeyPayload[ readPosition:readPosition + 64] readPosition += 64 - # Let us fetch the amount of work required by the recipient. - if toAddressVersionNumber == 2: + if toAddressVersionNumber == 2: requiredAverageProofOfWorkNonceTrialsPerByte = \ defaults.networkDefaultProofOfWorkNonceTrialsPerByte requiredPayloadLengthExtraBytes = \ @@ -970,6 +959,7 @@ class singleWorker(StoppableThread): "There is no required difficulty for" " version 2 addresses like this.")) )) + elif toAddressVersionNumber >= 3: requiredAverageProofOfWorkNonceTrialsPerByte, \ varintLength = decodeVarint( @@ -996,7 +986,6 @@ class singleWorker(StoppableThread): requiredAverageProofOfWorkNonceTrialsPerByte, requiredPayloadLengthExtraBytes ) - queues.UISignalQueue.put( ( 'updateSentItemStatusByAckdata', @@ -1021,17 +1010,15 @@ class singleWorker(StoppableThread): ) ) ) - if status != 'forcepow': - maxacceptablenoncetrialsperbyte = BMConfigParser().getint( - 'bitmessagesettings', 'maxacceptablenoncetrialsperbyte') - maxacceptablepayloadlengthextrabytes = BMConfigParser().getint( - 'bitmessagesettings', 'maxacceptablepayloadlengthextrabytes') + maxacceptablenoncetrialsperbyte = int(BMConfigParser().get( + 'bitmessagesettings', 'maxacceptablenoncetrialsperbyte')) + maxacceptablepayloadlengthextrabytes = int(BMConfigParser().get( + 'bitmessagesettings', 'maxacceptablepayloadlengthextrabytes')) cond1 = maxacceptablenoncetrialsperbyte and \ requiredAverageProofOfWorkNonceTrialsPerByte > maxacceptablenoncetrialsperbyte cond2 = maxacceptablepayloadlengthextrabytes and \ requiredPayloadLengthExtraBytes > maxacceptablepayloadlengthextrabytes - if cond1 or cond2: # The demanded difficulty is more than # we are willing to do. @@ -1055,12 +1042,10 @@ class singleWorker(StoppableThread): l10n.formatTimestamp())))) continue else: # if we are sending a message to ourselves or a chan.. - print("sendmsg line no 1058#####################################################################") self.logger.info('Sending a message.') self.logger.debug( 'First 150 characters of message: %r', message[:150]) behaviorBitfield = protocol.getBitfield(fromaddress) - try: privEncryptionKeyBase58 = BMConfigParser().get( toaddress, 'privencryptionkey') @@ -1097,7 +1082,6 @@ class singleWorker(StoppableThread): "MainWindow", "Doing work necessary to send message.")) )) - print("sendmsg line no 1093#####################################################################") # Now we can start to assemble our message. payload = encodeVarint(fromAddressVersionNumber) payload += encodeVarint(fromStreamNumber) @@ -1105,10 +1089,8 @@ class singleWorker(StoppableThread): # that can be expected from me. (See # https://bitmessage.org/wiki/Protocol_specification#Pubkey_bitfield_features) payload += protocol.getBitfield(fromaddress) - print("sendmsg line no 1101#####################################################################") # We need to convert our private keys to public keys in order # to include them. - # import pdb; pdb.set_trace() try: privSigningKeyHex, privEncryptionKeyHex, \ pubSigningKey, pubEncryptionKey = self._getKeysForAddress( @@ -1123,9 +1105,7 @@ class singleWorker(StoppableThread): " (your address) in the keys.dat file.")) )) continue - print("sendmsg line no 1119#####################################################################") payload += pubSigningKey + pubEncryptionKey - if fromAddressVersionNumber >= 3: # If the receiver of our message is in our address book, # subscriptions list, or whitelist then we will allow them to @@ -1142,13 +1122,11 @@ class singleWorker(StoppableThread): fromaddress, 'noncetrialsperbyte'))) payload += encodeVarint(int(BMConfigParser().get( fromaddress, 'payloadlengthextrabytes'))) - print('@@@@@@@@@@@@@@ before payload creating@@@@@@@@@@@@@@@@') # This hash will be checked by the receiver of the message # to verify that toRipe belongs to them. This prevents # a Surreptitious Forwarding Attack. payload += toRipe payload += encodeVarint(encoding) # message encoding type - # import pdb;pdb.set_trace() encodedMessage = helper_msgcoding.MsgEncode( {"subject": subject, "body": message}, encoding ) @@ -1174,7 +1152,7 @@ class singleWorker(StoppableThread): fullAckPayload = self.generateFullAckMessage( ackdata, toStreamNumber, TTL) payload += encodeVarint(len(fullAckPayload)) - payload += fullAckPayload.encode() + payload += fullAckPayload if isinstance(fullAckPayload,bytes) else fullAckPayload.encode() dataToSign = pack('>Q', embeddedTime) + '\x00\x00\x00\x02'.encode() + \ encodeVarint(1) + encodeVarint(toStreamNumber) + payload signature = highlevelcrypto.sign(dataToSign, privSigningKeyHex) @@ -1201,7 +1179,6 @@ class singleWorker(StoppableThread): ).arg(l10n.formatTimestamp())) )) continue - print('@@@@@@@@@@@@@@ before encryptedPayload creating@@@@@@@@@@@@@@@@') encryptedPayload = pack('>Q', embeddedTime) encryptedPayload += '\x00\x00\x00\x02'.encode() # object type: msg encryptedPayload += encodeVarint(1) # msg version @@ -1226,10 +1203,7 @@ class singleWorker(StoppableThread): powStartTime = time.time() initialHash = hashlib.sha512(encryptedPayload).digest() - # import pdb; pdb.set_trace() - trialValue, nonce = proofofwork.run(target, initialHash) - print("nonce calculated value#############################", nonce) self.logger.info( '(For msg message) Found proof of work %s Nonce: %s', trialValue, nonce @@ -1242,8 +1216,6 @@ class singleWorker(StoppableThread): ) except: pass - print("line no 1234#########################################") - # import pdb; pdb.set_trace() encryptedPayload = pack('>Q', nonce) + encryptedPayload # Sanity check. The encryptedPayload size should never be @@ -1257,18 +1229,12 @@ class singleWorker(StoppableThread): len(encryptedPayload) ) continue - print("line no 1248#########################################") inventoryHash = calculateInventoryHash(encryptedPayload) - print("line no 1250248#########################################") objectType = 2 - print("line no 1252#########################################") - # import pdb; pdb.set_trace() inventoryHashlist = ( objectType, toStreamNumber,encryptedPayload, embeddedTime, '') - print("line no 1255#########################################") - # import pdb; pdb.set_trace() - Inventory()[inventoryHashlist] - print("line no 1257#########################################") + Inventory()._realInventory[inventoryHash] = ( + objectType, toStreamNumber, encryptedPayload, embeddedTime, '') if BMConfigParser().has_section(toaddress) or \ not protocol.checkBitfield(behaviorBitfield, protocol.BITFIELD_DOESACK): queues.UISignalQueue.put(( @@ -1289,7 +1255,6 @@ class singleWorker(StoppableThread): " Sent on %1" ).arg(l10n.formatTimestamp())) )) - print("line no 1282#########################################") self.logger.info( 'Broadcasting inv for my msg(within sendmsg function): %s', hexlify(inventoryHash) @@ -1297,7 +1262,6 @@ class singleWorker(StoppableThread): queues.invQueue.put((toStreamNumber, inventoryHash)) # Update the sent message in the sent table with the # necessary information. - print("line no 1290#########################################") if BMConfigParser().has_section(toaddress) or \ not protocol.checkBitfield(behaviorBitfield, protocol.BITFIELD_DOESACK): newStatus = 'msgsentnoackexpected' @@ -1313,7 +1277,6 @@ class singleWorker(StoppableThread): ) # If we are sending to ourselves or a chan, let's put # the message in our own inbox. - print("line no 1306#########################################") if BMConfigParser().has_section(toaddress): # Used to detect and ignore duplicate messages in our inbox sigHash = hashlib.sha512(hashlib.sha512( @@ -1340,7 +1303,6 @@ class singleWorker(StoppableThread): def requestPubKey(self, toAddress): """Send a getpubkey object""" - # import pdb;pdb.set_trace() toStatus, addressVersionNumber, streamNumber, ripe = decodeAddress( toAddress) if toStatus != 'success': @@ -1350,7 +1312,6 @@ class singleWorker(StoppableThread): toAddress ) return - queryReturn = sqlQuery( '''SELECT retrynumber FROM sent WHERE toaddress=? ''' ''' AND (status='doingpubkeypow' OR status='awaitingpubkey') ''' @@ -1365,10 +1326,9 @@ class singleWorker(StoppableThread): ) return retryNumber = queryReturn[0][0] - - if addressVersionNumber <= 3: + if addressVersionNumber <= 3: state.neededPubkeys[toAddress] = 0 - elif addressVersionNumber >= 4: + elif addressVersionNumber >= 4: # If the user just clicked 'send' then the tag # (and other information) will already be in the # neededPubkeys dictionary. But if we are recovering @@ -1424,17 +1384,14 @@ class singleWorker(StoppableThread): "MainWindow", "Doing work necessary to request encryption key.")) )) - payload = self._doPOWDefaults(payload, TTL) - inventoryHash = calculateInventoryHash(payload) objectType = 1 - inventoryHashlist = ( + Inventory()._realInventory[inventoryHash] = ( objectType, streamNumber, payload, embeddedTime, '') - Inventory()[inventoryHashlist] + # Inventory()._realInventory[inventoryHashlist] self.logger.info('sending inv (for the getpubkey message)') queues.invQueue.put((streamNumber, inventoryHash)) - # wait 10% past expiration sleeptill = int(time.time() + TTL * 1.1) sqlExecute( @@ -1443,7 +1400,6 @@ class singleWorker(StoppableThread): ''' WHERE toaddress=? AND (status='doingpubkeypow' OR ''' ''' status='awaitingpubkey') ''', int(time.time()), retryNumber + 1, sleeptill, toAddress) - queues.UISignalQueue.put(( 'updateStatusBar', tr._translate( @@ -1461,7 +1417,7 @@ class singleWorker(StoppableThread): ).arg(l10n.formatTimestamp())) )) - def generateFullAckMessage(self, ackdata, _, TTL): + def generateFullAckMessage(self, ackdata, _, TTL): """ It might be perfectly fine to just use the same TTL for the ackdata that we use for the message. But I would rather it be more difficult for attackers to associate ackData with the associated msg object. However, users diff --git a/src/class_sqlThread.py b/src/class_sqlThread.py index c655439c..7decb304 100644 --- a/src/class_sqlThread.py +++ b/src/class_sqlThread.py @@ -574,7 +574,6 @@ class sqlThread(threading.Thread): # print 'item', item # print 'parameters', parameters # if 'inbox' in item: - # import pdb; pdb.set_trace() try: self.cur.execute(item, parameters) rowcount = self.cur.rowcount diff --git a/src/inventory.py b/src/inventory.py index e1566db5..fc06e455 100644 --- a/src/inventory.py +++ b/src/inventory.py @@ -24,8 +24,6 @@ class Inventory(): # cheap inheritance copied from asyncore def __getattr__(self, attr): - # attr = '__contains__' - print('$$$$$$$$$$$$$ inside the __getattr__ item $$$$$$$$$$$$$$$$') if attr == "__contains__": self.numberOfInventoryLookupsPerformed += 1 try: @@ -40,5 +38,4 @@ class Inventory(): # hint for pylint: this is dictionary like object def __getitem__(self, key): - print('@@@@@@@@@@@@@@@@@@ inside the __getitem__ item @@@@@@@@@@@@@@@') return self._realInventory[key] diff --git a/src/network/bmobject.py b/src/network/bmobject.py index 12b997d7..ee3bd388 100644 --- a/src/network/bmobject.py +++ b/src/network/bmobject.py @@ -116,7 +116,7 @@ class BMObject(object): # pylint: disable=too-many-instance-attributes # if it's a stem duplicate, pretend we don't have it if Dandelion().hasHash(self.inventoryHash): return - if self.inventoryHash in Inventory(): + if self.inventoryHash in Inventory()._realInventory: raise BMObjectAlreadyHaveError() def checkObjectByType(self): diff --git a/src/network/bmproto.py b/src/network/bmproto.py index 4e89fdfe..cd29a38a 100644 --- a/src/network/bmproto.py +++ b/src/network/bmproto.py @@ -34,20 +34,6 @@ from network.node import Node, Peer from queues import objectProcessorQueue, portCheckerQueue, invQueue, addrQueue from network.randomtrackingdict import RandomTrackingDict -global addr_count -addr_count = 0 - -global addr_verack -addr_verack = 0 - -global addr_version -addr_version = 0 - -# global addr_count -# addr_count = 0 - -count = 0 - logger = logging.getLogger('default') @@ -100,14 +86,6 @@ class BMProto(AdvancedDispatcher, ObjectTracker): # its shoule be in string self.command = self.command.rstrip('\x00'.encode('utf-8')) # pylint: disable=global-statement - global count, addr_version, addr_count, addr_verack - count += 1 - if self.command == 'verack'.encode(): - addr_verack += 1 - if self.command == 'version'.encode(): - addr_version += 1 - if self.command == 'addr'.encode(): - addr_count += 1 if self.magic != 0xE9BEB4D9: self.set_state("bm_header", length=1) self.bm_proto_reset() @@ -377,11 +355,9 @@ class BMProto(AdvancedDispatcher, ObjectTracker): # ignore dinv if dandelion turned off if dandelion and not state.dandelion: - return True - + return True for i in map(bytes, items): - import pdb;pdb.set_trace() - if i in Inventory() and not Dandelion().hasHash(i): + if i in Inventory()._realInventory and not Dandelion().hasHash(i): continue if dandelion and not Dandelion().hasHash(i): Dandelion().addHash(i, self) @@ -442,28 +418,15 @@ class BMProto(AdvancedDispatcher, ObjectTracker): except KeyError: pass - if self.object.inventoryHash in Inventory() and Dandelion().hasHash(self.object.inventoryHash): + if self.object.inventoryHash in Inventory()._realInventory and Dandelion().hasHash(self.object.inventoryHash): Dandelion().removeHash(self.object.inventoryHash, "cycle detection") - # import pdb; pdb.set_trace() + [self.object.inventoryHash] = ( - inventoryHash_list = [self.object.objectType, self.object.streamNumber, + self.object.objectType, self.object.streamNumber, memoryview(self.payload[objectOffset:]), self.object.expiresTime, - memoryview(self.object.tag)] - # [self.object.inventoryHash] = ( - - # self.object.objectType, self.object.streamNumber, - # memoryview(self.payload[objectOffset:]), self.object.expiresTime, - # memoryview(self.object.tag) - # ) - - - - # Inventory()[self.object.inventoryHash] = (self.object.objectType, self.object.streamNumber, - # buffer(self.payload[objectOffset:]), self.object.expiresTime, - # buffer(self.object.tag)) - - - + memoryview(self.object.tag) + ) + Inventory()[self.object.inventoryHash] self.handleReceivedObject( self.object.streamNumber, self.object.inventoryHash) invQueue.put(( @@ -738,4 +701,4 @@ class BMStringParser(BMProto): except Exception as e: logger.debug( 'Exception of type %s while sending ACK', - type(e), exc_info=True) + type(e), exc_info=True) \ No newline at end of file diff --git a/src/network/downloadthread.py b/src/network/downloadthread.py index 323819ca..bf0344b3 100644 --- a/src/network/downloadthread.py +++ b/src/network/downloadthread.py @@ -61,7 +61,7 @@ class DownloadThread(StoppableThread): payload = bytearray() chunkCount = 0 for chunk in request: - if chunk in Inventory() and not Dandelion().hasHash(chunk): + if chunk in Inventory()._realInventory and not Dandelion().hasHash(chunk): try: del i.objectsNewToMe[chunk] except KeyError: diff --git a/src/network/invthread.py b/src/network/invthread.py index a4edb8a2..1a4b7514 100644 --- a/src/network/invthread.py +++ b/src/network/invthread.py @@ -88,7 +88,6 @@ class InvThread(StoppableThread): except KeyError: fluffs.append(inv[1]) if fluffs: - # import pdb; pdb.set_trace() random.shuffle(fluffs) connection.append_write_buf(protocol.CreatePacket( 'inv', diff --git a/src/network/tcp.py b/src/network/tcp.py index 8e5c92f4..72a66772 100644 --- a/src/network/tcp.py +++ b/src/network/tcp.py @@ -211,8 +211,7 @@ class TCPConnection(BMProto, TLSDispatcher): # may lock for a long time, but I think it's better than # thousands of small locks with self.objectsNewToThemLock: - # import pdb;pdb.set_trace() - for objHash in Inventory().unexpired_hashes_by_stream(stream): + for objHash in Inventory()._realInventory.unexpired_hashes_by_stream(stream): # don't advertise stem objects on bigInv if Dandelion().hasHash(objHash): continue @@ -221,18 +220,18 @@ class TCPConnection(BMProto, TLSDispatcher): payload = bytes() # Now let us start appending all of these hashes together. They will be # sent out in a big inv message to our new peer. - if len(bigInvList) is not 0: - for obj_hash, _ in bigInvList.items(): - payload += obj_hash - objectCount += 1 - # Remove -1 below when sufficient time has passed for users to - # upgrade to versions of PyBitmessage that accept inv with 50,000 - # items - if objectCount >= MAX_OBJECT_COUNT - 1: - sendChunk() - payload = b'' - objectCount = 0 + for obj_hash, _ in bigInvList.items(): + payload += obj_hash + objectCount += 1 + + # Remove -1 below when sufficient time has passed for users to + # upgrade to versions of PyBitmessage that accept inv with 50,000 + # items + if objectCount >= MAX_OBJECT_COUNT - 1: + sendChunk() + payload = b'' + objectCount = 0 # flush sendChunk() @@ -429,4 +428,4 @@ class TCPServer(AdvancedDispatcher): connectionpool.BMConnectionPool().addConnection( TCPConnection(sock=sock)) except socket.error: - pass + pass \ No newline at end of file diff --git a/src/proofofwork.py b/src/proofofwork.py index 8c2abff0..945eb7ec 100644 --- a/src/proofofwork.py +++ b/src/proofofwork.py @@ -112,7 +112,6 @@ def _doFastPoW(target, initialHash): def _doCPoW(target, initialHash): - # import pdb; pdb.set_trace() out_h = ctypes.pointer(ctypes.create_string_buffer(initialHash, 64)) out_m = ctypes.c_ulonglong(target) logger.debug("C PoW start") @@ -253,7 +252,6 @@ def run(target, initialHash): pass # fallback if bmpow: try: - print('-------------inside the proofofwork-----------------') return _doCPoW(target, initialHash) except StopIteration: raise @@ -294,8 +292,6 @@ def init(): openclpow.initCL() if sys.platform == "win32": - print('@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@') - print('inside the sys.platform == "win32"') if ctypes.sizeof(ctypes.c_voidp) == 4: bitmsglib = 'bitmsghash32.dll' else: @@ -328,9 +324,6 @@ def init(): bso = None else: - # import pdb; pdb.set_trace() - print('####################################') - print('else else else eles else ') try: bso = ctypes.CDLL(os.path.join(paths.codePath(), "bitmsghash", bitmsglib)) except OSError: @@ -354,6 +347,4 @@ def init(): else: bmpow = None if bmpow is None: - print('$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$') - print('intailed the bmpow') buildCPoW() diff --git a/src/storage/sqlite.py b/src/storage/sqlite.py index 37bb75a1..912caf0d 100644 --- a/src/storage/sqlite.py +++ b/src/storage/sqlite.py @@ -13,7 +13,6 @@ from storage.storage import InventoryStorage, InventoryItem class SqliteInventory(InventoryStorage): # pylint: disable=too-many-ancestors """Inventory using SQLite""" def __init__(self): - # import pdb;pdb.set_trace() super(SqliteInventory, self).__init__() # of objects (like msg payloads and pubkey payloads) # Does not include protocol headers (the first 24 bytes of each packet). @@ -30,8 +29,6 @@ class SqliteInventory(InventoryStorage): # pylint: disable=too-many-ancestors self.lock = RLock() def __contains__(self, hash_): - print('__contains__(self, hash_)__contains__(self, hash_)__contains__(self, hash_) ',hash_) - hash_ = str(hash_).encode() if type(hash_) == int else hash_ with self.lock: if hash_ in self._objects: return True @@ -42,59 +39,34 @@ class SqliteInventory(InventoryStorage): # pylint: disable=too-many-ancestors return False self._objects[hash_] = rows[0][0] return True - - # def __getitem__(self, hash_): - # raw = [None] - # # some think broke - # if hash_ == 0: - # hash_ = bytes() - # with self.lock: - # try: - # if hash_ in self._inventory: - # return self._inventory[hash_] - # rows = sqlQuery( - # 'SELECT objecttype, streamnumber, payload, expirestime, tag FROM inventory WHERE hash=?', - # sqlite3.Binary(hash_)) - # if not rows: - # # raise KeyError(hash_) - # pass - # except: - # rows = [hash_] - # return InventoryItem(*rows[0]) - + def __getitem__(self, hash_): - # import pdb;pdb.set_trace() with self.lock: if hash_ in self._inventory: return self._inventory[hash_] rows = sqlQuery( 'SELECT objecttype, streamnumber, payload, expirestime, tag' - ' FROM inventory WHERE hash=?', sqlite3.Binary(bytes(hash_))) + ' FROM inventory WHERE hash=?', sqlite3.Binary(hash_)) if not rows: raise KeyError(hash_) - return InventoryItem(*rows[0]) - + return InventoryItem(*rows[0]) def __setitem__(self, hash_, value): - print('----------__setitem__------------------') with self.lock: value = InventoryItem(*value) self._inventory[hash_] = value self._objects[hash_] = value.stream def __delitem__(self, hash_): - print('----------__delitem__------------------') raise NotImplementedError def __iter__(self): - print('----------__iter__------------------') with self.lock: hashes = self._inventory.keys()[:] hashes += (x for x, in sqlQuery('SELECT hash FROM inventory')) return hashes.__iter__() def __len__(self): - print('----------__len__------------------') with self.lock: return len(self._inventory) + sqlQuery( 'SELECT count(*) FROM inventory')[0][0] @@ -112,17 +84,14 @@ class SqliteInventory(InventoryStorage): # pylint: disable=too-many-ancestors def unexpired_hashes_by_stream(self, stream): """Return unexpired inventory vectors filtered by stream""" - # print ('self._inventory.items() self._inventory.items() self._inventory.items()' ,self._inventory.items()) - # import pdb;pdb.set_trace() with self.lock: t = int(time.time()) hashes = [x for x, value in self._inventory.items() if value.stream == stream and value.expires > t] - # print ('hasheshasheshasheshasheshasheshasheshasheshashes',hashes) hashes += (payload for payload, in sqlQuery( 'SELECT hash FROM inventory WHERE streamnumber=?' ' AND expirestime>?', stream, t)) - # print ('hasheshasheshasheshasheshasheshasheshasheshashes aaaaaaaaffter',hashes) + # print('sqlllllllllllllllllllllllllllllllllll',hashes) return hashes def flush(self):