def _pack_pid(val) -> bytes:
data = bytes([TAG_PID_EXT]) + \
_pack_atom(val.node_name_) + \
util.to_u32(val.id_) + \
util.to_u32(val.serial_) + \
bytes([val.creation_])
return data
def _pack_ref(val) -> bytes:
data = bytes([TAG_NEWER_REF_EXT]) \
+ util.to_u16(len(val.id_) // 4) \
+ _pack_atom(val.node_name_) \
+ util.to_u32(val.creation_) \
+ val.id_
return data
def _send_name(self):
""" Create and send first welcome packet. """
pkt = b'n' + \
bytes([dist_protocol.DIST_VSN, dist_protocol.DIST_VSN]) + \
util.to_u32(self.get_node().node_opts_.dflags_) + \
bytes(self.node_name_, "latin-1")
LOG.info("send_name %s (name=%s)", pkt, self.node_name_)
self._send_packet2(pkt)
def _pack_tuple(val, encode_hook):
if len(val) < 256:
data = bytes([TAG_SMALL_TUPLE_EXT, len(val)])
else:
data = bytes([TAG_LARGE_TUPLE_EXT]) + util.to_u32(len(val))
for item in val:
data += term_to_binary_2(item, encode_hook)
return data
def _pack_list(lst, tail, encode_hook):
if len(lst) == 0:
return bytes([TAG_NIL_EXT])
data = b''
for item in lst:
data += term_to_binary_2(item, encode_hook)
tail = term_to_binary_2(tail, encode_hook)
return bytes([TAG_LIST_EXT]) + util.to_u32(len(lst)) + data + tail
def _pack_str(val):
str_bytes = bytes(val, "utf8")
len_str_bytes = len(str_bytes)
len_val = len(val)
if _can_be_a_bytestring(val) and len_str_bytes <= 65535:
# same length as byte length
header = bytes([TAG_STRING_EXT]) + util.to_u16(len_str_bytes)
return header + str_bytes
else:
# contains unicode characters! must be encoded as a list of ints
header = bytes([TAG_LIST_EXT]) + util.to_u32(len_val)
elements = [_pack_int(ord(ch)) for ch in val]
return header + b''.join(elements) + bytes([TAG_NIL_EXT])
def _pack_int(val: int):
if 0 <= val < 256:
return bytes([TAG_SMALL_INT, val])
size = val.bit_length()
if size <= 32:
return bytes([TAG_INT]) + util.to_i32(val)
# we get here we're packing smal or large big
sign = 0 if 0 <= val else 1
if sign:
val *= -1 # switch to positive value
size = int(size / 8) + 1
if size < 256:
hdr = bytes([TAG_SMALL_BIG_EXT, size, sign])
else:
hdr = bytes([TAG_LARGE_BIG_EXT]) + util.to_u32(size) + bytes([sign])
data = val.to_bytes(size, 'little')
return hdr + data
def _send_challenge_reply(self, challenge: int):
digest = self.make_digest(challenge, self.get_node().get_cookie())
self.my_challenge_ = int(random.random() * 0x7fffffff)
pkt = b'r' + util.to_u32(self.my_challenge_) + digest
return self._send_packet2(pkt)
def _pack_binary(data, last_byte_bits):
if last_byte_bits == 8:
return bytes([TAG_BINARY_EXT]) + util.to_u32(len(data)) + data
return bytes([TAG_BIT_BINARY_EXT]) + util.to_u32(len(data)) + \
bytes([last_byte_bits]) + data
def _pack_dict(val: dict, encode_hook) -> bytes:
data = bytes([TAG_MAP_EXT]) + util.to_u32(len(val))
for k in val.keys():
data += term_to_binary_2(k, encode_hook)
data += term_to_binary_2(val[k], encode_hook)
return data
