async def recv(self) -> MessageAPI:
header_bytes = await self.read(HEADER_LEN + MAC_LEN)
try:
padded_header = self._decrypt_header(header_bytes)
except (ValueError, DecryptionError) as err:
self.logger.info("Bad message header from peer %s: Error: %r",
self, err)
raise MalformedMessage(*err.args) from err
# TODO: use `int.from_bytes(...)`
frame_size = self._get_frame_size(padded_header)
# The frame_size specified in the header does not include the padding to 16-byte boundary,
# so need to do this here to ensure we read all the frame's data.
read_size = roundup_16(frame_size)
frame_data = await self.read(read_size + MAC_LEN)
try:
body = self._decrypt_body(frame_data, frame_size)
except (ValueError, DecryptionError) as err:
self.logger.info("Bad message body from peer %s: Error: %r", self,
err)
raise MalformedMessage(*err.args) from err
# Decode the header data and re-encode to recover the unpadded header size.
try:
header_data = _decode_header_data(padded_header[3:])
except rlp.exceptions.DeserializationError as err:
raise MalformedMessage(*err.args) from err
header = padded_header[:3] + rlp.encode(header_data)
return Message(header, body)
async def recv(self) -> MessageAPI:
# Check that Transport read state is IDLE.
if self.read_state is not TransportState.IDLE:
# This is logged at INFO level because it indicates we are not
# properly managing the Transport and are interrupting it mid-read
# somewhere.
self.logger.info(
'Corrupted transport: %s - state=%s',
self,
self.read_state.name,
)
raise CorruptTransport(f"Corrupted transport: {self} - state={self.read_state.name}")
# Set status to indicate we are waiting to read the message header
self.read_state = TransportState.HEADER
try:
header_bytes = await self.read(HEADER_LEN + MAC_LEN)
except asyncio.CancelledError:
self.logger.debug('Transport cancelled during header read. resetting to IDLE state')
self.read_state = TransportState.IDLE
raise
# Set status to indicate we are waiting to read the message body
self.read_state = TransportState.BODY
try:
padded_header = self._decrypt_header(header_bytes)
except DecryptionError as err:
self.logger.debug(
"Bad message header from peer %s: Error: %r",
self, err,
)
raise MalformedMessage from err
# TODO: use `int.from_bytes(...)`
frame_size = self._get_frame_size(padded_header)
# The frame_size specified in the header does not include the padding to 16-byte boundary,
# so need to do this here to ensure we read all the frame's data.
read_size = roundup_16(frame_size)
frame_data = await self.read(read_size + MAC_LEN)
try:
body = self._decrypt_body(frame_data, frame_size)
except DecryptionError as err:
self.logger.debug(
"Bad message body from peer %s: Error: %r",
self, err,
)
raise MalformedMessage from err
# Reset status back to IDLE
self.read_state = TransportState.IDLE
# Decode the header data and re-encode to recover the unpadded header size.
try:
header_data = _decode_header_data(padded_header[3:])
except rlp.exceptions.DeserializationError as err:
raise MalformedMessage from err
header = padded_header[:3] + rlp.encode(header_data)
return Message(header, body)
async def recv(self) -> MessageAPI:
self.read_state = TransportState.HEADER
try:
encoded_sizes = await self.read(8)
except asyncio.CancelledError:
self.read_state = TransportState.IDLE
raise
header_size, body_size = struct.unpack('>II', encoded_sizes)
self.read_state = TransportState.BODY
header = await self.read(header_size)
body = await self.read(body_size)
self.read_state = TransportState.IDLE
return Message(header, body)
def test_eip8_hello():
# Data taken from https://github.com/ethereum/EIPs/blob/master/EIPS/eip-8.md
payload_body = decode_hex(
"f87137916b6e6574682f76302e39312f706c616e39cdc5836574683dc6846d6f726b1682270fb840"
"fda1cff674c90c9a197539fe3dfb53086ace64f83ed7c6eabec741f7f381cc803e52ab2cd55d5569"
"bce4347107a310dfd5f88a010cd2ffd1005ca406f1842877c883666f6f836261720304"
)
msg = Message(b'', b'\x80' + payload_body)
cmd = Hello.decode(msg, snappy_support=False)
assert cmd.payload.capabilities == (('eth', 61), ('mork', 22))
assert cmd.payload.version == 55
assert cmd.payload.client_version_string == 'kneth/v0.91/plan9'
assert cmd.payload.listen_port == 9999
assert cmd.payload.remote_public_key == b'\xfd\xa1\xcf\xf6t\xc9\x0c\x9a\x19u9\xfe=\xfbS\x08j\xced\xf8>\xd7\xc6\xea\xbe\xc7A\xf7\xf3\x81\xcc\x80>R\xab,\xd5]Ui\xbc\xe44q\x07\xa3\x10\xdf\xd5\xf8\x8a\x01\x0c\xd2\xff\xd1\x00\\\xa4\x06\xf1\x84(w' # noqa: E501
def encode(self, cmd_id: int, snappy_support: bool) -> MessageAPI:
raw_payload_data = self.serialization_codec.encode(self.payload)
if snappy_support:
payload_data = self.compression_codec.compress(raw_payload_data)
else:
payload_data = raw_payload_data
cmd_id_data = rlp.encode(cmd_id, sedes=rlp.sedes.big_endian_int)
frame_size = len(cmd_id_data) + len(payload_data)
if frame_size.bit_length() > 24:
raise ValueError("Frame size has to fit in a 3-byte integer")
# Frame-size is a 3-bit integer
header = frame_size.to_bytes(3, 'big') + RLPX_HEADER_DATA
body = cmd_id_data + payload_data
return Message(header, body)
async def recv(self) -> MessageAPI:
encoded_sizes = await self.read(8)
header_size, body_size = struct.unpack('>II', encoded_sizes)
header = await self.read(header_size)
body = await self.read(body_size)
return Message(header, body)