Datasets:

---

monsterapi

/

code_search_net

like 0

Follow

MonsterAPI 14

[ "def", "_read_mode_route", "(", "self", ",", "size", ",", "kind", ")", ":", "if", "size", "<", "3", "or", "(", "size", "-", "3", ")", "%", "4", "!=", "0", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {kind}] invalid format'", ")", "_rptr", "=", "self", ".", "_read_unpack", "(", "1", ")", "if", "_rptr", "<", "4", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {kind}] invalid format'", ")", "data", "=", "dict", "(", "kind", "=", "kind", ",", "type", "=", "self", ".", "_read_opt_type", "(", "kind", ")", ",", "length", "=", "size", ",", "pointer", "=", "_rptr", ",", ")", "counter", "=", "4", "address", "=", "list", "(", ")", "endpoint", "=", "min", "(", "_rptr", ",", "size", ")", "while", "counter", "<", "endpoint", ":", "counter", "+=", "4", "address", ".", "append", "(", "self", ".", "_read_ipv4_addr", "(", ")", ")", "data", "[", "'ip'", "]", "=", "address", "or", "None", "return", "data" ]

[ "Read", "options", "with", "route", "data", "." ]

[ "def", "_read_mode_qs", "(", "self", ",", "size", ",", "kind", ")", ":", "if", "size", "!=", "8", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {kind}] invalid format'", ")", "_type", "=", "self", ".", "_read_opt_type", "(", "kind", ")", "_fcrr", "=", "self", ".", "_read_binary", "(", "1", ")", "_func", "=", "int", "(", "_fcrr", "[", ":", "4", "]", ",", "base", "=", "2", ")", "_rate", "=", "int", "(", "_fcrr", "[", "4", ":", "]", ",", "base", "=", "2", ")", "_ttlv", "=", "self", ".", "_read_unpack", "(", "1", ")", "_nonr", "=", "self", ".", "_read_binary", "(", "4", ")", "_qsnn", "=", "int", "(", "_nonr", "[", ":", "30", "]", ",", "base", "=", "2", ")", "if", "_func", "!=", "0", "and", "_func", "!=", "8", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {kind}] invalid format'", ")", "data", "=", "dict", "(", "kind", "=", "kind", ",", "type", "=", "_type", ",", "length", "=", "size", ",", "func", "=", "QS_FUNC", ".", "get", "(", "_func", ")", ",", "rate", "=", "40000", "*", "(", "2", "**", "_rate", ")", "/", "1000", ",", "ttl", "=", "None", "if", "_func", "else", "_rate", ",", "nounce", "=", "_qsnn", ",", ")", "return", "data" ]

[ "Read", "Quick", "Start", "option", "." ]

[ "def", "_read_mode_ts", "(", "self", ",", "size", ",", "kind", ")", ":", "if", "size", ">", "40", "or", "size", "<", "4", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {kind}] invalid format'", ")", "_tptr", "=", "self", ".", "_read_unpack", "(", "1", ")", "_oflg", "=", "self", ".", "_read_binary", "(", "1", ")", "_oflw", "=", "int", "(", "_oflg", "[", ":", "4", "]", ",", "base", "=", "2", ")", "_flag", "=", "int", "(", "_oflg", "[", "4", ":", "]", ",", "base", "=", "2", ")", "if", "_tptr", "<", "5", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {kind}] invalid format'", ")", "data", "=", "dict", "(", "kind", "=", "kind", ",", "type", "=", "self", ".", "_read_opt_type", "(", "kind", ")", ",", "length", "=", "size", ",", "pointer", "=", "_tptr", ",", "overflow", "=", "_oflw", ",", "flag", "=", "_flag", ",", ")", "endpoint", "=", "min", "(", "_tptr", ",", "size", ")", "if", "_flag", "==", "0", ":", "if", "(", "size", "-", "4", ")", "%", "4", "!=", "0", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {kind}] invalid format'", ")", "counter", "=", "5", "timestamp", "=", "list", "(", ")", "while", "counter", "<", "endpoint", ":", "counter", "+=", "4", "time", "=", "self", ".", "_read_unpack", "(", "4", ",", "lilendian", "=", "True", ")", "timestamp", ".", "append", "(", "datetime", ".", "datetime", ".", "fromtimestamp", "(", "time", ")", ")", "data", "[", "'timestamp'", "]", "=", "timestamp", "or", "None", "elif", "_flag", "==", "1", "or", "_flag", "==", "3", ":", "if", "(", "size", "-", "4", ")", "%", "8", "!=", "0", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {kind}] invalid format'", ")", "counter", "=", "5", "ipaddress", "=", "list", "(", ")", "timestamp", "=", "list", "(", ")", "while", "counter", "<", "endpoint", ":", "counter", "+=", "8", "ipaddress", ".", "append", "(", "self", ".", "_read_ipv4_addr", "(", ")", ")", "time", "=", "self", ".", "_read_unpack", "(", "4", ",", "lilendian", "=", "True", ")", "timestamp", ".", "append", "(", "datetime", ".", "datetime", ".", "fromtimestamp", "(", "time", ")", ")", "data", "[", "'ip'", "]", "=", "ipaddress", "or", "None", "data", "[", "'timestamp'", "]", "=", "timestamp", "or", "None", "else", ":", "data", "[", "'data'", "]", "=", "self", ".", "_read_fileng", "(", "size", "-", "4", ")", "or", "None", "return", "data" ]

[ "Read", "Time", "Stamp", "option", "." ]

[ "def", "_read_mode_tr", "(", "self", ",", "size", ",", "kind", ")", ":", "if", "size", "!=", "12", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {kind}] invalid format'", ")", "_idnm", "=", "self", ".", "_read_unpack", "(", "2", ")", "_ohcn", "=", "self", ".", "_read_unpack", "(", "2", ")", "_rhcn", "=", "self", ".", "_read_unpack", "(", "2", ")", "_ipad", "=", "self", ".", "_read_ipv4_addr", "(", ")", "data", "=", "dict", "(", "kind", "=", "kind", ",", "type", "=", "self", ".", "_read_opt_type", "(", "kind", ")", ",", "length", "=", "size", ",", "id", "=", "_idnm", ",", "ohc", "=", "_ohcn", ",", "rhc", "=", "_rhcn", ",", "ip", "=", "_ipad", ",", ")", "return", "data" ]

[ "Read", "Traceroute", "option", "." ]

[ "def", "_read_mode_sec", "(", "self", ",", "size", ",", "kind", ")", ":", "if", "size", "<", "3", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {kind}] invalid format'", ")", "_clvl", "=", "self", ".", "_read_unpack", "(", "1", ")", "data", "=", "dict", "(", "kind", "=", "kind", ",", "type", "=", "self", ".", "_read_opt_type", "(", "kind", ")", ",", "length", "=", "size", ",", "level", "=", "_CLASSIFICATION_LEVEL", ".", "get", "(", "_clvl", ",", "_clvl", ")", ",", ")", "if", "size", ">", "3", ":", "_list", "=", "list", "(", ")", "for", "counter", "in", "range", "(", "3", ",", "size", ")", ":", "_flag", "=", "self", ".", "_read_binary", "(", "1", ")", "if", "(", "counter", "<", "size", "-", "1", "and", "not", "int", "(", "_flag", "[", "7", "]", ",", "base", "=", "2", ")", ")", "or", "(", "counter", "==", "size", "-", "1", "and", "int", "(", "_flag", "[", "7", "]", ",", "base", "=", "2", ")", ")", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {kind}] invalid format'", ")", "_dict", "=", "dict", "(", ")", "for", "(", "index", ",", "bit", ")", "in", "enumerate", "(", "_flag", "[", ":", "5", "]", ")", ":", "_auth", "=", "_PROTECTION_AUTHORITY", ".", "get", "(", "index", ")", "_dict", "[", "_auth", "]", "=", "True", "if", "int", "(", "bit", ",", "base", "=", "2", ")", "else", "False", "_list", ".", "append", "(", "Info", "(", "_dict", ")", ")", "data", "[", "'flags'", "]", "=", "tuple", "(", "_list", ")", "return", "data" ]

[ "Read", "options", "with", "security", "info", "." ]

[ "def", "_read_mode_rsralt", "(", "self", ",", "size", ",", "kind", ")", ":", "if", "size", "!=", "4", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {kind}] invalid format'", ")", "_code", "=", "self", ".", "_read_unpack", "(", "2", ")", "data", "=", "dict", "(", "kind", "=", "kind", ",", "type", "=", "self", ".", "_read_opt_type", "(", "kind", ")", ",", "length", "=", "size", ",", "alert", "=", "_ROUTER_ALERT", ".", "get", "(", "_code", ",", "'Reserved'", ")", ",", "code", "=", "_code", ",", ")", "return", "data" ]

[ "Read", "Router", "Alert", "option", "." ]

[ "def", "read_header", "(", "self", ")", ":", "_magn", "=", "self", ".", "_read_fileng", "(", "4", ")", "if", "_magn", "==", "b'\\xd4\\xc3\\xb2\\xa1'", ":", "lilendian", "=", "True", "self", ".", "_nsec", "=", "False", "self", ".", "_byte", "=", "'little'", "elif", "_magn", "==", "b'\\xa1\\xb2\\xc3\\xd4'", ":", "lilendian", "=", "False", "self", ".", "_nsec", "=", "False", "self", ".", "_byte", "=", "'big'", "elif", "_magn", "==", "b'\\x4d\\x3c\\xb2\\xa1'", ":", "lilendian", "=", "True", "self", ".", "_nsec", "=", "True", "self", ".", "_byte", "=", "'little'", "elif", "_magn", "==", "b'\\xa1\\xb2\\x3c\\x4d'", ":", "lilendian", "=", "False", "self", ".", "_nsec", "=", "True", "self", ".", "_byte", "=", "'big'", "else", ":", "raise", "FileError", "(", "5", ",", "'Unknown file format'", ",", "self", ".", "_file", ".", "name", ")", "_vmaj", "=", "self", ".", "_read_unpack", "(", "2", ",", "lilendian", "=", "lilendian", ")", "_vmin", "=", "self", ".", "_read_unpack", "(", "2", ",", "lilendian", "=", "lilendian", ")", "_zone", "=", "self", ".", "_read_unpack", "(", "4", ",", "lilendian", "=", "lilendian", ",", "signed", "=", "True", ")", "_acts", "=", "self", ".", "_read_unpack", "(", "4", ",", "lilendian", "=", "lilendian", ")", "_slen", "=", "self", ".", "_read_unpack", "(", "4", ",", "lilendian", "=", "lilendian", ")", "_type", "=", "self", ".", "_read_protos", "(", "4", ")", "_byte", "=", "self", ".", "_read_packet", "(", "24", ")", "self", ".", "_file", "=", "io", ".", "BytesIO", "(", "_byte", ")", "header", "=", "dict", "(", "magic_number", "=", "dict", "(", "data", "=", "_magn", ",", "byteorder", "=", "self", ".", "_byte", ",", "nanosecond", "=", "self", ".", "_nsec", ",", ")", ",", "version_major", "=", "_vmaj", ",", "version_minor", "=", "_vmin", ",", "thiszone", "=", "_zone", ",", "sigfigs", "=", "_acts", ",", "snaplen", "=", "_slen", ",", "network", "=", "_type", ",", "packet", "=", "_byte", ",", ")", "return", "header" ]

[ "Read", "global", "header", "of", "PCAP", "file", "." ]

[ "def", "_read_protos", "(", "self", ",", "size", ")", ":", "_byte", "=", "self", ".", "_read_unpack", "(", "4", ",", "lilendian", "=", "True", ")", "_prot", "=", "LINKTYPE", ".", "get", "(", "_byte", ")", "return", "_prot" ]

[ "Read", "next", "layer", "protocol", "type", "." ]

[ "def", "read_frame", "(", "self", ")", ":", "# _scur = self._file.tell()", "_temp", "=", "self", ".", "_read_unpack", "(", "4", ",", "lilendian", "=", "True", ",", "quiet", "=", "True", ")", "if", "_temp", "is", "None", ":", "raise", "EOFError", "_tsss", "=", "_temp", "_tsus", "=", "self", ".", "_read_unpack", "(", "4", ",", "lilendian", "=", "True", ")", "_ilen", "=", "self", ".", "_read_unpack", "(", "4", ",", "lilendian", "=", "True", ")", "_olen", "=", "self", ".", "_read_unpack", "(", "4", ",", "lilendian", "=", "True", ")", "if", "self", ".", "_nsec", ":", "_epch", "=", "_tsss", "+", "_tsus", "/", "1000000000", "else", ":", "_epch", "=", "_tsss", "+", "_tsus", "/", "1000000", "_time", "=", "datetime", ".", "datetime", ".", "fromtimestamp", "(", "_epch", ")", "frame", "=", "dict", "(", "frame_info", "=", "dict", "(", "ts_sec", "=", "_tsss", ",", "ts_usec", "=", "_tsus", ",", "incl_len", "=", "_ilen", ",", "orig_len", "=", "_olen", ",", ")", ",", "time", "=", "_time", ",", "number", "=", "self", ".", "_fnum", ",", "time_epoch", "=", "_epch", ",", "len", "=", "_ilen", ",", "cap_len", "=", "_olen", ",", ")", "# load packet data", "length", "=", "frame", "[", "'len'", "]", "bytes_", "=", "self", ".", "_file", ".", "read", "(", "length", ")", "# record file pointer", "if", "self", ".", "_mpkt", "and", "self", ".", "_mpfp", ":", "# print(self._fnum, 'ready')", "self", ".", "_mpfp", ".", "put", "(", "self", ".", "_file", ".", "tell", "(", ")", ")", "self", ".", "_mpkt", ".", "pool", "+=", "1", "# make BytesIO from frame packet data", "frame", "[", "'packet'", "]", "=", "bytes_", "self", ".", "_file", "=", "io", ".", "BytesIO", "(", "bytes_", ")", "# frame['packet'] = self._read_packet(header=0, payload=length, discard=True)", "return", "self", ".", "_decode_next_layer", "(", "frame", ",", "length", ")" ]

[ "Read", "each", "block", "after", "global", "header", "." ]

[ "def", "_decode_next_layer", "(", "self", ",", "dict_", ",", "length", "=", "None", ")", ":", "seek_cur", "=", "self", ".", "_file", ".", "tell", "(", ")", "try", ":", "next_", "=", "self", ".", "_import_next_layer", "(", "self", ".", "_prot", ",", "length", ")", "except", "Exception", ":", "dict_", "[", "'error'", "]", "=", "traceback", ".", "format_exc", "(", "limit", "=", "1", ")", ".", "strip", "(", ")", ".", "split", "(", "os", ".", "linesep", ")", "[", "-", "1", "]", "self", ".", "_file", ".", "seek", "(", "seek_cur", ",", "os", ".", "SEEK_SET", ")", "next_", "=", "beholder", "(", "self", ".", "_import_next_layer", ")", "(", "self", ",", "self", ".", "_prot", ",", "length", ",", "error", "=", "True", ")", "info", ",", "chain", "=", "next_", ".", "info", ",", "next_", ".", "protochain", "# make next layer protocol name", "layer", "=", "next_", ".", "alias", ".", "lower", "(", ")", "# proto = next_.__class__.__name__", "# write info and protocol chain into dict", "self", ".", "_next", "=", "next_", "self", ".", "_protos", "=", "chain", "dict_", "[", "layer", "]", "=", "info", "dict_", "[", "'protocols'", "]", "=", "self", ".", "_protos", ".", "chain", "return", "dict_" ]

[ "Decode", "next", "layer", "protocol", "." ]

[ "def", "_import_next_layer", "(", "self", ",", "proto", ",", "length", ",", "error", "=", "False", ")", ":", "if", "proto", "==", "1", ":", "from", "pcapkit", ".", "protocols", ".", "link", "import", "Ethernet", "as", "Protocol", "elif", "proto", "==", "228", ":", "from", "pcapkit", ".", "protocols", ".", "internet", "import", "IPv4", "as", "Protocol", "elif", "proto", "==", "229", ":", "from", "pcapkit", ".", "protocols", ".", "internet", "import", "IPv6", "as", "Protocol", "else", ":", "from", "pcapkit", ".", "protocols", ".", "raw", "import", "Raw", "as", "Protocol", "next_", "=", "Protocol", "(", "self", ".", "_file", ",", "length", ",", "error", "=", "error", ",", "layer", "=", "self", ".", "_exlayer", ",", "protocol", "=", "self", ".", "_exproto", ")", "return", "next_" ]

[ "Import", "next", "layer", "extractor", "." ]

[ "def", "get", "(", "key", ",", "default", "=", "-", "1", ")", ":", "if", "isinstance", "(", "key", ",", "int", ")", ":", "return", "RegistrationFailure", "(", "key", ")", "if", "key", "not", "in", "RegistrationFailure", ".", "_member_map_", ":", "extend_enum", "(", "RegistrationFailure", ",", "key", ",", "default", ")", "return", "RegistrationFailure", "[", "key", "]" ]

[ "Backport", "support", "for", "original", "codes", "." ]

[ "def", "get", "(", "key", ",", "default", "=", "-", "1", ")", ":", "if", "isinstance", "(", "key", ",", "int", ")", ":", "return", "TOS_PRE", "(", "key", ")", "if", "key", "not", "in", "TOS_PRE", ".", "_member_map_", ":", "extend_enum", "(", "TOS_PRE", ",", "key", ",", "default", ")", "return", "TOS_PRE", "[", "key", "]" ]

[ "Backport", "support", "for", "original", "codes", "." ]

[ "def", "read_raw", "(", "self", ",", "length", ",", "*", ",", "error", "=", "None", ")", ":", "if", "length", "is", "None", ":", "length", "=", "len", "(", "self", ")", "raw", "=", "dict", "(", "packet", "=", "self", ".", "_read_fileng", "(", "length", ")", ",", "error", "=", "error", "or", "None", ",", ")", "return", "raw" ]

[ "Read", "raw", "packet", "data", "." ]

