67 def calculate_checksum(data):  argument
81 …halfwords = [((byte0 << 8) | byte1) for byte0, byte1 in zip_longest(data[::2], data[1::2], fillval…
118     def parse(self, data, message_info):  argument
133     def from_bytes(cls, data):  argument
250         data = bytearray()
251         data += self.source_address.packed
252         data += self.destination_address.packed
253         data += struct.pack(">I", self.payload_length)
254         data += struct.pack(">I", self.next_header)
256         return data
304         data = bytearray([
310         data += struct.pack(">H", self.payload_length)
311         data += bytearray([self.next_header, self.hop_limit])
312         data += self.source_address.packed
313         data += self.destination_address.packed
315         return data
318     def from_bytes(cls, data):  argument
319         b = bytearray(data.read(4))
325         payload_length = struct.unpack(">H", data.read(2))[0]
326         next_header = ord(data.read(1))
327         hop_limit = ord(data.read(1))
328         src_addr = bytearray(data.read(16))
329         dst_addr = bytearray(data.read(16))
502         data = struct.pack(">H", self.src_port)
503         data += struct.pack(">H", self.dst_port)
504         data += struct.pack(">H", self.payload_length)
505         data += struct.pack(">H", self.checksum)
507         return data
510     def from_bytes(cls, data):  argument
511         src_port = struct.unpack(">H", data.read(2))[0]
512         dst_port = struct.unpack(">H", data.read(2))[0]
513         payload_length = struct.unpack(">H", data.read(2))[0]
514         checksum = struct.unpack(">H", data.read(2))[0]
549         data = bytearray()
550         data += self.header.to_bytes()
551         data += self.payload.to_bytes()
552         return data
577     def from_bytes(cls, data):  argument
578         _type = ord(data.read(1))
579         code = ord(data.read(1))
580         checksum = struct.unpack(">H", data.read(2))[0]
658         data = bytearray([self.next_header, 0x00])
659 … data += bytearray([self._fragm_offset >> 5, ((self._fragm_offset << 3) | self._more_flag) & 0xff])
660         data += struct.pack(">I", self._identification)
662         return data
665     def from_bytes(cls, data):  argument
666         next_header = struct.unpack(">B", data.read(1))[0]
667         struct.unpack(">B", data.read(1))[0]  # reserved
668         fragment_offset = struct.unpack(">H", data.read(2))[0]
670         identificaton = struct.unpack(">I", data.read(4))[0]
724         data = bytearray([self.next_header, self.hdr_ext_len])
727             data += option.to_bytes()
734         excess_bytes = len(data) & 0x7
740                 data += bytearray([self._one_byte_padding])
744                 data += bytearray([self._many_bytes_padding, padding_length])
745                 data += bytearray([0x00 for _ in range(padding_length)])
747         return data
772     def from_bytes(cls, data):  argument
773         _type = ord(data.read(1))
774         length = ord(data.read(1))
834     def from_bytes(cls, data):  argument
835         b = ord(data.read(1))
841         sequence = ord(data.read(1))
842         seed_id = data.read(cls._seed_id_length[s])
922     def _parse_extension_headers(self, data, next_header, message_info):  argument
928             extension_header = factory.parse(data, message_info)
936     def _parse_upper_layer_protocol(self, data, next_header, message_info):  argument
939         return factory.parse(data, message_info)
941     def parse(self, data, message_info):  argument
942         ipv6_header = IPv6Header.from_bytes(data)
947 …next_header, extension_headers = self._parse_extension_headers(data, ipv6_header.next_header, mess…
949         upper_layer_protocol = self._parse_upper_layer_protocol(data, next_header, message_info)
969     def parse(self, data, message_info):  argument
972         while data.tell() < len(data.getvalue()):
973             option_header = HopByHopOptionHeader.from_bytes(data)
977                 data.read(1)
981                 data.read(option_header.length)
986                 option_data = data.read(option_header.length)
1007     def parse(self, data, message_info):  argument
1008         next_header = ord(data.read(1))
1010         hdr_ext_len = ord(data.read(1))
1016         hop_by_hop_data = data.read(hop_by_hop_length)
1030     def parse(self, data, message_info):  argument
1031         return MPLOption.from_bytes(data)
1037     def parse(self, data, message_info):  argument
1038         return UDPHeader.from_bytes(data)
1055     def parse(self, data, message_info):  argument
1070         return factory.parse(data, message_info)
1082     def parse(self, data, message_info):  argument
1083         header = self._udp_header_factory.parse(data, message_info)
1086         message_info.payload_length += len(header) + (len(data.getvalue()) - data.tell())
1091         payload = self._udp_payload_factory.parse(data, message_info)
1118     def parse(self, data, message_info):  argument
1119         header = ICMPv6Header.from_bytes(data)
1123         message_info.payload_length += len(header) + (len(data.getvalue()) - data.tell())
1125         return ICMPv6(header, factory.parse(data, message_info))
1131     def parse(self, data, message_info):  argument
1132         return ICMPv6EchoBody.from_bytes(data)
1138     def __init__(self, data):  argument
1139         self.data = data
1142         return bytearray(self.data)
1145     def from_bytes(cls, data):  argument
1146         return cls(data)
1149         return len(self.data)
1155     def parse(self, data, message_info):  argument
1156         return BytesPayload(data.read())
1164     def __init__(self, identifier, sequence_number, data):  argument
1167         self.data = data
1170         data = struct.pack(">H", self.identifier)
1171         data += struct.pack(">H", self.sequence_number)
1172         data += self.data
1173         return data
1176     def from_bytes(cls, data):  argument
1177         identifier = struct.unpack(">H", data.read(2))[0]
1178         sequence_number = struct.unpack(">H", data.read(2))[0]
1180         return cls(identifier, sequence_number, data.read())
1183         return self._header_length + len(self.data)
1189     def parse(self, data, message_info):  argument
1190         return ICMPv6DestinationUnreachable.from_bytes(data)
1199     def __init__(self, data):  argument
1200         self.data = data
1203         data = bytearray(struct.pack(">I", self._unused))
1204         data += self.data
1205         return data
1208     def from_bytes(cls, data):  argument
1209         unused = struct.unpack(">I", data.read(4))[0]
1214         return cls(bytearray(data.read()))
1217         return self._header_length + len(self.data)