def from_payload(cls, data, src, dst, timestamp):
if len(data) < 16:
raise BadPacket("Too small")
proto, offset = read_long(data, 0)
if proto == cls.PROTO_VER:
server_id, offset = read_long(data, offset)
election_addr, _ = read_string(data, offset)
return Initial(timestamp, src, dst, server_id, election_addr)
if len(data) >= cls.OLD_LEN:
state, offset = read_number(data, 0)
if PeerState.invalid(state):
raise BadPacket("Invalid state: %d" % state)
leader, offset = read_long(data, offset)
zxid, offset = read_long(data, offset)
election_epoch, offset = read_long(data, offset)
peer_epoch, offset = read_long(
data, offset) if len(data) > cls.OLD_LEN else (-1, offset)
config = data[cls.WITH_CONFIG_LEN:] if len(
data) > cls.WITH_CONFIG_LEN else ""
return Notification(timestamp, src, dst, state, leader, zxid,
election_epoch, peer_epoch, config)
raise BadPacket("Unknown unknown")
def from_payload(cls, data, src, dst, timestamp):
if len(data) < cls.MIN_SIZE:
raise BadPacket("Too small")
ptype, offset = read_number(data, 0)
if PacketType.invalid(ptype):
raise BadPacket("Invalid type")
zxid, offset = read_long(data, offset)
handler = QuorumPacketBase.get(ptype, cls)
return handler.with_params(timestamp, src, dst, ptype, zxid, data, offset)
def from_payload(cls, data, src, dst, timestamp):
if len(data) < cls.MIN_SIZE:
raise BadPacket("Too small")
ptype, offset = read_number(data, 0)
if PacketType.invalid(ptype):
raise BadPacket("Invalid type")
zxid, _ = read_long(data, offset)
return cls(timestamp, src, dst, ptype, zxid, len(data))
def _check_packet(self, packet):
"""
check tcp seq duplicates
NOTE: TX/RX duplicate happens on loopback interfaces
:param packet:
:return: None
"""
src, dst = self._parse_packet_src_dst(packet)
tcp = get_ip_packet(packet.load).data
if tcp.flags & dpkt.tcp.TH_RST:
if (src, dst) in self._last_tcp_seq:
del self._last_tcp_seq[(src, dst)]
else:
if not tcp.data: raise BadPacket("no payload")
if (src, dst) in self._last_tcp_seq:
last_seq = self._last_tcp_seq[(src, dst)]
if tcp.seq <= last_seq:
# this exception eliminates dups
raise BadPacket("This sequence(%d<=%d) seen before" %
(tcp.seq, last_seq))
self._last_tcp_seq[(src, dst)] = tcp.seq
def _message_from_packet(self, packet):
"""
:returns: Returns an instance of Message
:raises:
:exc:`BadPacket` if the packet is of an unknown type
:exc:`DeserializationError` if deserialization failed
:exc:`struct.error` if deserialization failed
"""
ip_p = get_ip_packet(packet.load, 0, self._port)
if ip_p.data.sport != self._port and ip_p.data.dport != self._port:
raise BadPacket("Wrong port")
return self._msg_cls.from_payload(
ip_p.data.data,
intern("%s:%s" % (get_ip(ip_p, ip_p.src), ip_p.data.sport)),
intern("%s:%s" % (get_ip(ip_p, ip_p.dst), ip_p.data.dport)),
packet.time)
def message_from_packet(self, packet):
"""
:param packet: scapy.packet.Packet
:return: message
"""
self._check_packet(packet)
message = self._dispatch_message_from_packet(packet)
if message:
if isinstance(message, FLE.Notification):
self._setup_on_fle_notification(packet, message)
return message
if self._is_packet_fle_initial(packet):
message = self._fle_message_from_packet(packet)
assert isinstance(message, FLE.Initial)
self._setup_on_fle_initial(packet, message)
return message
raise BadPacket("Unknown packet")
def _setup_on_fle_notification(self, packet, message):
"""
parse config and setup self._sniffers on FLE.Notification
:param packet:
:param message:
"""
assert isinstance(message, FLE.Notification)
src, dst = self._parse_packet_src_dst(packet)
config = QuorumConfig(message.config)
servers = [
x for x in config.entries if isinstance(x, QuorumConfig.Server)
]
for server in servers:
zab_fle_ip = server.zab_fle_hostname
if zab_fle_ip == 'localhost':
assert src[
0] == '127.0.0.1', 'foreign localhost(src %s != 127.0.0.1)' % src[
0]
assert dst[
0] == '127.0.0.1', 'foreign localhost(dst %s != 127.0.0.1)' % dst[
0]
zab_fle_ip = '127.0.0.1'
zk_ip = server.zk_hostname
if zk_ip in ('localhost', '0.0.0.0'):
zk_ip = zab_fle_ip
try:
# check whether correct ip string
socket.inet_aton(zab_fle_ip)
socket.inet_aton(zk_ip)
except Exception as e:
raise BadPacket(e)
self._regist_sniffer(zab_fle_ip, server.fle_port, 'fle')
self._regist_sniffer(zab_fle_ip, server.zab_port, 'zab')
self._regist_sniffer(zk_ip, server.zk_port, 'zk')