[ "def", "get", "(", "key", ",", "default", "=", "-", "1", ")", ":", "if", "isinstance", "(", "key", ",", "int", ")", ":", "return", "NotifyMessage", "(", "key", ")", "if", "key", "not", "in", "NotifyMessage", ".", "_member_map_", ":", "extend_enum", "(", "NotifyMessage", ",", "key", ",", "default", ")", "return", "NotifyMessage", "[", "key", "]" ]

[ "Backport", "support", "for", "original", "codes", "." ]

[ "def", "_missing_", "(", "cls", ",", "value", ")", ":", "if", "not", "(", "isinstance", "(", "value", ",", "int", ")", "and", "0", "<=", "value", "<=", "65535", ")", ":", "raise", "ValueError", "(", "'%r is not a valid %s'", "%", "(", "value", ",", "cls", ".", "__name__", ")", ")", "if", "2", "<=", "value", "<=", "6", ":", "extend_enum", "(", "cls", ",", "'Unassigned [%d]'", "%", "value", ",", "value", ")", "return", "cls", "(", "value", ")", "if", "8", "<=", "value", "<=", "13", ":", "extend_enum", "(", "cls", ",", "'Unassigned [%d]'", "%", "value", ",", "value", ")", "return", "cls", "(", "value", ")", "if", "21", "<=", "value", "<=", "23", ":", "extend_enum", "(", "cls", ",", "'Unassigned [%d]'", "%", "value", ",", "value", ")", "return", "cls", "(", "value", ")", "if", "29", "<=", "value", "<=", "31", ":", "extend_enum", "(", "cls", ",", "'Unassigned [%d]'", "%", "value", ",", "value", ")", "return", "cls", "(", "value", ")", "if", "33", "<=", "value", "<=", "39", ":", "extend_enum", "(", "cls", ",", "'Unassigned [%d]'", "%", "value", ",", "value", ")", "return", "cls", "(", "value", ")", "if", "52", "<=", "value", "<=", "59", ":", "extend_enum", "(", "cls", ",", "'Unassigned [%d]'", "%", "value", ",", "value", ")", "return", "cls", "(", "value", ")", "if", "63", "<=", "value", "<=", "69", ":", "extend_enum", "(", "cls", ",", "'Unassigned [%d]'", "%", "value", ",", "value", ")", "return", "cls", "(", "value", ")", "if", "71", "<=", "value", "<=", "89", ":", "extend_enum", "(", "cls", ",", "'Unassigned [%d]'", "%", "value", ",", "value", ")", "return", "cls", "(", "value", ")", "if", "91", "<=", "value", "<=", "99", ":", "extend_enum", "(", "cls", ",", "'Unassigned [%d]'", "%", "value", ",", "value", ")", "return", "cls", "(", "value", ")", "if", "101", "<=", "value", "<=", "8191", ":", "extend_enum", "(", "cls", ",", "'Unassigned [%d]'", "%", "value", ",", "value", ")", "return", "cls", "(", "value", ")", "if", "8192", "<=", "value", "<=", "16383", ":", "# [RFC 7401]", "extend_enum", "(", "cls", ",", "'Reserved for Private Use [%d]'", "%", "value", ",", "value", ")", "return", "cls", "(", "value", ")", "if", "16385", "<=", "value", "<=", "40959", ":", "extend_enum", "(", "cls", ",", "'Unassigned [%d]'", "%", "value", ",", "value", ")", "return", "cls", "(", "value", ")", "if", "40960", "<=", "value", "<=", "65535", ":", "# [RFC 7401]", "extend_enum", "(", "cls", ",", "'Reserved for Private Use [%d]'", "%", "value", ",", "value", ")", "return", "cls", "(", "value", ")", "super", "(", ")", ".", "_missing_", "(", "value", ")" ]

[ "Lookup", "function", "used", "when", "value", "is", "not", "found", "." ]

[ "def", "ipv6_hdr_len", "(", "ipv6", ")", ":", "hdr_len", "=", "ipv6", ".", "__hdr_len__", "for", "code", "in", "(", "0", ",", "60", ",", "43", ")", ":", "ext_hdr", "=", "ipv6", ".", "extension_hdrs", ".", "get", "(", "code", ")", "if", "ext_hdr", "is", "not", "None", ":", "hdr_len", "+=", "ext_hdr", ".", "length", "return", "hdr_len" ]

[ "Calculate", "length", "of", "headers", "before", "IPv6", "-", "Frag" ]

[ "def", "packet2chain", "(", "packet", ")", ":", "chain", "=", "[", "type", "(", "packet", ")", ".", "__name__", "]", "payload", "=", "packet", ".", "data", "while", "not", "isinstance", "(", "payload", ",", "bytes", ")", ":", "chain", ".", "append", "(", "type", "(", "payload", ")", ".", "__name__", ")", "payload", "=", "payload", ".", "data", "return", "':'", ".", "join", "(", "chain", ")" ]

[ "Fetch", "DPKT", "packet", "protocol", "chain", "." ]

[ "def", "packet2dict", "(", "packet", ",", "timestamp", ",", "*", ",", "data_link", ")", ":", "def", "wrapper", "(", "packet", ")", ":", "dict_", "=", "dict", "(", ")", "for", "field", "in", "packet", ".", "__hdr_fields__", ":", "dict_", "[", "field", "]", "=", "getattr", "(", "packet", ",", "field", ",", "None", ")", "payload", "=", "packet", ".", "data", "if", "not", "isinstance", "(", "payload", ",", "bytes", ")", ":", "dict_", "[", "type", "(", "payload", ")", ".", "__name__", "]", "=", "wrapper", "(", "payload", ")", "return", "dict_", "return", "{", "'timestamp'", ":", "timestamp", ",", "'packet'", ":", "packet", ".", "pack", "(", ")", ",", "data_link", ".", "name", ":", "wrapper", "(", "packet", ")", ",", "}" ]

[ "Convert", "DPKT", "packet", "into", "dict", "." ]

[ "def", "ipv4_reassembly", "(", "packet", ",", "*", ",", "count", "=", "NotImplemented", ")", ":", "ipv4", "=", "getattr", "(", "packet", ",", "'ip'", ",", "None", ")", "if", "ipv4", "is", "not", "None", ":", "if", "ipv4", ".", "df", ":", "# dismiss not fragmented packet", "return", "False", ",", "None", "data", "=", "dict", "(", "bufid", "=", "(", "ipaddress", ".", "ip_address", "(", "ipv4", ".", "src", ")", ",", "# source IP address", "ipaddress", ".", "ip_address", "(", "ipv4", ".", "dst", ")", ",", "# destination IP address", "ipv4", ".", "id", ",", "# identification", "TP_PROTO", ".", "get", "(", "ipv4", ".", "p", ")", ".", "name", ",", "# payload protocol type", ")", ",", "num", "=", "count", ",", "# original packet range number", "fo", "=", "ipv4", ".", "off", ",", "# fragment offset", "ihl", "=", "ipv4", ".", "__hdr_len__", ",", "# internet header length", "mf", "=", "bool", "(", "ipv4", ".", "mf", ")", ",", "# more fragment flag", "tl", "=", "ipv4", ".", "len", ",", "# total length, header includes", "header", "=", "bytearray", "(", "ipv4", ".", "pack", "(", ")", "[", ":", "ipv4", ".", "__hdr_len__", "]", ")", ",", "# raw bytearray type header", "payload", "=", "bytearray", "(", "ipv4", ".", "pack", "(", ")", "[", "ipv4", ".", "__hdr_len__", ":", "]", ")", ",", "# raw bytearray type payload", ")", "return", "True", ",", "data", "return", "False", ",", "None" ]

[ "Make", "data", "for", "IPv4", "reassembly", "." ]

[ "def", "ipv6_reassembly", "(", "packet", ",", "*", ",", "count", "=", "NotImplemented", ")", ":", "ipv6", "=", "getattr", "(", "packet", ",", "'ip6'", ",", "None", ")", "if", "ipv6", "is", "not", "None", ":", "ipv6_frag", "=", "ipv6", ".", "extension_hdrs", ".", "get", "(", "44", ")", "if", "ipv6_frag", "is", "None", ":", "# dismiss not fragmented packet", "return", "False", ",", "None", "hdr_len", "=", "ipv6_hdr_len", "(", "ipv6", ")", "data", "=", "dict", "(", "bufid", "=", "(", "ipaddress", ".", "ip_address", "(", "ipv6", ".", "src", ")", ",", "# source IP address", "ipaddress", ".", "ip_address", "(", "ipv6", ".", "dst", ")", ",", "# destination IP address", "ipv6", ".", "flow", ",", "# label", "TP_PROTO", ".", "get", "(", "ipv6_frag", ".", "nh", ")", ".", "name", ",", "# next header field in IPv6 Fragment Header", ")", ",", "num", "=", "count", ",", "# original packet range number", "fo", "=", "ipv6_frag", ".", "nxt", ",", "# fragment offset", "ihl", "=", "hdr_len", ",", "# header length, only headers before IPv6-Frag", "mf", "=", "bool", "(", "ipv6_frag", ".", "m_flag", ")", ",", "# more fragment flag", "tl", "=", "len", "(", "ipv6", ")", ",", "# total length, header includes", "header", "=", "bytearray", "(", "ipv6", ".", "pack", "(", ")", "[", ":", "hdr_len", "]", ")", ",", "# raw bytearray type header before IPv6-Frag", "payload", "=", "bytearray", "(", "ipv6", ".", "pack", "(", ")", "[", "hdr_len", "+", "ipv6_frag", ":", "]", ")", ",", "# raw bytearray type payload after IPv6-Frag", ")", "return", "True", ",", "data", "return", "False", ",", "None" ]

[ "Make", "data", "for", "IPv6", "reassembly", "." ]

[ "def", "tcp_reassembly", "(", "packet", ",", "*", ",", "count", "=", "NotImplemented", ")", ":", "if", "getattr", "(", "packet", ",", "'ip'", ",", "None", ")", ":", "ip", "=", "packet", "[", "'ip'", "]", "elif", "getattr", "(", "packet", ",", "'ip6'", ",", "None", ")", ":", "ip", "=", "packet", "[", "'ip6'", "]", "else", ":", "return", "False", ",", "None", "tcp", "=", "getattr", "(", "ip", ",", "'tcp'", ",", "None", ")", "if", "tcp", "is", "not", "None", ":", "flags", "=", "bin", "(", "tcp", ".", "flags", ")", "[", "2", ":", "]", ".", "zfill", "(", "8", ")", "data", "=", "dict", "(", "bufid", "=", "(", "ipaddress", ".", "ip_address", "(", "ip", ".", "src", ")", ",", "# source IP address", "ipaddress", ".", "ip_address", "(", "ip", ".", "dst", ")", ",", "# destination IP address", "tcp", ".", "sport", ",", "# source port", "tcp", ".", "dport", ",", "# destination port", ")", ",", "num", "=", "count", ",", "# original packet range number", "ack", "=", "tcp", ".", "ack", ",", "# acknowledgement", "dsn", "=", "tcp", ".", "seq", ",", "# data sequence number", "rst", "=", "bool", "(", "int", "(", "flags", "[", "5", "]", ")", ")", ",", "# reset connection flag", "syn", "=", "bool", "(", "int", "(", "flags", "[", "6", "]", ")", ")", ",", "# synchronise flag", "fin", "=", "bool", "(", "int", "(", "flags", "[", "7", "]", ")", ")", ",", "# finish flag", "payload", "=", "bytearray", "(", "tcp", ".", "pack", "(", ")", "[", "tcp", ".", "__hdr_len__", ":", "]", ")", ",", "# raw bytearray type payload", ")", "raw_len", "=", "len", "(", "tcp", ".", "data", ")", "# payload length, header excludes", "data", "[", "'first'", "]", "=", "tcp", ".", "seq", "# this sequence number", "data", "[", "'last'", "]", "=", "tcp", ".", "seq", "+", "raw_len", "# next (wanted) sequence number", "data", "[", "'len'", "]", "=", "raw_len", "# payload length, header excludes", "return", "True", ",", "data", "return", "False", ",", "None" ]

[ "Make", "data", "for", "TCP", "reassembly", "." ]

[ "def", "tcp_traceflow", "(", "packet", ",", "timestamp", ",", "*", ",", "data_link", ",", "count", "=", "NotImplemented", ")", ":", "if", "getattr", "(", "packet", ",", "'ip'", ",", "None", ")", ":", "ip", "=", "packet", "[", "'ip'", "]", "elif", "getattr", "(", "packet", ",", "'ip6'", ",", "None", ")", ":", "ip", "=", "packet", "[", "'ip6'", "]", "else", ":", "return", "False", ",", "None", "tcp", "=", "getattr", "(", "ip", ",", "'tcp'", ",", "None", ")", "if", "tcp", "is", "not", "None", ":", "flags", "=", "bin", "(", "tcp", ".", "flags", ")", "[", "2", ":", "]", ".", "zfill", "(", "8", ")", "data", "=", "dict", "(", "protocol", "=", "data_link", ",", "# data link type from global header", "index", "=", "count", ",", "# frame number", "frame", "=", "packet2dict", "(", "packet", ",", "timestamp", ",", "data_link", "=", "data_link", ")", ",", "# extracted packet", "syn", "=", "bool", "(", "int", "(", "flags", "[", "6", "]", ")", ")", ",", "# TCP synchronise (SYN) flag", "fin", "=", "bool", "(", "int", "(", "flags", "[", "7", "]", ")", ")", ",", "# TCP finish (FIN) flag", "src", "=", "ipaddress", ".", "ip_address", "(", "ip", ".", "src", ")", ",", "# source IP", "dst", "=", "ipaddress", ".", "ip_address", "(", "ip", ".", "dst", ")", ",", "# destination IP", "srcport", "=", "tcp", ".", "sport", ",", "# TCP source port", "dstport", "=", "tcp", ".", "dport", ",", "# TCP destination port", "timestamp", "=", "timestamp", ",", "# timestamp", ")", "return", "True", ",", "data", "return", "False", ",", "None" ]

[ "Trace", "packet", "flow", "for", "TCP", "." ]

[ "def", "read_http", "(", "self", ",", "length", ")", ":", "if", "length", "is", "None", ":", "length", "=", "len", "(", "self", ")", "if", "length", "<", "9", ":", "raise", "ProtocolError", "(", "f'HTTP/2: invalid format'", ",", "quiet", "=", "True", ")", "_tlen", "=", "self", ".", "_read_unpack", "(", "3", ")", "_type", "=", "self", ".", "_read_unpack", "(", "1", ")", "_flag", "=", "self", ".", "_read_binary", "(", "1", ")", "_rsid", "=", "self", ".", "_read_binary", "(", "4", ")", "if", "_tlen", "!=", "length", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {_type}] invalid format'", ",", "quiet", "=", "True", ")", "if", "int", "(", "_rsid", "[", "0", "]", ",", "base", "=", "2", ")", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {_type}] invalid format'", ",", "quiet", "=", "True", ")", "http", "=", "dict", "(", "length", "=", "_tlen", ",", "type", "=", "_HTTP_TYPE", ".", "get", "(", "_type", ")", ",", "sid", "=", "int", "(", "_rsid", "[", "1", ":", "]", ",", "base", "=", "2", ")", ",", "packet", "=", "self", ".", "_read_packet", "(", "_tlen", ")", ",", ")", "if", "http", "[", "'type'", "]", "is", "None", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {_type}] invalid format'", ",", "quiet", "=", "True", ")", "if", "http", "[", "'type'", "]", "in", "(", "'SETTINGS'", ",", "'PING'", ")", "and", "http", "[", "'sid'", "]", "!=", "0", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {_type}] invalid format'", ",", "quiet", "=", "True", ")", "_http", "=", "_HTTP_FUNC", "[", "_type", "]", "(", "self", ",", "_tlen", ",", "_type", ",", "_flag", ")", "http", ".", "update", "(", "_http", ")", "return", "http" ]

[ "Read", "Hypertext", "Transfer", "Protocol", "(", "HTTP", "/", "2", ")", "." ]

[ "def", "_read_http_none", "(", "self", ",", "size", ",", "kind", ",", "flag", ")", ":", "if", "any", "(", "(", "int", "(", "bit", ",", "base", "=", "2", ")", "for", "bit", "in", "flag", ")", ")", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "data", "=", "dict", "(", "flags", "=", "None", ",", "payload", "=", "self", ".", "_read_fileng", "(", "size", "-", "9", ")", "or", "None", ",", ")", "return", "data" ]

[ "Read", "HTTP", "packet", "with", "unsigned", "type", "." ]

[ "def", "_read_http_data", "(", "self", ",", "size", ",", "kind", ",", "flag", ")", ":", "_plen", "=", "0", "_flag", "=", "dict", "(", "END_STREAM", "=", "False", ",", "# bit 0", "PADDED", "=", "False", ",", "# bit 3", ")", "for", "index", ",", "bit", "in", "enumerate", "(", "flag", ")", ":", "if", "index", "==", "0", "and", "bit", ":", "_flag", "[", "'END_STREAM'", "]", "=", "True", "elif", "index", "==", "3", "and", "bit", ":", "_flag", "[", "'PADDED'", "]", "=", "True", "_plen", "=", "self", ".", "_read_unpack", "(", "1", ")", "elif", "bit", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "else", ":", "continue", "if", "_plen", ">", "size", "-", "10", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "if", "_flag", "[", "'PADDED'", "]", ":", "_dlen", "=", "size", "-", "_plen", "-", "1", "else", ":", "_dlen", "=", "size", "-", "_plen", "if", "_dlen", "<", "0", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "_data", "=", "self", ".", "_read_fileng", "(", "_dlen", ")", "padding", "=", "self", ".", "_read_binary", "(", "_plen", ")", "if", "any", "(", "(", "int", "(", "bit", ",", "base", "=", "2", ")", "for", "bit", "in", "padding", ")", ")", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "data", "=", "dict", "(", "flags", "=", "_flag", ",", "data", "=", "_data", ",", ")", "if", "_flag", "[", "'PADDED'", "]", ":", "data", "[", "'ped_len'", "]", "=", "_plen", "return", "data" ]

[ "Read", "HTTP", "/", "2", "DATA", "frames", "." ]

