218     def parse(self, data, next_header, message_info):  argument
219         ext_header_length = ord(data.read(1))
221         ext_header_data = data.read(ext_header_length)
241     def _decompress_nh(self, hc, data):  argument
243             return ord(data.read(1))
255     def parse(self, data, message_info):  argument
256         nhc = LowpanNHC.from_bytes(bytearray(data.read(1)))
258         next_header = self._decompress_nh(nhc, data)
262         return factory.parse(data, next_header, message_info)
276     def _decompress_udp_ports(self, udphc, data):  argument
278             src_port = struct.unpack(">H", data.read(2))[0]
279             dst_port = struct.unpack(">H", data.read(2))[0]
282             src_port = struct.unpack(">H", data.read(2))[0]
283             dst_port = 0xf000 + ord(data.read(1))
286             src_port = 0xf000 + ord(data.read(1))
287             dst_port = struct.unpack(">H", data.read(2))[0]
290             udp_ports_byte = ord(data.read(1))
296     def _decompress_udp_checksum(self, udphc, data):  argument
298             checksum = struct.unpack(">H", data.read(2))[0]
305     def parse(self, data, message_info):  argument
306         udphc = LowpanUDPHC.from_bytes(bytearray(data.read(1)))
308         src_port, dst_port = self._decompress_udp_ports(udphc, data)
310         checksum = self._decompress_udp_checksum(udphc, data)
456     def _decompress_tf_4bytes(self, data):  argument
457         data_bytes = [b for b in bytearray(data.read(4))]
467     def _decompress_tf_3bytes(self, data):  argument
468         data_bytes = [b for b in bytearray(data.read(3))]
477     def _decompress_tf_1byte(self, data):  argument
478         data_byte = ord(data.read(1))
488     def _decompress_tf(self, iphc, data):  argument
490             return self._decompress_tf_4bytes(data)
493             return self._decompress_tf_3bytes(data)
496             return self._decompress_tf_1byte(data)
501     def _decompress_nh(self, hc, data):  argument
503             return ord(data.read(1))
508     def _decompress_hlim(self, iphc, data):  argument
510             return ord(data.read(1))
521     def _decompress_cid(self, iphc, data):  argument
523             cid = ord(data.read(1))
533     def _decompress_src_addr_stateless(self, iphc, src_mac_addr, data):  argument
535             return bytearray(data.read(16))
538             return self.IPV6_LINKLOCAL_PREFIX + bytearray(data.read(8))
541 …      return (self.IPV6_LINKLOCAL_PREFIX + self.SHORT_ADDR_PADDING_BYTES + bytearray(data.read(2)))
598     def _decompress_src_addr_stateful(self, iphc, src_mac_addr, sci, data):  argument
608                 address_bytes=bytearray(data.read(8)),
613             address_bytes = self.SHORT_ADDR_PADDING_BYTES + bytearray(data.read(2))
630     def _decompress_src_addr(self, iphc, src_mac_addr, sci, data):  argument
632             return self._decompress_src_addr_stateless(iphc, src_mac_addr, data)
635             return self._decompress_src_addr_stateful(iphc, src_mac_addr, sci, data)
637     def _decompress_unicast_dst_addr_stateless(self, iphc, dst_mac_addr, data):  argument
639             return bytearray(data.read(16))
642             return self.IPV6_LINKLOCAL_PREFIX + bytearray(data.read(8))
645 …      return (self.IPV6_LINKLOCAL_PREFIX + self.SHORT_ADDR_PADDING_BYTES + bytearray(data.read(2)))
650     def _decompress_unicast_dst_addr_stateful(self, iphc, dst_mac_addr, dci, data):  argument
660                 address_bytes=bytearray(data.read(8)),
665             address_bytes = self.SHORT_ADDR_PADDING_BYTES + bytearray(data.read(2))
682     def _decompress_unicast_dst_addr(self, iphc, dst_mac_addr, dci, data):  argument
684             return self._decompress_unicast_dst_addr_stateless(iphc, dst_mac_addr, data)
687             return self._decompress_unicast_dst_addr_stateful(iphc, dst_mac_addr, dci, data)
689     def _decompress_multicast_dst_addr_stateless(self, iphc, data):  argument
691             return bytearray(data.read(16))
694             addr48b = bytearray(data.read(6))
698             addr32b = bytearray(data.read(4))
702             return (bytearray([0xff, 0x02]) + bytearray([0x00] * 13) + data.read(1))
704     def _decompress_multicast_dst_addr_stateful(self, iphc, dci, data):  argument
708             addr48b = bytearray(data.read(6))
731     def _decompress_multicast_dst_addr(self, iphc, dci, data):  argument
733             return self._decompress_multicast_dst_addr_stateless(iphc, data)
736             return self._decompress_multicast_dst_addr_stateful(iphc, dci, data)
738     def _decompress_dst_addr(self, iphc, dst_mac_addr, dci, data):  argument
740             return self._decompress_unicast_dst_addr(iphc, dst_mac_addr, dci, data)
743             return self._decompress_multicast_dst_addr(iphc, dci, data)
748     def parse(self, data, message_info):  argument
749         iphc = LowpanIPHC.from_bytes(bytearray(data.read(2)))
751         sci, dci = self._decompress_cid(iphc, data)
753         traffic_class, flow_label = self._decompress_tf(iphc, data)
755         next_header = self._decompress_nh(iphc, data)
757         hop_limit = self._decompress_hlim(iphc, data)
759         src_address = self._decompress_src_addr(iphc, message_info.source_mac_address, sci, data)
761 …     dst_address = self._decompress_dst_addr(iphc, message_info.destination_mac_address, dci, data)
789     def _peek_n_bytes(self, data, n):  argument
790         read_data = data.read(n)
791         data.seek(-n, io.SEEK_CUR)
800     def decompress(self, data, message_info):  argument
801         ipv6_header = self._lowpan_ip_header_factory.parse(data, message_info)
810             while data.tell() < len(data.getvalue()):
811                 header_first_byte = ord(self._peek_n_bytes(data, 1))
814 …                extension_header = self._lowpan_extension_headers_factory.parse(data, message_info)
826                     udp_header = self._lowpan_udp_header_factory.parse(data, message_info)
860     def _parse_address(self, data, is_short):  argument
862             return common.MacAddress.from_rloc16(bytearray(data.read(2)))
864             return common.MacAddress.from_eui64(bytearray(data.read(8)))
866     def parse(self, data, message_info):  argument
867         data_byte = ord(data.read(1))
875             hops_left = ord(data.read(1))
877         originator_address = self._parse_address(data, is_short_originator_address)
878         final_destination_address = self._parse_address(data, is_short_final_destination_address)
907     def from_bytes(cls, data):  argument
908         datagram_size = struct.unpack(">H", data.read(2))[0]
912         datagram_tag = struct.unpack(">H", data.read(2))[0]
916             datagram_offset = ord(data.read(1))
927     def write(self, data):  argument
928         if (self._position + len(data)) > len(self._buffer):
931         for i, byte in enumerate(data):
934         self._position += len(data)
935         return len(data)
1006     def _peek_n_bytes(self, data, n):  argument
1007         data_bytes = data.read(n)
1008         data.seek(-n, io.SEEK_CUR)
1023     def _decompress_iphc(self, data, message_info):  argument
1024         return self._lowpan_decompressor.decompress(data, message_info)
1026     def _handle_first_fragmentation_header(self, data, message_info):  argument
1027         fragmentation_header = LowpanFragmentationHeader.from_bytes(data)
1035         ipv6_header, extension_headers, udp_header = self._decompress_iphc(data, message_info)
1037         uncompressed_data = data.read()
1054             data = io.BytesIO(fragments_buffer.read())
1059             return self._ipv6_packet_factory.parse(data, message_info)
1063     def _handle_subsequent_fragmentation_header(self, data, message_info):  argument
1064         fragmentation_header = LowpanFragmentationHeader.from_bytes(data)
1075         fragments_buffer.write(data.read())
1078             data = io.BytesIO(fragments_buffer.read())
1083             return self._ipv6_packet_factory.parse(data, message_info)
1087     def _handle_iphc_header(self, data, message_info):  argument
1088         ipv6_header, extension_headers, udp_header = self._decompress_iphc(data, message_info)
1090         uncompressed_data = data.read()
1113     def parse(self, data, message_info):  argument
1115         while data.tell() < len(data.getvalue()):
1116             first_byte = ord(self._peek_n_bytes(data, n=1))
1119                 mesh_header = self._lowpan_mesh_header_factory.parse(data, message_info)
1125                 return self._handle_first_fragmentation_header(data, message_info)
1128                 return self._handle_subsequent_fragmentation_header(data, message_info)
1131                 return self._handle_iphc_header(data, message_info)