Lines Matching refs:self
47 def __init__(self, tf, nh, hlim, cid, sac, sam, m, dac, dam): argument
48 self._tf = tf
49 self._nh = nh
50 self._hlim = hlim
51 self._cid = cid
52 self._sac = sac
53 self._sam = sam
54 self._m = m
55 self._dac = dac
56 self._dam = dam
59 def tf(self): argument
60 return self._tf
63 def nh(self): argument
64 return self._nh
67 def hlim(self): argument
68 return self._hlim
71 def cid(self): argument
72 return self._cid
75 def sac(self): argument
76 return self._sac
79 def sam(self): argument
80 return self._sam
83 def m(self): argument
84 return self._m
87 def dac(self): argument
88 return self._dac
91 def dam(self): argument
92 return self._dam
117 def __repr__(self): argument
119 self.tf,
120 self.nh,
121 self.hlim,
122 self.cid,
123 self.sac,
124 self.sam,
125 self.m,
126 self.dac,
127 self.dam,
148 def __init__(self, eid, nh): argument
149 self._eid = eid
150 self._nh = nh
153 def eid(self): argument
154 return self._eid
157 def nh(self): argument
158 return self._nh
169 def __repr__(self): argument
170 return "LowpanNHC(eid={}, nh={})".format(self.eid, self.nh)
183 def __init__(self, c, p): argument
184 self._c = c
185 self._p = p
188 def c(self): argument
189 return self._c
192 def p(self): argument
193 return self._p
208 def __repr__(self): argument
209 return "LowpanUDPHC(c={}, p={})".format(self.c, self.p)
215 def __init__(self, hop_by_hop_options_factory): argument
216 self._hop_by_hop_options_factory = hop_by_hop_options_factory
218 def parse(self, data, next_header, message_info): argument
223 options = self._hop_by_hop_options_factory.parse(io.BytesIO(ext_header_data), message_info)
238 def __init__(self, ext_headers_factories): argument
239 … self._ext_headers_factories = (ext_headers_factories if ext_headers_factories is not None else {})
241 def _decompress_nh(self, hc, data): argument
242 if hc.nh == self.NHC_NH_INLINE:
245 elif hc.nh == self.NHC_NH_COMPRESSED:
248 def _get_ext_headers_factory(self, eid): argument
250 return self._ext_headers_factories[eid]
255 def parse(self, data, message_info): argument
258 next_header = self._decompress_nh(nhc, data)
260 factory = self._get_ext_headers_factory(nhc.eid)
276 def _decompress_udp_ports(self, udphc, data): argument
277 if udphc.p == self.UDP_HC_P_BOTH_FULL:
281 elif udphc.p == self.UDP_HC_P_DST_COMPR:
285 elif udphc.p == self.UDP_HC_P_SRC_COMPR:
289 elif udphc.p == self.UDP_HC_P_BOTH_COMPR:
296 def _decompress_udp_checksum(self, udphc, data): argument
297 if udphc.c == self.UDP_HC_C_INLINE:
300 if udphc.c == self.UDP_HC_C_ELIDED:
305 def parse(self, data, message_info): argument
308 src_port, dst_port = self._decompress_udp_ports(udphc, data)
310 checksum = self._decompress_udp_checksum(udphc, data)
319 def __init__(self, prefix, prefix_length=None): argument
326 self._prefix = bytearray(a.packed)
327 self._prefix_length = prefix_length
330 self._prefix = prefix
331 … self._prefix_length = (prefix_length if prefix_length is not None else len(self._prefix) * 8)
334 def prefix(self): argument
335 return self._prefix[:self.prefix_length_all_bytes]
338 def prefix_full_bytes(self): argument
339 return self._prefix[:self.prefix_length_full_bytes]
342 def prefix_length(self): argument
343 return self._prefix_length
346 def prefix_length_full_bytes(self): argument
347 return int(self._prefix_length / 8)
350 def prefix_length_rest_bits(self): argument
351 return int(self._prefix_length % 8)
354 def prefix_length_all_bytes(self): argument
355 if self.prefix_length_rest_bits > 0:
356 return self.prefix_length_full_bytes + 1
358 return self.prefix_length_full_bytes
364 def __check_index(self, index): argument
368 def __check_type(self, value): argument
372 def __getitem__(self, index): argument
373 self.__check_index(index)
375 return super(ContextManager, self).__getitem__(index)
377 def __setitem__(self, index, value): argument
378 self.__check_index(index)
379 self.__check_type(value)
381 return super(ContextManager, self).__setitem__(index, value)
438 def __init__(self, context_manager=None): argument
439 self._context_manager = context_manager
441 def _flow_label(self, data_bytes): argument
447 def _traffic_class(self, dscp, ecn): argument
450 def _unpack_dscp(self, data_byte): argument
453 def _unpack_ecn(self, data_byte): argument
456 def _decompress_tf_4bytes(self, data): argument
459 dscp = self._unpack_dscp(data_bytes[0])
460 ecn = self._unpack_ecn(data_bytes[0])
462 traffic_class = self._traffic_class(dscp, ecn)
463 flow_label = self._flow_label(data_bytes[1:])
467 def _decompress_tf_3bytes(self, data): argument
470 ecn = self._unpack_ecn(data_bytes[0])
472 traffic_class = self._traffic_class(dscp=0, ecn=ecn)
473 flow_label = self._flow_label(data_bytes)
477 def _decompress_tf_1byte(self, data): argument
480 dscp = self._unpack_dscp(data_byte)
481 ecn = self._unpack_ecn(data_byte)
483 traffic_class = self._traffic_class(dscp, ecn)
488 def _decompress_tf(self, iphc, data): argument
489 if iphc.tf == self.IPHC_TF_4B:
490 return self._decompress_tf_4bytes(data)
492 elif iphc.tf == self.IPHC_TF_3B:
493 return self._decompress_tf_3bytes(data)
495 elif iphc.tf == self.IPHC_TF_1B:
496 return self._decompress_tf_1byte(data)
498 elif iphc.tf == self.IPHC_TF_ELIDED:
501 def _decompress_nh(self, hc, data): argument
502 if hc.nh == self.IPHC_NH_INLINE:
505 elif hc.nh == self.IPHC_NH_COMPRESSED:
508 def _decompress_hlim(self, iphc, data): argument
509 if iphc.hlim == self.IPHC_HLIM_INLINE:
512 elif iphc.hlim == self.IPHC_HLIM_1:
515 elif iphc.hlim == self.IPHC_HLIM_64:
518 elif iphc.hlim == self.IPHC_HLIM_255:
521 def _decompress_cid(self, iphc, data): argument
522 if iphc.cid == self.IPHC_CID_SET:
530 elif iphc.cid == self.IPHC_CID_CLEAR:
533 def _decompress_src_addr_stateless(self, iphc, src_mac_addr, data): argument
534 if iphc.sam == self.IPHC_SAM_128B:
537 elif iphc.sam == self.IPHC_SAM_64B:
538 return self.IPV6_LINKLOCAL_PREFIX + bytearray(data.read(8))
540 elif iphc.sam == self.IPHC_SAM_16B:
541 … return (self.IPV6_LINKLOCAL_PREFIX + self.SHORT_ADDR_PADDING_BYTES + bytearray(data.read(2)))
543 elif iphc.sam == self.IPHC_SAM_ELIDED:
544 return self.IPV6_LINKLOCAL_PREFIX + src_mac_addr.convert_to_iid()
546 def _merge_prefix_with_address(self, prefix, prefix_length, address_bytes): argument
598 def _decompress_src_addr_stateful(self, iphc, src_mac_addr, sci, data): argument
599 if iphc.sam == self.IPHC_SAM_UNSPECIFIED:
602 elif iphc.sam == self.IPHC_SAM_64B:
603 context = self._context_manager[sci]
605 return self._merge_prefix_with_address(
611 elif iphc.sam == self.IPHC_SAM_16B:
612 context = self._context_manager[sci]
613 address_bytes = self.SHORT_ADDR_PADDING_BYTES + bytearray(data.read(2))
615 return self._merge_prefix_with_address(
621 elif iphc.sam == self.IPHC_SAM_0B:
622 context = self._context_manager[sci]
624 return self._merge_prefix_with_address(
630 def _decompress_src_addr(self, iphc, src_mac_addr, sci, data): argument
631 if iphc.sac == self.IPHC_SAC_STATELESS:
632 return self._decompress_src_addr_stateless(iphc, src_mac_addr, data)
634 elif iphc.sac == self.IPHC_SAC_STATEFUL:
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
638 if iphc.dam == self.IPHC_DAM_128B:
641 elif iphc.dam == self.IPHC_DAM_64B:
642 return self.IPV6_LINKLOCAL_PREFIX + bytearray(data.read(8))
644 elif iphc.dam == self.IPHC_DAM_16B:
645 … return (self.IPV6_LINKLOCAL_PREFIX + self.SHORT_ADDR_PADDING_BYTES + bytearray(data.read(2)))
647 elif iphc.dam == self.IPHC_DAM_ELIDED:
648 return self.IPV6_LINKLOCAL_PREFIX + dst_mac_addr.convert_to_iid()
650 def _decompress_unicast_dst_addr_stateful(self, iphc, dst_mac_addr, dci, data): argument
651 if iphc.dam == self.IPHC_DAM_128B:
654 elif iphc.dam == self.IPHC_DAM_64B:
655 context = self._context_manager[dci]
657 return self._merge_prefix_with_address(
663 elif iphc.dam == self.IPHC_DAM_16B:
664 context = self._context_manager[dci]
665 address_bytes = self.SHORT_ADDR_PADDING_BYTES + bytearray(data.read(2))
667 return self._merge_prefix_with_address(
673 elif iphc.dam == self.IPHC_DAM_0B:
674 context = self._context_manager[dci]
676 return self._merge_prefix_with_address(
682 def _decompress_unicast_dst_addr(self, iphc, dst_mac_addr, dci, data): argument
683 if iphc.dac == self.IPHC_DAC_STATELESS:
684 return self._decompress_unicast_dst_addr_stateless(iphc, dst_mac_addr, data)
686 elif iphc.dac == self.IPHC_DAC_STATEFUL:
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
690 if iphc.dam == self.IPHC_DAM_128B:
693 elif iphc.dam == self.IPHC_DAM_48B:
697 elif iphc.dam == self.IPHC_DAM_32B:
701 elif iphc.dam == self.IPHC_DAM_8B:
704 def _decompress_multicast_dst_addr_stateful(self, iphc, dci, data): argument
705 if iphc.dam == self.IPHC_M_DAM_00:
706 context = self._context_manager[dci]
722 elif iphc.dam == self.IPHC_M_DAM_01:
725 elif iphc.dam == self.IPHC_M_DAM_10:
728 elif iphc.dam == self.IPHC_M_DAM_11:
731 def _decompress_multicast_dst_addr(self, iphc, dci, data): argument
732 if iphc.dac == self.IPHC_DAC_STATELESS:
733 return self._decompress_multicast_dst_addr_stateless(iphc, data)
735 elif iphc.dac == self.IPHC_DAC_STATEFUL:
736 return self._decompress_multicast_dst_addr_stateful(iphc, dci, data)
738 def _decompress_dst_addr(self, iphc, dst_mac_addr, dci, data): argument
739 if iphc.m == self.IPHC_M_NO:
740 return self._decompress_unicast_dst_addr(iphc, dst_mac_addr, dci, data)
742 elif iphc.m == self.IPHC_M_YES:
743 return self._decompress_multicast_dst_addr(iphc, dci, data)
745 def set_lowpan_context(self, cid, prefix): argument
746 self._context_manager[cid] = Context(prefix)
748 def parse(self, data, message_info): argument
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)
774 self, argument
779 self._lowpan_ip_header_factory = lowpan_ip_header_factory
780 self._lowpan_extension_headers_factory = (lowpan_extension_headers_factory)
781 self._lowpan_udp_header_factory = lowpan_udp_header_factory
783 def _is_ipv6_extension_header(self, header_first_byte): argument
786 def _is_udp_header(self, header_first_byte): argument
789 def _peek_n_bytes(self, data, n): argument
794 def _is_next_header_compressed(self, header): argument
797 def set_lowpan_context(self, cid, prefix): argument
798 self._lowpan_ip_header_factory.set_lowpan_context(cid, prefix)
800 def decompress(self, data, message_info): argument
801 ipv6_header = self._lowpan_ip_header_factory.parse(data, message_info)
808 if self._is_next_header_compressed(ipv6_header):
811 header_first_byte = ord(self._peek_n_bytes(data, 1))
813 if self._is_ipv6_extension_header(header_first_byte):
814 … extension_header = self._lowpan_extension_headers_factory.parse(data, message_info)
821 if not self._is_next_header_compressed(extension_header):
825 elif self._is_udp_header(header_first_byte):
826 udp_header = self._lowpan_udp_header_factory.parse(data, message_info)
840 def __init__(self, hops_left, originator_address, final_destination_address): argument
841 self._hops_left = hops_left
842 self._originator_address = originator_address
843 self._final_destination_address = final_destination_address
846 def hops_left(self): argument
847 return self._hops_left
850 def originator_address(self): argument
851 return self._originator_address
854 def final_destination_address(self): argument
855 return self._final_destination_address
860 def _parse_address(self, data, is_short): argument
866 def parse(self, data, message_info): argument
877 originator_address = self._parse_address(data, is_short_originator_address)
878 final_destination_address = self._parse_address(data, is_short_final_destination_address)
885 def __init__(self, datagram_size, datagram_tag, datagram_offset=0): argument
886 self._datagram_size = datagram_size
887 self._datagram_tag = datagram_tag
888 self._datagram_offset = datagram_offset
891 def datagram_size(self): argument
892 return self._datagram_size
895 def datagram_tag(self): argument
896 return self._datagram_tag
899 def datagram_offset(self): argument
900 return self._datagram_offset
903 def is_first(self): argument
904 return self.datagram_offset == 0
923 def __init__(self, buffer_size): argument
924 self._buffer = [None] * buffer_size
925 self._position = 0
927 def write(self, data): argument
928 if (self._position + len(data)) > len(self._buffer):
932 self._buffer[self._position + i] = byte
934 self._position += len(data)
937 def seek(self, offset): argument
938 if offset >= len(self._buffer):
941 self._position = offset
943 def tell(self): argument
944 return self._position
946 def whole_packet_received(self): argument
947 return all([byte is not None for byte in self._buffer])
949 def read(self): argument
950 if not self.whole_packet_received():
953 return bytearray(self._buffer)
955 def __len__(self): argument
956 return len(self._buffer)
961 def __init__(self): argument
962 self._fragments_buffers = {}
964 def _create_key(self, message_info, datagram_tag): argument
969 def _allocate_fragments_buffer(self, key, datagram_size): argument
975 self._fragments_buffers[key] = fragments_buffer
978 def get_fragments_buffer(self, message_info, datagram_tag, datagram_size=None): argument
979 key = self._create_key(message_info, datagram_tag)
981 if key not in self._fragments_buffers:
982 self._allocate_fragments_buffer(key, datagram_size)
984 return self._fragments_buffers[key]
986 def free_fragments_buffer(self, message_info, datagram_tag): argument
987 key = self._create_key(message_info, datagram_tag)
989 del self._fragments_buffers[key]
995 self, argument
1001 self._lowpan_mesh_header_factory = lowpan_mesh_header_factory
1002 self._lowpan_decompressor = lowpan_decompressor
1003 self._lowpan_fragments_buffers_manager = (lowpan_fragements_buffers_manager)
1004 self._ipv6_packet_factory = ipv6_packet_factory
1006 def _peek_n_bytes(self, data, n): argument
1011 def _is_mesh_header(self, first_byte): argument
1014 def _is_first_fragmentation_header(self, first_byte): argument
1017 def _is_subsequent_fragmentation_header(self, first_byte): argument
1020 def _is_iphc(self, first_byte): argument
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
1029 fragments_buffer = self._lowpan_fragments_buffers_manager.get_fragments_buffer(
1035 ipv6_header, extension_headers, udp_header = self._decompress_iphc(data, message_info)
1056 self._lowpan_fragments_buffers_manager.free_fragments_buffer(message_info,
1059 return self._ipv6_packet_factory.parse(data, message_info)
1063 def _handle_subsequent_fragmentation_header(self, data, message_info): argument
1066 fragments_buffer = self._lowpan_fragments_buffers_manager.get_fragments_buffer(
1080 self._lowpan_fragments_buffers_manager.free_fragments_buffer(message_info,
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)
1108 return self._ipv6_packet_factory.parse(io.BytesIO(decompressed_data), message_info)
1110 def set_lowpan_context(self, cid, prefix): argument
1111 self._lowpan_decompressor.set_lowpan_context(cid, prefix)
1113 def parse(self, data, message_info): argument
1116 first_byte = ord(self._peek_n_bytes(data, n=1))
1118 if self._is_mesh_header(first_byte):
1119 mesh_header = self._lowpan_mesh_header_factory.parse(data, message_info)
1124 elif self._is_first_fragmentation_header(first_byte):
1125 return self._handle_first_fragmentation_header(data, message_info)
1127 elif self._is_subsequent_fragmentation_header(first_byte):
1128 return self._handle_subsequent_fragmentation_header(data, message_info)
1130 elif self._is_iphc(first_byte):
1131 return self._handle_iphc_header(data, message_info)