[ "def", "_read_http_headers", "(", "self", ",", "size", ",", "kind", ",", "flag", ")", ":", "_plen", "=", "0", "_elen", "=", "0", "_flag", "=", "dict", "(", "END_STREAM", "=", "False", ",", "# bit 0", "END_HEADERS", "=", "False", ",", "# bit 2", "PADDED", "=", "False", ",", "# bit 3", "PRIORITY", "=", "False", ",", "# bit 5", ")", "for", "index", ",", "bit", "in", "enumerate", "(", "flag", ")", ":", "if", "index", "==", "0", "and", "bit", ":", "_flag", "[", "'END_STREAM'", "]", "=", "True", "elif", "index", "==", "2", "and", "bit", ":", "_flag", "[", "'END_HEADERS'", "]", "=", "True", "elif", "index", "==", "3", "and", "bit", ":", "_flag", "[", "'PADDED'", "]", "=", "True", "_plen", "=", "self", ".", "_read_unpack", "(", "1", ")", "elif", "index", "==", "5", "and", "bit", ":", "_flag", "[", "'PRIORITY'", "]", "=", "True", "_edep", "=", "self", ".", "_read_binary", "(", "4", ")", "_wght", "=", "self", ".", "_read_unpack", "(", "1", ")", "_elen", "=", "5", "elif", "bit", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "else", ":", "continue", "if", "_flag", "[", "'PADDED'", "]", ":", "_dlen", "=", "size", "-", "_plen", "-", "_elen", "-", "1", "else", ":", "_dlen", "=", "size", "-", "_plen", "-", "_elen", "if", "_dlen", "<", "0", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "_frag", "=", "self", ".", "_read_fileng", "(", "_dlen", ")", "or", "None", "padding", "=", "self", ".", "_read_binary", "(", "_plen", ")", "if", "any", "(", "(", "int", "(", "bit", ",", "base", "=", "2", ")", "for", "bit", "in", "padding", ")", ")", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "data", "=", "dict", "(", "flags", "=", "_flag", ",", "frag", "=", "_frag", ",", ")", "if", "_flag", "[", "'PADDED'", "]", ":", "data", "[", "'ped_len'", "]", "=", "_plen", "if", "_flag", "[", "'PRIORITY'", "]", ":", "data", "[", "'exclusive'", "]", "=", "True", "if", "int", "(", "_edep", "[", "0", "]", ",", "base", "=", "2", ")", "else", "False", "data", "[", "'deps'", "]", "=", "int", "(", "_edep", "[", "1", ":", "]", ",", "base", "=", "2", ")", "data", "[", "'weight'", "]", "=", "_wght", "+", "1", "return", "data" ]

[ "Read", "HTTP", "/", "2", "HEADERS", "frames", "." ]

[ "def", "_read_http_priority", "(", "self", ",", "size", ",", "kind", ",", "flag", ")", ":", "if", "size", "!=", "9", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "if", "any", "(", "(", "int", "(", "bit", ",", "base", "=", "2", ")", "for", "bit", "in", "flag", ")", ")", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "_edep", "=", "self", ".", "_read_binary", "(", "4", ")", "_wght", "=", "self", ".", "_read_unpack", "(", "1", ")", "data", "=", "dict", "(", "flags", "=", "None", ",", "exclusive", "=", "True", "if", "int", "(", "_edep", "[", "0", "]", ",", "base", "=", "2", ")", "else", "False", ",", "deps", "=", "int", "(", "_edep", "[", "1", ":", "]", ",", "base", "=", "2", ")", ",", "weight", "=", "_wght", "+", "1", ",", ")", "return", "data" ]

[ "Read", "HTTP", "/", "2", "PRIORITY", "frames", "." ]

[ "def", "_read_http_rst_stream", "(", "self", ",", "size", ",", "kind", ",", "flag", ")", ":", "if", "size", "!=", "8", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "if", "any", "(", "(", "int", "(", "bit", ",", "base", "=", "2", ")", "for", "bit", "in", "flag", ")", ")", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "_code", "=", "self", ".", "_read_unpack", "(", "4", ")", "data", "=", "dict", "(", "flags", "=", "None", ",", "error", "=", "_ERROR_CODE", ".", "get", "(", "_code", ",", "_code", ")", ",", ")", "return", "data" ]

[ "Read", "HTTP", "/", "2", "RST_STREAM", "frames", "." ]

[ "def", "_read_http_settings", "(", "self", ",", "size", ",", "kind", ",", "flag", ")", ":", "if", "size", "%", "5", "!=", "0", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "_flag", "=", "dict", "(", "ACK", "=", "False", ",", "# bit 0", ")", "for", "index", ",", "bit", "in", "enumerate", "(", "flag", ")", ":", "if", "index", "==", "0", "and", "bit", ":", "_flag", "[", "'ACK'", "]", "=", "True", "elif", "bit", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "else", ":", "continue", "if", "_flag", "[", "'ACK'", "]", "and", "size", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "_para", "=", "dict", "(", ")", "counter", "=", "0", "while", "counter", "<", "size", ":", "_stid", "=", "self", ".", "_read_unpack", "(", "1", ")", "_pval", "=", "self", ".", "_read_unpack", "(", "4", ")", "_pkey", "=", "_PARA_NAME", ".", "get", "(", "_stid", ",", "'Unsigned'", ")", "if", "_pkey", "in", "_para", ":", "if", "isinstance", "(", "_para", "[", "_pkey", "]", ",", "tuple", ")", ":", "_para", "[", "_pkey", "]", "+=", "(", "_pval", ",", ")", "else", ":", "_para", "[", "_pkey", "]", "=", "(", "_para", "[", "_pkey", "]", ",", "_pval", ")", "else", ":", "_para", "[", "_pkey", "]", "=", "_pval", "data", "=", "dict", "(", "flags", "=", "_flag", ",", ")", "data", ".", "update", "(", "_para", ")", "return", "data" ]

[ "Read", "HTTP", "/", "2", "SETTINGS", "frames", "." ]

[ "def", "_read_http_push_promise", "(", "self", ",", "size", ",", "kind", ",", "flag", ")", ":", "if", "size", "<", "4", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "_plen", "=", "0", "_flag", "=", "dict", "(", "END_HEADERS", "=", "False", ",", "# bit 2", "PADDED", "=", "False", ",", "# bit 3", ")", "for", "index", ",", "bit", "in", "enumerate", "(", "flag", ")", ":", "if", "index", "==", "2", "and", "bit", ":", "_flag", "[", "'END_HEADERS'", "]", "=", "True", "elif", "index", "==", "3", "and", "bit", ":", "_flag", "[", "'PADDED'", "]", "=", "True", "_plen", "=", "self", ".", "_read_unpack", "(", "1", ")", "elif", "bit", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "else", ":", "continue", "if", "_flag", "[", "'PADDED'", "]", ":", "_dlen", "=", "size", "-", "_plen", "-", "5", "else", ":", "_dlen", "=", "size", "-", "_plen", "-", "4", "if", "_dlen", "<", "0", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "_rpid", "=", "self", ".", "_read_binary", "(", "4", ")", "_frag", "=", "self", ".", "_read_fileng", "(", "_dlen", ")", "or", "None", "if", "int", "(", "_rpid", "[", "0", "]", ",", "base", "=", "2", ")", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "padding", "=", "self", ".", "_read_binary", "(", "_plen", ")", "if", "any", "(", "(", "int", "(", "bit", ",", "base", "=", "2", ")", "for", "bit", "in", "padding", ")", ")", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "data", "=", "dict", "(", "flags", "=", "_flag", ",", "pid", "=", "int", "(", "_rpid", "[", "1", ":", "]", ",", "base", "=", "2", ")", ",", "frag", "=", "_frag", ",", ")", "if", "_flag", "[", "'PADDED'", "]", ":", "data", "[", "'ped_len'", "]", "=", "_plen", "return", "data" ]

[ "Read", "HTTP", "/", "2", "PUSH_PROMISE", "frames", "." ]

[ "def", "_read_http_ping", "(", "self", ",", "size", ",", "kind", ",", "flag", ")", ":", "if", "size", "!=", "8", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "_flag", "=", "dict", "(", "ACK", "=", "False", ",", "# bit 0", ")", "for", "index", ",", "bit", "in", "enumerate", "(", "flag", ")", ":", "if", "index", "==", "0", "and", "bit", ":", "_flag", "[", "'ACK'", "]", "=", "True", "elif", "bit", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "else", ":", "continue", "_data", "=", "self", ".", "_read_fileng", "(", "8", ")", "data", "=", "dict", "(", "flags", "=", "_flag", ",", "data", "=", "_data", ",", ")", "return", "data" ]

[ "Read", "HTTP", "/", "2", "PING", "frames", "." ]

[ "def", "_read_http_goaway", "(", "self", ",", "size", ",", "kind", ",", "flag", ")", ":", "_dlen", "=", "size", "-", "8", "if", "_dlen", "<", "0", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "if", "any", "(", "(", "int", "(", "bit", ",", "base", "=", "2", ")", "for", "bit", "in", "flag", ")", ")", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "_rsid", "=", "self", ".", "_read_binary", "(", "4", ")", "_code", "=", "self", ".", "_read_unpack", "(", "4", ")", "_data", "=", "self", ".", "_read_fileng", "(", "_dlen", ")", "or", "None", "if", "int", "(", "_rsid", "[", "0", "]", ",", "base", "=", "2", ")", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "data", "=", "dict", "(", "flags", "=", "None", ",", "last_sid", "=", "int", "(", "_rsid", "[", "1", ":", "]", ",", "base", "=", "2", ")", ",", "error", "=", "_ERROR_CODE", ".", "get", "(", "_code", ",", "_code", ")", ",", "data", "=", "_data", ",", ")", "return", "data" ]

[ "Read", "HTTP", "/", "2", "GOAWAY", "frames", "." ]

[ "def", "_read_http_window_update", "(", "self", ",", "size", ",", "kind", ",", "flag", ")", ":", "if", "size", "!=", "4", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "if", "any", "(", "(", "int", "(", "bit", ",", "base", "=", "2", ")", "for", "bit", "in", "flag", ")", ")", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "_size", "=", "self", ".", "_read_binary", "(", "4", ")", "if", "int", "(", "_size", "[", "0", "]", ",", "base", "=", "2", ")", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "data", "=", "dict", "(", "flags", "=", "None", ",", "window", "=", "int", "(", "_size", "[", "1", ":", "]", ",", "base", "=", "2", ")", ",", ")", "return", "data" ]

[ "Read", "HTTP", "/", "2", "WINDOW_UPDATE", "frames", "." ]

[ "def", "_read_http_continuation", "(", "self", ",", "size", ",", "kind", ",", "flag", ")", ":", "_flag", "=", "dict", "(", "END_HEADERS", "=", "False", ",", "# bit 2", ")", "for", "index", ",", "bit", "in", "enumerate", "(", "flag", ")", ":", "if", "index", "==", "2", "and", "bit", ":", "_flag", "[", "'END_HEADERS'", "]", "=", "True", "elif", "bit", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {kind}] invalid format'", ",", "quiet", "=", "True", ")", "else", ":", "continue", "_frag", "=", "self", ".", "_read_fileng", "(", "size", ")", "or", "None", "data", "=", "dict", "(", "flags", "=", "_flag", ",", "frag", "=", "_frag", ",", ")", "return", "data" ]

[ "Read", "HTTP", "/", "2", "WINDOW_UPDATE", "frames", "." ]

[ "def", "get", "(", "key", ",", "default", "=", "-", "1", ")", ":", "if", "isinstance", "(", "key", ",", "int", ")", ":", "return", "OptionNumber", "(", "key", ")", "if", "key", "not", "in", "OptionNumber", ".", "_member_map_", ":", "extend_enum", "(", "OptionNumber", ",", "key", ",", "default", ")", "return", "OptionNumber", "[", "key", "]" ]

[ "Backport", "support", "for", "original", "codes", "." ]

[ "def", "_import_next_layer", "(", "self", ",", "proto", ",", "length", ")", ":", "if", "self", ".", "_exproto", "==", "'null'", "and", "self", ".", "_exlayer", "==", "'None'", ":", "from", "pcapkit", ".", "protocols", ".", "raw", "import", "Raw", "as", "NextLayer", "else", ":", "from", "pcapkit", ".", "foundation", ".", "analysis", "import", "analyse", "as", "NextLayer", "# from pcapkit.foundation.analysis import analyse as NextLayer", "if", "length", "==", "0", ":", "next_", "=", "NoPayload", "(", ")", "elif", "self", ".", "_onerror", ":", "next_", "=", "beholder_ng", "(", "NextLayer", ")", "(", "self", ".", "_file", ",", "length", ",", "_termination", "=", "self", ".", "_sigterm", ")", "else", ":", "next_", "=", "NextLayer", "(", "self", ".", "_file", ",", "length", ",", "_termination", "=", "self", ".", "_sigterm", ")", "return", "next_" ]

[ "Import", "next", "layer", "extractor", "." ]

[ "def", "get", "(", "key", ",", "default", "=", "-", "1", ")", ":", "if", "isinstance", "(", "key", ",", "int", ")", ":", "return", "ProtectionAuthority", "(", "key", ")", "if", "key", "not", "in", "ProtectionAuthority", ".", "_member_map_", ":", "extend_enum", "(", "ProtectionAuthority", ",", "key", ",", "default", ")", "return", "ProtectionAuthority", "[", "key", "]" ]

[ "Backport", "support", "for", "original", "codes", "." ]

[ "def", "get", "(", "key", ",", "default", "=", "-", "1", ")", ":", "if", "isinstance", "(", "key", ",", "int", ")", ":", "return", "RouterAlert", "(", "key", ")", "if", "key", "not", "in", "RouterAlert", ".", "_member_map_", ":", "extend_enum", "(", "RouterAlert", ",", "key", ",", "default", ")", "return", "RouterAlert", "[", "key", "]" ]

[ "Backport", "support", "for", "original", "codes", "." ]

[ "def", "get", "(", "key", ",", "default", "=", "-", "1", ")", ":", "if", "isinstance", "(", "key", ",", "int", ")", ":", "return", "QS_Function", "(", "key", ")", "if", "key", "not", "in", "QS_Function", ".", "_member_map_", ":", "extend_enum", "(", "QS_Function", ",", "key", ",", "default", ")", "return", "QS_Function", "[", "key", "]" ]

[ "Backport", "support", "for", "original", "codes", "." ]

[ "def", "run", "(", "self", ")", ":", "flag", "=", "True", "if", "self", ".", "_exeng", "==", "'dpkt'", ":", "flag", ",", "engine", "=", "self", ".", "import_test", "(", "'dpkt'", ",", "name", "=", "'DPKT'", ")", "if", "flag", ":", "return", "self", ".", "_run_dpkt", "(", "engine", ")", "elif", "self", ".", "_exeng", "==", "'scapy'", ":", "flag", ",", "engine", "=", "self", ".", "import_test", "(", "'scapy.all'", ",", "name", "=", "'Scapy'", ")", "if", "flag", ":", "return", "self", ".", "_run_scapy", "(", "engine", ")", "elif", "self", ".", "_exeng", "==", "'pyshark'", ":", "flag", ",", "engine", "=", "self", ".", "import_test", "(", "'pyshark'", ",", "name", "=", "'PyShark'", ")", "if", "flag", ":", "return", "self", ".", "_run_pyshark", "(", "engine", ")", "elif", "self", ".", "_exeng", "==", "'pipeline'", ":", "flag", ",", "engine", "=", "self", ".", "import_test", "(", "'multiprocessing'", ",", "name", "=", "'Pipeline Multiprocessing'", ")", "self", ".", "_flag_m", "=", "flag", "=", "bool", "(", "flag", "and", "(", "self", ".", "_flag_a", "and", "CPU_CNT", ">", "1", ")", ")", "if", "self", ".", "_flag_m", ":", "return", "self", ".", "_run_pipeline", "(", "engine", ")", "warnings", ".", "warn", "(", "f'extraction engine Pipeline Multiprocessing is not available; '", "'using default engine instead'", ",", "EngineWarning", ",", "stacklevel", "=", "stacklevel", "(", ")", ")", "elif", "self", ".", "_exeng", "==", "'server'", ":", "flag", ",", "engine", "=", "self", ".", "import_test", "(", "'multiprocessing'", ",", "name", "=", "'Server Multiprocessing'", ")", "self", ".", "_flag_m", "=", "flag", "=", "bool", "(", "flag", "and", "(", "self", ".", "_flag_a", "and", "CPU_CNT", ">", "2", ")", ")", "if", "self", ".", "_flag_m", ":", "return", "self", ".", "_run_server", "(", "engine", ")", "warnings", ".", "warn", "(", "f'extraction engine Server Multiprocessing is not available; '", "'using default engine instead'", ",", "EngineWarning", ",", "stacklevel", "=", "stacklevel", "(", ")", ")", "elif", "self", ".", "_exeng", "not", "in", "(", "'default'", ",", "'pcapkit'", ")", ":", "flag", "=", "False", "warnings", ".", "warn", "(", "f'unsupported extraction engine: {self._exeng}; '", "'using default engine instead'", ",", "EngineWarning", ",", "stacklevel", "=", "stacklevel", "(", ")", ")", "# using default/pcapkit engine", "self", ".", "_exeng", "=", "self", ".", "_exeng", "if", "flag", "else", "'default'", "self", ".", "record_header", "(", ")", "# read PCAP global header", "self", ".", "record_frames", "(", ")" ]

[ "Start", "extraction", "." ]

