Solved sending message issues
This commit is contained in:
jai.s
parent
eb2b948576
commit
ec618d9d1a
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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]
|
||||
|
|
|
|||
|
|
@ -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):
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
@ -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:
|
||||
|
|
|
|||
|
|
@ -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',
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
@ -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()
|
||||
|
|
|
|||
|
|
@ -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):
|
||||
|
|
|
|||
Reference in New Issue
Block a user