def dataReceived(self, data):
for line in data.splitlines():
line = line.strip()
try:
envelopes = messages.read_envelope(line)
for envelope in envelopes:
if self.state in ["GETHELLO", "SENTHELLO"]:
# Force first message to be HELLO or crash
if envelope['msgtype'] == 'hello':
self.handle_HELLO(json.dumps(envelope))
else:
_print(" [!] Ignoring", envelope['msgtype'], "in",
self.state)
else:
if envelope['msgtype'] == 'ping':
self.handle_PING(json.dumps(envelope))
elif envelope['msgtype'] == 'pong':
self.handle_PONG(json.dumps(envelope))
elif envelope['msgtype'] == 'addr':
self.handle_ADDR(json.dumps(envelope))
elif envelope['msgtype'] == 'tx':
self.receiveTx(json.dumps(envelope))
elif envelope['msgtype'] == 'block':
self.receiveBlock(json.dumps(envelope))
except:
pass
def handle_sendBlocks(self, data):
# handle client messages wich ask us to send it blocks
# Client Bestheight
envelope = messages.read_envelope(data)
thisHeight = envelope["data"]["height"]
print "start synced"
if CBlockIndex(CBlockchainDB().GetBestHash()).Height() > thisHeight:
# client is back
isBack = CBlockIndex(
CBlockchainDB().GetBestHash()).Height() - thisHeight
# get all blocks from db where their height is > client height
blocks = self.cur.execute("SELECT * FROM blocks where height > ?",
(thisHeight, )).fetchall()
for block in blocks:
thisHeight = block[0]
thisRaw = block[2]
thisNonce = block[3]
thisCoinbase = self.cur.execute(
"SELECT * FROM transactions where block = ?",
(thisHeight, )).fetchone()
thisTransactions = self.cur.execute(
"SELECT * FROM transactions where block = ?",
(thisHeight, )).fetchall()
message = messages.getblock(self.nodeid, thisRaw, thisCoinbase,
thisTransactions, thisNonce)
self.write(message)
def dataReceived(self, data):
for line in data.splitlines():
line = line.strip()
envelope = messages.read_envelope(line)
if self.state in ["GETHELLO", "SENTHELLO"]:
# Force first message to be HELLO or crash
if envelope['msgtype'] == 'hello':
self.handle_HELLO(line)
else:
_print(" [!] Ignoring", envelope['msgtype'], "in",
self.state)
if envelope['msgtype'] == 'ping':
self.handle_PING(line)
elif envelope['msgtype'] == 'pong':
self.handle_PONG(line)
elif envelope['msgtype'] == 'addr':
self.handle_ADDR(line)
elif envelope["msgtype"] == "ask_needsync":
self.handle_SyncNeed(line)
elif envelope['msgtype'] == "getblocks":
self.handle_sendBlocks(line)
elif envelope["msgtype"] == "needsync":
self.handle_Sync(line)
elif envelope["msgtype"] == "getblock":
self.handle_ReceivedBlock(line)
elif envelope["msgtype"] == "a_mempool":
self.SendMempool()
elif envelope["msgtype"] == "s_memppol":
self.Handle_Mempool(line)
def Handle_Mempool(self, data):
logg("Received mempool transactions from %s" % self.remoteip)
for line in data.splitlines():
line = line.strip()
envelope = messages.read_envelope(line)
transactions = envelope["data"]["transactions"]
Mempool().gotMempool(transactions)
def read(self):
buffer = ''
while True:
rlist, _, _ = select.select([self.sock], [], [])
if rlist:
buffer += self.sock.recv(4096)
if buffer[-2:] == "\r\n":
return messages.read_envelope(buffer.strip())
def handle_Sync(self, data):
envelope = messages.read_envelope(data)
# ask if we need sync
if envelope["data"]["need"]:
msg = messages.create_getblocks(self.nodeid,
CBlockchainDB().getBestHeight())
logg("We need sync, we are %d block back")
self.write(msg)
def handle_ReceivedBlock(self, data):
print "Received new block from %s " % self.remote_nodeid
for line in data.splitlines():
line = line.strip()
envelope = messages.read_envelope(line)
thisRaw = envelope["data"]["raw"]
thisCoinbase = envelope["data"]["coinbase"]
thisTransactions = envelope["data"]["transactions"]
thisNonce = envelope["data"]["b_nonce"]
print thisBlock(self.remote_ip, thisRaw, thisCoinbase,
thisTransactions, thisNonce).isVaild()
def handle_ReceivedBlock(self, data):
logg("Received new block from %s " % self.remote_ip)
for line in data.splitlines():
line = line.strip()
envelope = messages.read_envelope(line)
thisRaw = envelope["data"]["raw"]
thisCoinbase = envelope["data"]["coinbase"]
thisTransactions = envelope["data"]["transactions"]
thisNonce = envelope["data"]["b_nonce"]
if thisBlock(self.remote_ip, thisRaw, thisCoinbase, thisTransactions,
thisNonce).isVaild():
logg("Received block from %s is vaild" % self.remote_ip)
else:
logg("Received block from %s rejected" % self.remote_ip)
def dataReceived(self, data):
for line in data.splitlines():
line = line.strip()
envelope = messages.read_envelope(line)
if self.state in ["GETHELLO", "SENTHELLO"]:
if envelope['msgtype'] == 'hello':
self.handle_HELLO(line)
else:
print(" [!] Ignoring", envelope['msgtype'], "in",
self.state)
else:
if envelope['msgtype'] == 'ping':
self.handle_PING(line)
elif envelope['msgtype'] == 'pong':
self.handle_PONG(line)
elif envelope['msgtype'] == 'addr':
self.handle_ADDR(line)
def handle_SyncNeed(self, data):
envelope = messages.read_envelope(data)
if envelope['msgtype'] == "ask_needsync":
# handle client messages wich ask us if he needs sync
# Client Bestheight
thisHeight = envelope["data"]["height"]
# Client Besthash
thisHash = envelope["data"]["hash"]
# check if our besthash height is > than client height
if CBlockIndex(
CBlockchainDB().GetBestHash()).Height() > thisHeight:
# client is back
isBack = CBlockIndex(
CBlockchainDB().GetBestHash()).Height() - thisHeight
# create a message, included our nodeid, our best height, and the diffrence
message = messages.create_reply_need_sync(
self.nodeid,
CBlockIndex(CBlockchainDB().GetBestHash()).Height(),
isBack)
self.write(message)
def dataReceived(self, data):
for line in data.splitlines():
line = line.strip()
envelope = messages.read_envelope(line)
if self.state in ["GETHELLO", "SENTHELLO"]:
# Force first message to be HELLO or crash
if envelope['msgtype'] == 'hello':
self.handle_HELLO(line)
else:
logg(" [!] Ignoring", envelope['msgtype'], "in",
self.state)
else:
if envelope['msgtype'] == 'ping':
self.handle_PING(line)
elif envelope['msgtype'] == 'pong':
self.handle_PONG(line)
elif envelope['msgtype'] == 'addr':
self.handle_ADDR(line)
elif envelope['msgtype'] == 'sync':
self.handle_SYNC(line)
elif envelope['msgtype'] == 'givemeblocks':
self.handle_SENDBLOCKS(line)
elif envelope['msgtype'] == 'getblock':
self.handleRECEIVEDBLOCK(line)
def dataReceived(self, data):
self.buffer += data
if self.buffer[-2:] == "\r\n":
for line in self.buffer.splitlines():
line = line.strip()
if self.state == 'NODEID':
if self.factory.peers.get(line) is None:
self.nodeid = line
self.factory.peers[self.nodeid] = self
self.factory.peers_ip[
self.nodeid] = self.transport.getPeer().host
_print("New Peer: {} {}".format(
line, self.transport.getPeer()))
self.state = None
else:
_print("Peer Already Known: {} {}".format(
line, self.transport.getPeer()))
self.transport.loseConnection()
else:
try:
data = messages.read_envelope(line)
_print(data["msgtype"])
#_print (data)
if data["msgtype"] == "ping":
#print self.transport.getPeer().host
self.sendPong()
elif data["msgtype"] == "pong":
#print self.transport.getPeer().host
self.pong = True
elif data["msgtype"] == "get_peers":
self.sendMsg(
messages.set_peers(self.factory.peers_ip))
elif data["msgtype"] == "set_peers":
if self.factory.bootstrap == True:
_print(data.get("peers"))
peers = data.get("peers")
for key in peers:
exists = self.factory.peers_ip.get(key)
if exists is None and key != self.factory.nodeid:
point = TCP4ClientEndpoint(
reactor, peers.get(key), P2P_PORT)
#point = TCP4ClientEndpoint(reactor, peers.get(key), P2P_PORT, bindAddress=(LOCALHOST, 0))
connectProtocol(
point, p2pProtocol(self.factory))
self.sendGetNumBlocks()
elif data["msgtype"] == "get_num_blocks":
self.sendMsg(
messages.set_num_blocks(
self.factory.num_block))
elif data["msgtype"] == "set_num_blocks":
if self.factory.bootstrap:
if data["num"] > self.factory.num_block:
self.factory.num_block = data["num"]
#print data["num"]
self.factory.ck_num = True
elif data["msgtype"] == "set_tx":
try:
tx = rlp.decode(data["tx"].decode('base64'),
Transaction)
self.factory.transactions.add(data["tx"])
except:
_print("Wrong Tx")
elif data["msgtype"] == "set_block":
try:
block = rlp.decode(
data["block"].decode('base64'), Block)
if self.factory.num_block == block.header.number - 1:
self.factory.blocks[
block.header.number] = data["block"]
self.factory.num_block += 1
#print block.header.number
except:
_print("Wrong Block")
elif data["msgtype"] == "set_blocks":
if self.factory.bootstrap:
for b in data["blocks"]:
try:
block = rlp.decode(
b.decode('base64'), Block)
if block.header.number > self.factory.last_served_block and \
self.factory.blocks.get(block.header.number) is None:
self.factory.blocks[
block.header.number] = b
_print(block.header.number)
except:
_print("Wrong Block")
elif data["msgtype"] == "get_block_num":
num = data["num"]
if num <= self.factory.last_served_block and not self.factory.bootstrap:
if self.factory.block_queries.get(
self) is None:
self.factory.block_queries[self] = set(
[num])
else:
self.factory.block_queries[self].add(num)
elif num <= self.factory.num_block:
block = self.factory.blocks.get(num)
if block is not None:
self.sendMsg(messages.set_blocks([block]))
elif data["msgtype"] == "get_blocks":
num = data["num"]
chunk = data["chunk"]
blocks = []
for n in range(num, num + chunk):
if n <= self.factory.last_served_block and not self.factory.bootstrap:
if self.factory.block_queries.get(
self) is None:
self.factory.block_queries[self] = set(
[n])
else:
self.factory.block_queries[self].add(n)
elif n <= self.factory.num_block:
block = self.factory.blocks.get(n)
if block is not None:
blocks.append(block)
if blocks:
self.sendMsg(messages.set_blocks(blocks))
elif data["msgtype"] == "get_tx_pool":
if not self.factory.bootstrap:
self.factory.tx_pool_query.add(self)
elif data["msgtype"] == "set_tx_pool":
if self.factory.bootstrap and not self.factory.tx_pool:
txs = data["txs"]
for raw_tx in txs:
try:
tx = rlp.decode(
raw_tx.decode('base64'),
Transaction)
self.factory.transactions.add(raw_tx)
except:
_print("Wrong Tx")
self.factory.tx_pool = True
elif data["msgtype"] == "set_share":
try:
share = rlp.decode(
data["share"].decode('base64'), Share)
self.factory.shares.add(data["share"])
except Exception as e:
_print("Wrong Share")
_print(e)
elif data["msgtype"] == "set_dkg_share":
try:
share = rlp.decode(
data["share"].decode('base64'), Dkg_Share)
self.factory.dkg_shares.add(data["share"])
except Exception as e:
_print("Wrong DKG Share")
_print(e)
except Exception as exception:
print "except", exception.__class__.__name__, exception
self.transport.loseConnection()
#else:
#print (line)
self.buffer = ''
def dataReceived(self, data):
self.buffer += data
if self.buffer[-2:] == "\r\n":
for line in self.buffer.splitlines():
line = line.strip()
try:
data = messages.read_envelope(line)
#print data
if data["msgtype"] == "quit":
reactor.stop()
elif data["msgtype"] == "bootstrap":
if self.factory.bootstrap:
self.sendMsg(messages.true())
else:
self.sendMsg(messages.false())
elif data["msgtype"] == "get_tx":
if not self.factory.transactions:
self.sendMsg(messages.none())
else:
tx = self.factory.transactions.pop().encode(
'utf-8')
self.sendMsg(messages.set_tx_local(tx))
elif data["msgtype"] == "set_tx":
self.sendPeers(line + '\r\n')
elif data["msgtype"] == "get_block":
if not self.factory.blocks:
self.sendMsg(messages.none())
else:
block = self.factory.blocks.get(
self.factory.last_served_block + 1)
if block:
self.sendMsg(
messages.set_block_local(
block.encode('utf-8')))
self.factory.last_served_block += 1
else:
self.sendMsg(messages.none())
elif data["msgtype"] == "set_block":
self.sendPeers(line + '\r\n')
self.factory.num_block += 1
self.factory.last_served_block += 1
self.factory.dht.set("last_block",
str(self.factory.num_block))
elif data["msgtype"] == "get_block_queries":
if not self.factory.block_queries:
self.sendMsg(messages.none())
else:
blocks = set()
for v in self.factory.block_queries.values():
blocks.update(v)
if len(blocks) >= 10: # Max Blocks Query
break
self.sendMsg(
messages.set_block_queries(list(blocks)[:10]))
elif data["msgtype"] == "answer_block_queries":
peers = self.factory.block_queries.keys()
for peer in peers:
blocks = []
for b in data["blocks"]:
block = rlp.decode(b.decode('base64'), Block)
if block.header.number in self.factory.block_queries[
peer]:
blocks.append(b)
self.factory.block_queries[peer].discard(
block.header.number)
if not self.factory.block_queries[peer]:
del self.factory.block_queries[peer]
peer.sendMsg(messages.set_blocks(blocks))
elif data["msgtype"] == "tx_pool_query":
if not self.factory.tx_pool_query:
self.sendMsg(messages.false())
else:
self.sendMsg(messages.true())
elif data["msgtype"] == "answer_tx_pool_query":
while self.factory.tx_pool_query:
peer = self.factory.tx_pool_query.pop()
peer.sendMsg(messages.set_tx_pool(data["txs"]))
elif data["msgtype"] == "set_share":
self.sendPeers(line + '\r\n')
elif data["msgtype"] == "get_share":
if not self.factory.shares:
self.sendMsg(messages.none())
else:
share = self.factory.shares.pop().encode('utf-8')
self.sendMsg(messages.set_share_local(share))
elif data["msgtype"] == "set_dkg_share":
self.sendPeers(line + '\r\n')
elif data["msgtype"] == "get_dkg_share":
if not self.factory.dkg_shares:
self.sendMsg(messages.none())
else:
share = self.factory.dkg_shares.pop().encode(
'utf-8')
self.sendMsg(messages.set_dkg_share_local(share))
'''else:
for nodeid, address in self.factory.peers.items():
address.sendMsg(line + '\r\n')'''
except Exception as exception:
print "except", exception.__class__.__name__, exception
self.transport.loseConnection()
self.buffer = ''