[ "def", "record_header", "(", "self", ")", ":", "self", ".", "_gbhdr", "=", "Header", "(", "self", ".", "_ifile", ")", "self", ".", "_vinfo", "=", "self", ".", "_gbhdr", ".", "version", "self", ".", "_dlink", "=", "self", ".", "_gbhdr", ".", "protocol", "self", ".", "_nnsec", "=", "self", ".", "_gbhdr", ".", "nanosecond", "if", "self", ".", "_trace", "is", "not", "NotImplemented", ":", "self", ".", "_trace", ".", "_endian", "=", "self", ".", "_gbhdr", ".", "byteorder", "self", ".", "_trace", ".", "_nnsecd", "=", "self", ".", "_gbhdr", ".", "nanosecond", "if", "not", "self", ".", "_flag_q", ":", "if", "self", ".", "_flag_f", ":", "ofile", "=", "self", ".", "_ofile", "(", "f'{self._ofnm}/Global Header.{self._fext}'", ")", "ofile", "(", "self", ".", "_gbhdr", ".", "info", ",", "name", "=", "'Global Header'", ")", "self", ".", "_type", "=", "ofile", ".", "kind", "else", ":", "self", ".", "_ofile", "(", "self", ".", "_gbhdr", ".", "info", ",", "name", "=", "'Global Header'", ")", "self", ".", "_type", "=", "self", ".", "_ofile", ".", "kind" ]

[ "Read", "global", "header", "." ]

[ "def", "_cleanup", "(", "self", ")", ":", "self", ".", "_expkg", "=", "None", "self", ".", "_extmp", "=", "None", "self", ".", "_flag_e", "=", "True", "self", ".", "_ifile", ".", "close", "(", ")" ]

[ "Cleanup", "after", "extraction", "&", "analysis", "." ]

[ "def", "_aftermathmp", "(", "self", ")", ":", "if", "not", "self", ".", "_flag_e", "and", "self", ".", "_flag_m", ":", "# join processes", "[", "proc", ".", "join", "(", ")", "for", "proc", "in", "self", ".", "_mpprc", "]", "if", "self", ".", "_exeng", "==", "'server'", ":", "self", ".", "_mpsvc", ".", "join", "(", ")", "# restore attributes", "if", "self", ".", "_exeng", "==", "'server'", ":", "self", ".", "_frame", "=", "list", "(", "self", ".", "_mpfrm", ")", "self", ".", "_reasm", "=", "list", "(", "self", ".", "_mprsm", ")", "self", ".", "_trace", "=", "copy", ".", "deepcopy", "(", "self", ".", "_mpkit", ".", "trace", ")", "if", "self", ".", "_exeng", "==", "'pipeline'", ":", "self", ".", "_frame", "=", "[", "self", ".", "_mpkit", ".", "frames", "[", "x", "]", "for", "x", "in", "sorted", "(", "self", ".", "_mpkit", ".", "frames", ")", "]", "self", ".", "_reasm", "=", "copy", ".", "deepcopy", "(", "self", ".", "_mpkit", ".", "reassembly", ")", "self", ".", "_trace", "=", "copy", ".", "deepcopy", "(", "self", ".", "_mpkit", ".", "trace", ")", "# shutdown & cleanup", "self", ".", "_mpmng", ".", "shutdown", "(", ")", "[", "delattr", "(", "self", ",", "attr", ")", "for", "attr", "in", "filter", "(", "lambda", "s", ":", "s", ".", "startswith", "(", "'_mp'", ")", ",", "dir", "(", "self", ")", ")", "]", "self", ".", "_frnum", "-=", "2" ]

[ "Aftermath", "for", "multiprocessing", "." ]

[ "def", "_update_eof", "(", "self", ")", ":", "self", ".", "_aftermathmp", "(", ")", "self", ".", "_ifile", ".", "close", "(", ")", "self", ".", "_flag_e", "=", "True" ]

[ "Update", "EOF", "flag", "." ]

[ "def", "_read_frame", "(", "self", ")", ":", "if", "self", ".", "_exeng", "==", "'scapy'", ":", "return", "self", ".", "_scapy_read_frame", "(", ")", "elif", "self", ".", "_exeng", "==", "'dpkt'", ":", "return", "self", ".", "_dpkt_read_frame", "(", ")", "elif", "self", ".", "_exeng", "==", "'pyshark'", ":", "return", "self", ".", "_pyshark_read_frame", "(", ")", "else", ":", "return", "self", ".", "_default_read_frame", "(", ")" ]

[ "Headquarters", "for", "frame", "reader", "." ]

[ "def", "_default_read_frame", "(", "self", ",", "*", ",", "frame", "=", "None", ",", "mpkit", "=", "None", ")", ":", "from", "pcapkit", ".", "toolkit", ".", "default", "import", "(", "ipv4_reassembly", ",", "ipv6_reassembly", ",", "tcp_reassembly", ",", "tcp_traceflow", ")", "# read frame header", "if", "not", "self", ".", "_flag_m", ":", "frame", "=", "Frame", "(", "self", ".", "_ifile", ",", "num", "=", "self", ".", "_frnum", "+", "1", ",", "proto", "=", "self", ".", "_dlink", ",", "layer", "=", "self", ".", "_exlyr", ",", "protocol", "=", "self", ".", "_exptl", ",", "nanosecond", "=", "self", ".", "_nnsec", ")", "self", ".", "_frnum", "+=", "1", "# verbose output", "if", "self", ".", "_flag_v", ":", "print", "(", "f' - Frame {self._frnum:>3d}: {frame.protochain}'", ")", "# write plist", "frnum", "=", "f'Frame {self._frnum}'", "if", "not", "self", ".", "_flag_q", ":", "if", "self", ".", "_flag_f", ":", "ofile", "=", "self", ".", "_ofile", "(", "f'{self._ofnm}/{frnum}.{self._fext}'", ")", "ofile", "(", "frame", ".", "info", ",", "name", "=", "frnum", ")", "else", ":", "self", ".", "_ofile", "(", "frame", ".", "info", ",", "name", "=", "frnum", ")", "# record fragments", "if", "self", ".", "_ipv4", ":", "flag", ",", "data", "=", "ipv4_reassembly", "(", "frame", ")", "if", "flag", ":", "self", ".", "_reasm", "[", "0", "]", "(", "data", ")", "# pylint: disable=E1102", "if", "self", ".", "_ipv6", ":", "flag", ",", "data", "=", "ipv6_reassembly", "(", "frame", ")", "if", "flag", ":", "self", ".", "_reasm", "[", "1", "]", "(", "data", ")", "# pylint: disable=E1102", "if", "self", ".", "_tcp", ":", "flag", ",", "data", "=", "tcp_reassembly", "(", "frame", ")", "if", "flag", ":", "self", ".", "_reasm", "[", "2", "]", "(", "data", ")", "# pylint: disable=E1102", "# trace flows", "if", "self", ".", "_flag_t", ":", "flag", ",", "data", "=", "tcp_traceflow", "(", "frame", ",", "data_link", "=", "self", ".", "_dlink", ")", "if", "flag", ":", "self", ".", "_trace", "(", "data", ")", "# record frames", "if", "self", ".", "_exeng", "==", "'pipeline'", ":", "if", "self", ".", "_flag_d", ":", "# frame._file = NotImplemented", "mpkit", ".", "frames", "[", "self", ".", "_frnum", "]", "=", "frame", "# print(self._frnum, 'stored')", "mpkit", ".", "current", "+=", "1", "elif", "self", ".", "_exeng", "==", "'server'", ":", "# record frames", "if", "self", ".", "_flag_d", ":", "# frame._file = NotImplemented", "self", ".", "_frame", ".", "append", "(", "frame", ")", "# print(self._frnum, 'stored')", "self", ".", "_frnum", "+=", "1", "else", ":", "if", "self", ".", "_flag_d", ":", "self", ".", "_frame", ".", "append", "(", "frame", ")", "self", ".", "_proto", "=", "frame", ".", "protochain", ".", "chain", "# return frame record", "return", "frame" ]

[ "Read", "frames", "with", "default", "engine", "." ]

[ "def", "_run_scapy", "(", "self", ",", "scapy_all", ")", ":", "# if not self._flag_a:", "# self._flag_a = True", "# warnings.warn(f\"'Extractor(engine=scapy)' object is not iterable; \"", "# \"so 'auto=False' will be ignored\", AttributeWarning, stacklevel=stacklevel())", "if", "self", ".", "_exlyr", "!=", "'None'", "or", "self", ".", "_exptl", "!=", "'null'", ":", "warnings", ".", "warn", "(", "\"'Extractor(engine=scapy)' does not support protocol and layer threshold; \"", "f\"'layer={self._exlyr}' and 'protocol={self._exptl}' ignored\"", ",", "AttributeWarning", ",", "stacklevel", "=", "stacklevel", "(", ")", ")", "# extract & analyse file", "self", ".", "_expkg", "=", "scapy_all", "self", ".", "_extmp", "=", "iter", "(", "scapy_all", ".", "sniff", "(", "offline", "=", "self", ".", "_ifnm", ")", ")", "# start iteration", "self", ".", "record_frames", "(", ")" ]

[ "Call", "scapy", ".", "all", ".", "sniff", "to", "extract", "PCAP", "files", "." ]

[ "def", "_scapy_read_frame", "(", "self", ")", ":", "from", "pcapkit", ".", "toolkit", ".", "scapy", "import", "(", "ipv4_reassembly", ",", "ipv6_reassembly", ",", "packet2chain", ",", "packet2dict", ",", "tcp_reassembly", ",", "tcp_traceflow", ")", "# fetch Scapy packet", "packet", "=", "next", "(", "self", ".", "_extmp", ")", "# verbose output", "self", ".", "_frnum", "+=", "1", "self", ".", "_proto", "=", "packet2chain", "(", "packet", ")", "if", "self", ".", "_flag_v", ":", "print", "(", "f' - Frame {self._frnum:>3d}: {self._proto}'", ")", "# write plist", "frnum", "=", "f'Frame {self._frnum}'", "if", "not", "self", ".", "_flag_q", ":", "info", "=", "packet2dict", "(", "packet", ")", "if", "self", ".", "_flag_f", ":", "ofile", "=", "self", ".", "_ofile", "(", "f'{self._ofnm}/{frnum}.{self._fext}'", ")", "ofile", "(", "info", ",", "name", "=", "frnum", ")", "else", ":", "self", ".", "_ofile", "(", "info", ",", "name", "=", "frnum", ")", "# record frames", "if", "self", ".", "_flag_d", ":", "# setattr(packet, 'packet2dict', packet2dict)", "# setattr(packet, 'packet2chain', packet2chain)", "self", ".", "_frame", ".", "append", "(", "packet", ")", "# record fragments", "if", "self", ".", "_ipv4", ":", "flag", ",", "data", "=", "ipv4_reassembly", "(", "packet", ",", "count", "=", "self", ".", "_frnum", ")", "if", "flag", ":", "self", ".", "_reasm", "[", "0", "]", "(", "data", ")", "# pylint: disable=E1102", "if", "self", ".", "_ipv6", ":", "flag", ",", "data", "=", "ipv6_reassembly", "(", "packet", ",", "count", "=", "self", ".", "_frnum", ")", "if", "flag", ":", "self", ".", "_reasm", "[", "1", "]", "(", "data", ")", "# pylint: disable=E1102", "if", "self", ".", "_tcp", ":", "flag", ",", "data", "=", "tcp_reassembly", "(", "packet", ",", "count", "=", "self", ".", "_frnum", ")", "if", "flag", ":", "self", ".", "_reasm", "[", "2", "]", "(", "data", ")", "# pylint: disable=E1102", "# trace flows", "if", "self", ".", "_flag_t", ":", "flag", ",", "data", "=", "tcp_traceflow", "(", "packet", ",", "count", "=", "self", ".", "_frnum", ")", "if", "flag", ":", "self", ".", "_trace", "(", "data", ")", "return", "packet" ]

[ "Read", "frames", "with", "Scapy", "." ]

[ "def", "_run_dpkt", "(", "self", ",", "dpkt", ")", ":", "# if not self._flag_a:", "# self._flag_a = True", "# warnings.warn(f\"'Extractor(engine=dpkt)' object is not iterable; \"", "# \"so 'auto=False' will be ignored\", AttributeWarning, stacklevel=stacklevel())", "if", "self", ".", "_exlyr", "!=", "'None'", "or", "self", ".", "_exptl", "!=", "'null'", ":", "warnings", ".", "warn", "(", "\"'Extractor(engine=dpkt)' does not support protocol and layer threshold; \"", "f\"'layer={self._exlyr}' and 'protocol={self._exptl}' ignored\"", ",", "AttributeWarning", ",", "stacklevel", "=", "stacklevel", "(", ")", ")", "# extract global header", "self", ".", "record_header", "(", ")", "self", ".", "_ifile", ".", "seek", "(", "0", ",", "os", ".", "SEEK_SET", ")", "# extract & analyse file", "self", ".", "_expkg", "=", "dpkt", "self", ".", "_extmp", "=", "iter", "(", "dpkt", ".", "pcap", ".", "Reader", "(", "self", ".", "_ifile", ")", ")", "# start iteration", "self", ".", "record_frames", "(", ")" ]

[ "Call", "dpkt", ".", "pcap", ".", "Reader", "to", "extract", "PCAP", "files", "." ]

[ "def", "_dpkt_read_frame", "(", "self", ")", ":", "from", "pcapkit", ".", "toolkit", ".", "dpkt", "import", "(", "ipv4_reassembly", ",", "ipv6_reassembly", ",", "packet2chain", ",", "packet2dict", ",", "tcp_reassembly", ",", "tcp_traceflow", ")", "# fetch DPKT packet", "timestamp", ",", "packet", "=", "next", "(", "self", ".", "_extmp", ")", "# extract packet", "if", "self", ".", "_dlink", ".", "value", "==", "1", ":", "packet", "=", "self", ".", "_expkg", ".", "ethernet", ".", "Ethernet", "(", "packet", ")", "elif", "self", ".", "_dlink", ".", "value", "==", "228", ":", "packet", "=", "self", ".", "_expkg", ".", "ip", ".", "IP", "(", "packet", ")", "elif", "self", ".", "_dlink", ".", "value", "==", "229", ":", "packet", "=", "self", ".", "_expkg", ".", "ip6", ".", "IP6", "(", "packet", ")", "else", ":", "warnings", ".", "warn", "(", "'unrecognised link layer protocol; all analysis functions ignored'", ",", "DPKTWarning", ",", "stacklevel", "=", "stacklevel", "(", ")", ")", "self", ".", "_frnum", "+=", "1", "if", "self", ".", "_flag_d", ":", "self", ".", "_frame", ".", "append", "(", "packet", ")", "return", "packet", "# verbose output", "self", ".", "_frnum", "+=", "1", "self", ".", "_proto", "=", "packet2chain", "(", "packet", ")", "if", "self", ".", "_flag_v", ":", "print", "(", "f' - Frame {self._frnum:>3d}: {self._proto}'", ")", "# write plist", "frnum", "=", "f'Frame {self._frnum}'", "if", "not", "self", ".", "_flag_q", ":", "info", "=", "packet2dict", "(", "packet", ",", "timestamp", ",", "data_link", "=", "self", ".", "_dlink", ")", "if", "self", ".", "_flag_f", ":", "ofile", "=", "self", ".", "_ofile", "(", "f'{self._ofnm}/{frnum}.{self._fext}'", ")", "ofile", "(", "info", ",", "name", "=", "frnum", ")", "else", ":", "self", ".", "_ofile", "(", "info", ",", "name", "=", "frnum", ")", "# record frames", "if", "self", ".", "_flag_d", ":", "setattr", "(", "packet", ",", "'packet2dict'", ",", "packet2dict", ")", "setattr", "(", "packet", ",", "'packet2chain'", ",", "packet2chain", ")", "self", ".", "_frame", ".", "append", "(", "packet", ")", "# record fragments", "if", "self", ".", "_ipv4", ":", "flag", ",", "data", "=", "ipv4_reassembly", "(", "packet", ",", "count", "=", "self", ".", "_frnum", ")", "if", "flag", ":", "self", ".", "_reasm", "[", "0", "]", "(", "data", ")", "# pylint: disable=E1102", "if", "self", ".", "_ipv6", ":", "flag", ",", "data", "=", "ipv6_reassembly", "(", "packet", ",", "count", "=", "self", ".", "_frnum", ")", "if", "flag", ":", "self", ".", "_reasm", "[", "1", "]", "(", "data", ")", "# pylint: disable=E1102", "if", "self", ".", "_tcp", ":", "flag", ",", "data", "=", "tcp_reassembly", "(", "packet", ",", "count", "=", "self", ".", "_frnum", ")", "if", "flag", ":", "self", ".", "_reasm", "[", "2", "]", "(", "data", ")", "# pylint: disable=E1102", "# trace flows", "if", "self", ".", "_flag_t", ":", "flag", ",", "data", "=", "tcp_traceflow", "(", "packet", ",", "timestamp", ",", "data_link", "=", "self", ".", "_dlink", ",", "count", "=", "self", ".", "_frnum", ")", "if", "flag", ":", "self", ".", "_trace", "(", "data", ")", "return", "packet" ]

[ "Read", "frames", "." ]

[ "def", "_run_pyshark", "(", "self", ",", "pyshark", ")", ":", "# if not self._flag_a:", "# self._flag_a = True", "# warnings.warn(f\"'Extractor(engine=pyshark)' object is not iterable; \"", "# \"so 'auto=False' will be ignored\", AttributeWarning, stacklevel=stacklevel())", "if", "self", ".", "_exlyr", "!=", "'None'", "or", "self", ".", "_exptl", "!=", "'null'", ":", "warnings", ".", "warn", "(", "\"'Extractor(engine=pyshark)' does not support protocol and layer threshold; \"", "f\"'layer={self._exlyr}' and 'protocol={self._exptl}' ignored\"", ",", "AttributeWarning", ",", "stacklevel", "=", "stacklevel", "(", ")", ")", "if", "(", "self", ".", "_ipv4", "or", "self", ".", "_ipv6", "or", "self", ".", "_tcp", ")", ":", "self", ".", "_ipv4", "=", "self", ".", "_ipv6", "=", "self", ".", "_tcp", "=", "False", "self", ".", "_reasm", "=", "[", "None", "]", "*", "3", "warnings", ".", "warn", "(", "\"'Extractor(engine=pyshark)' object dose not support reassembly; \"", "f\"so 'ipv4={self._ipv4}', 'ipv6={self._ipv6}' and 'tcp={self._tcp}' will be ignored\"", ",", "AttributeWarning", ",", "stacklevel", "=", "stacklevel", "(", ")", ")", "# extract & analyse file", "self", ".", "_expkg", "=", "pyshark", "self", ".", "_extmp", "=", "iter", "(", "pyshark", ".", "FileCapture", "(", "self", ".", "_ifnm", ",", "keep_packets", "=", "False", ")", ")", "# start iteration", "self", ".", "record_frames", "(", ")" ]

