Se reinstalo ryu para configurar STP y que el restAPI no sea publico(127.0.0.1)
[vsorcdistro/.git] / ryu / ryu / lib / packet / icmpv6.py
1 # Copyright (C) 2012 Nippon Telegraph and Telephone Corporation.
2 #
3 # Licensed under the Apache License, Version 2.0 (the "License");
4 # you may not use this file except in compliance with the License.
5 # You may obtain a copy of the License at
6 #
7 #    http://www.apache.org/licenses/LICENSE-2.0
8 #
9 # Unless required by applicable law or agreed to in writing, software
10 # distributed under the License is distributed on an "AS IS" BASIS,
11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
12 # implied.
13 # See the License for the specific language governing permissions and
14 # limitations under the License.
15
16 import abc
17 import struct
18 import six
19 import sys
20 import array
21 import binascii
22
23 from . import packet_base
24 from . import packet_utils
25 from ryu.lib import addrconv
26 from ryu.lib import stringify
27
28 ICMPV6_DST_UNREACH = 1       # dest unreachable, codes:
29 ICMPV6_PACKET_TOO_BIG = 2       # packet too big
30 ICMPV6_TIME_EXCEEDED = 3       # time exceeded, code:
31 ICMPV6_PARAM_PROB = 4       # ip6 header bad
32
33 ICMPV6_ECHO_REQUEST = 128     # echo service
34 ICMPV6_ECHO_REPLY = 129     # echo reply
35 MLD_LISTENER_QUERY = 130     # multicast listener query
36 MLD_LISTENER_REPOR = 131     # multicast listener report
37 MLD_LISTENER_DONE = 132     # multicast listener done
38 MLDV2_LISTENER_REPORT = 143     # multicast listern report (v2)
39
40 # RFC2292 decls
41 ICMPV6_MEMBERSHIP_QUERY = 130     # group membership query
42 ICMPV6_MEMBERSHIP_REPORT = 131     # group membership report
43 ICMPV6_MEMBERSHIP_REDUCTION = 132     # group membership termination
44
45 ND_ROUTER_SOLICIT = 133     # router solicitation
46 ND_ROUTER_ADVERT = 134     # router advertisment
47 ND_NEIGHBOR_SOLICIT = 135     # neighbor solicitation
48 ND_NEIGHBOR_ADVERT = 136     # neighbor advertisment
49 ND_REDIREC = 137     # redirect
50
51 ICMPV6_ROUTER_RENUMBERING = 138     # router renumbering
52
53 ICMPV6_WRUREQUEST = 139     # who are you request
54 ICMPV6_WRUREPLY = 140     # who are you reply
55 ICMPV6_FQDN_QUERY = 139     # FQDN query
56 ICMPV6_FQDN_REPLY = 140     # FQDN reply
57 ICMPV6_NI_QUERY = 139     # node information request
58 ICMPV6_NI_REPLY = 140     # node information reply
59
60 ICMPV6_MAXTYPE = 201
61
62 # ND_OPTIONS from RFC 4861
63 ND_OPTION_SLA = 1  # Source Link-Layer Address
64 ND_OPTION_TLA = 2  # Target Link-Layer Address
65 ND_OPTION_PI = 3   # Prefix Information
66 ND_OPTION_RH = 4   # Redirected Header
67 ND_OPTION_MTU = 5  # MTU
68
69 MODE_IS_INCLUDE = 1
70 MODE_IS_EXCLUDE = 2
71 CHANGE_TO_INCLUDE_MODE = 3
72 CHANGE_TO_EXCLUDE_MODE = 4
73 ALLOW_NEW_SOURCES = 5
74 BLOCK_OLD_SOURCES = 6
75
76
77 class icmpv6(packet_base.PacketBase):
78     r"""ICMPv6 (RFC 2463) header encoder/decoder class.
79
80     An instance has the following attributes at least.
81     Most of them are same to the on-wire counterparts but in host byte order.
82     __init__ takes the corresponding args in this order.
83
84     .. tabularcolumns:: |l|p{35em}|
85
86     ============== ====================
87     Attribute      Description
88     ============== ====================
89     type\_         Type
90     code           Code
91     csum           CheckSum
92                    (0 means automatically-calculate when encoding)
93     data           Payload.
94
95                    ryu.lib.packet.icmpv6.echo object, \
96                    ryu.lib.packet.icmpv6.nd_neighbor object, \
97                    ryu.lib.packet.icmpv6.nd_router_solicit object, \
98                    ryu.lib.packet.icmpv6.nd_router_advert object, \
99                    ryu.lib.packet.icmpv6.mld object, \
100                    or a bytearray.
101     ============== ====================
102     """
103     _PACK_STR = '!BBH'
104     _MIN_LEN = struct.calcsize(_PACK_STR)
105     _ICMPV6_TYPES = {}
106
107     @staticmethod
108     def register_icmpv6_type(*args):
109         def _register_icmpv6_type(cls):
110             for type_ in args:
111                 icmpv6._ICMPV6_TYPES[type_] = cls
112             return cls
113         return _register_icmpv6_type
114
115     def __init__(self, type_=0, code=0, csum=0, data=b''):
116         super(icmpv6, self).__init__()
117         self.type_ = type_
118         self.code = code
119         self.csum = csum
120         self.data = data
121
122     @classmethod
123     def parser(cls, buf):
124         (type_, code, csum) = struct.unpack_from(cls._PACK_STR, buf)
125         msg = cls(type_, code, csum)
126         offset = cls._MIN_LEN
127         if len(buf) > offset:
128             cls_ = cls._ICMPV6_TYPES.get(type_, None)
129             if cls_:
130                 msg.data = cls_.parser(buf, offset)
131             else:
132                 msg.data = buf[offset:]
133
134         return msg, None, None
135
136     def serialize(self, payload, prev):
137         hdr = bytearray(struct.pack(icmpv6._PACK_STR, self.type_,
138                                     self.code, self.csum))
139
140         if self.data:
141             if self.type_ in icmpv6._ICMPV6_TYPES:
142                 assert isinstance(self.data, _ICMPv6Payload)
143                 hdr += self.data.serialize()
144             else:
145                 hdr += self.data
146         if self.csum == 0:
147             self.csum = packet_utils.checksum_ip(prev, len(hdr), hdr + payload)
148             struct.pack_into('!H', hdr, 2, self.csum)
149
150         return hdr
151
152     def __len__(self):
153         return self._MIN_LEN + len(self.data)
154
155
156 @six.add_metaclass(abc.ABCMeta)
157 class _ICMPv6Payload(stringify.StringifyMixin):
158     """
159     Base class for the payload of ICMPv6 packet.
160     """
161
162
163 @icmpv6.register_icmpv6_type(ND_NEIGHBOR_SOLICIT, ND_NEIGHBOR_ADVERT)
164 class nd_neighbor(_ICMPv6Payload):
165     """ICMPv6 sub encoder/decoder class for Neighbor Solicitation and
166     Neighbor Advertisement messages. (RFC 4861)
167
168     This is used with ryu.lib.packet.icmpv6.icmpv6.
169
170     An instance has the following attributes at least.
171     Most of them are same to the on-wire counterparts but in host byte order.
172     __init__ takes the corresponding args in this order.
173
174     .. tabularcolumns:: |l|p{35em}|
175
176     ============== ====================
177     Attribute      Description
178     ============== ====================
179     res            R,S,O Flags for Neighbor Advertisement. \
180                    The 3 MSBs of "Reserved" field for Neighbor Solicitation.
181     dst            Target Address
182     option         a derived object of ryu.lib.packet.icmpv6.nd_option \
183                    or a bytearray. None if no options.
184     ============== ====================
185     """
186
187     _PACK_STR = '!I16s'
188     _MIN_LEN = struct.calcsize(_PACK_STR)
189     _ND_OPTION_TYPES = {}
190     _TYPE = {
191         'ascii': [
192             'dst'
193         ]
194     }
195
196     @staticmethod
197     def register_nd_option_type(*args):
198         def _register_nd_option_type(cls):
199             nd_neighbor._ND_OPTION_TYPES[cls.option_type()] = cls
200             return cls
201         return _register_nd_option_type(args[0])
202
203     def __init__(self, res=0, dst='::', option=None):
204         self.res = res
205         self.dst = dst
206         self.option = option
207
208     @classmethod
209     def parser(cls, buf, offset):
210         (res, dst) = struct.unpack_from(cls._PACK_STR, buf, offset)
211         offset += cls._MIN_LEN
212         option = None
213         if len(buf) > offset:
214             (type_, length) = struct.unpack_from('!BB', buf, offset)
215             if length == 0:
216                 raise struct.error('Invalid length: {len}'.format(len=length))
217             cls_ = cls._ND_OPTION_TYPES.get(type_)
218             if cls_ is not None:
219                 option = cls_.parser(buf, offset)
220             else:
221                 option = buf[offset:]
222         msg = cls(res >> 29, addrconv.ipv6.bin_to_text(dst), option)
223         return msg
224
225     def serialize(self):
226         res = self.res << 29
227         hdr = bytearray(struct.pack(
228             nd_neighbor._PACK_STR, res,
229             addrconv.ipv6.text_to_bin(self.dst)))
230         if self.option is not None:
231             if isinstance(self.option, nd_option):
232                 hdr.extend(self.option.serialize())
233             else:
234                 hdr.extend(self.option)
235         return six.binary_type(hdr)
236
237     def __len__(self):
238         length = self._MIN_LEN
239         if self.option is not None:
240             length += len(self.option)
241         return length
242
243
244 @icmpv6.register_icmpv6_type(ND_ROUTER_SOLICIT)
245 class nd_router_solicit(_ICMPv6Payload):
246     """ICMPv6 sub encoder/decoder class for Router Solicitation messages.
247     (RFC 4861)
248
249     This is used with ryu.lib.packet.icmpv6.icmpv6.
250
251     An instance has the following attributes at least.
252     Most of them are same to the on-wire counterparts but in host byte order.
253     __init__ takes the corresponding args in this order.
254
255     .. tabularcolumns:: |l|p{35em}|
256
257     ============== ====================
258     Attribute      Description
259     ============== ====================
260     res            This field is unused.  It MUST be initialized to zero.
261     option         a derived object of ryu.lib.packet.icmpv6.nd_option \
262                    or a bytearray. None if no options.
263     ============== ====================
264     """
265
266     _PACK_STR = '!I'
267     _MIN_LEN = struct.calcsize(_PACK_STR)
268     _ND_OPTION_TYPES = {}
269
270     @staticmethod
271     def register_nd_option_type(*args):
272         def _register_nd_option_type(cls):
273             nd_router_solicit._ND_OPTION_TYPES[cls.option_type()] = cls
274             return cls
275         return _register_nd_option_type(args[0])
276
277     def __init__(self, res=0, option=None):
278         self.res = res
279         self.option = option
280
281     @classmethod
282     def parser(cls, buf, offset):
283         (res, ) = struct.unpack_from(cls._PACK_STR, buf, offset)
284         offset += cls._MIN_LEN
285         option = None
286         if len(buf) > offset:
287             (type_, length) = struct.unpack_from('!BB', buf, offset)
288             if length == 0:
289                 raise struct.error('Invalid length: {len}'.format(len=length))
290             cls_ = cls._ND_OPTION_TYPES.get(type_)
291             if cls_ is not None:
292                 option = cls_.parser(buf, offset)
293             else:
294                 option = buf[offset:]
295         msg = cls(res, option)
296         return msg
297
298     def serialize(self):
299         hdr = bytearray(struct.pack(
300             nd_router_solicit._PACK_STR, self.res))
301         if self.option is not None:
302             if isinstance(self.option, nd_option):
303                 hdr.extend(self.option.serialize())
304             else:
305                 hdr.extend(self.option)
306         return six.binary_type(hdr)
307
308     def __len__(self):
309         length = self._MIN_LEN
310         if self.option is not None:
311             length += len(self.option)
312         return length
313
314
315 @icmpv6.register_icmpv6_type(ND_ROUTER_ADVERT)
316 class nd_router_advert(_ICMPv6Payload):
317     """ICMPv6 sub encoder/decoder class for Router Advertisement messages.
318     (RFC 4861)
319
320     This is used with ryu.lib.packet.icmpv6.icmpv6.
321
322     An instance has the following attributes at least.
323     Most of them are same to the on-wire counterparts but in host byte order.
324     __init__ takes the corresponding args in this order.
325
326     .. tabularcolumns:: |l|p{35em}|
327
328     ============== ====================
329     Attribute      Description
330     ============== ====================
331     ch_l           Cur Hop Limit.
332     res            M,O Flags for Router Advertisement.
333     rou_l          Router Lifetime.
334     rea_t          Reachable Time.
335     ret_t          Retrans Timer.
336     options        List of a derived object of \
337                    ryu.lib.packet.icmpv6.nd_option or a bytearray. \
338                    None if no options.
339     ============== ====================
340     """
341
342     _PACK_STR = '!BBHII'
343     _MIN_LEN = struct.calcsize(_PACK_STR)
344     _ND_OPTION_TYPES = {}
345
346     @staticmethod
347     def register_nd_option_type(*args):
348         def _register_nd_option_type(cls):
349             nd_router_advert._ND_OPTION_TYPES[cls.option_type()] = cls
350             return cls
351         return _register_nd_option_type(args[0])
352
353     def __init__(self, ch_l=0, res=0, rou_l=0, rea_t=0, ret_t=0, options=None):
354         self.ch_l = ch_l
355         self.res = res
356         self.rou_l = rou_l
357         self.rea_t = rea_t
358         self.ret_t = ret_t
359         options = options or []
360         assert isinstance(options, list)
361         self.options = options
362
363     @classmethod
364     def parser(cls, buf, offset):
365         (ch_l, res, rou_l, rea_t, ret_t
366          ) = struct.unpack_from(cls._PACK_STR, buf, offset)
367         offset += cls._MIN_LEN
368         options = []
369         while len(buf) > offset:
370             (type_, length) = struct.unpack_from('!BB', buf, offset)
371             if length == 0:
372                 raise struct.error('Invalid length: {len}'.format(len=length))
373             cls_ = cls._ND_OPTION_TYPES.get(type_)
374             if cls_ is not None:
375                 option = cls_.parser(buf, offset)
376             else:
377                 option = buf[offset:offset + (length * 8)]
378             options.append(option)
379             offset += len(option)
380         msg = cls(ch_l, res >> 6, rou_l, rea_t, ret_t, options)
381         return msg
382
383     def serialize(self):
384         res = self.res << 6
385         hdr = bytearray(struct.pack(
386             nd_router_advert._PACK_STR, self.ch_l, res, self.rou_l,
387             self.rea_t, self.ret_t))
388         for option in self.options:
389             if isinstance(option, nd_option):
390                 hdr.extend(option.serialize())
391             else:
392                 hdr.extend(option)
393         return six.binary_type(hdr)
394
395     def __len__(self):
396         length = self._MIN_LEN
397         for option in self.options:
398             length += len(option)
399         return length
400
401
402 @six.add_metaclass(abc.ABCMeta)
403 class nd_option(stringify.StringifyMixin):
404     @classmethod
405     @abc.abstractmethod
406     def option_type(cls):
407         pass
408
409     @abc.abstractmethod
410     def __init__(self, _type, length):
411         self._type = _type
412         self.length = length
413
414     @classmethod
415     @abc.abstractmethod
416     def parser(cls, buf):
417         pass
418
419     @abc.abstractmethod
420     def serialize(self):
421         pass
422
423     def __len__(self):
424         return self._MIN_LEN
425
426
427 class nd_option_la(nd_option):
428
429     _PACK_STR = '!BB6s'
430     _MIN_LEN = struct.calcsize(_PACK_STR)
431     _TYPE = {
432         'ascii': [
433             'hw_src'
434         ]
435     }
436
437     @abc.abstractmethod
438     def __init__(self, length, hw_src, data):
439         super(nd_option_la, self).__init__(self.option_type(), length)
440         self.hw_src = hw_src
441         self.data = data
442
443     @classmethod
444     def parser(cls, buf, offset):
445         (_, length, hw_src) = struct.unpack_from(cls._PACK_STR, buf, offset)
446         msg = cls(length, addrconv.mac.bin_to_text(hw_src))
447         offset += cls._MIN_LEN
448         if len(buf) > offset:
449             msg.data = buf[offset:]
450
451         return msg
452
453     def serialize(self):
454         buf = bytearray(struct.pack(
455             self._PACK_STR, self.option_type(), self.length,
456             addrconv.mac.text_to_bin(self.hw_src)))
457         if self.data is not None:
458             buf.extend(self.data)
459         mod = len(buf) % 8
460         if mod:
461             buf.extend(bytearray(8 - mod))
462         if 0 == self.length:
463             self.length = len(buf) // 8
464             struct.pack_into('!B', buf, 1, self.length)
465         return six.binary_type(buf)
466
467     def __len__(self):
468         length = self._MIN_LEN
469         if self.data is not None:
470             length += len(self.data)
471         return length
472
473
474 @nd_neighbor.register_nd_option_type
475 @nd_router_solicit.register_nd_option_type
476 @nd_router_advert.register_nd_option_type
477 class nd_option_sla(nd_option_la):
478     """ICMPv6 sub encoder/decoder class for Neighbor discovery
479     Source Link-Layer Address Option. (RFC 4861)
480
481     This is used with ryu.lib.packet.icmpv6.nd_neighbor,
482     ryu.lib.packet.icmpv6.nd_router_solicit or
483     ryu.lib.packet.icmpv6.nd_router_advert.
484
485     An instance has the following attributes at least.
486     Most of them are same to the on-wire counterparts but in host byte order.
487     __init__ takes the corresponding args in this order.
488
489     .. tabularcolumns:: |l|p{35em}|
490
491     ============== ====================
492     Attribute      Description
493     ============== ====================
494     length         length of the option. \
495                    (0 means automatically-calculate when encoding)
496     hw_src         Link-Layer Address. \
497                    NOTE: If the address is longer than 6 octets this contains \
498                    the first 6 octets in the address. \
499                    This implementation assumes the address has at least \
500                    6 octets.
501     data           A bytearray which contains the rest of Link-Layer Address \
502                    and padding.  When encoding a packet, it's user's \
503                    responsibility to provide necessary padding for 8-octets \
504                    alignment required by the protocol.
505     ============== ====================
506     """
507
508     @classmethod
509     def option_type(cls):
510         return ND_OPTION_SLA
511
512     def __init__(self, length=0, hw_src='00:00:00:00:00:00', data=None):
513         super(nd_option_sla, self).__init__(length, hw_src, data)
514
515
516 @nd_neighbor.register_nd_option_type
517 class nd_option_tla(nd_option_la):
518     """ICMPv6 sub encoder/decoder class for Neighbor discovery
519     Target Link-Layer Address Option. (RFC 4861)
520
521     This is used with ryu.lib.packet.icmpv6.nd_neighbor.
522
523     An instance has the following attributes at least.
524     Most of them are same to the on-wire counterparts but in host byte order.
525     __init__ takes the corresponding args in this order.
526
527     .. tabularcolumns:: |l|p{35em}|
528
529     ============== ====================
530     Attribute      Description
531     ============== ====================
532     length         length of the option. \
533                    (0 means automatically-calculate when encoding)
534     hw_src         Link-Layer Address. \
535                    NOTE: If the address is longer than 6 octets this contains \
536                    the first 6 octets in the address. \
537                    This implementation assumes the address has at least \
538                    6 octets.
539     data           A bytearray which contains the rest of Link-Layer Address \
540                    and padding.  When encoding a packet, it's user's \
541                    responsibility to provide necessary padding for 8-octets \
542                    alignment required by the protocol.
543     ============== ====================
544     """
545
546     @classmethod
547     def option_type(cls):
548         return ND_OPTION_TLA
549
550     def __init__(self, length=0, hw_src='00:00:00:00:00:00', data=None):
551         super(nd_option_tla, self).__init__(length, hw_src, data)
552
553
554 @nd_router_advert.register_nd_option_type
555 class nd_option_pi(nd_option):
556     r"""ICMPv6 sub encoder/decoder class for Neighbor discovery
557     Prefix Information Option. (RFC 4861)
558
559     This is used with ryu.lib.packet.icmpv6.nd_router_advert.
560
561     An instance has the following attributes at least.
562     Most of them are same to the on-wire counterparts but in host byte order.
563     __init__ takes the corresponding args in this order.
564
565     .. tabularcolumns:: |l|p{35em}|
566
567     ============== ====================
568     Attribute      Description
569     ============== ====================
570     length         length of the option. \
571                    (0 means automatically-calculate when encoding)
572     pl             Prefix Length.
573     res1           L,A,R\* Flags for Prefix Information.
574     val_l          Valid Lifetime.
575     pre_l          Preferred Lifetime.
576     res2           This field is unused. It MUST be initialized to zero.
577     prefix         An IP address or a prefix of an IP address.
578     ============== ====================
579
580     \*R flag is defined in (RFC 3775)
581     """
582
583     _PACK_STR = '!BBBBIII16s'
584     _MIN_LEN = struct.calcsize(_PACK_STR)
585     _TYPE = {
586         'ascii': [
587             'prefix'
588         ]
589     }
590
591     @classmethod
592     def option_type(cls):
593         return ND_OPTION_PI
594
595     def __init__(self, length=0, pl=0, res1=0, val_l=0, pre_l=0, res2=0,
596                  prefix='::'):
597         super(nd_option_pi, self).__init__(self.option_type(), length)
598         self.pl = pl
599         self.res1 = res1
600         self.val_l = val_l
601         self.pre_l = pre_l
602         self.res2 = res2
603         self.prefix = prefix
604
605     @classmethod
606     def parser(cls, buf, offset):
607         (_, length, pl, res1, val_l, pre_l, res2, prefix
608          ) = struct.unpack_from(cls._PACK_STR, buf, offset)
609         msg = cls(length, pl, res1 >> 5, val_l, pre_l, res2,
610                   addrconv.ipv6.bin_to_text(prefix))
611
612         return msg
613
614     def serialize(self):
615         res1 = self.res1 << 5
616         hdr = bytearray(struct.pack(
617             self._PACK_STR, self.option_type(), self.length, self.pl,
618             res1, self.val_l, self.pre_l, self.res2,
619             addrconv.ipv6.text_to_bin(self.prefix)))
620         if 0 == self.length:
621             self.length = len(hdr) // 8
622             struct.pack_into('!B', hdr, 1, self.length)
623         return six.binary_type(hdr)
624
625
626 @icmpv6.register_icmpv6_type(ICMPV6_ECHO_REPLY, ICMPV6_ECHO_REQUEST)
627 class echo(_ICMPv6Payload):
628     """ICMPv6 sub encoder/decoder class for Echo Request and Echo Reply
629     messages.
630
631     This is used with ryu.lib.packet.icmpv6.icmpv6 for
632     ICMPv6 Echo Request and Echo Reply messages.
633
634     An instance has the following attributes at least.
635     Most of them are same to the on-wire counterparts but in host byte order.
636     __init__ takes the corresponding args in this order.
637
638     ============== ====================
639     Attribute      Description
640     ============== ====================
641     id             Identifier
642     seq            Sequence Number
643     data           Data
644     ============== ====================
645     """
646
647     _PACK_STR = '!HH'
648     _MIN_LEN = struct.calcsize(_PACK_STR)
649
650     def __init__(self, id_=0, seq=0, data=None):
651         self.id = id_
652         self.seq = seq
653         self.data = data
654
655     @classmethod
656     def parser(cls, buf, offset):
657         (id_, seq) = struct.unpack_from(cls._PACK_STR, buf, offset)
658         msg = cls(id_, seq)
659         offset += cls._MIN_LEN
660
661         if len(buf) > offset:
662             msg.data = buf[offset:]
663
664         return msg
665
666     def serialize(self):
667         hdr = bytearray(struct.pack(echo._PACK_STR, self.id,
668                                     self.seq))
669         if self.data is not None:
670             hdr += bytearray(self.data)
671
672         return hdr
673
674     def __len__(self):
675         length = self._MIN_LEN
676         if self.data is not None:
677             length += len(self.data)
678         return length
679
680
681 @icmpv6.register_icmpv6_type(
682     MLD_LISTENER_QUERY, MLD_LISTENER_REPOR, MLD_LISTENER_DONE)
683 class mld(_ICMPv6Payload):
684     """ICMPv6 sub encoder/decoder class for MLD Lister Query,
685     MLD Listener Report, and MLD Listener Done messages. (RFC 2710)
686
687     http://www.ietf.org/rfc/rfc2710.txt
688
689     This is used with ryu.lib.packet.icmpv6.icmpv6.
690
691     An instance has the following attributes at least.
692     Most of them are same to the on-wire counterparts but in host byte order.
693     __init__ takes the corresponding args in this order.
694
695     ============== =========================================
696     Attribute      Description
697     ============== =========================================
698     maxresp        max response time in millisecond. it is
699                    meaningful only in Query Message.
700     address        a group address value.
701     ============== =========================================
702     """
703
704     _PACK_STR = '!H2x16s'
705     _MIN_LEN = struct.calcsize(_PACK_STR)
706     _TYPE = {
707         'ascii': [
708             'address'
709         ]
710     }
711
712     def __init__(self, maxresp=0, address='::'):
713         self.maxresp = maxresp
714         self.address = address
715
716     @classmethod
717     def parser(cls, buf, offset):
718         if cls._MIN_LEN < len(buf[offset:]):
719             msg = mldv2_query.parser(buf[offset:])
720         else:
721             (maxresp, address) = struct.unpack_from(
722                 cls._PACK_STR, buf, offset)
723             msg = cls(maxresp, addrconv.ipv6.bin_to_text(address))
724
725         return msg
726
727     def serialize(self):
728         buf = struct.pack(mld._PACK_STR, self.maxresp,
729                           addrconv.ipv6.text_to_bin(self.address))
730         return buf
731
732     def __len__(self):
733         return self._MIN_LEN
734
735
736 class mldv2_query(mld):
737     """
738     ICMPv6 sub encoder/decoder class for MLD v2 Lister Query messages.
739     (RFC 3810)
740
741     http://www.ietf.org/rfc/rfc3810.txt
742
743     This is used with ryu.lib.packet.icmpv6.icmpv6.
744
745     An instance has the following attributes at least.
746     Most of them are same to the on-wire counterparts but in host byte order.
747     __init__ takes the corresponding args in this order.
748
749     ============== =========================================
750     Attribute      Description
751     ============== =========================================
752     maxresp        max response time in millisecond. it is
753                    meaningful only in Query Message.
754     address        a group address value.
755     s_flg          when set to 1, routers suppress the timer
756                    process.
757     qrv            robustness variable for a querier.
758     qqic           an interval time for a querier in unit of
759                    seconds.
760     num            a number of the multicast servers.
761     srcs           a list of IPv6 addresses of the multicast
762                    servers.
763     ============== =========================================
764     """
765
766     _PACK_STR = '!H2x16sBBH'
767     _MIN_LEN = struct.calcsize(_PACK_STR)
768     _TYPE = {
769         'ascii': [
770             'address'
771         ],
772         'asciilist': [
773             'srcs'
774         ]
775     }
776
777     def __init__(self, maxresp=0, address='::', s_flg=0, qrv=2,
778                  qqic=0, num=0, srcs=None):
779         super(mldv2_query, self).__init__(maxresp, address)
780         self.s_flg = s_flg
781         self.qrv = qrv
782         self.qqic = qqic
783         self.num = num
784         srcs = srcs or []
785         assert isinstance(srcs, list)
786         for src in srcs:
787             assert isinstance(src, str)
788         self.srcs = srcs
789
790     @classmethod
791     def parser(cls, buf):
792         (maxresp, address, s_qrv, qqic, num
793          ) = struct.unpack_from(cls._PACK_STR, buf)
794         s_flg = (s_qrv >> 3) & 0b1
795         qrv = s_qrv & 0b111
796         offset = cls._MIN_LEN
797         srcs = []
798         while 0 < len(buf[offset:]) and num > len(srcs):
799             assert 16 <= len(buf[offset:])
800             (src, ) = struct.unpack_from('16s', buf, offset)
801             srcs.append(addrconv.ipv6.bin_to_text(src))
802             offset += 16
803         assert num == len(srcs)
804         return cls(maxresp, addrconv.ipv6.bin_to_text(address), s_flg,
805                    qrv, qqic, num, srcs)
806
807     def serialize(self):
808         s_qrv = self.s_flg << 3 | self.qrv
809         buf = bytearray(struct.pack(self._PACK_STR, self.maxresp,
810                                     addrconv.ipv6.text_to_bin(self.address), s_qrv,
811                                     self.qqic, self.num))
812         for src in self.srcs:
813             buf.extend(struct.pack('16s', addrconv.ipv6.text_to_bin(src)))
814         if 0 == self.num:
815             self.num = len(self.srcs)
816             struct.pack_into('!H', buf, 22, self.num)
817         return six.binary_type(buf)
818
819     def __len__(self):
820         return self._MIN_LEN + len(self.srcs) * 16
821
822
823 @icmpv6.register_icmpv6_type(MLDV2_LISTENER_REPORT)
824 class mldv2_report(mld):
825     """
826     ICMPv6 sub encoder/decoder class for MLD v2 Lister Report messages.
827     (RFC 3810)
828
829     http://www.ietf.org/rfc/rfc3810.txt
830
831     This is used with ryu.lib.packet.icmpv6.icmpv6.
832
833     An instance has the following attributes at least.
834     Most of them are same to the on-wire counterparts but in host byte order.
835     __init__ takes the corresponding args in this order.
836
837     ============== =========================================
838     Attribute      Description
839     ============== =========================================
840     record_num     a number of the group records.
841     records        a list of ryu.lib.packet.icmpv6.mldv2_report_group.
842                    None if no records.
843     ============== =========================================
844     """
845
846     _PACK_STR = '!2xH'
847     _MIN_LEN = struct.calcsize(_PACK_STR)
848     _class_prefixes = ['mldv2_report_group']
849
850     def __init__(self, record_num=0, records=None):
851         self.record_num = record_num
852         records = records or []
853         assert isinstance(records, list)
854         for record in records:
855             assert isinstance(record, mldv2_report_group)
856         self.records = records
857
858     @classmethod
859     def parser(cls, buf, offset):
860         (record_num, ) = struct.unpack_from(cls._PACK_STR, buf, offset)
861         offset += cls._MIN_LEN
862         records = []
863         while 0 < len(buf[offset:]) and record_num > len(records):
864             record = mldv2_report_group.parser(buf[offset:])
865             records.append(record)
866             offset += len(record)
867         assert record_num == len(records)
868         return cls(record_num, records)
869
870     def serialize(self):
871         buf = bytearray(struct.pack(self._PACK_STR, self.record_num))
872         for record in self.records:
873             buf.extend(record.serialize())
874         if 0 == self.record_num:
875             self.record_num = len(self.records)
876             struct.pack_into('!H', buf, 2, self.record_num)
877         return six.binary_type(buf)
878
879     def __len__(self):
880         records_len = 0
881         for record in self.records:
882             records_len += len(record)
883         return self._MIN_LEN + records_len
884
885
886 class mldv2_report_group(stringify.StringifyMixin):
887     r"""
888     ICMPv6 sub encoder/decoder class for MLD v2 Lister Report Group
889     Record messages. (RFC 3810)
890
891     This is used with ryu.lib.packet.icmpv6.mldv2_report.
892
893     An instance has the following attributes at least.
894     Most of them are same to the on-wire counterparts but in host byte
895     order.
896     __init__ takes the corresponding args in this order.
897
898     =============== ====================================================
899     Attribute       Description
900     =============== ====================================================
901     type\_          a group record type for v3.
902     aux_len         the length of the auxiliary data in 32-bit words.
903     num             a number of the multicast servers.
904     address         a group address value.
905     srcs            a list of IPv6 addresses of the multicast servers.
906     aux             the auxiliary data.
907     =============== ====================================================
908     """
909     _PACK_STR = '!BBH16s'
910     _MIN_LEN = struct.calcsize(_PACK_STR)
911     _TYPE = {
912         'ascii': [
913             'address'
914         ],
915         'asciilist': [
916             'srcs'
917         ]
918     }
919
920     def __init__(self, type_=0, aux_len=0, num=0, address='::',
921                  srcs=None, aux=None):
922         self.type_ = type_
923         self.aux_len = aux_len
924         self.num = num
925         self.address = address
926         srcs = srcs or []
927         assert isinstance(srcs, list)
928         for src in srcs:
929             assert isinstance(src, str)
930         self.srcs = srcs
931         self.aux = aux
932
933     @classmethod
934     def parser(cls, buf):
935         (type_, aux_len, num, address
936          ) = struct.unpack_from(cls._PACK_STR, buf)
937         offset = cls._MIN_LEN
938         srcs = []
939         while 0 < len(buf[offset:]) and num > len(srcs):
940             assert 16 <= len(buf[offset:])
941             (src, ) = struct.unpack_from('16s', buf, offset)
942             srcs.append(addrconv.ipv6.bin_to_text(src))
943             offset += 16
944         assert num == len(srcs)
945         aux = None
946         if aux_len:
947             (aux, ) = struct.unpack_from('%ds' % (aux_len * 4), buf, offset)
948         msg = cls(type_, aux_len, num, addrconv.ipv6.bin_to_text(address),
949                   srcs, aux)
950         return msg
951
952     def serialize(self):
953         buf = bytearray(struct.pack(self._PACK_STR, self.type_,
954                                     self.aux_len, self.num,
955                                     addrconv.ipv6.text_to_bin(self.address)))
956         for src in self.srcs:
957             buf.extend(struct.pack('16s', addrconv.ipv6.text_to_bin(src)))
958         if 0 == self.num:
959             self.num = len(self.srcs)
960             struct.pack_into('!H', buf, 2, self.num)
961         if self.aux is not None:
962             mod = len(self.aux) % 4
963             if mod:
964                 self.aux += bytearray(4 - mod)
965                 self.aux = six.binary_type(self.aux)
966             buf.extend(self.aux)
967             if 0 == self.aux_len:
968                 self.aux_len = len(self.aux) // 4
969                 struct.pack_into('!B', buf, 1, self.aux_len)
970         return six.binary_type(buf)
971
972     def __len__(self):
973         return self._MIN_LEN + len(self.srcs) * 16 + self.aux_len * 4
974
975
976 icmpv6.set_classes(icmpv6._ICMPV6_TYPES)
977 nd_neighbor.set_classes(nd_neighbor._ND_OPTION_TYPES)
978 nd_router_solicit.set_classes(nd_router_solicit._ND_OPTION_TYPES)
979 nd_router_advert.set_classes(nd_router_advert._ND_OPTION_TYPES)