class WPA_key(Packet):
name = "WPA_key"
fields_desc = [
ByteField("descriptor_type", 1),
ShortField("key_info", 0),
LenField("len", None, "H"),
StrFixedLenField("replay_counter", "", 8),
StrFixedLenField("nonce", "", 32),
StrFixedLenField("key_iv", "", 16),
StrFixedLenField("wpa_key_rsc", "", 8),
StrFixedLenField("wpa_key_id", "", 8),
StrFixedLenField("wpa_key_mic", "", 16),
LenField("wpa_key_length", None, "H"),
StrLenField("wpa_key", "", length_from=lambda pkt: pkt.wpa_key_length)
] # noqa: E501
def extract_padding(self, s):
tmp_len = self.len
return s[:tmp_len], s[tmp_len:]
def hashret(self):
return chr(self.type) + self.payload.hashret()
def answers(self, other):
if isinstance(other, WPA_key):
return 1
return 0
class SAPEnqueue(PacketNoPadded):
"""SAP Enqueue Server packet
This packet is used for general Enqueue packets.
"""
name = "SAP Enqueue"
fields_desc = [
StrFixedLenField("magic_bytes", "\xab\xcd\xe1\x23", 4),
IntField("id", 0),
LenField("len", None, fmt="!I"),
LenField("len_frag", None, fmt="!I"),
ByteEnumKeysField("dest", 0x00, enqueue_dest_values),
ByteEnumKeysField("opcode", 0x00, enqueue_conn_admin_opcode_values),
ByteField("more_frags", 0),
ByteEnumKeysField("type", 0x00, enqueue_type_values),
# Server Admin fields
ConditionalField(StrNullFixedLenField("adm_eyecatcher1", "ENC", 3), lambda pkt:pkt.dest == 3),
ConditionalField(ByteField("adm_version", 1), lambda pkt:pkt.dest == 3),
ConditionalField(ByteField("adm_padd1", 0), lambda pkt:pkt.dest == 3),
ConditionalField(ByteField("adm_padd2", 0), lambda pkt:pkt.dest == 3),
ConditionalField(ByteField("adm_padd3", 0), lambda pkt:pkt.dest == 3),
ConditionalField(StrFixedLenField("adm_eyecatcher2", "#EAA", 4), lambda pkt:pkt.dest == 3),
ConditionalField(ByteField("adm_1", 1), lambda pkt:pkt.dest == 3),
ConditionalField(IntField("adm_len", 0), lambda pkt:pkt.dest == 3),
ConditionalField(ByteEnumKeysField("adm_opcode", 0, enqueue_server_admin_opcode_values), lambda pkt:pkt.dest == 3),
ConditionalField(ByteField("adm_flags", 0), lambda pkt:pkt.dest == 3),
ConditionalField(IntField("adm_rc", 0), lambda pkt:pkt.dest == 3),
ConditionalField(StrFixedLenField("adm_eyecatcher3", "#EAE", 4), lambda pkt:pkt.dest == 3),
# Server Admin Trace fields
ConditionalField(ByteField("adm_trace_protocol_version", 1), lambda pkt:pkt.dest == 3 and pkt.adm_opcode in [0x06]),
ConditionalField(ByteEnumKeysField("adm_trace_action", 3, enqueue_server_admin_trace_action_values), lambda pkt:pkt.dest == 3 and pkt.adm_opcode in [0x06]),
ConditionalField(ByteEnumKeysField("adm_trace_limit", 0, enqueue_server_admin_trace_limit_values), lambda pkt:pkt.dest == 3 and pkt.adm_opcode in [0x06]),
ConditionalField(ByteEnumKeysField("adm_trace_thread", 0, enqueue_server_admin_trace_thread_values), lambda pkt:pkt.dest == 3 and pkt.adm_opcode in [0x06]),
ConditionalField(IntField("adm_trace_unknown1", 0), lambda pkt:pkt.dest == 3 and pkt.adm_opcode in [0x06]),
ConditionalField(IntField("adm_trace_level", 1), lambda pkt:pkt.dest == 3 and pkt.adm_opcode in [0x06]),
ConditionalField(IntField("adm_trace_level1", 1), lambda pkt:pkt.dest == 3 and pkt.adm_opcode in [0x06]),
ConditionalField(ByteField("adm_trace_logging", 0), lambda pkt:pkt.dest == 3 and pkt.adm_opcode in [0x06]),
ConditionalField(IntField("adm_trace_max_file_size", 20 * 1024 * 1024), lambda pkt:pkt.dest == 3 and pkt.adm_opcode in [0x06]),
ConditionalField(FieldLenField("adm_trace_nopatterns", 0, count_of="adm_trace_patterns", fmt="!I"), lambda pkt:pkt.dest == 3 and pkt.adm_opcode in [0x06]),
ConditionalField(FieldLenField("adm_trace_nopatterns1", 0, count_of="adm_trace_patterns", fmt="!I"), lambda pkt:pkt.dest == 3 and pkt.adm_opcode in [0x06]),
ConditionalField(IntField("adm_trace_unknown3", 37), lambda pkt:pkt.dest == 3 and pkt.adm_opcode in [0x06]),
ConditionalField(StrFixedLenField("adm_trace_eyecatcher4", "#EAH", 4), lambda pkt:pkt.dest == 3 and pkt.adm_opcode in [0x06]),
ConditionalField(PacketListField("adm_trace_patterns", None, SAPEnqueueTracePattern, count_from=lambda pkt:pkt.adm_trace_nopatterns), lambda pkt:pkt.dest == 3 and pkt.adm_opcode in [0x06]),
ConditionalField(StrFixedLenField("adm_trace_eyecatcher5", "#EAD", 4), lambda pkt:pkt.dest == 3 and pkt.adm_opcode in [0x06]),
# Connection Admin fields
ConditionalField(FieldLenField("params_count", None, count_of="params", fmt="!I"), lambda pkt:pkt.dest == 6 and pkt.opcode in [1, 2]),
ConditionalField(PacketListField("params", None, SAPEnqueueParam, count_from=lambda pkt:pkt.params_count), lambda pkt:pkt.dest == 6 and pkt.opcode in [1, 2]),
]
def post_build(self, pkt, pay):
"""Adjust the len and len_frags fields after the build of the whole
packet. """
l = struct.pack("!I", len(pkt) + len(pay))
pkt = pkt[:8] + l + l + pkt[16:]
return pkt + pay
def __init__(self, name, default=None, fmt="I", width=None):
self.name = name
self.width = width
self.default = self.any2i(None, default)
if fmt[0] in "@=<>!":
self.fmt = fmt
else:
self.fmt = "!" + fmt
self.size = self.width or struct.calcsize(self.fmt)
# Scapy uses old style classes. No super() here
# super(ByteLenField, self).__init__(name, default, fmt)
LenField.__init__(self, name, default, fmt)
class DCPFullIPBlock(Packet):
fields_desc = [
ByteEnumField("option", 1, DCP_OPTIONS),
MultiEnumField("sub_option",
3,
DCP_SUBOPTIONS,
fmt='B',
depends_on=lambda p: p.option),
LenField("dcp_block_length", None),
ShortEnumField("block_info", 1, IP_BLOCK_INFOS),
IPField("ip", "192.168.0.2"),
IPField("netmask", "255.255.255.0"),
IPField("gateway", "192.168.0.1"),
FieldListField("dnsaddr", [],
IPField("", "0.0.0.0"),
count_from=lambda x: 4),
PadField(StrLenField("padding",
b"\x00",
length_from=lambda p: p.dcp_block_length % 2),
1,
padwith=b"\x00")
]
def extract_padding(self, s):
return '', s
class Apple_BLE_Submessage(Packet, LowEnergyBeaconHelper):
"""
A basic Apple submessage.
"""
name = "Apple BLE submessage"
fields_desc = [
ByteEnumField(
"subtype", None, {
0x02: "ibeacon",
0x05: "airdrop",
0x07: "airpods",
0x09: "airplay_sink",
0x0a: "airplay_src",
0x0c: "handoff",
0x10: "nearby",
}),
LenField("len", None, fmt="B")
]
def extract_padding(self, s):
# Needed to end each EIR_Element packet and make PacketListField work.
return s[:self.len], s[self.len:]
# These methods are here in case you only want to send 1 submessage.
# It creates an Apple_BLE_Frame to wrap your (single) Apple_BLE_Submessage.
def build_frame(self):
"""Wraps this submessage in a Apple_BLE_Frame."""
return Apple_BLE_Frame(plist=[self])
def build_eir(self):
"""See Apple_BLE_Frame.build_eir."""
return self.build_frame().build_eir()
class USBpcap(Packet):
name = "USBpcap URB"
fields_desc = [ByteField("headerLen", None),
ByteField("res", 0),
XLELongField("irpId", 0),
LEIntEnumField("usbd_status", 0x0, _usbd_status_codes),
LEShortEnumField("function", 0, _urb_functions),
XByteField("info", 0),
LEShortField("bus", 0),
LEShortField("device", 0),
XByteField("endpoint", 0),
ByteEnumField("transfer", 0, _transfer_types),
LenField("dataLength", None, fmt="<I")]
def post_build(self, p, pay):
if self.headerLen is None:
headerLen = len(p)
if isinstance(self.payload, (USBpcapTransferIsochronous,
USBpcapTransferInterrupt,
USBpcapTransferControl)):
headerLen += len(self.payload) - len(self.payload.payload)
p = chb(headerLen) + p[1:]
return p + pay
def guess_payload_class(self, payload):
if self.headerLen == 27:
# No Transfer layer
return super(USBpcap, self).guess_payload_class(payload)
if self.transfer == 0:
return USBpcapTransferIsochronous
elif self.transfer == 1:
return USBpcapTransferInterrupt
elif self.transfer == 2:
return USBpcapTransferControl
return super(USBpcap, self).guess_payload_class(payload)
class DCPControlBlock(Packet):
fields_desc = [
ByteEnumField("option", 5, DCP_OPTIONS),
MultiEnumField("sub_option",
4,
DCP_SUBOPTIONS,
fmt='B',
depends_on=lambda p: p.option),
LenField("dcp_block_length", 3),
ByteEnumField("response", 2, DCP_OPTIONS),
MultiEnumField("response_sub_option",
2,
DCP_SUBOPTIONS,
fmt='B',
depends_on=lambda p: p.option),
ByteEnumField("block_error", 0, BLOCK_ERRORS),
PadField(StrLenField("padding",
b"\x00",
length_from=lambda p: p.dcp_block_length % 2),
1,
padwith=b"\x00")
]
def extract_padding(self, s):
return '', s
class SignalHeader(CAN):
"""Special implementation of a CAN Packet to allow dynamic binding.
This class can be provided to CANSockets as basecls.
Example:
>>> class floatSignals(SignalPacket):
>>> fields_desc = [
>>> LEFloatSignalField("floatSignal2", default=0, start=32),
>>> BEFloatSignalField("floatSignal1", default=0, start=7)]
>>>
>>> bind_layers(SignalHeader, floatSignals, identifier=0x321)
>>>
>>> dbc_sock = CANSocket("can0", basecls=SignalHeader)
All CAN messages received from this dbc_sock CANSocket will be interpreted
as SignalHeader. Through Scapys ``bind_layers`` mechanism, all CAN messages
with CAN identifier 0x321 will interpret the payload bytes of these
CAN messages as floatSignals packet.
"""
fields_desc = [
FlagsField('flags', 0, 3, ['error',
'remote_transmission_request',
'extended']),
XBitField('identifier', 0, 29),
LenField('length', None, fmt='B'),
ThreeBytesField('reserved', 0)
]
def extract_padding(self, s):
# type: (bytes) -> Tuple[bytes, Optional[bytes]]
return s, None
class Dot3(Packet):
name = "802.3"
fields_desc = [
DestMACField("dst"),
SourceMACField("src"),
LenField("len", None, "H")
]
def extract_padding(self, s):
# type: (bytes) -> Tuple[bytes, bytes]
tmp_len = self.len
return s[:tmp_len], s[tmp_len:]
def answers(self, other):
# type: (Ether) -> int
if isinstance(other, Dot3):
return self.payload.answers(other.payload)
return 0
def mysummary(self):
# type: () -> str
return "802.3 %s > %s" % (self.src, self.dst)
@classmethod
def dispatch_hook(cls, _pkt=None, *args, **kargs):
# type: (Optional[Any], *Any, **Any) -> Type[Packet]
if _pkt and len(_pkt) >= 14:
if struct.unpack("!H", _pkt[12:14])[0] > 1500:
return Ether
return cls
class SAPNI(Packet):
"""SAP NI (Network Interface) packet
This packet is used for craft Network Interface packets. It serves only
as a container for packets in the different protocols. As this protocol
is used by different protocols and the only way to differentiate each one
is by the TCP port used, each script using the NI protocol must bind the
respective layer with the respective protocol.
For example, a script using the SAP Diag protocol must include the
following binds::
bind_layers(SAPNI, SAPDiag, )
bind_layers(SAPNI, SAPDiagDP, )
bind_layers(SAPDiagDP, SAPDiag, )
bind_layers(SAPDiag, SAPDiagItem, )
bind_layers(SAPDiagItem,SAPDiagItem, )
"""
name = "SAP NI (Network Interface) protocol"
fields_desc = [LenField("length", None, fmt="!I")]
# Constants for keep-alive messages
SAPNI_PING = "NI_PING\x00"
""" :cvar: Constant for keep-alive request messages (NI_PING)
:type: C{string} """
SAPNI_PONG = "NI_PONG\x00"
""" :cvar: Constant for keep-alive response messages (NI_PONG)
class Dot3(Packet):
name = "802.3"
fields_desc = [
DestMACField("dst"),
MACField("src", ETHER_ANY),
LenField("len", None, "H")
]
def extract_padding(self, s):
tmp_len = self.len
return s[:tmp_len], s[tmp_len:]
def answers(self, other):
if isinstance(other, Dot3):
return self.payload.answers(other.payload)
return 0
def mysummary(self):
return "802.3 %s > %s" % (self.src, self.dst)
@classmethod
def dispatch_hook(cls, _pkt=None, *args, **kargs):
if _pkt and len(_pkt) >= 14:
if struct.unpack("!H", _pkt[12:14])[0] > 1500:
return Ether
return cls
class IODWriteReq(Block):
"""IODWrite request block"""
fields_desc = [
BlockHeader,
ShortField("seqNum", 0),
UUIDField("ARUUID", None),
XIntField("API", 0),
XShortField("slotNumber", 0),
XShortField("subslotNumber", 0),
StrFixedLenField("padding", "", length=2),
XShortEnumField("index", 0, IOD_WRITE_REQ_INDEX),
LenField("recordDataLength", None, fmt="I"),
StrFixedLenField("RWPadding", "", length=24),
]
# default block_type value
block_type = 0x0008
def payload_length(self):
return self.recordDataLength
def get_response(self):
"""Generate the response block of this request.
Careful: it only sets the fields which can be set from the request
"""
res = IODWriteRes()
for field in ["seqNum", "ARUUID", "API", "slotNumber",
"subslotNumber", "index"]:
res.setfieldval(field, self.getfieldval(field))
return res
class EAPOL(Packet):
"""
EAPOL - IEEE Std 802.1X-2010
"""
name = "EAPOL"
fields_desc = [
ByteEnumField("version", 1, eapol_versions),
ByteEnumField("type", 0, eapol_types),
LenField("len", None, "H")
]
EAP_PACKET = 0
START = 1
LOGOFF = 2
KEY = 3
ASF = 4
def extract_padding(self, s):
tmp_len = self.len
return s[:tmp_len], s[tmp_len:]
def hashret(self):
return chb(self.type) + self.payload.hashret()
def answers(self, other):
if isinstance(other, EAPOL):
if ((self.type == self.EAP_PACKET)
and (other.type == self.EAP_PACKET)):
return self.payload.answers(other.payload)
return 0
def mysummary(self):
return self.sprintf("EAPOL %EAPOL.type%")
class RTCP(Packet):
name = "RTCP"
fields_desc = [
# HEADER
BitField('version', 2, 2),
BitField('padding', 0, 1),
BitFieldLenField('count', 0, 5, count_of='report_blocks'),
ByteEnumField('packet_type', 0, _rtcp_packet_types),
LenField('length', None, fmt='!h'),
# SR/RR
ConditionalField(IntField('sourcesync', 0),
lambda pkt: pkt.packet_type in (200, 201)),
ConditionalField(PacketField('sender_info', SenderInfo(), SenderInfo),
lambda pkt: pkt.packet_type == 200),
ConditionalField(
PacketListField('report_blocks',
None,
pkt_cls=ReceptionReport,
count_from=lambda pkt: pkt.count),
lambda pkt: pkt.packet_type in (200, 201)),
# SDES
ConditionalField(
PacketListField('sdes_chunks',
None,
pkt_cls=SDESChunk,
count_from=lambda pkt: pkt.count),
lambda pkt: pkt.packet_type == 202),
]
def post_build(self, pkt, pay):
pkt += pay
if self.length is None:
pkt = pkt[:2] + struct.pack("!h", len(pkt) // 4 - 1) + pkt[4:]
return pkt
class PPTPEchoRequest(PPTP):
name = "PPTP Echo Request"
fields_desc = [LenField("len", 16),
ShortEnumField("type", 1, _PPTP_msg_type),
XIntField("magic_cookie", _PPTP_MAGIC_COOKIE),
ShortEnumField("ctrl_msg_type", 5, _PPTP_ctrl_msg_type),
XShortField("reserved_0", 0x0000),
IntField("identifier", None)]
class HTTP2Headers(HTTP2PaddedFrame):
name = "HTTP2 %s Frame" % HTTP2_FRAME_TYPES[HTTP2FrameTypes.HEADERS]
fields_desc = [ConditionalField(LenField("padding_length", None, fmt="B"), underlayer_has_padding_flag_set),
ConditionalField(BitField("E", 0, 1), underlayer_has_priority_flag_set),
ConditionalField(BitField("stream_dependency", 0, 31), underlayer_has_priority_flag_set),
ConditionalField(ByteField("weight", 0), underlayer_has_priority_flag_set),
# Encoding for => :method: GET, :scheme: https, :path: /, host: localhost
StrField("headers", "\x87\x84f\x86\xa0\xe4\x1d\x13\x9d\t\x82")]
class HCI_Command_Hdr(Packet):
name = "HCI Command header"
fields_desc = [
XLEShortField("opcode", 0),
LenField("len", None, fmt="B"),
]
def answers(self, other):
return False
class ISO_8327_1_Session_Accept(Packet):
name = "ISO 8327-1 Session Accept"
fields_desc = [ByteField("spdu_type", 0x0e),
LenField("length", None,
fmt="!B", adjust=lambda pkt, x: len(pkt) + x),
PacketListField("parameters", None,
ISO_8327_1_Session_Protocol_Parameter,
count_from=lambda x: 3),
PacketField("user_data", None, ISO_8327_1_Session_User_Data)]
class PPTPCallClearRequest(PPTP):
name = "PPTP Call Clear Request"
fields_desc = [LenField("len", 16),
ShortEnumField("type", 1, _PPTP_msg_type),
XIntField("magic_cookie", _PPTP_MAGIC_COOKIE),
ShortEnumField("ctrl_msg_type", 12, _PPTP_ctrl_msg_type),
XShortField("reserved_0", 0x0000),
ShortField("call_id", 1),
XShortField("reserved_1", 0x0000)]
class PPI_Hdr(Packet):
name = 'PPI Header'
fields_desc = [
LEShortEnumField('pfh_type', 0, PPI_TYPES),
LenField('pfh_length', None, fmt='<H'),
]
def mysummary(self):
return self.sprintf('PPI %pfh_type%')
class EIR_Hdr(Packet):
name = "EIR Header"
fields_desc = [
LenField("len", None, fmt="B",
adjust=lambda x: x + 1), # Add bytes mark # noqa: E501
# https://www.bluetooth.com/specifications/assigned-numbers/generic-access-profile
ByteEnumField(
"type", 0, {
0x01: "flags",
0x02: "incomplete_list_16_bit_svc_uuids",
0x03: "complete_list_16_bit_svc_uuids",
0x04: "incomplete_list_32_bit_svc_uuids",
0x05: "complete_list_32_bit_svc_uuids",
0x06: "incomplete_list_128_bit_svc_uuids",
0x07: "complete_list_128_bit_svc_uuids",
0x08: "shortened_local_name",
0x09: "complete_local_name",
0x0a: "tx_power_level",
0x0d: "class_of_device",
0x0e: "simple_pairing_hash",
0x0f: "simple_pairing_rand",
0x10: "sec_mgr_tk",
0x11: "sec_mgr_oob_flags",
0x12: "slave_conn_intvl_range",
0x14: "list_16_bit_svc_sollication_uuids",
0x15: "list_128_bit_svc_sollication_uuids",
0x16: "svc_data_16_bit_uuid",
0x17: "pub_target_addr",
0x18: "rand_target_addr",
0x19: "appearance",
0x1a: "adv_intvl",
0x1b: "le_addr",
0x1c: "le_role",
0x1d: "simple_pairing_hash_256",
0x1e: "simple_pairing_rand_256",
0x1f: "list_32_bit_svc_sollication_uuids",
0x20: "svc_data_32_bit_uuid",
0x21: "svc_data_128_bit_uuid",
0x22: "sec_conn_confirm",
0x23: "sec_conn_rand",
0x24: "uri",
0x25: "indoor_positioning",
0x26: "transport_discovery",
0x27: "le_supported_features",
0x28: "channel_map_update",
0x29: "mesh_pb_adv",
0x2a: "mesh_message",
0x2b: "mesh_beacon",
0x3d: "3d_information",
0xff: "mfg_specific_data",
}),
]
def mysummary(self):
return self.sprintf("EIR %type%")
class PPTPStopControlConnectionRequest(PPTP):
name = "PPTP Stop Control Connection Request"
fields_desc = [LenField("len", 16),
ShortEnumField("type", 1, _PPTP_msg_type),
XIntField("magic_cookie", _PPTP_MAGIC_COOKIE),
ShortEnumField("ctrl_msg_type", 3, _PPTP_ctrl_msg_type),
XShortField("reserved_0", 0x0000),
ByteEnumField("reason", 1,
_PPTP_stop_control_connection_reason),
XByteField("reserved_1", 0x00),
XShortField("reserved_2", 0x0000)]
class SignalHeader(CAN):
fields_desc = [
FlagsField('flags', 0, 3,
['error', 'remote_transmission_request', 'extended']),
XBitField('identifier', 0, 29),
LenField('length', None, fmt='B'),
ThreeBytesField('reserved', 0)
]
def extract_padding(self, s):
return s, None
class PPTPSetLinkInfo(PPTP):
name = "PPTP Set Link Info"
fields_desc = [LenField("len", 24),
ShortEnumField("type", 1, _PPTP_msg_type),
XIntField("magic_cookie", _PPTP_MAGIC_COOKIE),
ShortEnumField("ctrl_msg_type", 15, _PPTP_ctrl_msg_type),
XShortField("reserved_0", 0x0000),
ShortField("peer_call_id", 1),
XShortField("reserved_1", 0x0000),
XIntField("send_accm", 0x00000000),
XIntField("receive_accm", 0x00000000)]
class COTP_Connection_Request(Packet):
name = "COTP Connection Request (CR)"
fields_desc = [
LenField("length", None, fmt="!B", adjust=lambda x: x + 5),
ByteField("tpdu_code", 0xd0),
ShortField("destination_reference", None),
ShortField("source_reference", None),
BitField("class", 0, 4),
BitField("reserved", 0, 2),
BitField("extended_format", 0, 1),
BitField("explicit", 0, 1),
PacketListField("parameters", None, COTP_Parameter)
]
class HCI_Event_Hdr(Packet):
name = "HCI Event header"
fields_desc = [
XByteField("code", 0),
LenField("len", None, fmt="B"),
]
def answers(self, other):
if HCI_Command_Hdr not in other:
return False
# Delegate answers to event types
return self.payload.answers(other)
class PPTPStopControlConnectionReply(PPTP):
name = "PPTP Stop Control Connection Reply"
fields_desc = [LenField("len", 16),
ShortEnumField("type", 1, _PPTP_msg_type),
XIntField("magic_cookie", _PPTP_MAGIC_COOKIE),
ShortEnumField("ctrl_msg_type", 4, _PPTP_ctrl_msg_type),
XShortField("reserved_0", 0x0000),
ByteEnumField("result_code", 1,
_PPTP_stop_control_connection_result),
ByteEnumField("error_code", 0, _PPTP_general_error_code),
XShortField("reserved_2", 0x0000)]
def answers(self, other):
return isinstance(other, PPTPStopControlConnectionRequest)
class PPTPEchoReply(PPTP):
name = "PPTP Echo Reply"
fields_desc = [LenField("len", 20),
ShortEnumField("type", 1, _PPTP_msg_type),
XIntField("magic_cookie", _PPTP_MAGIC_COOKIE),
ShortEnumField("ctrl_msg_type", 6, _PPTP_ctrl_msg_type),
XShortField("reserved_0", 0x0000),
IntField("identifier", None),
ByteEnumField("result_code", 1, _PPTP_echo_result),
ByteEnumField("error_code", 0, _PPTP_general_error_code),
XShortField("reserved_1", 0x0000)]
def answers(self, other):
return isinstance(other, PPTPEchoRequest) and other.identifier == self.identifier # noqa: E501
class PPTPCallDisconnectNotify(PPTP):
name = "PPTP Call Disconnect Notify"
fields_desc = [LenField("len", 148),
ShortEnumField("type", 1, _PPTP_msg_type),
XIntField("magic_cookie", _PPTP_MAGIC_COOKIE),
ShortEnumField("ctrl_msg_type", 13, _PPTP_ctrl_msg_type),
XShortField("reserved_0", 0x0000),
ShortField("call_id", 1),
ByteEnumField("result_code", 1,
_PPTP_call_disconnect_result),
ByteEnumField("error_code", 0, _PPTP_general_error_code),
ShortField("cause_code", 0),
XShortField("reserved_1", 0x0000),
StrFixedLenField("call_statistic", "", 128)]
class HCI_Command_Hdr(Packet):
name = "HCI Command header"
fields_desc = [
XLEShortField("opcode", 0),
LenField("len", None, fmt="B"),
]
def answers(self, other):
return False
def post_build(self, p, pay):
p += pay
if self.len is None:
p = p[:2] + struct.pack("B", len(pay)) + p[3:]
return p
def addfield(self, pkt, s, val):
return s + raw(SDNVUtil.encode(LenField.i2m(self, pkt, val)))