[ "Call", "pyshark", ".", "FileCapture", "to", "extract", "PCAP", "files", "." ]

[ "def", "_pyshark_read_frame", "(", "self", ")", ":", "from", "pcapkit", ".", "toolkit", ".", "pyshark", "import", "packet2dict", ",", "tcp_traceflow", "# fetch PyShark packet", "packet", "=", "next", "(", "self", ".", "_extmp", ")", "# def _pyshark_packet2chain(packet):", "# \"\"\"Fetch PyShark packet protocol chain.\"\"\"", "# return ':'.join(map(lambda layer: layer.layer_name.upper(), packet.layers))", "# verbose output", "self", ".", "_frnum", "=", "int", "(", "packet", ".", "number", ")", "self", ".", "_proto", "=", "packet", ".", "frame_info", ".", "protocols", "if", "self", ".", "_flag_v", ":", "print", "(", "f' - Frame {self._frnum:>3d}: {self._proto}'", ")", "# write plist", "frnum", "=", "f'Frame {self._frnum}'", "if", "not", "self", ".", "_flag_q", ":", "info", "=", "packet2dict", "(", "packet", ")", "if", "self", ".", "_flag_f", ":", "ofile", "=", "self", ".", "_ofile", "(", "f'{self._ofnm}/{frnum}.{self._fext}'", ")", "ofile", "(", "info", ",", "name", "=", "frnum", ")", "else", ":", "self", ".", "_ofile", "(", "info", ",", "name", "=", "frnum", ")", "# record frames", "if", "self", ".", "_flag_d", ":", "setattr", "(", "packet", ",", "'packet2dict'", ",", "packet2dict", ")", "self", ".", "_frame", ".", "append", "(", "packet", ")", "# trace flows", "if", "self", ".", "_flag_t", ":", "flag", ",", "data", "=", "tcp_traceflow", "(", "packet", ")", "if", "flag", ":", "self", ".", "_trace", "(", "data", ")", "return", "packet" ]

[ "Read", "frames", "." ]

[ "def", "_run_pipeline", "(", "self", ",", "multiprocessing", ")", ":", "if", "not", "self", ".", "_flag_m", ":", "raise", "UnsupportedCall", "(", "f\"Extractor(engine={self._exeng})' has no attribute '_run_pipline'\"", ")", "if", "not", "self", ".", "_flag_q", ":", "self", ".", "_flag_q", "=", "True", "warnings", ".", "warn", "(", "\"'Extractor(engine=pipeline)' does not support output; \"", "f\"'fout={self._ofnm}' ignored\"", ",", "AttributeWarning", ",", "stacklevel", "=", "stacklevel", "(", ")", ")", "self", ".", "_frnum", "=", "1", "# frame number (revised)", "self", ".", "_expkg", "=", "multiprocessing", "# multiprocessing module", "self", ".", "_mpprc", "=", "list", "(", ")", "# multiprocessing process list", "self", ".", "_mpfdp", "=", "collections", ".", "defaultdict", "(", "multiprocessing", ".", "Queue", ")", "# multiprocessing file pointer", "self", ".", "_mpmng", "=", "multiprocessing", ".", "Manager", "(", ")", "# multiprocessing manager", "self", ".", "_mpkit", "=", "self", ".", "_mpmng", ".", "Namespace", "(", ")", "# multiprocessing work kit", "self", ".", "_mpkit", ".", "counter", "=", "0", "# work count (on duty)", "self", ".", "_mpkit", ".", "pool", "=", "1", "# work pool (ready)", "self", ".", "_mpkit", ".", "current", "=", "1", "# current frame number", "self", ".", "_mpkit", ".", "eof", "=", "False", "# EOF flag", "self", ".", "_mpkit", ".", "frames", "=", "dict", "(", ")", "# frame storage", "self", ".", "_mpkit", ".", "trace", "=", "self", ".", "_trace", "# flow tracer", "self", ".", "_mpkit", ".", "reassembly", "=", "copy", ".", "deepcopy", "(", "self", ".", "_reasm", ")", "# reassembly buffers", "# preparation", "self", ".", "record_header", "(", ")", "self", ".", "_mpfdp", "[", "0", "]", ".", "put", "(", "self", ".", "_gbhdr", ".", "length", ")", "# extraction", "while", "True", ":", "# check EOF", "if", "self", ".", "_mpkit", ".", "eof", ":", "self", ".", "_update_eof", "(", ")", "break", "# check counter", "if", "self", ".", "_mpkit", ".", "pool", "and", "self", ".", "_mpkit", ".", "counter", "<", "CPU_CNT", ":", "# update file offset", "self", ".", "_ifile", ".", "seek", "(", "self", ".", "_mpfdp", ".", "pop", "(", "self", ".", "_frnum", "-", "1", ")", ".", "get", "(", ")", ",", "os", ".", "SEEK_SET", ")", "# create worker", "# print(self._frnum, 'start')", "proc", "=", "multiprocessing", ".", "Process", "(", "target", "=", "self", ".", "_pipeline_read_frame", ",", "kwargs", "=", "{", "'mpkit'", ":", "self", ".", "_mpkit", ",", "'mpfdp'", ":", "self", ".", "_mpfdp", "[", "self", ".", "_frnum", "]", "}", ")", "# update status", "self", ".", "_mpkit", ".", "pool", "-=", "1", "self", ".", "_mpkit", ".", "counter", "+=", "1", "# start and record", "proc", ".", "start", "(", ")", "self", ".", "_frnum", "+=", "1", "self", ".", "_mpprc", ".", "append", "(", "proc", ")", "# check buffer", "if", "len", "(", "self", ".", "_mpprc", ")", ">=", "CPU_CNT", ":", "[", "proc", ".", "join", "(", ")", "for", "proc", "in", "self", ".", "_mpprc", "[", ":", "-", "4", "]", "]", "del", "self", ".", "_mpprc", "[", ":", "-", "4", "]" ]

[ "Use", "pipeline", "multiprocessing", "to", "extract", "PCAP", "files", "." ]

[ "def", "_pipeline_read_frame", "(", "self", ",", "*", ",", "mpfdp", ",", "mpkit", ")", ":", "# check EOF", "if", "self", ".", "_flag_e", ":", "raise", "EOFError", "def", "_analyse_frame", "(", "*", ",", "frame", ",", "mpkit", ")", ":", "\"\"\"Analyse frame.\"\"\"", "# wait until ready", "while", "mpkit", ".", "current", "!=", "self", ".", "_frnum", ":", "time", ".", "sleep", "(", "random", ".", "randint", "(", "0", ",", "datetime", ".", "datetime", ".", "now", "(", ")", ".", "second", ")", "//", "600", ")", "# analysis and storage", "# print(self._frnum, 'get')", "self", ".", "_trace", "=", "mpkit", ".", "trace", "self", ".", "_reasm", "=", "mpkit", ".", "reassembly", "self", ".", "_default_read_frame", "(", "frame", "=", "frame", ",", "mpkit", "=", "mpkit", ")", "# print(self._frnum, 'analysed')", "mpkit", ".", "trace", "=", "copy", ".", "deepcopy", "(", "self", ".", "_trace", ")", "mpkit", ".", "reassembly", "=", "copy", ".", "deepcopy", "(", "self", ".", "_reasm", ")", "# print(self._frnum, 'put')", "# extract frame", "try", ":", "# extraction", "frame", "=", "Frame", "(", "self", ".", "_ifile", ",", "num", "=", "self", ".", "_frnum", ",", "proto", "=", "self", ".", "_dlink", ",", "layer", "=", "self", ".", "_exlyr", ",", "protocol", "=", "self", ".", "_exptl", ",", "nanosecond", "=", "self", ".", "_nnsec", ",", "mpkit", "=", "mpkit", ",", "mpfdp", "=", "mpfdp", ")", "# analysis", "_analyse_frame", "(", "frame", "=", "frame", ",", "mpkit", "=", "mpkit", ")", "except", "EOFError", ":", "mpkit", ".", "eof", "=", "True", "finally", ":", "mpkit", ".", "counter", "-=", "1", "self", ".", "_ifile", ".", "close", "(", ")" ]

[ "Extract", "frame", "." ]

[ "def", "_run_server", "(", "self", ",", "multiprocessing", ")", ":", "if", "not", "self", ".", "_flag_m", ":", "raise", "UnsupportedCall", "(", "f\"Extractor(engine={self._exeng})' has no attribute '_run_server'\"", ")", "if", "not", "self", ".", "_flag_q", ":", "self", ".", "_flag_q", "=", "True", "warnings", ".", "warn", "(", "\"'Extractor(engine=pipeline)' does not support output; \"", "f\"'fout={self._ofnm}' ignored\"", ",", "AttributeWarning", ",", "stacklevel", "=", "stacklevel", "(", ")", ")", "self", ".", "_frnum", "=", "1", "# frame number (revised)", "self", ".", "_expkg", "=", "multiprocessing", "# multiprocessing module", "self", ".", "_mpsvc", "=", "NotImplemented", "# multiprocessing server process", "self", ".", "_mpprc", "=", "list", "(", ")", "# multiprocessing process list", "self", ".", "_mpfdp", "=", "collections", ".", "defaultdict", "(", "multiprocessing", ".", "Queue", ")", "# multiprocessing file pointer", "self", ".", "_mpmng", "=", "multiprocessing", ".", "Manager", "(", ")", "# multiprocessing manager", "self", ".", "_mpbuf", "=", "self", ".", "_mpmng", ".", "dict", "(", ")", "# multiprocessing frame dict", "self", ".", "_mpfrm", "=", "self", ".", "_mpmng", ".", "list", "(", ")", "# multiprocessing frame storage", "self", ".", "_mprsm", "=", "self", ".", "_mpmng", ".", "list", "(", ")", "# multiprocessing reassembly buffer", "self", ".", "_mpkit", "=", "self", ".", "_mpmng", ".", "Namespace", "(", ")", "# multiprocessing work kit", "self", ".", "_mpkit", ".", "counter", "=", "0", "# work count (on duty)", "self", ".", "_mpkit", ".", "pool", "=", "1", "# work pool (ready)", "self", ".", "_mpkit", ".", "eof", "=", "False", "# EOF flag", "self", ".", "_mpkit", ".", "trace", "=", "None", "# flow tracer", "# preparation", "self", ".", "record_header", "(", ")", "self", ".", "_mpfdp", "[", "0", "]", ".", "put", "(", "self", ".", "_gbhdr", ".", "length", ")", "self", ".", "_mpsvc", "=", "multiprocessing", ".", "Process", "(", "target", "=", "self", ".", "_server_analyse_frame", ",", "kwargs", "=", "{", "'mpfrm'", ":", "self", ".", "_mpfrm", ",", "'mprsm'", ":", "self", ".", "_mprsm", ",", "'mpbuf'", ":", "self", ".", "_mpbuf", ",", "'mpkit'", ":", "self", ".", "_mpkit", "}", ")", "self", ".", "_mpsvc", ".", "start", "(", ")", "# extraction", "while", "True", ":", "# check EOF", "if", "self", ".", "_mpkit", ".", "eof", ":", "self", ".", "_update_eof", "(", ")", "break", "# check counter", "if", "self", ".", "_mpkit", ".", "pool", "and", "self", ".", "_mpkit", ".", "counter", "<", "CPU_CNT", "-", "1", ":", "# update file offset", "self", ".", "_ifile", ".", "seek", "(", "self", ".", "_mpfdp", ".", "pop", "(", "self", ".", "_frnum", "-", "1", ")", ".", "get", "(", ")", ",", "os", ".", "SEEK_SET", ")", "# create worker", "# print(self._frnum, 'start')", "proc", "=", "multiprocessing", ".", "Process", "(", "target", "=", "self", ".", "_server_extract_frame", ",", "kwargs", "=", "{", "'mpkit'", ":", "self", ".", "_mpkit", ",", "'mpbuf'", ":", "self", ".", "_mpbuf", ",", "'mpfdp'", ":", "self", ".", "_mpfdp", "[", "self", ".", "_frnum", "]", "}", ")", "# update status", "self", ".", "_mpkit", ".", "pool", "-=", "1", "self", ".", "_mpkit", ".", "counter", "+=", "1", "# start and record", "proc", ".", "start", "(", ")", "self", ".", "_frnum", "+=", "1", "self", ".", "_mpprc", ".", "append", "(", "proc", ")", "# check buffer", "if", "len", "(", "self", ".", "_mpprc", ")", ">=", "CPU_CNT", "-", "1", ":", "[", "proc", ".", "join", "(", ")", "for", "proc", "in", "self", ".", "_mpprc", "[", ":", "-", "4", "]", "]", "del", "self", ".", "_mpprc", "[", ":", "-", "4", "]" ]

[ "Use", "server", "multiprocessing", "to", "extract", "PCAP", "files", "." ]

[ "def", "_server_extract_frame", "(", "self", ",", "*", ",", "mpfdp", ",", "mpkit", ",", "mpbuf", ")", ":", "# check EOF", "if", "self", ".", "_flag_e", ":", "raise", "EOFError", "# extract frame", "try", ":", "frame", "=", "Frame", "(", "self", ".", "_ifile", ",", "num", "=", "self", ".", "_frnum", ",", "proto", "=", "self", ".", "_dlink", ",", "layer", "=", "self", ".", "_exlyr", ",", "protocol", "=", "self", ".", "_exptl", ",", "nanosecond", "=", "self", ".", "_nnsec", ",", "mpkit", "=", "mpkit", ",", "mpfdp", "=", "mpfdp", ")", "# frame._file = NotImplemented", "mpbuf", "[", "self", ".", "_frnum", "]", "=", "frame", "except", "EOFError", ":", "mpbuf", "[", "self", ".", "_frnum", "]", "=", "EOFError", "mpkit", ".", "eof", "=", "True", "finally", ":", "mpkit", ".", "counter", "-=", "1", "self", ".", "_ifile", ".", "close", "(", ")" ]

[ "Extract", "frame", "." ]

[ "def", "_server_analyse_frame", "(", "self", ",", "*", ",", "mpkit", ",", "mpfrm", ",", "mprsm", ",", "mpbuf", ")", ":", "while", "True", ":", "# fetch frame", "# print(self._frnum, 'trying')", "frame", "=", "mpbuf", ".", "pop", "(", "self", ".", "_frnum", ",", "None", ")", "if", "frame", "is", "EOFError", ":", "break", "if", "frame", "is", "None", ":", "continue", "# print(self._frnum, 'get')", "self", ".", "_default_read_frame", "(", "frame", "=", "frame", ")", "mpfrm", "+=", "self", ".", "_frame", "mprsm", "+=", "self", ".", "_reasm", "mpkit", ".", "trace", "=", "copy", ".", "deepcopy", "(", "self", ".", "_trace", ")" ]

[ "Analyse", "frame", "." ]

[ "def", "get", "(", "key", ",", "default", "=", "-", "1", ")", ":", "if", "isinstance", "(", "key", ",", "int", ")", ":", "return", "Checksum", "(", "key", ")", "if", "key", "not", "in", "Checksum", ".", "_member_map_", ":", "extend_enum", "(", "Checksum", ",", "key", ",", "default", ")", "return", "Checksum", "[", "key", "]" ]

[ "Backport", "support", "for", "original", "codes", "." ]

[ "def", "get", "(", "key", ",", "default", "=", "-", "1", ")", ":", "if", "isinstance", "(", "key", ",", "int", ")", ":", "return", "Operation", "(", "key", ")", "if", "key", "not", "in", "Operation", ".", "_member_map_", ":", "extend_enum", "(", "Operation", ",", "key", ",", "default", ")", "return", "Operation", "[", "key", "]" ]

[ "Backport", "support", "for", "original", "codes", "." ]

[ "def", "read_http", "(", "self", ",", "length", ")", ":", "_plen", "=", "self", ".", "_read_binary", "(", "3", ")", "_type", "=", "self", ".", "_read_unpack", "(", "1", ")", "_flag", "=", "self", ".", "_read_binary", "(", "1", ")", "_stid", "=", "self", ".", "_read_binary", "(", "4", ")" ]

[ "Read", "Hypertext", "Transfer", "Protocol", "version", "2", "." ]

[ "def", "analyse", "(", "file", ",", "length", "=", "None", ",", "*", ",", "_termination", "=", "False", ")", ":", "seekset", "=", "file", ".", "tell", "(", ")", "if", "not", "_termination", ":", "# FTP analysis", "flag", ",", "ftp", "=", "_analyse_ftp", "(", "file", ",", "length", ",", "seekset", "=", "seekset", ")", "if", "flag", ":", "return", "ftp", "# HTTP/1.* analysis", "flag", ",", "http", "=", "_analyse_httpv1", "(", "file", ",", "length", ",", "seekset", "=", "seekset", ")", "if", "flag", ":", "return", "http", "# NOTE: due to format similarity of HTTP/2 and TLS/SSL, HTTP/2 won't be analysed before TLS/SSL is implemented.", "# NB: the NOTE above is deprecated, since validations are performed", "# HTTP/2 analysis", "flag", ",", "http", "=", "_analyse_httpv2", "(", "file", ",", "length", ",", "seekset", "=", "seekset", ")", "if", "flag", ":", "return", "http", "# backup file offset", "file", ".", "seek", "(", "seekset", ",", "os", ".", "SEEK_SET", ")", "# raw packet analysis", "return", "Raw", "(", "file", ",", "length", ")" ]

[ "Analyse", "application", "layer", "packets", "." ]

[ "def", "get", "(", "key", ",", "default", "=", "-", "1", ")", ":", "if", "isinstance", "(", "key", ",", "int", ")", ":", "return", "Routing", "(", "key", ")", "if", "key", "not", "in", "Routing", ".", "_member_map_", ":", "extend_enum", "(", "Routing", ",", "key", ",", "default", ")", "return", "Routing", "[", "key", "]" ]

[ "Backport", "support", "for", "original", "codes", "." ]

[ "def", "_read_protos", "(", "self", ",", "size", ")", ":", "_byte", "=", "self", ".", "_read_unpack", "(", "size", ")", "_prot", "=", "ETHERTYPE", ".", "get", "(", "_byte", ")", "return", "_prot" ]

[ "Read", "next", "layer", "protocol", "type", "." ]

[ "def", "_import_next_layer", "(", "self", ",", "proto", ",", "length", ")", ":", "if", "length", "==", "0", ":", "from", "pcapkit", ".", "protocols", ".", "null", "import", "NoPayload", "as", "Protocol", "elif", "self", ".", "_sigterm", ":", "from", "pcapkit", ".", "protocols", ".", "raw", "import", "Raw", "as", "Protocol", "elif", "proto", "==", "0x0806", ":", "from", "pcapkit", ".", "protocols", ".", "link", ".", "arp", "import", "ARP", "as", "Protocol", "elif", "proto", "==", "0x8035", ":", "from", "pcapkit", ".", "protocols", ".", "link", ".", "rarp", "import", "RARP", "as", "Protocol", "elif", "proto", "==", "0x8100", ":", "from", "pcapkit", ".", "protocols", ".", "link", ".", "vlan", "import", "VLAN", "as", "Protocol", "elif", "proto", "==", "0x0800", ":", "from", "pcapkit", ".", "protocols", ".", "internet", ".", "ipv4", "import", "IPv4", "as", "Protocol", "elif", "proto", "==", "0x86DD", ":", "from", "pcapkit", ".", "protocols", ".", "internet", ".", "ipv6", "import", "IPv6", "as", "Protocol", "elif", "proto", "==", "0x8137", ":", "from", "pcapkit", ".", "protocols", ".", "internet", ".", "ipx", "import", "IPX", "as", "Protocol", "else", ":", "from", "pcapkit", ".", "protocols", ".", "raw", "import", "Raw", "as", "Protocol", "next_", "=", "Protocol", "(", "self", ".", "_file", ",", "length", ",", "error", "=", "self", ".", "_onerror", ",", "layer", "=", "self", ".", "_exlayer", ",", "protocol", "=", "self", ".", "_exproto", ")", "return", "next_" ]

[ "Import", "next", "layer", "extractor", "." ]

[ "def", "get", "(", "key", ",", "default", "=", "-", "1", ")", ":", "if", "isinstance", "(", "key", ",", "int", ")", ":", "return", "HIT_Suite", "(", "key", ")", "if", "key", "not", "in", "HIT_Suite", ".", "_member_map_", ":", "extend_enum", "(", "HIT_Suite", ",", "key", ",", "default", ")", "return", "HIT_Suite", "[", "key", "]" ]

[ "Backport", "support", "for", "original", "codes", "." ]

[ "def", "get", "(", "key", ",", "default", "=", "-", "1", ")", ":", "if", "isinstance", "(", "key", ",", "int", ")", ":", "return", "Authentication", "(", "key", ")", "if", "key", "not", "in", "Authentication", ".", "_member_map_", ":", "extend_enum", "(", "Authentication", ",", "key", ",", "default", ")", "return", "Authentication", "[", "key", "]" ]

[ "Backport", "support", "for", "original", "codes", "." ]

[ "def", "make_fout", "(", "fout", "=", "'./tmp'", ",", "fmt", "=", "'pcap'", ")", ":", "if", "fmt", "==", "'pcap'", ":", "# output PCAP file", "from", "pcapkit", ".", "dumpkit", "import", "PCAP", "as", "output", "elif", "fmt", "==", "'plist'", ":", "# output PLIST file", "from", "dictdumper", "import", "PLIST", "as", "output", "elif", "fmt", "==", "'json'", ":", "# output JSON file", "from", "dictdumper", "import", "JSON", "as", "output", "elif", "fmt", "==", "'tree'", ":", "# output treeview text file", "from", "dictdumper", "import", "Tree", "as", "output", "fmt", "=", "'txt'", "elif", "fmt", "==", "'html'", ":", "# output JavaScript file", "from", "dictdumper", "import", "JavaScript", "as", "output", "fmt", "=", "'js'", "elif", "fmt", "==", "'xml'", ":", "# output XML file", "from", "dictdumper", "import", "XML", "as", "output", "else", ":", "# no output file", "from", "pcapkit", ".", "dumpkit", "import", "NotImplementedIO", "as", "output", "if", "fmt", "is", "not", "None", ":", "warnings", ".", "warn", "(", "f'Unsupported output format: {fmt}; disabled file output feature'", ",", "FormatWarning", ",", "stacklevel", "=", "stacklevel", "(", ")", ")", "return", "output", ",", "''", "try", ":", "pathlib", ".", "Path", "(", "fout", ")", ".", "mkdir", "(", "parents", "=", "True", ",", "exist_ok", "=", "True", ")", "except", "FileExistsError", "as", "error", ":", "if", "fmt", "is", "None", ":", "warnings", ".", "warn", "(", "error", ".", "strerror", ",", "FileWarning", ",", "stacklevel", "=", "stacklevel", "(", ")", ")", "else", ":", "raise", "FileExists", "(", "*", "error", ".", "args", ")", "from", "None", "return", "output", ",", "fmt" ]

[ "Make", "root", "path", "for", "output", "." ]

[ "def", "dump", "(", "self", ",", "packet", ")", ":", "# fetch flow label", "output", "=", "self", ".", "trace", "(", "packet", ",", "_check", "=", "False", ",", "_output", "=", "True", ")", "# dump files", "output", "(", "packet", "[", "'frame'", "]", ",", "name", "=", "f\"Frame {packet['index']}\"", ",", "byteorder", "=", "self", ".", "_endian", ",", "nanosecond", "=", "self", ".", "_nnsecd", ")" ]

[ "Dump", "frame", "to", "output", "files", "." ]

[ "def", "trace", "(", "self", ",", "packet", ",", "*", ",", "_check", "=", "True", ",", "_output", "=", "False", ")", ":", "self", ".", "_newflg", "=", "True", "if", "_check", ":", "pkt_check", "(", "packet", ")", "info", "=", "Info", "(", "packet", ")", "# Buffer Identifier", "BUFID", "=", "tuple", "(", "sorted", "(", "[", "str", "(", "info", ".", "src", ")", ",", "str", "(", "info", ".", "srcport", ")", ",", "# pylint: disable=E1101", "str", "(", "info", ".", "dst", ")", ",", "str", "(", "info", ".", "dstport", ")", "]", ")", ")", "# pylint: disable=E1101", "# SYN = info.syn # Synchronise Flag (Establishment)", "# Finish Flag (Termination)", "FIN", "=", "info", ".", "fin", "# pylint: disable=E1101", "# # when SYN is set, reset buffer of this seesion", "# if SYN and BUFID in self._buffer:", "# temp = self._buffer.pop(BUFID)", "# temp['fpout'] = (self._fproot, self._fdpext)", "# temp['index'] = tuple(temp['index'])", "# self._stream.append(Info(temp))", "# initialise buffer with BUFID", "if", "BUFID", "not", "in", "self", ".", "_buffer", ":", "label", "=", "f'{info.src}_{info.srcport}-{info.dst}_{info.dstport}-{info.timestamp}'", "# pylint: disable=E1101", "self", ".", "_buffer", "[", "BUFID", "]", "=", "dict", "(", "fpout", "=", "self", ".", "_foutio", "(", "f'{self._fproot}/{label}.{self._fdpext}'", ",", "protocol", "=", "info", ".", "protocol", ")", ",", "# pylint: disable=E1101", "index", "=", "list", "(", ")", ",", "label", "=", "label", ",", ")", "# trace frame record", "self", ".", "_buffer", "[", "BUFID", "]", "[", "'index'", "]", ".", "append", "(", "info", ".", "index", ")", "# pylint: disable=E1101", "fpout", "=", "self", ".", "_buffer", "[", "BUFID", "]", "[", "'fpout'", "]", "label", "=", "self", ".", "_buffer", "[", "BUFID", "]", "[", "'label'", "]", "# when FIN is set, submit buffer of this session", "if", "FIN", ":", "buf", "=", "self", ".", "_buffer", ".", "pop", "(", "BUFID", ")", "# fpout, label = buf['fpout'], buf['label']", "if", "self", ".", "_fdpext", ":", "buf", "[", "'fpout'", "]", "=", "f'{self._fproot}/{label}.{self._fdpext}'", "else", ":", "del", "buf", "[", "'fpout'", "]", "buf", "[", "'index'", "]", "=", "tuple", "(", "buf", "[", "'index'", "]", ")", "self", ".", "_stream", ".", "append", "(", "Info", "(", "buf", ")", ")", "# return label or output object", "return", "fpout", "if", "_output", "else", "label" ]

[ "Trace", "packets", "." ]

[ "def", "submit", "(", "self", ")", ":", "self", ".", "_newflg", "=", "False", "ret", "=", "list", "(", ")", "for", "buf", "in", "self", ".", "_buffer", ".", "values", "(", ")", ":", "buf", "=", "copy", ".", "deepcopy", "(", "buf", ")", "if", "self", ".", "_fdpext", ":", "buf", "[", "'fpout'", "]", "=", "f\"{self._fproot}/{buf['label']}.{self._fdpext}\"", "else", ":", "del", "buf", "[", "'fpout'", "]", "buf", "[", "'index'", "]", "=", "tuple", "(", "buf", "[", "'index'", "]", ")", "ret", ".", "append", "(", "Info", "(", "buf", ")", ")", "ret", "+=", "self", ".", "_stream", "return", "tuple", "(", "ret", ")" ]

[ "Submit", "traced", "TCP", "flows", "." ]

[ "def", "read_ah", "(", "self", ",", "length", ",", "version", ",", "extension", ")", ":", "if", "length", "is", "None", ":", "length", "=", "len", "(", "self", ")", "_next", "=", "self", ".", "_read_protos", "(", "1", ")", "_plen", "=", "self", ".", "_read_unpack", "(", "1", ")", "_resv", "=", "self", ".", "_read_fileng", "(", "2", ")", "_scpi", "=", "self", ".", "_read_unpack", "(", "4", ")", "_dsnf", "=", "self", ".", "_read_unpack", "(", "4", ")", "# ICV length & value", "_tlen", "=", "_plen", "*", "4", "-", "2", "_vlen", "=", "_tlen", "-", "12", "_chkv", "=", "self", ".", "_read_fileng", "(", "_vlen", ")", "ah", "=", "dict", "(", "next", "=", "_next", ",", "length", "=", "_tlen", ",", "spi", "=", "_scpi", ",", "seq", "=", "_dsnf", ",", "icv", "=", "_chkv", ",", ")", "if", "version", "==", "6", ":", "_plen", "=", "8", "-", "(", "_tlen", "%", "8", ")", "elif", "version", "==", "4", ":", "_plen", "=", "4", "-", "(", "_tlen", "%", "4", ")", "else", ":", "raise", "VersionError", "(", "f'Unknown IP version {version}'", ")", "if", "_plen", ":", "# explicit padding in need", "padding", "=", "self", ".", "_read_binary", "(", "_plen", ")", "if", "any", "(", "(", "int", "(", "bit", ",", "base", "=", "2", ")", "for", "bit", "in", "padding", ")", ")", ":", "raise", "ProtocolError", "(", "f'{self.alias}: invalid format'", ")", "length", "-=", "ah", "[", "'length'", "]", "ah", "[", "'packet'", "]", "=", "self", ".", "_read_packet", "(", "header", "=", "ah", "[", "'length'", "]", ",", "payload", "=", "length", ")", "if", "extension", ":", "self", ".", "_protos", "=", "None", "return", "ah", "return", "self", ".", "_decode_next_layer", "(", "ah", ",", "_next", ",", "length", ")" ]

[ "Read", "Authentication", "Header", "." ]

[ "def", "read_ethernet", "(", "self", ",", "length", ")", ":", "if", "length", "is", "None", ":", "length", "=", "len", "(", "self", ")", "_dstm", "=", "self", ".", "_read_mac_addr", "(", ")", "_srcm", "=", "self", ".", "_read_mac_addr", "(", ")", "_type", "=", "self", ".", "_read_protos", "(", "2", ")", "ethernet", "=", "dict", "(", "dst", "=", "_dstm", ",", "src", "=", "_srcm", ",", "type", "=", "_type", ",", ")", "length", "-=", "14", "ethernet", "[", "'packet'", "]", "=", "self", ".", "_read_packet", "(", "header", "=", "14", ",", "payload", "=", "length", ")", "return", "self", ".", "_decode_next_layer", "(", "ethernet", ",", "_type", ",", "length", ")" ]

[ "Read", "Ethernet", "Protocol", "." ]

[ "def", "_read_mac_addr", "(", "self", ")", ":", "_byte", "=", "self", ".", "_read_fileng", "(", "6", ")", "_addr", "=", "'-'", ".", "join", "(", "textwrap", ".", "wrap", "(", "_byte", ".", "hex", "(", ")", ",", "2", ")", ")", "return", "_addr" ]

[ "Read", "MAC", "address", "." ]

[ "def", "get", "(", "key", ",", "default", "=", "-", "1", ")", ":", "if", "isinstance", "(", "key", ",", "int", ")", ":", "return", "Suite", "(", "key", ")", "if", "key", "not", "in", "Suite", ".", "_member_map_", ":", "extend_enum", "(", "Suite", ",", "key", ",", "default", ")", "return", "Suite", "[", "key", "]" ]

[ "Backport", "support", "for", "original", "codes", "." ]

[ "def", "get", "(", "key", ",", "default", "=", "-", "1", ")", ":", "if", "isinstance", "(", "key", ",", "int", ")", ":", "return", "ECDSA_Curve", "(", "key", ")", "if", "key", "not", "in", "ECDSA_Curve", ".", "_member_map_", ":", "extend_enum", "(", "ECDSA_Curve", ",", "key", ",", "default", ")", "return", "ECDSA_Curve", "[", "key", "]" ]

[ "Backport", "support", "for", "original", "codes", "." ]

[ "def", "packet2dict", "(", "packet", ")", ":", "dict_", "=", "dict", "(", ")", "frame", "=", "packet", ".", "frame_info", "for", "field", "in", "frame", ".", "field_names", ":", "dict_", "[", "field", "]", "=", "getattr", "(", "frame", ",", "field", ")", "tempdict", "=", "dict_", "for", "layer", "in", "packet", ".", "layers", ":", "tempdict", "[", "layer", ".", "layer_name", ".", "upper", "(", ")", "]", "=", "dict", "(", ")", "tempdict", "=", "tempdict", "[", "layer", ".", "layer_name", ".", "upper", "(", ")", "]", "for", "field", "in", "layer", ".", "field_names", ":", "tempdict", "[", "field", "]", "=", "getattr", "(", "layer", ",", "field", ")", "return", "dict_" ]

[ "Convert", "PyShark", "packet", "into", "dict", "." ]

[ "def", "tcp_traceflow", "(", "packet", ")", ":", "if", "'TCP'", "in", "packet", ":", "ip", "=", "packet", ".", "ip", "if", "'IP'", "in", "packet", "else", "packet", ".", "ipv6", "tcp", "=", "packet", ".", "tcp", "data", "=", "dict", "(", "protocol", "=", "LINKTYPE", ".", "get", "(", "packet", ".", "layers", "[", "0", "]", ".", "layer_name", ".", "upper", "(", ")", ")", ",", "# data link type from global header", "index", "=", "int", "(", "packet", ".", "number", ")", ",", "# frame number", "frame", "=", "packet2dict", "(", "packet", ")", ",", "# extracted packet", "syn", "=", "bool", "(", "int", "(", "tcp", ".", "flags_syn", ")", ")", ",", "# TCP synchronise (SYN) flag", "fin", "=", "bool", "(", "int", "(", "tcp", ".", "flags_fin", ")", ")", ",", "# TCP finish (FIN) flag", "src", "=", "ipaddress", ".", "ip_address", "(", "ip", ".", "src", ")", ",", "# source IP", "dst", "=", "ipaddress", ".", "ip_address", "(", "ip", ".", "dst", ")", ",", "# destination IP", "srcport", "=", "int", "(", "tcp", ".", "srcport", ")", ",", "# TCP source port", "dstport", "=", "int", "(", "tcp", ".", "dstport", ")", ",", "# TCP destination port", "timestamp", "=", "packet", ".", "frame_info", ".", "time_epoch", ",", "# timestamp", ")", "return", "True", ",", "data", "return", "False", ",", "None" ]

[ "Trace", "packet", "flow", "for", "TCP", "." ]

[ "def", "reassembly", "(", "self", ",", "info", ")", ":", "BUFID", "=", "info", ".", "bufid", "# Buffer Identifier", "DSN", "=", "info", ".", "dsn", "# Data Sequence Number", "ACK", "=", "info", ".", "ack", "# Acknowledgement Number", "FIN", "=", "info", ".", "fin", "# Finish Flag (Termination)", "RST", "=", "info", ".", "rst", "# Reset Connection Flag (Termination)", "SYN", "=", "info", ".", "syn", "# Synchronise Flag (Establishment)", "# when SYN is set, reset buffer of this session", "if", "SYN", "and", "BUFID", "in", "self", ".", "_buffer", ":", "self", ".", "_dtgram", "+=", "self", ".", "submit", "(", "self", ".", "_buffer", "[", "BUFID", "]", ",", "bufid", "=", "BUFID", ")", "del", "self", ".", "_buffer", "[", "BUFID", "]", "# initialise buffer with BUFID & ACK", "if", "BUFID", "not", "in", "self", ".", "_buffer", ":", "self", ".", "_buffer", "[", "BUFID", "]", "=", "{", "'hdl'", ":", "[", "Info", "(", "first", "=", "info", ".", "len", ",", "last", "=", "sys", ".", "maxsize", ")", "]", ",", "ACK", ":", "dict", "(", "ind", "=", "[", "info", ".", "num", "]", ",", "isn", "=", "info", ".", "dsn", ",", "len", "=", "info", ".", "len", ",", "raw", "=", "info", ".", "payload", ",", ")", ",", "}", "else", ":", "# initialise buffer with ACK", "if", "ACK", "not", "in", "self", ".", "_buffer", "[", "BUFID", "]", ":", "self", ".", "_buffer", "[", "BUFID", "]", "[", "ACK", "]", "=", "dict", "(", "ind", "=", "[", "info", ".", "num", "]", ",", "isn", "=", "info", ".", "dsn", ",", "len", "=", "info", ".", "len", ",", "raw", "=", "info", ".", "payload", ",", ")", "else", ":", "# append packet index", "self", ".", "_buffer", "[", "BUFID", "]", "[", "ACK", "]", "[", "'ind'", "]", ".", "append", "(", "info", ".", "num", ")", "# record fragment payload", "ISN", "=", "self", ".", "_buffer", "[", "BUFID", "]", "[", "ACK", "]", "[", "'isn'", "]", "# Initial Sequence Number", "RAW", "=", "self", ".", "_buffer", "[", "BUFID", "]", "[", "ACK", "]", "[", "'raw'", "]", "# Raw Payload Data", "if", "DSN", ">=", "ISN", ":", "# if fragment goes after existing payload", "LEN", "=", "self", ".", "_buffer", "[", "BUFID", "]", "[", "ACK", "]", "[", "'len'", "]", "GAP", "=", "DSN", "-", "(", "ISN", "+", "LEN", ")", "# gap length between payloads", "if", "GAP", ">=", "0", ":", "# if fragment goes after existing payload", "RAW", "+=", "bytearray", "(", "GAP", ")", "+", "info", ".", "payload", "else", ":", "# if fragment partially overlaps existing payload", "RAW", "[", "DSN", "-", "ISN", ":", "]", "=", "info", ".", "payload", "else", ":", "# if fragment exceeds existing payload", "LEN", "=", "info", ".", "len", "GAP", "=", "ISN", "-", "(", "DSN", "+", "LEN", ")", "# gap length between payloads", "self", ".", "_buffer", "[", "BUFID", "]", "[", "ACK", "]", "[", "'isn'", "]", "=", "DSN", "if", "GAP", ">=", "0", ":", "# if fragment exceeds existing payload", "RAW", "=", "info", ".", "payload", "+", "bytearray", "(", "GAP", ")", "+", "RAW", "else", ":", "# if fragment partially overlaps existing payload", "RAW", "=", "info", ".", "payload", "+", "RAW", "[", "ISN", "-", "GAP", ":", "]", "self", ".", "_buffer", "[", "BUFID", "]", "[", "ACK", "]", "[", "'raw'", "]", "=", "RAW", "# update payload datagram", "self", ".", "_buffer", "[", "BUFID", "]", "[", "ACK", "]", "[", "'len'", "]", "=", "len", "(", "RAW", ")", "# update payload length", "# update hole descriptor list", "HDL", "=", "self", ".", "_buffer", "[", "BUFID", "]", "[", "'hdl'", "]", "for", "(", "index", ",", "hole", ")", "in", "enumerate", "(", "HDL", ")", ":", "# step one", "if", "info", ".", "first", ">", "hole", ".", "last", ":", "# step two", "continue", "if", "info", ".", "last", "<", "hole", ".", "first", ":", "# step three", "continue", "del", "HDL", "[", "index", "]", "# step four", "if", "info", ".", "first", ">", "hole", ".", "first", ":", "# step five", "new_hole", "=", "Info", "(", "first", "=", "hole", ".", "first", ",", "last", "=", "info", ".", "first", "-", "1", ",", ")", "HDL", ".", "insert", "(", "index", ",", "new_hole", ")", "index", "+=", "1", "if", "info", ".", "last", "<", "hole", ".", "last", "and", "not", "FIN", "and", "not", "RST", ":", "# step six", "new_hole", "=", "Info", "(", "first", "=", "info", ".", "last", "+", "1", ",", "last", "=", "hole", ".", "last", ")", "HDL", ".", "insert", "(", "index", ",", "new_hole", ")", "break", "# step seven", "self", ".", "_buffer", "[", "BUFID", "]", "[", "'hdl'", "]", "=", "HDL", "# update HDL", "# when FIN/RST is set, submit buffer of this session", "if", "FIN", "or", "RST", ":", "self", ".", "_dtgram", "+=", "self", ".", "submit", "(", "self", ".", "_buffer", "[", "BUFID", "]", ",", "bufid", "=", "BUFID", ")", "del", "self", ".", "_buffer", "[", "BUFID", "]" ]

[ "Reassembly", "procedure", "." ]

[ "def", "submit", "(", "self", ",", "buf", ",", "*", ",", "bufid", ")", ":", "datagram", "=", "[", "]", "# reassembled datagram", "HDL", "=", "buf", ".", "pop", "(", "'hdl'", ")", "# hole descriptor list (remove from dict)", "# check through every buffer with ACK", "for", "(", "ack", ",", "buffer", ")", "in", "buf", ".", "items", "(", ")", ":", "# if this buffer is not implemented", "# go through every hole and extract received payload", "if", "len", "(", "HDL", ")", ">", "2", "and", "self", ".", "_strflg", ":", "data", "=", "[", "]", "start", "=", "stop", "=", "0", "for", "hole", "in", "HDL", ":", "stop", "=", "hole", ".", "first", "byte", "=", "buffer", "[", "'raw'", "]", "[", "start", ":", "stop", "]", "start", "=", "hole", ".", "last", "if", "byte", ":", "# strip empty payload", "data", ".", "append", "(", "byte", ")", "byte", "=", "buffer", "[", "'raw'", "]", "[", "start", ":", "]", "if", "byte", ":", "# strip empty payload", "data", ".", "append", "(", "byte", ")", "if", "data", ":", "# strip empty buffer", "packet", "=", "Info", "(", "NotImplemented", "=", "True", ",", "id", "=", "Info", "(", "src", "=", "(", "bufid", "[", "0", "]", ",", "bufid", "[", "2", "]", ")", ",", "dst", "=", "(", "bufid", "[", "1", "]", ",", "bufid", "[", "3", "]", ")", ",", "ack", "=", "ack", ",", ")", ",", "index", "=", "tuple", "(", "buffer", "[", "'ind'", "]", ")", ",", "payload", "=", "tuple", "(", "data", ")", "or", "None", ",", "packets", "=", "tuple", "(", "analyse", "(", "io", ".", "BytesIO", "(", "frag", ")", ",", "len", "(", "frag", ")", ")", "for", "frag", "in", "data", ")", ",", ")", "datagram", ".", "append", "(", "packet", ")", "# if this buffer is implemented", "# export payload data & convert into bytes", "else", ":", "data", "=", "buffer", "[", "'raw'", "]", "if", "data", ":", "# strip empty buffer", "packet", "=", "Info", "(", "NotImplemented", "=", "False", ",", "id", "=", "Info", "(", "src", "=", "(", "bufid", "[", "0", "]", ",", "bufid", "[", "2", "]", ")", ",", "dst", "=", "(", "bufid", "[", "1", "]", ",", "bufid", "[", "3", "]", ")", ",", "ack", "=", "ack", ",", ")", ",", "index", "=", "tuple", "(", "buffer", "[", "'ind'", "]", ")", ",", "payload", "=", "bytes", "(", "data", ")", "or", "None", ",", "packets", "=", "(", "analyse", "(", "io", ".", "BytesIO", "(", "data", ")", ",", "len", "(", "data", ")", ")", ",", ")", ",", ")", "datagram", ".", "append", "(", "packet", ")", "return", "datagram" ]

[ "Submit", "reassembled", "payload", "." ]

[ "def", "packet2chain", "(", "packet", ")", ":", "if", "scapy_all", "is", "None", ":", "raise", "ModuleNotFound", "(", "\"No module named 'scapy'\"", ",", "name", "=", "'scapy'", ")", "chain", "=", "[", "packet", ".", "name", "]", "payload", "=", "packet", ".", "payload", "while", "not", "isinstance", "(", "payload", ",", "scapy_all", ".", "packet", ".", "NoPayload", ")", ":", "chain", ".", "append", "(", "payload", ".", "name", ")", "payload", "=", "payload", ".", "payload", "return", "':'", ".", "join", "(", "chain", ")" ]

[ "Fetch", "Scapy", "packet", "protocol", "chain", "." ]

[ "def", "packet2dict", "(", "packet", ",", "*", ",", "count", "=", "NotImplemented", ")", ":", "if", "scapy_all", "is", "None", ":", "raise", "ModuleNotFound", "(", "\"No module named 'scapy'\"", ",", "name", "=", "'scapy'", ")", "def", "wrapper", "(", "packet", ")", ":", "dict_", "=", "packet", ".", "fields", "payload", "=", "packet", ".", "payload", "if", "not", "isinstance", "(", "payload", ",", "scapy_all", ".", "packet", ".", "NoPayload", ")", ":", "dict_", "[", "payload", ".", "name", "]", "=", "wrapper", "(", "payload", ")", "return", "dict_", "return", "{", "'packet'", ":", "bytes", "(", "packet", ")", ",", "packet", ".", "name", ":", "wrapper", "(", "packet", ")", ",", "}" ]

[ "Convert", "Scapy", "packet", "into", "dict", "." ]

[ "def", "ipv4_reassembly", "(", "packet", ",", "*", ",", "count", "=", "NotImplemented", ")", ":", "if", "'IP'", "in", "packet", ":", "ipv4", "=", "packet", "[", "'IP'", "]", "if", "ipv4", ".", "flags", ".", "DF", ":", "# dismiss not fragmented packet", "return", "False", ",", "None", "data", "=", "dict", "(", "bufid", "=", "(", "ipaddress", ".", "ip_address", "(", "ipv4", ".", "src", ")", ",", "# source IP address", "ipaddress", ".", "ip_address", "(", "ipv4", ".", "dst", ")", ",", "# destination IP address", "ipv4", ".", "id", ",", "# identification", "TP_PROTO", ".", "get", "(", "ipv4", ".", "proto", ")", ".", "name", ",", "# payload protocol type", ")", ",", "num", "=", "count", ",", "# original packet range number", "fo", "=", "ipv4", ".", "frag", ",", "# fragment offset", "ihl", "=", "ipv4", ".", "ihl", ",", "# internet header length", "mf", "=", "bool", "(", "ipv4", ".", "flags", ".", "MF", ")", ",", "# more fragment flag", "tl", "=", "ipv4", ".", "len", ",", "# total length, header includes", "header", "=", "bytearray", "(", "ipv4", ".", "raw_packet_cache", ")", ",", "# raw bytearray type header", "payload", "=", "bytearray", "(", "bytes", "(", "ipv4", ".", "payload", ")", ")", ",", "# raw bytearray type payload", ")", "return", "True", ",", "data", "return", "False", ",", "None" ]

[ "Make", "data", "for", "IPv4", "reassembly", "." ]

[ "def", "ipv6_reassembly", "(", "packet", ",", "*", ",", "count", "=", "NotImplemented", ")", ":", "if", "scapy_all", "is", "None", ":", "raise", "ModuleNotFound", "(", "\"No module named 'scapy'\"", ",", "name", "=", "'scapy'", ")", "if", "'IPv6'", "in", "packet", ":", "ipv6", "=", "packet", "[", "'IPv6'", "]", "if", "scapy_all", ".", "IPv6ExtHdrFragment", "not", "in", "ipv6", ":", "# pylint: disable=E1101", "return", "False", ",", "None", "# dismiss not fragmented packet", "ipv6_frag", "=", "ipv6", "[", "'IPv6ExtHdrFragment'", "]", "data", "=", "dict", "(", "bufid", "=", "(", "ipaddress", ".", "ip_address", "(", "ipv6", ".", "src", ")", ",", "# source IP address", "ipaddress", ".", "ip_address", "(", "ipv6", ".", "dst", ")", ",", "# destination IP address", "ipv6", ".", "fl", ",", "# label", "TP_PROTO", ".", "get", "(", "ipv6_frag", ".", "nh", ")", ".", "name", ",", "# next header field in IPv6 Fragment Header", ")", ",", "num", "=", "count", ",", "# original packet range number", "fo", "=", "ipv6_frag", ".", "offset", ",", "# fragment offset", "ihl", "=", "len", "(", "ipv6", ")", "-", "len", "(", "ipv6_frag", ")", ",", "# header length, only headers before IPv6-Frag", "mf", "=", "bool", "(", "ipv6_frag", ".", "m", ")", ",", "# more fragment flag", "tl", "=", "len", "(", "ipv6", ")", ",", "# total length, header includes", "header", "=", "bytearray", "(", "bytes", "(", "ipv6", ")", "[", ":", "-", "len", "(", "ipv6_frag", ")", "]", ")", ",", "# raw bytearray type header before IPv6-Frag", "payload", "=", "bytearray", "(", "bytes", "(", "ipv6_frag", ".", "payload", ")", ")", ",", "# raw bytearray type payload after IPv6-Frag", ")", "return", "True", ",", "data", "return", "False", ",", "None" ]

[ "Make", "data", "for", "IPv6", "reassembly", "." ]

[ "def", "tcp_reassembly", "(", "packet", ",", "*", ",", "count", "=", "NotImplemented", ")", ":", "if", "'TCP'", "in", "packet", ":", "ip", "=", "packet", "[", "'IP'", "]", "if", "'IP'", "in", "packet", "else", "packet", "[", "'IPv6'", "]", "tcp", "=", "packet", "[", "'TCP'", "]", "data", "=", "dict", "(", "bufid", "=", "(", "ipaddress", ".", "ip_address", "(", "ip", ".", "src", ")", ",", "# source IP address", "ipaddress", ".", "ip_address", "(", "ip", ".", "dst", ")", ",", "# destination IP address", "tcp", ".", "sport", ",", "# source port", "tcp", ".", "dport", ",", "# destination port", ")", ",", "num", "=", "count", ",", "# original packet range number", "ack", "=", "tcp", ".", "ack", ",", "# acknowledgement", "dsn", "=", "tcp", ".", "seq", ",", "# data sequence number", "syn", "=", "bool", "(", "tcp", ".", "flags", ".", "S", ")", ",", "# synchronise flag", "fin", "=", "bool", "(", "tcp", ".", "flags", ".", "F", ")", ",", "# finish flag", "rst", "=", "bool", "(", "tcp", ".", "flags", ".", "R", ")", ",", "# reset connection flag", "payload", "=", "bytearray", "(", "bytes", "(", "tcp", ".", "payload", ")", ")", ",", "# raw bytearray type payload", ")", "raw_len", "=", "len", "(", "tcp", ".", "payload", ")", "# payload length, header excludes", "data", "[", "'first'", "]", "=", "tcp", ".", "seq", "# this sequence number", "data", "[", "'last'", "]", "=", "tcp", ".", "seq", "+", "raw_len", "# next (wanted) sequence number", "data", "[", "'len'", "]", "=", "raw_len", "# payload length, header excludes", "return", "True", ",", "data", "return", "False", ",", "None" ]

[ "Store", "data", "for", "TCP", "reassembly", "." ]

[ "def", "tcp_traceflow", "(", "packet", ",", "*", ",", "count", "=", "NotImplemented", ")", ":", "if", "'TCP'", "in", "packet", ":", "ip", "=", "packet", "[", "'IP'", "]", "if", "'IP'", "in", "packet", "else", "packet", "[", "'IPv6'", "]", "tcp", "=", "packet", "[", "'TCP'", "]", "data", "=", "dict", "(", "protocol", "=", "LINKTYPE", ".", "get", "(", "packet", ".", "name", ".", "upper", "(", ")", ")", ",", "# data link type from global header", "index", "=", "count", ",", "# frame number", "frame", "=", "packet2dict", "(", "packet", ")", ",", "# extracted packet", "syn", "=", "bool", "(", "tcp", ".", "flags", ".", "S", ")", ",", "# TCP synchronise (SYN) flag", "fin", "=", "bool", "(", "tcp", ".", "flags", ".", "F", ")", ",", "# TCP finish (FIN) flag", "src", "=", "ipaddress", ".", "ip_address", "(", "ip", ".", "src", ")", ",", "# source IP", "dst", "=", "ipaddress", ".", "ip_address", "(", "ip", ".", "dst", ")", ",", "# destination IP", "srcport", "=", "tcp", ".", "sport", ",", "# TCP source port", "dstport", "=", "tcp", ".", "dport", ",", "# TCP destination port", "timestamp", "=", "time", ".", "time", "(", ")", ",", "# timestamp", ")", "return", "True", ",", "data", "return", "False", ",", "None" ]

[ "Trace", "packet", "flow", "for", "TCP", "." ]

[ "def", "read_hopopt", "(", "self", ",", "length", ",", "extension", ")", ":", "if", "length", "is", "None", ":", "length", "=", "len", "(", "self", ")", "_next", "=", "self", ".", "_read_protos", "(", "1", ")", "_hlen", "=", "self", ".", "_read_unpack", "(", "1", ")", "# _opts = self._read_fileng(_hlen*8+6)", "hopopt", "=", "dict", "(", "next", "=", "_next", ",", "length", "=", "(", "_hlen", "+", "1", ")", "*", "8", ",", ")", "options", "=", "self", ".", "_read_hopopt_options", "(", "_hlen", "*", "8", "+", "6", ")", "hopopt", "[", "'options'", "]", "=", "options", "[", "0", "]", "# tuple of option acronyms", "hopopt", ".", "update", "(", "options", "[", "1", "]", ")", "# merge option info to buffer", "length", "-=", "hopopt", "[", "'length'", "]", "hopopt", "[", "'packet'", "]", "=", "self", ".", "_read_packet", "(", "header", "=", "hopopt", "[", "'length'", "]", ",", "payload", "=", "length", ")", "if", "extension", ":", "self", ".", "_protos", "=", "None", "return", "hopopt", "return", "self", ".", "_decode_next_layer", "(", "hopopt", ",", "_next", ",", "length", ")" ]

[ "Read", "IPv6", "Hop", "-", "by", "-", "Hop", "Options", "." ]

[ "def", "_read_hopopt_options", "(", "self", ",", "length", ")", ":", "counter", "=", "0", "# length of read options", "optkind", "=", "list", "(", ")", "# option type list", "options", "=", "dict", "(", ")", "# dict of option data", "while", "counter", "<", "length", ":", "# break when eol triggered", "code", "=", "self", ".", "_read_unpack", "(", "1", ")", "if", "not", "code", ":", "break", "# extract parameter", "abbr", ",", "desc", "=", "_HOPOPT_OPT", ".", "get", "(", "code", ",", "(", "'none'", ",", "'Unassigned'", ")", ")", "data", "=", "_HOPOPT_PROC", "(", "abbr", ")", "(", "self", ",", "code", ",", "desc", "=", "desc", ")", "enum", "=", "_OPT_TYPE", ".", "get", "(", "code", ")", "# record parameter data", "counter", "+=", "data", "[", "'length'", "]", "if", "enum", "in", "optkind", ":", "if", "isinstance", "(", "options", "[", "abbr", "]", ",", "tuple", ")", ":", "options", "[", "abbr", "]", "+=", "(", "Info", "(", "data", ")", ",", ")", "else", ":", "options", "[", "abbr", "]", "=", "(", "Info", "(", "options", "[", "abbr", "]", ")", ",", "Info", "(", "data", ")", ")", "else", ":", "optkind", ".", "append", "(", "enum", ")", "options", "[", "abbr", "]", "=", "data", "# check threshold", "if", "counter", "!=", "length", ":", "raise", "ProtocolError", "(", "f'{self.alias}: invalid format'", ")", "return", "tuple", "(", "optkind", ")", ",", "options" ]

[ "Read", "HOPOPT", "options", "." ]

[ "def", "_read_opt_pad", "(", "self", ",", "code", ",", "*", ",", "desc", ")", ":", "_type", "=", "self", ".", "_read_opt_type", "(", "code", ")", "if", "code", "==", "0", ":", "opt", "=", "dict", "(", "desc", "=", "desc", ",", "type", "=", "_type", ",", "length", "=", "1", ",", ")", "elif", "code", "==", "1", ":", "_size", "=", "self", ".", "_read_unpack", "(", "1", ")", "_padn", "=", "self", ".", "_read_fileng", "(", "_size", ")", "opt", "=", "dict", "(", "desc", "=", "desc", ",", "type", "=", "_type", ",", "length", "=", "_size", "+", "2", ",", "padding", "=", "_padn", ",", ")", "else", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {code}] invalid format'", ")", "return", "opt" ]

[ "Read", "HOPOPT", "padding", "options", "." ]

[ "def", "_read_opt_tun", "(", "self", ",", "code", ",", "*", ",", "desc", ")", ":", "_type", "=", "self", ".", "_read_opt_type", "(", "code", ")", "_size", "=", "self", ".", "_read_unpack", "(", "1", ")", "if", "_size", "!=", "1", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {code}] invalid format'", ")", "_limt", "=", "self", ".", "_read_unpack", "(", "1", ")", "opt", "=", "dict", "(", "desc", "=", "desc", ",", "type", "=", "_type", ",", "length", "=", "_size", "+", "2", ",", "limit", "=", "_limt", ",", ")", "return", "opt" ]

[ "Read", "HOPOPT", "Tunnel", "Encapsulation", "Limit", "option", "." ]

[ "def", "_read_opt_ra", "(", "self", ",", "code", ",", "*", ",", "desc", ")", ":", "_type", "=", "self", ".", "_read_opt_type", "(", "code", ")", "_size", "=", "self", ".", "_read_unpack", "(", "1", ")", "if", "_size", "!=", "2", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {code}] invalid format'", ")", "_rval", "=", "self", ".", "_read_unpack", "(", "2", ")", "if", "4", "<=", "_rval", "<=", "35", ":", "_dscp", "=", "f'Aggregated Reservation Nesting Level {_rval-4}'", "# [RFC 3175]", "elif", "36", "<=", "_rval", "<=", "67", ":", "_dscp", "=", "f'QoS NSLP Aggregation Level {_rval-36}'", "# [RFC 5974]", "elif", "65503", "<=", "_rval", "<=", "65534", ":", "_dscp", "=", "'Reserved for experimental use'", "# [RFC 5350]", "else", ":", "_dscp", "=", "_ROUTER_ALERT", ".", "get", "(", "_rval", ",", "'Unassigned'", ")", "opt", "=", "dict", "(", "desc", "=", "desc", ",", "type", "=", "_type", ",", "length", "=", "_size", "+", "2", ",", "value", "=", "_rval", ",", "alert", "=", "_dscp", ",", ")", "return", "opt" ]

[ "Read", "HOPOPT", "Router", "Alert", "option", "." ]

[ "def", "_read_opt_calipso", "(", "self", ",", "code", ",", "*", ",", "desc", ")", ":", "_type", "=", "self", ".", "_read_opt_type", "(", "code", ")", "_size", "=", "self", ".", "_read_unpack", "(", "1", ")", "if", "_size", "<", "8", "and", "_size", "%", "8", "!=", "0", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {code}] invalid format'", ")", "_cmpt", "=", "self", ".", "_read_unpack", "(", "4", ")", "_clen", "=", "self", ".", "_read_unpack", "(", "1", ")", "if", "_clen", "%", "2", "!=", "0", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {code}] invalid format'", ")", "_sens", "=", "self", ".", "_read_unpack", "(", "1", ")", "_csum", "=", "self", ".", "_read_fileng", "(", "2", ")", "opt", "=", "dict", "(", "desc", "=", "desc", ",", "type", "=", "_type", ",", "length", "=", "_size", "+", "2", ",", "domain", "=", "_cmpt", ",", "cmpt_len", "=", "_clen", "*", "4", ",", "level", "=", "_sens", ",", "chksum", "=", "_csum", ",", ")", "if", "_clen", ":", "_bmap", "=", "list", "(", ")", "for", "_", "in", "range", "(", "_clen", "//", "2", ")", ":", "_bmap", ".", "append", "(", "self", ".", "_read_binary", "(", "8", ")", ")", "opt", "[", "'bitmap'", "]", "=", "tuple", "(", "_bmap", ")", "_plen", "=", "_size", "-", "_clen", "*", "4", "-", "8", "if", "_plen", ":", "self", ".", "_read_fileng", "(", "_plen", ")", "return", "opt" ]

[ "Read", "HOPOPT", "CALIPSO", "option", "." ]

[ "def", "_read_opt_smf_dpd", "(", "self", ",", "code", ",", "*", ",", "desc", ")", ":", "_type", "=", "self", ".", "_read_opt_type", "(", "code", ")", "_size", "=", "self", ".", "_read_unpack", "(", "1", ")", "_tidd", "=", "self", ".", "_read_binary", "(", "1", ")", "if", "_tidd", "[", "0", "]", "==", "'0'", ":", "_mode", "=", "'I-DPD'", "_tidt", "=", "_TID_TYPE", ".", "get", "(", "_tidd", "[", "1", ":", "4", "]", ",", "'Unassigned'", ")", "_tidl", "=", "int", "(", "_tidd", "[", "4", ":", "]", ",", "base", "=", "2", ")", "if", "_tidt", "==", "'NULL'", ":", "if", "_tidl", "!=", "0", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {code}] invalid format'", ")", "_iden", "=", "self", ".", "_read_fileng", "(", "_size", "-", "1", ")", "opt", "=", "dict", "(", "desc", "=", "desc", ",", "type", "=", "_type", ",", "length", "=", "_size", "+", "2", ",", "dpd_type", "=", "_mode", ",", "tid_type", "=", "_tidt", ",", "tid_len", "=", "_tidl", ",", "id", "=", "_iden", ",", ")", "elif", "_tidt", "==", "'IPv4'", ":", "if", "_tidl", "!=", "3", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {code}] invalid format'", ")", "_tidf", "=", "self", ".", "_read_fileng", "(", "4", ")", "_iden", "=", "self", ".", "_read_fileng", "(", "_size", "-", "4", ")", "opt", "=", "dict", "(", "desc", "=", "desc", ",", "type", "=", "_type", ",", "length", "=", "_size", "+", "2", ",", "dpd_type", "=", "_mode", ",", "tid_type", "=", "_tidt", ",", "tid_len", "=", "_tidl", ",", "tid", "=", "ipaddress", ".", "ip_address", "(", "_tidf", ")", ",", "id", "=", "_iden", ",", ")", "elif", "_tidt", "==", "'IPv6'", ":", "if", "_tidl", "!=", "15", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {code}] invalid format'", ")", "_tidf", "=", "self", ".", "_read_fileng", "(", "15", ")", "_iden", "=", "self", ".", "_read_fileng", "(", "_size", "-", "15", ")", "opt", "=", "dict", "(", "desc", "=", "desc", ",", "type", "=", "_type", ",", "length", "=", "_size", "+", "2", ",", "dpd_type", "=", "_mode", ",", "tid_type", "=", "_tidt", ",", "tid_len", "=", "_tidl", ",", "tid", "=", "ipaddress", ".", "ip_address", "(", "_tidf", ")", ",", "id", "=", "_iden", ",", ")", "else", ":", "_tidf", "=", "self", ".", "_read_unpack", "(", "_tidl", "+", "1", ")", "_iden", "=", "self", ".", "_read_fileng", "(", "_size", "-", "_tidl", "-", "2", ")", "opt", "=", "dict", "(", "desc", "=", "desc", ",", "type", "=", "_type", ",", "length", "=", "_size", "+", "2", ",", "dpd_type", "=", "_mode", ",", "tid_type", "=", "_tidt", ",", "tid_len", "=", "_tidl", ",", "tid", "=", "_tidf", ",", "id", "=", "_iden", ",", ")", "elif", "_tidd", "[", "0", "]", "==", "'1'", ":", "_data", "=", "self", ".", "_read_binary", "(", "_size", "-", "1", ")", "opt", "=", "dict", "(", "desc", "=", "desc", ",", "type", "=", "_type", ",", "length", "=", "_size", "+", "2", ",", "dpd_type", "=", "_mode", ",", "tid_type", "=", "_tidt", ",", "hav", "=", "_tidd", "[", "1", ":", "]", "+", "_data", ",", ")", "else", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {code}] invalid format'", ")", "return", "opt" ]

[ "Read", "HOPOPT", "SMF_DPD", "option", "." ]

[ "def", "_read_opt_pdm", "(", "self", ",", "code", ",", "*", ",", "desc", ")", ":", "_type", "=", "self", ".", "_read_opt_type", "(", "code", ")", "_size", "=", "self", ".", "_read_unpack", "(", "1", ")", "if", "_size", "!=", "10", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {code}] invalid format'", ")", "_stlr", "=", "self", ".", "_read_unpack", "(", "1", ")", "_stls", "=", "self", ".", "_read_unpack", "(", "1", ")", "_psnt", "=", "self", ".", "_read_unpack", "(", "2", ")", "_psnl", "=", "self", ".", "_read_unpack", "(", "2", ")", "_dtlr", "=", "self", ".", "_read_unpack", "(", "2", ")", "_dtls", "=", "self", ".", "_read_unpack", "(", "2", ")", "opt", "=", "dict", "(", "desc", "=", "desc", ",", "type", "=", "_type", ",", "length", "=", "_size", "+", "2", ",", "scaledtlr", "=", "datetime", ".", "timedelta", "(", "seconds", "=", "_stlr", ")", ",", "scaledtls", "=", "datetime", ".", "timedelta", "(", "seconds", "=", "_stls", ")", ",", "psntp", "=", "_psnt", ",", "psnlr", "=", "_psnl", ",", "deltatlr", "=", "datetime", ".", "timedelta", "(", "seconds", "=", "_dtlr", ")", ",", "deltatls", "=", "datetime", ".", "timedelta", "(", "seconds", "=", "_dtls", ")", ",", ")", "return", "opt" ]

[ "Read", "HOPOPT", "PDM", "option", "." ]

[ "def", "_read_opt_qs", "(", "self", ",", "code", ",", "*", ",", "desc", ")", ":", "_type", "=", "self", ".", "_read_opt_type", "(", "code", ")", "_size", "=", "self", ".", "_read_unpack", "(", "1", ")", "if", "_size", "!=", "6", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {code}] invalid format'", ")", "_fcrr", "=", "self", ".", "_read_binary", "(", "1", ")", "_func", "=", "int", "(", "_fcrr", "[", ":", "4", "]", ",", "base", "=", "2", ")", "_rate", "=", "int", "(", "_fcrr", "[", "4", ":", "]", ",", "base", "=", "2", ")", "_ttlv", "=", "self", ".", "_read_unpack", "(", "1", ")", "_nonr", "=", "self", ".", "_read_binary", "(", "4", ")", "_qsnn", "=", "int", "(", "_nonr", "[", ":", "30", "]", ",", "base", "=", "2", ")", "if", "_func", "!=", "0", "and", "_func", "!=", "8", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {code}] invalid format'", ")", "data", "=", "dict", "(", "type", "=", "_type", ",", "length", "=", "_size", "+", "2", ",", "func", "=", "_QS_FUNC", ".", "get", "(", "_func", ")", ",", "rate", "=", "40000", "*", "(", "2", "**", "_rate", ")", "/", "1000", ",", "ttl", "=", "None", "if", "_func", "else", "_rate", ",", "nounce", "=", "_qsnn", ",", ")", "return", "data" ]

[ "Read", "HOPOPT", "Quick", "Start", "option", "." ]

[ "def", "_read_opt_rpl", "(", "self", ",", "code", ",", "*", ",", "desc", ")", ":", "_type", "=", "self", ".", "_read_opt_type", "(", "code", ")", "_size", "=", "self", ".", "_read_unpack", "(", "1", ")", "if", "_size", "<", "4", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {code}] invalid format'", ")", "_flag", "=", "self", ".", "_read_binary", "(", "1", ")", "_rpld", "=", "self", ".", "_read_unpack", "(", "1", ")", "_rank", "=", "self", ".", "_read_unpack", "(", "2", ")", "opt", "=", "dict", "(", "desc", "=", "desc", ",", "type", "=", "_type", ",", "length", "=", "_size", "+", "2", ",", "flags", "=", "dict", "(", "down", "=", "True", "if", "int", "(", "_flag", "[", "0", "]", ",", "base", "=", "2", ")", "else", "False", ",", "rank_error", "=", "True", "if", "int", "(", "_flag", "[", "1", "]", ",", "base", "=", "2", ")", "else", "False", ",", "fwd_error", "=", "True", "if", "int", "(", "_flag", "[", "2", "]", ",", "base", "=", "2", ")", "else", "False", ",", ")", ",", "id", "=", "_rpld", ",", "rank", "=", "_rank", ",", ")", "if", "_size", ">", "4", ":", "opt", "[", "'data'", "]", "=", "self", ".", "_read_fileng", "(", "_size", "-", "4", ")", "return", "opt" ]

[ "Read", "HOPOPT", "RPL", "option", "." ]

[ "def", "_read_opt_ilnp", "(", "self", ",", "code", ",", "*", ",", "desc", ")", ":", "_type", "=", "self", ".", "_read_opt_type", "(", "code", ")", "_size", "=", "self", ".", "_read_unpack", "(", "1", ")", "_nval", "=", "self", ".", "_read_fileng", "(", "_size", ")", "opt", "=", "dict", "(", "desc", "=", "desc", ",", "type", "=", "_type", ",", "length", "=", "_size", "+", "2", ",", "value", "=", "_nval", ",", ")", "return", "opt" ]

[ "Read", "HOPOPT", "ILNP", "Nonce", "option", "." ]

[ "def", "_read_opt_lio", "(", "self", ",", "code", ",", "*", ",", "desc", ")", ":", "_type", "=", "self", ".", "_read_opt_type", "(", "code", ")", "_size", "=", "self", ".", "_read_unpack", "(", "1", ")", "_llen", "=", "self", ".", "_read_unpack", "(", "1", ")", "_line", "=", "self", ".", "_read_fileng", "(", "_llen", ")", "opt", "=", "dict", "(", "desc", "=", "desc", ",", "type", "=", "_type", ",", "length", "=", "_size", "+", "2", ",", "lid_len", "=", "_llen", ",", "lid", "=", "_line", ",", ")", "_plen", "=", "_size", "-", "_llen", "if", "_plen", ":", "self", ".", "_read_fileng", "(", "_plen", ")", "return", "opt" ]

[ "Read", "HOPOPT", "Line", "-", "Identification", "option", "." ]

[ "def", "_read_opt_jumbo", "(", "self", ",", "code", ",", "*", ",", "desc", ")", ":", "_type", "=", "self", ".", "_read_opt_type", "(", "code", ")", "_size", "=", "self", ".", "_read_unpack", "(", "1", ")", "if", "_size", "!=", "4", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {code}] invalid format'", ")", "_jlen", "=", "self", ".", "_read_unpack", "(", "4", ")", "opt", "=", "dict", "(", "desc", "=", "desc", ",", "type", "=", "_type", ",", "length", "=", "_size", "+", "2", ",", "payload_len", "=", "_jlen", ",", ")", "return", "opt" ]

[ "Read", "HOPOPT", "Jumbo", "Payload", "option", "." ]

[ "def", "_read_opt_home", "(", "self", ",", "code", ",", "*", ",", "desc", ")", ":", "_type", "=", "self", ".", "_read_opt_type", "(", "code", ")", "_size", "=", "self", ".", "_read_unpack", "(", "1", ")", "if", "_size", "!=", "16", ":", "raise", "ProtocolError", "(", "f'{self.alias}: [Optno {code}] invalid format'", ")", "_addr", "=", "self", ".", "_read_fileng", "(", "16", ")", "opt", "=", "dict", "(", "desc", "=", "desc", ",", "type", "=", "_type", ",", "length", "=", "_size", "+", "2", ",", "ip", "=", "ipaddress", ".", "ip_address", "(", "_addr", ")", ",", ")", "return", "opt" ]

[ "Read", "HOPOPT", "Home", "Address", "option", "." ]