Refactor GoVPP
[govpp.git] / examples / bin_api / ip / ip.ba.go
1 // Code generated by GoVPP binapi-generator. DO NOT EDIT.
2 // source: ip.api.json
3
4 /*
5 Package ip is a generated VPP binary API of the 'ip' VPP module.
6
7 It is generated from this file:
8         ip.api.json
9
10 It contains these VPP binary API objects:
11         87 messages
12         8 types
13         1 enum
14         1 union
15         42 services
16 */
17 package ip
18
19 import "git.fd.io/govpp.git/api"
20 import "github.com/lunixbochs/struc"
21 import "bytes"
22
23 // Reference imports to suppress errors if they are not otherwise used.
24 var _ = struc.Pack
25 var _ = bytes.NewBuffer
26
27 /* Enums */
28
29 // AddressFamily represents the VPP binary API enum 'address_family'.
30 // Generated from 'ip.api.json', line 2727:
31 //
32 //            "address_family",
33 //            [
34 //                "ADDRESS_IP4",
35 //                0
36 //            ],
37 //            [
38 //                "ADDRESS_IP6",
39 //                1
40 //            ],
41 //            {
42 //                "enumtype": "u32"
43 //            }
44 //
45 type AddressFamily uint32
46
47 const (
48         ADDRESS_IP4 AddressFamily = 0
49         ADDRESS_IP6 AddressFamily = 1
50 )
51
52 /* Types */
53
54 // IP4Address represents the VPP binary API type 'ip4_address'.
55 // Generated from 'ip.api.json', line 2743:
56 //
57 //            "ip4_address",
58 //            [
59 //                "u8",
60 //                "address",
61 //                4
62 //            ],
63 //            {
64 //                "crc": "0xfc4baa28"
65 //            }
66 //
67 type IP4Address struct {
68         Address []byte `struc:"[4]byte"`
69 }
70
71 func (*IP4Address) GetTypeName() string {
72         return "ip4_address"
73 }
74 func (*IP4Address) GetCrcString() string {
75         return "fc4baa28"
76 }
77
78 // IP6Address represents the VPP binary API type 'ip6_address'.
79 // Generated from 'ip.api.json', line 2754:
80 //
81 //            "ip6_address",
82 //            [
83 //                "u8",
84 //                "address",
85 //                16
86 //            ],
87 //            {
88 //                "crc": "0xad99ccc2"
89 //            }
90 //
91 type IP6Address struct {
92         Address []byte `struc:"[16]byte"`
93 }
94
95 func (*IP6Address) GetTypeName() string {
96         return "ip6_address"
97 }
98 func (*IP6Address) GetCrcString() string {
99         return "ad99ccc2"
100 }
101
102 // Address represents the VPP binary API type 'address'.
103 // Generated from 'ip.api.json', line 2765:
104 //
105 //            "address",
106 //            [
107 //                "vl_api_address_family_t",
108 //                "af"
109 //            ],
110 //            [
111 //                "vl_api_address_union_t",
112 //                "un"
113 //            ],
114 //            {
115 //                "crc": "0x09f11671"
116 //            }
117 //
118 type Address struct {
119         Af AddressFamily
120         Un AddressUnion
121 }
122
123 func (*Address) GetTypeName() string {
124         return "address"
125 }
126 func (*Address) GetCrcString() string {
127         return "09f11671"
128 }
129
130 // Prefix represents the VPP binary API type 'prefix'.
131 // Generated from 'ip.api.json', line 2779:
132 //
133 //            "prefix",
134 //            [
135 //                "vl_api_address_t",
136 //                "address"
137 //            ],
138 //            [
139 //                "u8",
140 //                "address_length"
141 //            ],
142 //            {
143 //                "crc": "0x0403aebc"
144 //            }
145 //
146 type Prefix struct {
147         Address       Address
148         AddressLength uint8
149 }
150
151 func (*Prefix) GetTypeName() string {
152         return "prefix"
153 }
154 func (*Prefix) GetCrcString() string {
155         return "0403aebc"
156 }
157
158 // FibMplsLabel represents the VPP binary API type 'fib_mpls_label'.
159 // Generated from 'ip.api.json', line 2793:
160 //
161 //            "fib_mpls_label",
162 //            [
163 //                "u8",
164 //                "is_uniform"
165 //            ],
166 //            [
167 //                "u32",
168 //                "label"
169 //            ],
170 //            [
171 //                "u8",
172 //                "ttl"
173 //            ],
174 //            [
175 //                "u8",
176 //                "exp"
177 //            ],
178 //            {
179 //                "crc": "0xc93bf35c"
180 //            }
181 //
182 type FibMplsLabel struct {
183         IsUniform uint8
184         Label     uint32
185         TTL       uint8
186         Exp       uint8
187 }
188
189 func (*FibMplsLabel) GetTypeName() string {
190         return "fib_mpls_label"
191 }
192 func (*FibMplsLabel) GetCrcString() string {
193         return "c93bf35c"
194 }
195
196 // FibPath represents the VPP binary API type 'fib_path'.
197 // Generated from 'ip.api.json', line 2815:
198 //
199 //            "fib_path",
200 //            [
201 //                "u32",
202 //                "sw_if_index"
203 //            ],
204 //            [
205 //                "u32",
206 //                "table_id"
207 //            ],
208 //            [
209 //                "u8",
210 //                "weight"
211 //            ],
212 //            [
213 //                "u8",
214 //                "preference"
215 //            ],
216 //            [
217 //                "u8",
218 //                "is_local"
219 //            ],
220 //            [
221 //                "u8",
222 //                "is_drop"
223 //            ],
224 //            [
225 //                "u8",
226 //                "is_udp_encap"
227 //            ],
228 //            [
229 //                "u8",
230 //                "is_unreach"
231 //            ],
232 //            [
233 //                "u8",
234 //                "is_prohibit"
235 //            ],
236 //            [
237 //                "u8",
238 //                "is_resolve_host"
239 //            ],
240 //            [
241 //                "u8",
242 //                "is_resolve_attached"
243 //            ],
244 //            [
245 //                "u8",
246 //                "is_dvr"
247 //            ],
248 //            [
249 //                "u8",
250 //                "is_source_lookup"
251 //            ],
252 //            [
253 //                "u8",
254 //                "afi"
255 //            ],
256 //            [
257 //                "u8",
258 //                "next_hop",
259 //                16
260 //            ],
261 //            [
262 //                "u32",
263 //                "next_hop_id"
264 //            ],
265 //            [
266 //                "u32",
267 //                "rpf_id"
268 //            ],
269 //            [
270 //                "u32",
271 //                "via_label"
272 //            ],
273 //            [
274 //                "u8",
275 //                "n_labels"
276 //            ],
277 //            [
278 //                "vl_api_fib_mpls_label_t",
279 //                "label_stack",
280 //                16
281 //            ],
282 //            {
283 //                "crc": "0xabe483ef"
284 //            }
285 //
286 type FibPath struct {
287         SwIfIndex         uint32
288         TableID           uint32
289         Weight            uint8
290         Preference        uint8
291         IsLocal           uint8
292         IsDrop            uint8
293         IsUDPEncap        uint8
294         IsUnreach         uint8
295         IsProhibit        uint8
296         IsResolveHost     uint8
297         IsResolveAttached uint8
298         IsDvr             uint8
299         IsSourceLookup    uint8
300         Afi               uint8
301         NextHop           []byte `struc:"[16]byte"`
302         NextHopID         uint32
303         RpfID             uint32
304         ViaLabel          uint32
305         NLabels           uint8
306         LabelStack        []FibMplsLabel `struc:"[16]FibMplsLabel"`
307 }
308
309 func (*FibPath) GetTypeName() string {
310         return "fib_path"
311 }
312 func (*FibPath) GetCrcString() string {
313         return "abe483ef"
314 }
315
316 // IP6RaPrefixInfo represents the VPP binary API type 'ip6_ra_prefix_info'.
317 // Generated from 'ip.api.json', line 2903:
318 //
319 //            "ip6_ra_prefix_info",
320 //            [
321 //                "u8",
322 //                "dst_address",
323 //                16
324 //            ],
325 //            [
326 //                "u8",
327 //                "dst_address_length"
328 //            ],
329 //            [
330 //                "u8",
331 //                "flags"
332 //            ],
333 //            [
334 //                "u32",
335 //                "valid_time"
336 //            ],
337 //            [
338 //                "u32",
339 //                "preferred_time"
340 //            ],
341 //            {
342 //                "crc": "0x83d7c6e5"
343 //            }
344 //
345 type IP6RaPrefixInfo struct {
346         DstAddress       []byte `struc:"[16]byte"`
347         DstAddressLength uint8
348         Flags            uint8
349         ValidTime        uint32
350         PreferredTime    uint32
351 }
352
353 func (*IP6RaPrefixInfo) GetTypeName() string {
354         return "ip6_ra_prefix_info"
355 }
356 func (*IP6RaPrefixInfo) GetCrcString() string {
357         return "83d7c6e5"
358 }
359
360 // ProxyArp represents the VPP binary API type 'proxy_arp'.
361 // Generated from 'ip.api.json', line 2930:
362 //
363 //            "proxy_arp",
364 //            [
365 //                "u32",
366 //                "vrf_id"
367 //            ],
368 //            [
369 //                "u8",
370 //                "low_address",
371 //                4
372 //            ],
373 //            [
374 //                "u8",
375 //                "hi_address",
376 //                4
377 //            ],
378 //            {
379 //                "crc": "0x6d88106e"
380 //            }
381 //
382 type ProxyArp struct {
383         VrfID      uint32
384         LowAddress []byte `struc:"[4]byte"`
385         HiAddress  []byte `struc:"[4]byte"`
386 }
387
388 func (*ProxyArp) GetTypeName() string {
389         return "proxy_arp"
390 }
391 func (*ProxyArp) GetCrcString() string {
392         return "6d88106e"
393 }
394
395 /* Unions */
396
397 // AddressUnion represents the VPP binary API union 'address_union'.
398 // Generated from 'ip.api.json', line 2562:
399 //
400 //            "address_union",
401 //            [
402 //                "vl_api_ip4_address_t",
403 //                "ip4"
404 //            ],
405 //            [
406 //                "vl_api_ip6_address_t",
407 //                "ip6"
408 //            ],
409 //            {
410 //                "crc": "0xd68a2fb4"
411 //            }
412 //
413 type AddressUnion struct {
414         Union_data [16]byte
415 }
416
417 func (*AddressUnion) GetTypeName() string {
418         return "address_union"
419 }
420 func (*AddressUnion) GetCrcString() string {
421         return "d68a2fb4"
422 }
423
424 func (u *AddressUnion) SetIP4(a IP4Address) {
425         var b = new(bytes.Buffer)
426         if err := struc.Pack(b, &a); err != nil {
427                 return
428         }
429         copy(u.Union_data[:], b.Bytes())
430 }
431 func (u *AddressUnion) GetIP4() (a IP4Address) {
432         var b = bytes.NewReader(u.Union_data[:])
433         struc.Unpack(b, &a)
434         return
435 }
436
437 func (u *AddressUnion) SetIP6(a IP6Address) {
438         var b = new(bytes.Buffer)
439         if err := struc.Pack(b, &a); err != nil {
440                 return
441         }
442         copy(u.Union_data[:], b.Bytes())
443 }
444 func (u *AddressUnion) GetIP6() (a IP6Address) {
445         var b = bytes.NewReader(u.Union_data[:])
446         struc.Unpack(b, &a)
447         return
448 }
449
450 /* Messages */
451
452 // IPTableAddDel represents the VPP binary API message 'ip_table_add_del'.
453 // Generated from 'ip.api.json', line 4:
454 //
455 //            "ip_table_add_del",
456 //            [
457 //                "u16",
458 //                "_vl_msg_id"
459 //            ],
460 //            [
461 //                "u32",
462 //                "client_index"
463 //            ],
464 //            [
465 //                "u32",
466 //                "context"
467 //            ],
468 //            [
469 //                "u32",
470 //                "table_id"
471 //            ],
472 //            [
473 //                "u8",
474 //                "is_ipv6"
475 //            ],
476 //            [
477 //                "u8",
478 //                "is_add"
479 //            ],
480 //            [
481 //                "u8",
482 //                "name",
483 //                64
484 //            ],
485 //            {
486 //                "crc": "0x0240c89d"
487 //            }
488 //
489 type IPTableAddDel struct {
490         TableID uint32
491         IsIPv6  uint8
492         IsAdd   uint8
493         Name    []byte `struc:"[64]byte"`
494 }
495
496 func (*IPTableAddDel) GetMessageName() string {
497         return "ip_table_add_del"
498 }
499 func (*IPTableAddDel) GetCrcString() string {
500         return "0240c89d"
501 }
502 func (*IPTableAddDel) GetMessageType() api.MessageType {
503         return api.RequestMessage
504 }
505 func NewIPTableAddDel() api.Message {
506         return &IPTableAddDel{}
507 }
508
509 // IPTableAddDelReply represents the VPP binary API message 'ip_table_add_del_reply'.
510 // Generated from 'ip.api.json', line 39:
511 //
512 //            "ip_table_add_del_reply",
513 //            [
514 //                "u16",
515 //                "_vl_msg_id"
516 //            ],
517 //            [
518 //                "u32",
519 //                "context"
520 //            ],
521 //            [
522 //                "i32",
523 //                "retval"
524 //            ],
525 //            {
526 //                "crc": "0xe8d4e804"
527 //            }
528 //
529 type IPTableAddDelReply struct {
530         Retval int32
531 }
532
533 func (*IPTableAddDelReply) GetMessageName() string {
534         return "ip_table_add_del_reply"
535 }
536 func (*IPTableAddDelReply) GetCrcString() string {
537         return "e8d4e804"
538 }
539 func (*IPTableAddDelReply) GetMessageType() api.MessageType {
540         return api.ReplyMessage
541 }
542 func NewIPTableAddDelReply() api.Message {
543         return &IPTableAddDelReply{}
544 }
545
546 // IPFibDump represents the VPP binary API message 'ip_fib_dump'.
547 // Generated from 'ip.api.json', line 57:
548 //
549 //            "ip_fib_dump",
550 //            [
551 //                "u16",
552 //                "_vl_msg_id"
553 //            ],
554 //            [
555 //                "u32",
556 //                "client_index"
557 //            ],
558 //            [
559 //                "u32",
560 //                "context"
561 //            ],
562 //            {
563 //                "crc": "0x51077d14"
564 //            }
565 //
566 type IPFibDump struct{}
567
568 func (*IPFibDump) GetMessageName() string {
569         return "ip_fib_dump"
570 }
571 func (*IPFibDump) GetCrcString() string {
572         return "51077d14"
573 }
574 func (*IPFibDump) GetMessageType() api.MessageType {
575         return api.RequestMessage
576 }
577 func NewIPFibDump() api.Message {
578         return &IPFibDump{}
579 }
580
581 // IPFibDetails represents the VPP binary API message 'ip_fib_details'.
582 // Generated from 'ip.api.json', line 75:
583 //
584 //            "ip_fib_details",
585 //            [
586 //                "u16",
587 //                "_vl_msg_id"
588 //            ],
589 //            [
590 //                "u32",
591 //                "context"
592 //            ],
593 //            [
594 //                "u32",
595 //                "table_id"
596 //            ],
597 //            [
598 //                "u8",
599 //                "table_name",
600 //                64
601 //            ],
602 //            [
603 //                "u8",
604 //                "address_length"
605 //            ],
606 //            [
607 //                "u8",
608 //                "address",
609 //                4
610 //            ],
611 //            [
612 //                "u32",
613 //                "count"
614 //            ],
615 //            [
616 //                "vl_api_fib_path_t",
617 //                "path",
618 //                0,
619 //                "count"
620 //            ],
621 //            {
622 //                "crc": "0x99dfd73b"
623 //            }
624 //
625 type IPFibDetails struct {
626         TableID       uint32
627         TableName     []byte `struc:"[64]byte"`
628         AddressLength uint8
629         Address       []byte `struc:"[4]byte"`
630         Count         uint32 `struc:"sizeof=Path"`
631         Path          []FibPath
632 }
633
634 func (*IPFibDetails) GetMessageName() string {
635         return "ip_fib_details"
636 }
637 func (*IPFibDetails) GetCrcString() string {
638         return "99dfd73b"
639 }
640 func (*IPFibDetails) GetMessageType() api.MessageType {
641         return api.ReplyMessage
642 }
643 func NewIPFibDetails() api.Message {
644         return &IPFibDetails{}
645 }
646
647 // IP6FibDump represents the VPP binary API message 'ip6_fib_dump'.
648 // Generated from 'ip.api.json', line 117:
649 //
650 //            "ip6_fib_dump",
651 //            [
652 //                "u16",
653 //                "_vl_msg_id"
654 //            ],
655 //            [
656 //                "u32",
657 //                "client_index"
658 //            ],
659 //            [
660 //                "u32",
661 //                "context"
662 //            ],
663 //            {
664 //                "crc": "0x51077d14"
665 //            }
666 //
667 type IP6FibDump struct{}
668
669 func (*IP6FibDump) GetMessageName() string {
670         return "ip6_fib_dump"
671 }
672 func (*IP6FibDump) GetCrcString() string {
673         return "51077d14"
674 }
675 func (*IP6FibDump) GetMessageType() api.MessageType {
676         return api.RequestMessage
677 }
678 func NewIP6FibDump() api.Message {
679         return &IP6FibDump{}
680 }
681
682 // IP6FibDetails represents the VPP binary API message 'ip6_fib_details'.
683 // Generated from 'ip.api.json', line 135:
684 //
685 //            "ip6_fib_details",
686 //            [
687 //                "u16",
688 //                "_vl_msg_id"
689 //            ],
690 //            [
691 //                "u32",
692 //                "context"
693 //            ],
694 //            [
695 //                "u32",
696 //                "table_id"
697 //            ],
698 //            [
699 //                "u8",
700 //                "table_name",
701 //                64
702 //            ],
703 //            [
704 //                "u8",
705 //                "address_length"
706 //            ],
707 //            [
708 //                "u8",
709 //                "address",
710 //                16
711 //            ],
712 //            [
713 //                "u32",
714 //                "count"
715 //            ],
716 //            [
717 //                "vl_api_fib_path_t",
718 //                "path",
719 //                0,
720 //                "count"
721 //            ],
722 //            {
723 //                "crc": "0xabd0060e"
724 //            }
725 //
726 type IP6FibDetails struct {
727         TableID       uint32
728         TableName     []byte `struc:"[64]byte"`
729         AddressLength uint8
730         Address       []byte `struc:"[16]byte"`
731         Count         uint32 `struc:"sizeof=Path"`
732         Path          []FibPath
733 }
734
735 func (*IP6FibDetails) GetMessageName() string {
736         return "ip6_fib_details"
737 }
738 func (*IP6FibDetails) GetCrcString() string {
739         return "abd0060e"
740 }
741 func (*IP6FibDetails) GetMessageType() api.MessageType {
742         return api.ReplyMessage
743 }
744 func NewIP6FibDetails() api.Message {
745         return &IP6FibDetails{}
746 }
747
748 // IPNeighborDump represents the VPP binary API message 'ip_neighbor_dump'.
749 // Generated from 'ip.api.json', line 177:
750 //
751 //            "ip_neighbor_dump",
752 //            [
753 //                "u16",
754 //                "_vl_msg_id"
755 //            ],
756 //            [
757 //                "u32",
758 //                "client_index"
759 //            ],
760 //            [
761 //                "u32",
762 //                "context"
763 //            ],
764 //            [
765 //                "u32",
766 //                "sw_if_index"
767 //            ],
768 //            [
769 //                "u8",
770 //                "is_ipv6"
771 //            ],
772 //            {
773 //                "crc": "0x6b7bcd0a"
774 //            }
775 //
776 type IPNeighborDump struct {
777         SwIfIndex uint32
778         IsIPv6    uint8
779 }
780
781 func (*IPNeighborDump) GetMessageName() string {
782         return "ip_neighbor_dump"
783 }
784 func (*IPNeighborDump) GetCrcString() string {
785         return "6b7bcd0a"
786 }
787 func (*IPNeighborDump) GetMessageType() api.MessageType {
788         return api.RequestMessage
789 }
790 func NewIPNeighborDump() api.Message {
791         return &IPNeighborDump{}
792 }
793
794 // IPNeighborDetails represents the VPP binary API message 'ip_neighbor_details'.
795 // Generated from 'ip.api.json', line 203:
796 //
797 //            "ip_neighbor_details",
798 //            [
799 //                "u16",
800 //                "_vl_msg_id"
801 //            ],
802 //            [
803 //                "u32",
804 //                "context"
805 //            ],
806 //            [
807 //                "u32",
808 //                "sw_if_index"
809 //            ],
810 //            [
811 //                "u8",
812 //                "is_static"
813 //            ],
814 //            [
815 //                "u8",
816 //                "is_ipv6"
817 //            ],
818 //            [
819 //                "u8",
820 //                "mac_address",
821 //                6
822 //            ],
823 //            [
824 //                "u8",
825 //                "ip_address",
826 //                16
827 //            ],
828 //            {
829 //                "crc": "0x85e32a72"
830 //            }
831 //
832 type IPNeighborDetails struct {
833         SwIfIndex  uint32
834         IsStatic   uint8
835         IsIPv6     uint8
836         MacAddress []byte `struc:"[6]byte"`
837         IPAddress  []byte `struc:"[16]byte"`
838 }
839
840 func (*IPNeighborDetails) GetMessageName() string {
841         return "ip_neighbor_details"
842 }
843 func (*IPNeighborDetails) GetCrcString() string {
844         return "85e32a72"
845 }
846 func (*IPNeighborDetails) GetMessageType() api.MessageType {
847         return api.ReplyMessage
848 }
849 func NewIPNeighborDetails() api.Message {
850         return &IPNeighborDetails{}
851 }
852
853 // IPNeighborAddDel represents the VPP binary API message 'ip_neighbor_add_del'.
854 // Generated from 'ip.api.json', line 239:
855 //
856 //            "ip_neighbor_add_del",
857 //            [
858 //                "u16",
859 //                "_vl_msg_id"
860 //            ],
861 //            [
862 //                "u32",
863 //                "client_index"
864 //            ],
865 //            [
866 //                "u32",
867 //                "context"
868 //            ],
869 //            [
870 //                "u32",
871 //                "sw_if_index"
872 //            ],
873 //            [
874 //                "u8",
875 //                "is_add"
876 //            ],
877 //            [
878 //                "u8",
879 //                "is_ipv6"
880 //            ],
881 //            [
882 //                "u8",
883 //                "is_static"
884 //            ],
885 //            [
886 //                "u8",
887 //                "is_no_adj_fib"
888 //            ],
889 //            [
890 //                "u8",
891 //                "mac_address",
892 //                6
893 //            ],
894 //            [
895 //                "u8",
896 //                "dst_address",
897 //                16
898 //            ],
899 //            {
900 //                "crc": "0x4711eb25"
901 //            }
902 //
903 type IPNeighborAddDel struct {
904         SwIfIndex  uint32
905         IsAdd      uint8
906         IsIPv6     uint8
907         IsStatic   uint8
908         IsNoAdjFib uint8
909         MacAddress []byte `struc:"[6]byte"`
910         DstAddress []byte `struc:"[16]byte"`
911 }
912
913 func (*IPNeighborAddDel) GetMessageName() string {
914         return "ip_neighbor_add_del"
915 }
916 func (*IPNeighborAddDel) GetCrcString() string {
917         return "4711eb25"
918 }
919 func (*IPNeighborAddDel) GetMessageType() api.MessageType {
920         return api.RequestMessage
921 }
922 func NewIPNeighborAddDel() api.Message {
923         return &IPNeighborAddDel{}
924 }
925
926 // IPNeighborAddDelReply represents the VPP binary API message 'ip_neighbor_add_del_reply'.
927 // Generated from 'ip.api.json', line 287:
928 //
929 //            "ip_neighbor_add_del_reply",
930 //            [
931 //                "u16",
932 //                "_vl_msg_id"
933 //            ],
934 //            [
935 //                "u32",
936 //                "context"
937 //            ],
938 //            [
939 //                "i32",
940 //                "retval"
941 //            ],
942 //            {
943 //                "crc": "0xe8d4e804"
944 //            }
945 //
946 type IPNeighborAddDelReply struct {
947         Retval int32
948 }
949
950 func (*IPNeighborAddDelReply) GetMessageName() string {
951         return "ip_neighbor_add_del_reply"
952 }
953 func (*IPNeighborAddDelReply) GetCrcString() string {
954         return "e8d4e804"
955 }
956 func (*IPNeighborAddDelReply) GetMessageType() api.MessageType {
957         return api.ReplyMessage
958 }
959 func NewIPNeighborAddDelReply() api.Message {
960         return &IPNeighborAddDelReply{}
961 }
962
963 // SetIPFlowHash represents the VPP binary API message 'set_ip_flow_hash'.
964 // Generated from 'ip.api.json', line 305:
965 //
966 //            "set_ip_flow_hash",
967 //            [
968 //                "u16",
969 //                "_vl_msg_id"
970 //            ],
971 //            [
972 //                "u32",
973 //                "client_index"
974 //            ],
975 //            [
976 //                "u32",
977 //                "context"
978 //            ],
979 //            [
980 //                "u32",
981 //                "vrf_id"
982 //            ],
983 //            [
984 //                "u8",
985 //                "is_ipv6"
986 //            ],
987 //            [
988 //                "u8",
989 //                "src"
990 //            ],
991 //            [
992 //                "u8",
993 //                "dst"
994 //            ],
995 //            [
996 //                "u8",
997 //                "sport"
998 //            ],
999 //            [
1000 //                "u8",
1001 //                "dport"
1002 //            ],
1003 //            [
1004 //                "u8",
1005 //                "proto"
1006 //            ],
1007 //            [
1008 //                "u8",
1009 //                "reverse"
1010 //            ],
1011 //            {
1012 //                "crc": "0x32ebf737"
1013 //            }
1014 //
1015 type SetIPFlowHash struct {
1016         VrfID   uint32
1017         IsIPv6  uint8
1018         Src     uint8
1019         Dst     uint8
1020         Sport   uint8
1021         Dport   uint8
1022         Proto   uint8
1023         Reverse uint8
1024 }
1025
1026 func (*SetIPFlowHash) GetMessageName() string {
1027         return "set_ip_flow_hash"
1028 }
1029 func (*SetIPFlowHash) GetCrcString() string {
1030         return "32ebf737"
1031 }
1032 func (*SetIPFlowHash) GetMessageType() api.MessageType {
1033         return api.RequestMessage
1034 }
1035 func NewSetIPFlowHash() api.Message {
1036         return &SetIPFlowHash{}
1037 }
1038
1039 // SetIPFlowHashReply represents the VPP binary API message 'set_ip_flow_hash_reply'.
1040 // Generated from 'ip.api.json', line 355:
1041 //
1042 //            "set_ip_flow_hash_reply",
1043 //            [
1044 //                "u16",
1045 //                "_vl_msg_id"
1046 //            ],
1047 //            [
1048 //                "u32",
1049 //                "context"
1050 //            ],
1051 //            [
1052 //                "i32",
1053 //                "retval"
1054 //            ],
1055 //            {
1056 //                "crc": "0xe8d4e804"
1057 //            }
1058 //
1059 type SetIPFlowHashReply struct {
1060         Retval int32
1061 }
1062
1063 func (*SetIPFlowHashReply) GetMessageName() string {
1064         return "set_ip_flow_hash_reply"
1065 }
1066 func (*SetIPFlowHashReply) GetCrcString() string {
1067         return "e8d4e804"
1068 }
1069 func (*SetIPFlowHashReply) GetMessageType() api.MessageType {
1070         return api.ReplyMessage
1071 }
1072 func NewSetIPFlowHashReply() api.Message {
1073         return &SetIPFlowHashReply{}
1074 }
1075
1076 // SwInterfaceIP6ndRaConfig represents the VPP binary API message 'sw_interface_ip6nd_ra_config'.
1077 // Generated from 'ip.api.json', line 373:
1078 //
1079 //            "sw_interface_ip6nd_ra_config",
1080 //            [
1081 //                "u16",
1082 //                "_vl_msg_id"
1083 //            ],
1084 //            [
1085 //                "u32",
1086 //                "client_index"
1087 //            ],
1088 //            [
1089 //                "u32",
1090 //                "context"
1091 //            ],
1092 //            [
1093 //                "u32",
1094 //                "sw_if_index"
1095 //            ],
1096 //            [
1097 //                "u8",
1098 //                "suppress"
1099 //            ],
1100 //            [
1101 //                "u8",
1102 //                "managed"
1103 //            ],
1104 //            [
1105 //                "u8",
1106 //                "other"
1107 //            ],
1108 //            [
1109 //                "u8",
1110 //                "ll_option"
1111 //            ],
1112 //            [
1113 //                "u8",
1114 //                "send_unicast"
1115 //            ],
1116 //            [
1117 //                "u8",
1118 //                "cease"
1119 //            ],
1120 //            [
1121 //                "u8",
1122 //                "is_no"
1123 //            ],
1124 //            [
1125 //                "u8",
1126 //                "default_router"
1127 //            ],
1128 //            [
1129 //                "u32",
1130 //                "max_interval"
1131 //            ],
1132 //            [
1133 //                "u32",
1134 //                "min_interval"
1135 //            ],
1136 //            [
1137 //                "u32",
1138 //                "lifetime"
1139 //            ],
1140 //            [
1141 //                "u32",
1142 //                "initial_count"
1143 //            ],
1144 //            [
1145 //                "u32",
1146 //                "initial_interval"
1147 //            ],
1148 //            {
1149 //                "crc": "0xc3f02daa"
1150 //            }
1151 //
1152 type SwInterfaceIP6ndRaConfig struct {
1153         SwIfIndex       uint32
1154         Suppress        uint8
1155         Managed         uint8
1156         Other           uint8
1157         LlOption        uint8
1158         SendUnicast     uint8
1159         Cease           uint8
1160         IsNo            uint8
1161         DefaultRouter   uint8
1162         MaxInterval     uint32
1163         MinInterval     uint32
1164         Lifetime        uint32
1165         InitialCount    uint32
1166         InitialInterval uint32
1167 }
1168
1169 func (*SwInterfaceIP6ndRaConfig) GetMessageName() string {
1170         return "sw_interface_ip6nd_ra_config"
1171 }
1172 func (*SwInterfaceIP6ndRaConfig) GetCrcString() string {
1173         return "c3f02daa"
1174 }
1175 func (*SwInterfaceIP6ndRaConfig) GetMessageType() api.MessageType {
1176         return api.RequestMessage
1177 }
1178 func NewSwInterfaceIP6ndRaConfig() api.Message {
1179         return &SwInterfaceIP6ndRaConfig{}
1180 }
1181
1182 // SwInterfaceIP6ndRaConfigReply represents the VPP binary API message 'sw_interface_ip6nd_ra_config_reply'.
1183 // Generated from 'ip.api.json', line 447:
1184 //
1185 //            "sw_interface_ip6nd_ra_config_reply",
1186 //            [
1187 //                "u16",
1188 //                "_vl_msg_id"
1189 //            ],
1190 //            [
1191 //                "u32",
1192 //                "context"
1193 //            ],
1194 //            [
1195 //                "i32",
1196 //                "retval"
1197 //            ],
1198 //            {
1199 //                "crc": "0xe8d4e804"
1200 //            }
1201 //
1202 type SwInterfaceIP6ndRaConfigReply struct {
1203         Retval int32
1204 }
1205
1206 func (*SwInterfaceIP6ndRaConfigReply) GetMessageName() string {
1207         return "sw_interface_ip6nd_ra_config_reply"
1208 }
1209 func (*SwInterfaceIP6ndRaConfigReply) GetCrcString() string {
1210         return "e8d4e804"
1211 }
1212 func (*SwInterfaceIP6ndRaConfigReply) GetMessageType() api.MessageType {
1213         return api.ReplyMessage
1214 }
1215 func NewSwInterfaceIP6ndRaConfigReply() api.Message {
1216         return &SwInterfaceIP6ndRaConfigReply{}
1217 }
1218
1219 // SwInterfaceIP6ndRaPrefix represents the VPP binary API message 'sw_interface_ip6nd_ra_prefix'.
1220 // Generated from 'ip.api.json', line 465:
1221 //
1222 //            "sw_interface_ip6nd_ra_prefix",
1223 //            [
1224 //                "u16",
1225 //                "_vl_msg_id"
1226 //            ],
1227 //            [
1228 //                "u32",
1229 //                "client_index"
1230 //            ],
1231 //            [
1232 //                "u32",
1233 //                "context"
1234 //            ],
1235 //            [
1236 //                "u32",
1237 //                "sw_if_index"
1238 //            ],
1239 //            [
1240 //                "u8",
1241 //                "address",
1242 //                16
1243 //            ],
1244 //            [
1245 //                "u8",
1246 //                "address_length"
1247 //            ],
1248 //            [
1249 //                "u8",
1250 //                "use_default"
1251 //            ],
1252 //            [
1253 //                "u8",
1254 //                "no_advertise"
1255 //            ],
1256 //            [
1257 //                "u8",
1258 //                "off_link"
1259 //            ],
1260 //            [
1261 //                "u8",
1262 //                "no_autoconfig"
1263 //            ],
1264 //            [
1265 //                "u8",
1266 //                "no_onlink"
1267 //            ],
1268 //            [
1269 //                "u8",
1270 //                "is_no"
1271 //            ],
1272 //            [
1273 //                "u32",
1274 //                "val_lifetime"
1275 //            ],
1276 //            [
1277 //                "u32",
1278 //                "pref_lifetime"
1279 //            ],
1280 //            {
1281 //                "crc": "0xca763c9a"
1282 //            }
1283 //
1284 type SwInterfaceIP6ndRaPrefix struct {
1285         SwIfIndex     uint32
1286         Address       []byte `struc:"[16]byte"`
1287         AddressLength uint8
1288         UseDefault    uint8
1289         NoAdvertise   uint8
1290         OffLink       uint8
1291         NoAutoconfig  uint8
1292         NoOnlink      uint8
1293         IsNo          uint8
1294         ValLifetime   uint32
1295         PrefLifetime  uint32
1296 }
1297
1298 func (*SwInterfaceIP6ndRaPrefix) GetMessageName() string {
1299         return "sw_interface_ip6nd_ra_prefix"
1300 }
1301 func (*SwInterfaceIP6ndRaPrefix) GetCrcString() string {
1302         return "ca763c9a"
1303 }
1304 func (*SwInterfaceIP6ndRaPrefix) GetMessageType() api.MessageType {
1305         return api.RequestMessage
1306 }
1307 func NewSwInterfaceIP6ndRaPrefix() api.Message {
1308         return &SwInterfaceIP6ndRaPrefix{}
1309 }
1310
1311 // SwInterfaceIP6ndRaPrefixReply represents the VPP binary API message 'sw_interface_ip6nd_ra_prefix_reply'.
1312 // Generated from 'ip.api.json', line 528:
1313 //
1314 //            "sw_interface_ip6nd_ra_prefix_reply",
1315 //            [
1316 //                "u16",
1317 //                "_vl_msg_id"
1318 //            ],
1319 //            [
1320 //                "u32",
1321 //                "context"
1322 //            ],
1323 //            [
1324 //                "i32",
1325 //                "retval"
1326 //            ],
1327 //            {
1328 //                "crc": "0xe8d4e804"
1329 //            }
1330 //
1331 type SwInterfaceIP6ndRaPrefixReply struct {
1332         Retval int32
1333 }
1334
1335 func (*SwInterfaceIP6ndRaPrefixReply) GetMessageName() string {
1336         return "sw_interface_ip6nd_ra_prefix_reply"
1337 }
1338 func (*SwInterfaceIP6ndRaPrefixReply) GetCrcString() string {
1339         return "e8d4e804"
1340 }
1341 func (*SwInterfaceIP6ndRaPrefixReply) GetMessageType() api.MessageType {
1342         return api.ReplyMessage
1343 }
1344 func NewSwInterfaceIP6ndRaPrefixReply() api.Message {
1345         return &SwInterfaceIP6ndRaPrefixReply{}
1346 }
1347
1348 // IP6ndProxyAddDel represents the VPP binary API message 'ip6nd_proxy_add_del'.
1349 // Generated from 'ip.api.json', line 546:
1350 //
1351 //            "ip6nd_proxy_add_del",
1352 //            [
1353 //                "u16",
1354 //                "_vl_msg_id"
1355 //            ],
1356 //            [
1357 //                "u32",
1358 //                "client_index"
1359 //            ],
1360 //            [
1361 //                "u32",
1362 //                "context"
1363 //            ],
1364 //            [
1365 //                "u32",
1366 //                "sw_if_index"
1367 //            ],
1368 //            [
1369 //                "u8",
1370 //                "is_del"
1371 //            ],
1372 //            [
1373 //                "u8",
1374 //                "address",
1375 //                16
1376 //            ],
1377 //            {
1378 //                "crc": "0xd95f0fa0"
1379 //            }
1380 //
1381 type IP6ndProxyAddDel struct {
1382         SwIfIndex uint32
1383         IsDel     uint8
1384         Address   []byte `struc:"[16]byte"`
1385 }
1386
1387 func (*IP6ndProxyAddDel) GetMessageName() string {
1388         return "ip6nd_proxy_add_del"
1389 }
1390 func (*IP6ndProxyAddDel) GetCrcString() string {
1391         return "d95f0fa0"
1392 }
1393 func (*IP6ndProxyAddDel) GetMessageType() api.MessageType {
1394         return api.RequestMessage
1395 }
1396 func NewIP6ndProxyAddDel() api.Message {
1397         return &IP6ndProxyAddDel{}
1398 }
1399
1400 // IP6ndProxyAddDelReply represents the VPP binary API message 'ip6nd_proxy_add_del_reply'.
1401 // Generated from 'ip.api.json', line 577:
1402 //
1403 //            "ip6nd_proxy_add_del_reply",
1404 //            [
1405 //                "u16",
1406 //                "_vl_msg_id"
1407 //            ],
1408 //            [
1409 //                "u32",
1410 //                "context"
1411 //            ],
1412 //            [
1413 //                "i32",
1414 //                "retval"
1415 //            ],
1416 //            {
1417 //                "crc": "0xe8d4e804"
1418 //            }
1419 //
1420 type IP6ndProxyAddDelReply struct {
1421         Retval int32
1422 }
1423
1424 func (*IP6ndProxyAddDelReply) GetMessageName() string {
1425         return "ip6nd_proxy_add_del_reply"
1426 }
1427 func (*IP6ndProxyAddDelReply) GetCrcString() string {
1428         return "e8d4e804"
1429 }
1430 func (*IP6ndProxyAddDelReply) GetMessageType() api.MessageType {
1431         return api.ReplyMessage
1432 }
1433 func NewIP6ndProxyAddDelReply() api.Message {
1434         return &IP6ndProxyAddDelReply{}
1435 }
1436
1437 // IP6ndProxyDetails represents the VPP binary API message 'ip6nd_proxy_details'.
1438 // Generated from 'ip.api.json', line 595:
1439 //
1440 //            "ip6nd_proxy_details",
1441 //            [
1442 //                "u16",
1443 //                "_vl_msg_id"
1444 //            ],
1445 //            [
1446 //                "u32",
1447 //                "client_index"
1448 //            ],
1449 //            [
1450 //                "u32",
1451 //                "context"
1452 //            ],
1453 //            [
1454 //                "u32",
1455 //                "sw_if_index"
1456 //            ],
1457 //            [
1458 //                "u8",
1459 //                "address",
1460 //                16
1461 //            ],
1462 //            {
1463 //                "crc": "0xd73bf1ab"
1464 //            }
1465 //
1466 type IP6ndProxyDetails struct {
1467         SwIfIndex uint32
1468         Address   []byte `struc:"[16]byte"`
1469 }
1470
1471 func (*IP6ndProxyDetails) GetMessageName() string {
1472         return "ip6nd_proxy_details"
1473 }
1474 func (*IP6ndProxyDetails) GetCrcString() string {
1475         return "d73bf1ab"
1476 }
1477 func (*IP6ndProxyDetails) GetMessageType() api.MessageType {
1478         return api.RequestMessage
1479 }
1480 func NewIP6ndProxyDetails() api.Message {
1481         return &IP6ndProxyDetails{}
1482 }
1483
1484 // IP6ndProxyDump represents the VPP binary API message 'ip6nd_proxy_dump'.
1485 // Generated from 'ip.api.json', line 622:
1486 //
1487 //            "ip6nd_proxy_dump",
1488 //            [
1489 //                "u16",
1490 //                "_vl_msg_id"
1491 //            ],
1492 //            [
1493 //                "u32",
1494 //                "client_index"
1495 //            ],
1496 //            [
1497 //                "u32",
1498 //                "context"
1499 //            ],
1500 //            {
1501 //                "crc": "0x51077d14"
1502 //            }
1503 //
1504 type IP6ndProxyDump struct{}
1505
1506 func (*IP6ndProxyDump) GetMessageName() string {
1507         return "ip6nd_proxy_dump"
1508 }
1509 func (*IP6ndProxyDump) GetCrcString() string {
1510         return "51077d14"
1511 }
1512 func (*IP6ndProxyDump) GetMessageType() api.MessageType {
1513         return api.RequestMessage
1514 }
1515 func NewIP6ndProxyDump() api.Message {
1516         return &IP6ndProxyDump{}
1517 }
1518
1519 // IP6ndSendRouterSolicitation represents the VPP binary API message 'ip6nd_send_router_solicitation'.
1520 // Generated from 'ip.api.json', line 640:
1521 //
1522 //            "ip6nd_send_router_solicitation",
1523 //            [
1524 //                "u16",
1525 //                "_vl_msg_id"
1526 //            ],
1527 //            [
1528 //                "u32",
1529 //                "client_index"
1530 //            ],
1531 //            [
1532 //                "u32",
1533 //                "context"
1534 //            ],
1535 //            [
1536 //                "u32",
1537 //                "irt"
1538 //            ],
1539 //            [
1540 //                "u32",
1541 //                "mrt"
1542 //            ],
1543 //            [
1544 //                "u32",
1545 //                "mrc"
1546 //            ],
1547 //            [
1548 //                "u32",
1549 //                "mrd"
1550 //            ],
1551 //            [
1552 //                "u32",
1553 //                "sw_if_index"
1554 //            ],
1555 //            [
1556 //                "u8",
1557 //                "stop"
1558 //            ],
1559 //            {
1560 //                "crc": "0xbd968917"
1561 //            }
1562 //
1563 type IP6ndSendRouterSolicitation struct {
1564         Irt       uint32
1565         Mrt       uint32
1566         Mrc       uint32
1567         Mrd       uint32
1568         SwIfIndex uint32
1569         Stop      uint8
1570 }
1571
1572 func (*IP6ndSendRouterSolicitation) GetMessageName() string {
1573         return "ip6nd_send_router_solicitation"
1574 }
1575 func (*IP6ndSendRouterSolicitation) GetCrcString() string {
1576         return "bd968917"
1577 }
1578 func (*IP6ndSendRouterSolicitation) GetMessageType() api.MessageType {
1579         return api.RequestMessage
1580 }
1581 func NewIP6ndSendRouterSolicitation() api.Message {
1582         return &IP6ndSendRouterSolicitation{}
1583 }
1584
1585 // IP6ndSendRouterSolicitationReply represents the VPP binary API message 'ip6nd_send_router_solicitation_reply'.
1586 // Generated from 'ip.api.json', line 682:
1587 //
1588 //            "ip6nd_send_router_solicitation_reply",
1589 //            [
1590 //                "u16",
1591 //                "_vl_msg_id"
1592 //            ],
1593 //            [
1594 //                "u32",
1595 //                "context"
1596 //            ],
1597 //            [
1598 //                "i32",
1599 //                "retval"
1600 //            ],
1601 //            {
1602 //                "crc": "0xe8d4e804"
1603 //            }
1604 //
1605 type IP6ndSendRouterSolicitationReply struct {
1606         Retval int32
1607 }
1608
1609 func (*IP6ndSendRouterSolicitationReply) GetMessageName() string {
1610         return "ip6nd_send_router_solicitation_reply"
1611 }
1612 func (*IP6ndSendRouterSolicitationReply) GetCrcString() string {
1613         return "e8d4e804"
1614 }
1615 func (*IP6ndSendRouterSolicitationReply) GetMessageType() api.MessageType {
1616         return api.ReplyMessage
1617 }
1618 func NewIP6ndSendRouterSolicitationReply() api.Message {
1619         return &IP6ndSendRouterSolicitationReply{}
1620 }
1621
1622 // SwInterfaceIP6EnableDisable represents the VPP binary API message 'sw_interface_ip6_enable_disable'.
1623 // Generated from 'ip.api.json', line 700:
1624 //
1625 //            "sw_interface_ip6_enable_disable",
1626 //            [
1627 //                "u16",
1628 //                "_vl_msg_id"
1629 //            ],
1630 //            [
1631 //                "u32",
1632 //                "client_index"
1633 //            ],
1634 //            [
1635 //                "u32",
1636 //                "context"
1637 //            ],
1638 //            [
1639 //                "u32",
1640 //                "sw_if_index"
1641 //            ],
1642 //            [
1643 //                "u8",
1644 //                "enable"
1645 //            ],
1646 //            {
1647 //                "crc": "0xa36fadc0"
1648 //            }
1649 //
1650 type SwInterfaceIP6EnableDisable struct {
1651         SwIfIndex uint32
1652         Enable    uint8
1653 }
1654
1655 func (*SwInterfaceIP6EnableDisable) GetMessageName() string {
1656         return "sw_interface_ip6_enable_disable"
1657 }
1658 func (*SwInterfaceIP6EnableDisable) GetCrcString() string {
1659         return "a36fadc0"
1660 }
1661 func (*SwInterfaceIP6EnableDisable) GetMessageType() api.MessageType {
1662         return api.RequestMessage
1663 }
1664 func NewSwInterfaceIP6EnableDisable() api.Message {
1665         return &SwInterfaceIP6EnableDisable{}
1666 }
1667
1668 // SwInterfaceIP6EnableDisableReply represents the VPP binary API message 'sw_interface_ip6_enable_disable_reply'.
1669 // Generated from 'ip.api.json', line 726:
1670 //
1671 //            "sw_interface_ip6_enable_disable_reply",
1672 //            [
1673 //                "u16",
1674 //                "_vl_msg_id"
1675 //            ],
1676 //            [
1677 //                "u32",
1678 //                "context"
1679 //            ],
1680 //            [
1681 //                "i32",
1682 //                "retval"
1683 //            ],
1684 //            {
1685 //                "crc": "0xe8d4e804"
1686 //            }
1687 //
1688 type SwInterfaceIP6EnableDisableReply struct {
1689         Retval int32
1690 }
1691
1692 func (*SwInterfaceIP6EnableDisableReply) GetMessageName() string {
1693         return "sw_interface_ip6_enable_disable_reply"
1694 }
1695 func (*SwInterfaceIP6EnableDisableReply) GetCrcString() string {
1696         return "e8d4e804"
1697 }
1698 func (*SwInterfaceIP6EnableDisableReply) GetMessageType() api.MessageType {
1699         return api.ReplyMessage
1700 }
1701 func NewSwInterfaceIP6EnableDisableReply() api.Message {
1702         return &SwInterfaceIP6EnableDisableReply{}
1703 }
1704
1705 // SwInterfaceIP6SetLinkLocalAddress represents the VPP binary API message 'sw_interface_ip6_set_link_local_address'.
1706 // Generated from 'ip.api.json', line 744:
1707 //
1708 //            "sw_interface_ip6_set_link_local_address",
1709 //            [
1710 //                "u16",
1711 //                "_vl_msg_id"
1712 //            ],
1713 //            [
1714 //                "u32",
1715 //                "client_index"
1716 //            ],
1717 //            [
1718 //                "u32",
1719 //                "context"
1720 //            ],
1721 //            [
1722 //                "u32",
1723 //                "sw_if_index"
1724 //            ],
1725 //            [
1726 //                "u8",
1727 //                "address",
1728 //                16
1729 //            ],
1730 //            {
1731 //                "crc": "0xd73bf1ab"
1732 //            }
1733 //
1734 type SwInterfaceIP6SetLinkLocalAddress struct {
1735         SwIfIndex uint32
1736         Address   []byte `struc:"[16]byte"`
1737 }
1738
1739 func (*SwInterfaceIP6SetLinkLocalAddress) GetMessageName() string {
1740         return "sw_interface_ip6_set_link_local_address"
1741 }
1742 func (*SwInterfaceIP6SetLinkLocalAddress) GetCrcString() string {
1743         return "d73bf1ab"
1744 }
1745 func (*SwInterfaceIP6SetLinkLocalAddress) GetMessageType() api.MessageType {
1746         return api.RequestMessage
1747 }
1748 func NewSwInterfaceIP6SetLinkLocalAddress() api.Message {
1749         return &SwInterfaceIP6SetLinkLocalAddress{}
1750 }
1751
1752 // SwInterfaceIP6SetLinkLocalAddressReply represents the VPP binary API message 'sw_interface_ip6_set_link_local_address_reply'.
1753 // Generated from 'ip.api.json', line 771:
1754 //
1755 //            "sw_interface_ip6_set_link_local_address_reply",
1756 //            [
1757 //                "u16",
1758 //                "_vl_msg_id"
1759 //            ],
1760 //            [
1761 //                "u32",
1762 //                "context"
1763 //            ],
1764 //            [
1765 //                "i32",
1766 //                "retval"
1767 //            ],
1768 //            {
1769 //                "crc": "0xe8d4e804"
1770 //            }
1771 //
1772 type SwInterfaceIP6SetLinkLocalAddressReply struct {
1773         Retval int32
1774 }
1775
1776 func (*SwInterfaceIP6SetLinkLocalAddressReply) GetMessageName() string {
1777         return "sw_interface_ip6_set_link_local_address_reply"
1778 }
1779 func (*SwInterfaceIP6SetLinkLocalAddressReply) GetCrcString() string {
1780         return "e8d4e804"
1781 }
1782 func (*SwInterfaceIP6SetLinkLocalAddressReply) GetMessageType() api.MessageType {
1783         return api.ReplyMessage
1784 }
1785 func NewSwInterfaceIP6SetLinkLocalAddressReply() api.Message {
1786         return &SwInterfaceIP6SetLinkLocalAddressReply{}
1787 }
1788
1789 // IPAddDelRoute represents the VPP binary API message 'ip_add_del_route'.
1790 // Generated from 'ip.api.json', line 789:
1791 //
1792 //            "ip_add_del_route",
1793 //            [
1794 //                "u16",
1795 //                "_vl_msg_id"
1796 //            ],
1797 //            [
1798 //                "u32",
1799 //                "client_index"
1800 //            ],
1801 //            [
1802 //                "u32",
1803 //                "context"
1804 //            ],
1805 //            [
1806 //                "u32",
1807 //                "next_hop_sw_if_index"
1808 //            ],
1809 //            [
1810 //                "u32",
1811 //                "table_id"
1812 //            ],
1813 //            [
1814 //                "u32",
1815 //                "classify_table_index"
1816 //            ],
1817 //            [
1818 //                "u32",
1819 //                "next_hop_table_id"
1820 //            ],
1821 //            [
1822 //                "u32",
1823 //                "next_hop_id"
1824 //            ],
1825 //            [
1826 //                "u8",
1827 //                "is_add"
1828 //            ],
1829 //            [
1830 //                "u8",
1831 //                "is_drop"
1832 //            ],
1833 //            [
1834 //                "u8",
1835 //                "is_unreach"
1836 //            ],
1837 //            [
1838 //                "u8",
1839 //                "is_prohibit"
1840 //            ],
1841 //            [
1842 //                "u8",
1843 //                "is_ipv6"
1844 //            ],
1845 //            [
1846 //                "u8",
1847 //                "is_local"
1848 //            ],
1849 //            [
1850 //                "u8",
1851 //                "is_classify"
1852 //            ],
1853 //            [
1854 //                "u8",
1855 //                "is_multipath"
1856 //            ],
1857 //            [
1858 //                "u8",
1859 //                "is_resolve_host"
1860 //            ],
1861 //            [
1862 //                "u8",
1863 //                "is_resolve_attached"
1864 //            ],
1865 //            [
1866 //                "u8",
1867 //                "is_dvr"
1868 //            ],
1869 //            [
1870 //                "u8",
1871 //                "is_source_lookup"
1872 //            ],
1873 //            [
1874 //                "u8",
1875 //                "is_udp_encap"
1876 //            ],
1877 //            [
1878 //                "u8",
1879 //                "next_hop_weight"
1880 //            ],
1881 //            [
1882 //                "u8",
1883 //                "next_hop_preference"
1884 //            ],
1885 //            [
1886 //                "u8",
1887 //                "next_hop_proto"
1888 //            ],
1889 //            [
1890 //                "u8",
1891 //                "dst_address_length"
1892 //            ],
1893 //            [
1894 //                "u8",
1895 //                "dst_address",
1896 //                16
1897 //            ],
1898 //            [
1899 //                "u8",
1900 //                "next_hop_address",
1901 //                16
1902 //            ],
1903 //            [
1904 //                "u8",
1905 //                "next_hop_n_out_labels"
1906 //            ],
1907 //            [
1908 //                "u32",
1909 //                "next_hop_via_label"
1910 //            ],
1911 //            [
1912 //                "vl_api_fib_mpls_label_t",
1913 //                "next_hop_out_label_stack",
1914 //                0,
1915 //                "next_hop_n_out_labels"
1916 //            ],
1917 //            {
1918 //                "crc": "0x4219d62d"
1919 //            }
1920 //
1921 type IPAddDelRoute struct {
1922         NextHopSwIfIndex     uint32
1923         TableID              uint32
1924         ClassifyTableIndex   uint32
1925         NextHopTableID       uint32
1926         NextHopID            uint32
1927         IsAdd                uint8
1928         IsDrop               uint8
1929         IsUnreach            uint8
1930         IsProhibit           uint8
1931         IsIPv6               uint8
1932         IsLocal              uint8
1933         IsClassify           uint8
1934         IsMultipath          uint8
1935         IsResolveHost        uint8
1936         IsResolveAttached    uint8
1937         IsDvr                uint8
1938         IsSourceLookup       uint8
1939         IsUDPEncap           uint8
1940         NextHopWeight        uint8
1941         NextHopPreference    uint8
1942         NextHopProto         uint8
1943         DstAddressLength     uint8
1944         DstAddress           []byte `struc:"[16]byte"`
1945         NextHopAddress       []byte `struc:"[16]byte"`
1946         NextHopNOutLabels    uint8  `struc:"sizeof=NextHopOutLabelStack"`
1947         NextHopViaLabel      uint32
1948         NextHopOutLabelStack []FibMplsLabel
1949 }
1950
1951 func (*IPAddDelRoute) GetMessageName() string {
1952         return "ip_add_del_route"
1953 }
1954 func (*IPAddDelRoute) GetCrcString() string {
1955         return "4219d62d"
1956 }
1957 func (*IPAddDelRoute) GetMessageType() api.MessageType {
1958         return api.RequestMessage
1959 }
1960 func NewIPAddDelRoute() api.Message {
1961         return &IPAddDelRoute{}
1962 }
1963
1964 // IPAddDelRouteReply represents the VPP binary API message 'ip_add_del_route_reply'.
1965 // Generated from 'ip.api.json', line 919:
1966 //
1967 //            "ip_add_del_route_reply",
1968 //            [
1969 //                "u16",
1970 //                "_vl_msg_id"
1971 //            ],
1972 //            [
1973 //                "u32",
1974 //                "context"
1975 //            ],
1976 //            [
1977 //                "i32",
1978 //                "retval"
1979 //            ],
1980 //            {
1981 //                "crc": "0xe8d4e804"
1982 //            }
1983 //
1984 type IPAddDelRouteReply struct {
1985         Retval int32
1986 }
1987
1988 func (*IPAddDelRouteReply) GetMessageName() string {
1989         return "ip_add_del_route_reply"
1990 }
1991 func (*IPAddDelRouteReply) GetCrcString() string {
1992         return "e8d4e804"
1993 }
1994 func (*IPAddDelRouteReply) GetMessageType() api.MessageType {
1995         return api.ReplyMessage
1996 }
1997 func NewIPAddDelRouteReply() api.Message {
1998         return &IPAddDelRouteReply{}
1999 }
2000
2001 // IPMrouteAddDel represents the VPP binary API message 'ip_mroute_add_del'.
2002 // Generated from 'ip.api.json', line 937:
2003 //
2004 //            "ip_mroute_add_del",
2005 //            [
2006 //                "u16",
2007 //                "_vl_msg_id"
2008 //            ],
2009 //            [
2010 //                "u32",
2011 //                "client_index"
2012 //            ],
2013 //            [
2014 //                "u32",
2015 //                "context"
2016 //            ],
2017 //            [
2018 //                "u32",
2019 //                "next_hop_sw_if_index"
2020 //            ],
2021 //            [
2022 //                "u32",
2023 //                "table_id"
2024 //            ],
2025 //            [
2026 //                "u32",
2027 //                "entry_flags"
2028 //            ],
2029 //            [
2030 //                "u32",
2031 //                "itf_flags"
2032 //            ],
2033 //            [
2034 //                "u32",
2035 //                "rpf_id"
2036 //            ],
2037 //            [
2038 //                "u32",
2039 //                "bier_imp"
2040 //            ],
2041 //            [
2042 //                "u16",
2043 //                "grp_address_length"
2044 //            ],
2045 //            [
2046 //                "u8",
2047 //                "next_hop_afi"
2048 //            ],
2049 //            [
2050 //                "u8",
2051 //                "is_add"
2052 //            ],
2053 //            [
2054 //                "u8",
2055 //                "is_ipv6"
2056 //            ],
2057 //            [
2058 //                "u8",
2059 //                "is_local"
2060 //            ],
2061 //            [
2062 //                "u8",
2063 //                "grp_address",
2064 //                16
2065 //            ],
2066 //            [
2067 //                "u8",
2068 //                "src_address",
2069 //                16
2070 //            ],
2071 //            [
2072 //                "u8",
2073 //                "nh_address",
2074 //                16
2075 //            ],
2076 //            {
2077 //                "crc": "0xf44c17b1"
2078 //            }
2079 //
2080 type IPMrouteAddDel struct {
2081         NextHopSwIfIndex uint32
2082         TableID          uint32
2083         EntryFlags       uint32
2084         ItfFlags         uint32
2085         RpfID            uint32
2086         BierImp          uint32
2087         GrpAddressLength uint16
2088         NextHopAfi       uint8
2089         IsAdd            uint8
2090         IsIPv6           uint8
2091         IsLocal          uint8
2092         GrpAddress       []byte `struc:"[16]byte"`
2093         SrcAddress       []byte `struc:"[16]byte"`
2094         NhAddress        []byte `struc:"[16]byte"`
2095 }
2096
2097 func (*IPMrouteAddDel) GetMessageName() string {
2098         return "ip_mroute_add_del"
2099 }
2100 func (*IPMrouteAddDel) GetCrcString() string {
2101         return "f44c17b1"
2102 }
2103 func (*IPMrouteAddDel) GetMessageType() api.MessageType {
2104         return api.RequestMessage
2105 }
2106 func NewIPMrouteAddDel() api.Message {
2107         return &IPMrouteAddDel{}
2108 }
2109
2110 // IPMrouteAddDelReply represents the VPP binary API message 'ip_mroute_add_del_reply'.
2111 // Generated from 'ip.api.json', line 1014:
2112 //
2113 //            "ip_mroute_add_del_reply",
2114 //            [
2115 //                "u16",
2116 //                "_vl_msg_id"
2117 //            ],
2118 //            [
2119 //                "u32",
2120 //                "context"
2121 //            ],
2122 //            [
2123 //                "i32",
2124 //                "retval"
2125 //            ],
2126 //            {
2127 //                "crc": "0xe8d4e804"
2128 //            }
2129 //
2130 type IPMrouteAddDelReply struct {
2131         Retval int32
2132 }
2133
2134 func (*IPMrouteAddDelReply) GetMessageName() string {
2135         return "ip_mroute_add_del_reply"
2136 }
2137 func (*IPMrouteAddDelReply) GetCrcString() string {
2138         return "e8d4e804"
2139 }
2140 func (*IPMrouteAddDelReply) GetMessageType() api.MessageType {
2141         return api.ReplyMessage
2142 }
2143 func NewIPMrouteAddDelReply() api.Message {
2144         return &IPMrouteAddDelReply{}
2145 }
2146
2147 // IPMfibDump represents the VPP binary API message 'ip_mfib_dump'.
2148 // Generated from 'ip.api.json', line 1032:
2149 //
2150 //            "ip_mfib_dump",
2151 //            [
2152 //                "u16",
2153 //                "_vl_msg_id"
2154 //            ],
2155 //            [
2156 //                "u32",
2157 //                "client_index"
2158 //            ],
2159 //            [
2160 //                "u32",
2161 //                "context"
2162 //            ],
2163 //            {
2164 //                "crc": "0x51077d14"
2165 //            }
2166 //
2167 type IPMfibDump struct{}
2168
2169 func (*IPMfibDump) GetMessageName() string {
2170         return "ip_mfib_dump"
2171 }
2172 func (*IPMfibDump) GetCrcString() string {
2173         return "51077d14"
2174 }
2175 func (*IPMfibDump) GetMessageType() api.MessageType {
2176         return api.RequestMessage
2177 }
2178 func NewIPMfibDump() api.Message {
2179         return &IPMfibDump{}
2180 }
2181
2182 // IPMfibDetails represents the VPP binary API message 'ip_mfib_details'.
2183 // Generated from 'ip.api.json', line 1050:
2184 //
2185 //            "ip_mfib_details",
2186 //            [
2187 //                "u16",
2188 //                "_vl_msg_id"
2189 //            ],
2190 //            [
2191 //                "u32",
2192 //                "context"
2193 //            ],
2194 //            [
2195 //                "u32",
2196 //                "table_id"
2197 //            ],
2198 //            [
2199 //                "u32",
2200 //                "entry_flags"
2201 //            ],
2202 //            [
2203 //                "u32",
2204 //                "rpf_id"
2205 //            ],
2206 //            [
2207 //                "u8",
2208 //                "address_length"
2209 //            ],
2210 //            [
2211 //                "u8",
2212 //                "grp_address",
2213 //                4
2214 //            ],
2215 //            [
2216 //                "u8",
2217 //                "src_address",
2218 //                4
2219 //            ],
2220 //            [
2221 //                "u32",
2222 //                "count"
2223 //            ],
2224 //            [
2225 //                "vl_api_fib_path_t",
2226 //                "path",
2227 //                0,
2228 //                "count"
2229 //            ],
2230 //            {
2231 //                "crc": "0x5e530d5e"
2232 //            }
2233 //
2234 type IPMfibDetails struct {
2235         TableID       uint32
2236         EntryFlags    uint32
2237         RpfID         uint32
2238         AddressLength uint8
2239         GrpAddress    []byte `struc:"[4]byte"`
2240         SrcAddress    []byte `struc:"[4]byte"`
2241         Count         uint32 `struc:"sizeof=Path"`
2242         Path          []FibPath
2243 }
2244
2245 func (*IPMfibDetails) GetMessageName() string {
2246         return "ip_mfib_details"
2247 }
2248 func (*IPMfibDetails) GetCrcString() string {
2249         return "5e530d5e"
2250 }
2251 func (*IPMfibDetails) GetMessageType() api.MessageType {
2252         return api.ReplyMessage
2253 }
2254 func NewIPMfibDetails() api.Message {
2255         return &IPMfibDetails{}
2256 }
2257
2258 // IP6MfibDump represents the VPP binary API message 'ip6_mfib_dump'.
2259 // Generated from 'ip.api.json', line 1100:
2260 //
2261 //            "ip6_mfib_dump",
2262 //            [
2263 //                "u16",
2264 //                "_vl_msg_id"
2265 //            ],
2266 //            [
2267 //                "u32",
2268 //                "client_index"
2269 //            ],
2270 //            [
2271 //                "u32",
2272 //                "context"
2273 //            ],
2274 //            {
2275 //                "crc": "0x51077d14"
2276 //            }
2277 //
2278 type IP6MfibDump struct{}
2279
2280 func (*IP6MfibDump) GetMessageName() string {
2281         return "ip6_mfib_dump"
2282 }
2283 func (*IP6MfibDump) GetCrcString() string {
2284         return "51077d14"
2285 }
2286 func (*IP6MfibDump) GetMessageType() api.MessageType {
2287         return api.RequestMessage
2288 }
2289 func NewIP6MfibDump() api.Message {
2290         return &IP6MfibDump{}
2291 }
2292
2293 // IP6MfibDetails represents the VPP binary API message 'ip6_mfib_details'.
2294 // Generated from 'ip.api.json', line 1118:
2295 //
2296 //            "ip6_mfib_details",
2297 //            [
2298 //                "u16",
2299 //                "_vl_msg_id"
2300 //            ],
2301 //            [
2302 //                "u32",
2303 //                "context"
2304 //            ],
2305 //            [
2306 //                "u32",
2307 //                "table_id"
2308 //            ],
2309 //            [
2310 //                "u8",
2311 //                "address_length"
2312 //            ],
2313 //            [
2314 //                "u8",
2315 //                "grp_address",
2316 //                16
2317 //            ],
2318 //            [
2319 //                "u8",
2320 //                "src_address",
2321 //                16
2322 //            ],
2323 //            [
2324 //                "u32",
2325 //                "count"
2326 //            ],
2327 //            [
2328 //                "vl_api_fib_path_t",
2329 //                "path",
2330 //                0,
2331 //                "count"
2332 //            ],
2333 //            {
2334 //                "crc": "0xe02dcb4b"
2335 //            }
2336 //
2337 type IP6MfibDetails struct {
2338         TableID       uint32
2339         AddressLength uint8
2340         GrpAddress    []byte `struc:"[16]byte"`
2341         SrcAddress    []byte `struc:"[16]byte"`
2342         Count         uint32 `struc:"sizeof=Path"`
2343         Path          []FibPath
2344 }
2345
2346 func (*IP6MfibDetails) GetMessageName() string {
2347         return "ip6_mfib_details"
2348 }
2349 func (*IP6MfibDetails) GetCrcString() string {
2350         return "e02dcb4b"
2351 }
2352 func (*IP6MfibDetails) GetMessageType() api.MessageType {
2353         return api.ReplyMessage
2354 }
2355 func NewIP6MfibDetails() api.Message {
2356         return &IP6MfibDetails{}
2357 }
2358
2359 // IPAddressDetails represents the VPP binary API message 'ip_address_details'.
2360 // Generated from 'ip.api.json', line 1160:
2361 //
2362 //            "ip_address_details",
2363 //            [
2364 //                "u16",
2365 //                "_vl_msg_id"
2366 //            ],
2367 //            [
2368 //                "u32",
2369 //                "client_index"
2370 //            ],
2371 //            [
2372 //                "u32",
2373 //                "context"
2374 //            ],
2375 //            [
2376 //                "u8",
2377 //                "ip",
2378 //                16
2379 //            ],
2380 //            [
2381 //                "u8",
2382 //                "prefix_length"
2383 //            ],
2384 //            [
2385 //                "u32",
2386 //                "sw_if_index"
2387 //            ],
2388 //            [
2389 //                "u8",
2390 //                "is_ipv6"
2391 //            ],
2392 //            {
2393 //                "crc": "0xbc7442f2"
2394 //            }
2395 //
2396 type IPAddressDetails struct {
2397         IP           []byte `struc:"[16]byte"`
2398         PrefixLength uint8
2399         SwIfIndex    uint32
2400         IsIPv6       uint8
2401 }
2402
2403 func (*IPAddressDetails) GetMessageName() string {
2404         return "ip_address_details"
2405 }
2406 func (*IPAddressDetails) GetCrcString() string {
2407         return "bc7442f2"
2408 }
2409 func (*IPAddressDetails) GetMessageType() api.MessageType {
2410         return api.RequestMessage
2411 }
2412 func NewIPAddressDetails() api.Message {
2413         return &IPAddressDetails{}
2414 }
2415
2416 // IPAddressDump represents the VPP binary API message 'ip_address_dump'.
2417 // Generated from 'ip.api.json', line 1195:
2418 //
2419 //            "ip_address_dump",
2420 //            [
2421 //                "u16",
2422 //                "_vl_msg_id"
2423 //            ],
2424 //            [
2425 //                "u32",
2426 //                "client_index"
2427 //            ],
2428 //            [
2429 //                "u32",
2430 //                "context"
2431 //            ],
2432 //            [
2433 //                "u32",
2434 //                "sw_if_index"
2435 //            ],
2436 //            [
2437 //                "u8",
2438 //                "is_ipv6"
2439 //            ],
2440 //            {
2441 //                "crc": "0x6b7bcd0a"
2442 //            }
2443 //
2444 type IPAddressDump struct {
2445         SwIfIndex uint32
2446         IsIPv6    uint8
2447 }
2448
2449 func (*IPAddressDump) GetMessageName() string {
2450         return "ip_address_dump"
2451 }
2452 func (*IPAddressDump) GetCrcString() string {
2453         return "6b7bcd0a"
2454 }
2455 func (*IPAddressDump) GetMessageType() api.MessageType {
2456         return api.RequestMessage
2457 }
2458 func NewIPAddressDump() api.Message {
2459         return &IPAddressDump{}
2460 }
2461
2462 // IPUnnumberedDetails represents the VPP binary API message 'ip_unnumbered_details'.
2463 // Generated from 'ip.api.json', line 1221:
2464 //
2465 //            "ip_unnumbered_details",
2466 //            [
2467 //                "u16",
2468 //                "_vl_msg_id"
2469 //            ],
2470 //            [
2471 //                "u32",
2472 //                "client_index"
2473 //            ],
2474 //            [
2475 //                "u32",
2476 //                "context"
2477 //            ],
2478 //            [
2479 //                "u32",
2480 //                "sw_if_index"
2481 //            ],
2482 //            [
2483 //                "u32",
2484 //                "ip_sw_if_index"
2485 //            ],
2486 //            {
2487 //                "crc": "0x05b717ca"
2488 //            }
2489 //
2490 type IPUnnumberedDetails struct {
2491         SwIfIndex   uint32
2492         IPSwIfIndex uint32
2493 }
2494
2495 func (*IPUnnumberedDetails) GetMessageName() string {
2496         return "ip_unnumbered_details"
2497 }
2498 func (*IPUnnumberedDetails) GetCrcString() string {
2499         return "05b717ca"
2500 }
2501 func (*IPUnnumberedDetails) GetMessageType() api.MessageType {
2502         return api.RequestMessage
2503 }
2504 func NewIPUnnumberedDetails() api.Message {
2505         return &IPUnnumberedDetails{}
2506 }
2507
2508 // IPUnnumberedDump represents the VPP binary API message 'ip_unnumbered_dump'.
2509 // Generated from 'ip.api.json', line 1247:
2510 //
2511 //            "ip_unnumbered_dump",
2512 //            [
2513 //                "u16",
2514 //                "_vl_msg_id"
2515 //            ],
2516 //            [
2517 //                "u32",
2518 //                "client_index"
2519 //            ],
2520 //            [
2521 //                "u32",
2522 //                "context"
2523 //            ],
2524 //            [
2525 //                "u32",
2526 //                "sw_if_index"
2527 //            ],
2528 //            {
2529 //                "crc": "0x529cb13f"
2530 //            }
2531 //
2532 type IPUnnumberedDump struct {
2533         SwIfIndex uint32
2534 }
2535
2536 func (*IPUnnumberedDump) GetMessageName() string {
2537         return "ip_unnumbered_dump"
2538 }
2539 func (*IPUnnumberedDump) GetCrcString() string {
2540         return "529cb13f"
2541 }
2542 func (*IPUnnumberedDump) GetMessageType() api.MessageType {
2543         return api.RequestMessage
2544 }
2545 func NewIPUnnumberedDump() api.Message {
2546         return &IPUnnumberedDump{}
2547 }
2548
2549 // IPDetails represents the VPP binary API message 'ip_details'.
2550 // Generated from 'ip.api.json', line 1269:
2551 //
2552 //            "ip_details",
2553 //            [
2554 //                "u16",
2555 //                "_vl_msg_id"
2556 //            ],
2557 //            [
2558 //                "u32",
2559 //                "sw_if_index"
2560 //            ],
2561 //            [
2562 //                "u32",
2563 //                "context"
2564 //            ],
2565 //            [
2566 //                "u8",
2567 //                "is_ipv6"
2568 //            ],
2569 //            {
2570 //                "crc": "0x452ffc5a"
2571 //            }
2572 //
2573 type IPDetails struct {
2574         SwIfIndex uint32
2575         Context   uint32
2576         IsIPv6    uint8
2577 }
2578
2579 func (*IPDetails) GetMessageName() string {
2580         return "ip_details"
2581 }
2582 func (*IPDetails) GetCrcString() string {
2583         return "452ffc5a"
2584 }
2585 func (*IPDetails) GetMessageType() api.MessageType {
2586         return api.OtherMessage
2587 }
2588 func NewIPDetails() api.Message {
2589         return &IPDetails{}
2590 }
2591
2592 // IPDump represents the VPP binary API message 'ip_dump'.
2593 // Generated from 'ip.api.json', line 1291:
2594 //
2595 //            "ip_dump",
2596 //            [
2597 //                "u16",
2598 //                "_vl_msg_id"
2599 //            ],
2600 //            [
2601 //                "u32",
2602 //                "client_index"
2603 //            ],
2604 //            [
2605 //                "u32",
2606 //                "context"
2607 //            ],
2608 //            [
2609 //                "u8",
2610 //                "is_ipv6"
2611 //            ],
2612 //            {
2613 //                "crc": "0xde883da4"
2614 //            }
2615 //
2616 type IPDump struct {
2617         IsIPv6 uint8
2618 }
2619
2620 func (*IPDump) GetMessageName() string {
2621         return "ip_dump"
2622 }
2623 func (*IPDump) GetCrcString() string {
2624         return "de883da4"
2625 }
2626 func (*IPDump) GetMessageType() api.MessageType {
2627         return api.RequestMessage
2628 }
2629 func NewIPDump() api.Message {
2630         return &IPDump{}
2631 }
2632
2633 // MfibSignalDump represents the VPP binary API message 'mfib_signal_dump'.
2634 // Generated from 'ip.api.json', line 1313:
2635 //
2636 //            "mfib_signal_dump",
2637 //            [
2638 //                "u16",
2639 //                "_vl_msg_id"
2640 //            ],
2641 //            [
2642 //                "u32",
2643 //                "client_index"
2644 //            ],
2645 //            [
2646 //                "u32",
2647 //                "context"
2648 //            ],
2649 //            {
2650 //                "crc": "0x51077d14"
2651 //            }
2652 //
2653 type MfibSignalDump struct{}
2654
2655 func (*MfibSignalDump) GetMessageName() string {
2656         return "mfib_signal_dump"
2657 }
2658 func (*MfibSignalDump) GetCrcString() string {
2659         return "51077d14"
2660 }
2661 func (*MfibSignalDump) GetMessageType() api.MessageType {
2662         return api.RequestMessage
2663 }
2664 func NewMfibSignalDump() api.Message {
2665         return &MfibSignalDump{}
2666 }
2667
2668 // MfibSignalDetails represents the VPP binary API message 'mfib_signal_details'.
2669 // Generated from 'ip.api.json', line 1331:
2670 //
2671 //            "mfib_signal_details",
2672 //            [
2673 //                "u16",
2674 //                "_vl_msg_id"
2675 //            ],
2676 //            [
2677 //                "u32",
2678 //                "client_index"
2679 //            ],
2680 //            [
2681 //                "u32",
2682 //                "context"
2683 //            ],
2684 //            [
2685 //                "u32",
2686 //                "sw_if_index"
2687 //            ],
2688 //            [
2689 //                "u32",
2690 //                "table_id"
2691 //            ],
2692 //            [
2693 //                "u16",
2694 //                "grp_address_len"
2695 //            ],
2696 //            [
2697 //                "u8",
2698 //                "grp_address",
2699 //                16
2700 //            ],
2701 //            [
2702 //                "u8",
2703 //                "src_address",
2704 //                16
2705 //            ],
2706 //            [
2707 //                "u16",
2708 //                "ip_packet_len"
2709 //            ],
2710 //            [
2711 //                "u8",
2712 //                "ip_packet_data",
2713 //                256
2714 //            ],
2715 //            {
2716 //                "crc": "0x791bbeab"
2717 //            }
2718 //
2719 type MfibSignalDetails struct {
2720         SwIfIndex     uint32
2721         TableID       uint32
2722         GrpAddressLen uint16
2723         GrpAddress    []byte `struc:"[16]byte"`
2724         SrcAddress    []byte `struc:"[16]byte"`
2725         IPPacketLen   uint16
2726         IPPacketData  []byte `struc:"[256]byte"`
2727 }
2728
2729 func (*MfibSignalDetails) GetMessageName() string {
2730         return "mfib_signal_details"
2731 }
2732 func (*MfibSignalDetails) GetCrcString() string {
2733         return "791bbeab"
2734 }
2735 func (*MfibSignalDetails) GetMessageType() api.MessageType {
2736         return api.RequestMessage
2737 }
2738 func NewMfibSignalDetails() api.Message {
2739         return &MfibSignalDetails{}
2740 }
2741
2742 // IPPuntPolice represents the VPP binary API message 'ip_punt_police'.
2743 // Generated from 'ip.api.json', line 1380:
2744 //
2745 //            "ip_punt_police",
2746 //            [
2747 //                "u16",
2748 //                "_vl_msg_id"
2749 //            ],
2750 //            [
2751 //                "u32",
2752 //                "client_index"
2753 //            ],
2754 //            [
2755 //                "u32",
2756 //                "context"
2757 //            ],
2758 //            [
2759 //                "u32",
2760 //                "policer_index"
2761 //            ],
2762 //            [
2763 //                "u8",
2764 //                "is_add"
2765 //            ],
2766 //            [
2767 //                "u8",
2768 //                "is_ip6"
2769 //            ],
2770 //            {
2771 //                "crc": "0x38691592"
2772 //            }
2773 //
2774 type IPPuntPolice struct {
2775         PolicerIndex uint32
2776         IsAdd        uint8
2777         IsIP6        uint8
2778 }
2779
2780 func (*IPPuntPolice) GetMessageName() string {
2781         return "ip_punt_police"
2782 }
2783 func (*IPPuntPolice) GetCrcString() string {
2784         return "38691592"
2785 }
2786 func (*IPPuntPolice) GetMessageType() api.MessageType {
2787         return api.RequestMessage
2788 }
2789 func NewIPPuntPolice() api.Message {
2790         return &IPPuntPolice{}
2791 }
2792
2793 // IPPuntPoliceReply represents the VPP binary API message 'ip_punt_police_reply'.
2794 // Generated from 'ip.api.json', line 1410:
2795 //
2796 //            "ip_punt_police_reply",
2797 //            [
2798 //                "u16",
2799 //                "_vl_msg_id"
2800 //            ],
2801 //            [
2802 //                "u32",
2803 //                "context"
2804 //            ],
2805 //            [
2806 //                "i32",
2807 //                "retval"
2808 //            ],
2809 //            {
2810 //                "crc": "0xe8d4e804"
2811 //            }
2812 //
2813 type IPPuntPoliceReply struct {
2814         Retval int32
2815 }
2816
2817 func (*IPPuntPoliceReply) GetMessageName() string {
2818         return "ip_punt_police_reply"
2819 }
2820 func (*IPPuntPoliceReply) GetCrcString() string {
2821         return "e8d4e804"
2822 }
2823 func (*IPPuntPoliceReply) GetMessageType() api.MessageType {
2824         return api.ReplyMessage
2825 }
2826 func NewIPPuntPoliceReply() api.Message {
2827         return &IPPuntPoliceReply{}
2828 }
2829
2830 // IPPuntRedirect represents the VPP binary API message 'ip_punt_redirect'.
2831 // Generated from 'ip.api.json', line 1428:
2832 //
2833 //            "ip_punt_redirect",
2834 //            [
2835 //                "u16",
2836 //                "_vl_msg_id"
2837 //            ],
2838 //            [
2839 //                "u32",
2840 //                "client_index"
2841 //            ],
2842 //            [
2843 //                "u32",
2844 //                "context"
2845 //            ],
2846 //            [
2847 //                "u32",
2848 //                "rx_sw_if_index"
2849 //            ],
2850 //            [
2851 //                "u32",
2852 //                "tx_sw_if_index"
2853 //            ],
2854 //            [
2855 //                "u8",
2856 //                "is_add"
2857 //            ],
2858 //            [
2859 //                "u8",
2860 //                "is_ip6"
2861 //            ],
2862 //            [
2863 //                "u8",
2864 //                "nh",
2865 //                16
2866 //            ],
2867 //            {
2868 //                "crc": "0x996b6603"
2869 //            }
2870 //
2871 type IPPuntRedirect struct {
2872         RxSwIfIndex uint32
2873         TxSwIfIndex uint32
2874         IsAdd       uint8
2875         IsIP6       uint8
2876         Nh          []byte `struc:"[16]byte"`
2877 }
2878
2879 func (*IPPuntRedirect) GetMessageName() string {
2880         return "ip_punt_redirect"
2881 }
2882 func (*IPPuntRedirect) GetCrcString() string {
2883         return "996b6603"
2884 }
2885 func (*IPPuntRedirect) GetMessageType() api.MessageType {
2886         return api.RequestMessage
2887 }
2888 func NewIPPuntRedirect() api.Message {
2889         return &IPPuntRedirect{}
2890 }
2891
2892 // IPPuntRedirectReply represents the VPP binary API message 'ip_punt_redirect_reply'.
2893 // Generated from 'ip.api.json', line 1467:
2894 //
2895 //            "ip_punt_redirect_reply",
2896 //            [
2897 //                "u16",
2898 //                "_vl_msg_id"
2899 //            ],
2900 //            [
2901 //                "u32",
2902 //                "context"
2903 //            ],
2904 //            [
2905 //                "i32",
2906 //                "retval"
2907 //            ],
2908 //            {
2909 //                "crc": "0xe8d4e804"
2910 //            }
2911 //
2912 type IPPuntRedirectReply struct {
2913         Retval int32
2914 }
2915
2916 func (*IPPuntRedirectReply) GetMessageName() string {
2917         return "ip_punt_redirect_reply"
2918 }
2919 func (*IPPuntRedirectReply) GetCrcString() string {
2920         return "e8d4e804"
2921 }
2922 func (*IPPuntRedirectReply) GetMessageType() api.MessageType {
2923         return api.ReplyMessage
2924 }
2925 func NewIPPuntRedirectReply() api.Message {
2926         return &IPPuntRedirectReply{}
2927 }
2928
2929 // IPContainerProxyAddDel represents the VPP binary API message 'ip_container_proxy_add_del'.
2930 // Generated from 'ip.api.json', line 1485:
2931 //
2932 //            "ip_container_proxy_add_del",
2933 //            [
2934 //                "u16",
2935 //                "_vl_msg_id"
2936 //            ],
2937 //            [
2938 //                "u32",
2939 //                "client_index"
2940 //            ],
2941 //            [
2942 //                "u32",
2943 //                "context"
2944 //            ],
2945 //            [
2946 //                "u8",
2947 //                "ip",
2948 //                16
2949 //            ],
2950 //            [
2951 //                "u8",
2952 //                "is_ip4"
2953 //            ],
2954 //            [
2955 //                "u8",
2956 //                "plen"
2957 //            ],
2958 //            [
2959 //                "u32",
2960 //                "sw_if_index"
2961 //            ],
2962 //            [
2963 //                "u8",
2964 //                "is_add"
2965 //            ],
2966 //            {
2967 //                "crc": "0x0a355d39"
2968 //            }
2969 //
2970 type IPContainerProxyAddDel struct {
2971         IP        []byte `struc:"[16]byte"`
2972         IsIP4     uint8
2973         Plen      uint8
2974         SwIfIndex uint32
2975         IsAdd     uint8
2976 }
2977
2978 func (*IPContainerProxyAddDel) GetMessageName() string {
2979         return "ip_container_proxy_add_del"
2980 }
2981 func (*IPContainerProxyAddDel) GetCrcString() string {
2982         return "0a355d39"
2983 }
2984 func (*IPContainerProxyAddDel) GetMessageType() api.MessageType {
2985         return api.RequestMessage
2986 }
2987 func NewIPContainerProxyAddDel() api.Message {
2988         return &IPContainerProxyAddDel{}
2989 }
2990
2991 // IPContainerProxyAddDelReply represents the VPP binary API message 'ip_container_proxy_add_del_reply'.
2992 // Generated from 'ip.api.json', line 1524:
2993 //
2994 //            "ip_container_proxy_add_del_reply",
2995 //            [
2996 //                "u16",
2997 //                "_vl_msg_id"
2998 //            ],
2999 //            [
3000 //                "u32",
3001 //                "context"
3002 //            ],
3003 //            [
3004 //                "i32",
3005 //                "retval"
3006 //            ],
3007 //            {
3008 //                "crc": "0xe8d4e804"
3009 //            }
3010 //
3011 type IPContainerProxyAddDelReply struct {
3012         Retval int32
3013 }
3014
3015 func (*IPContainerProxyAddDelReply) GetMessageName() string {
3016         return "ip_container_proxy_add_del_reply"
3017 }
3018 func (*IPContainerProxyAddDelReply) GetCrcString() string {
3019         return "e8d4e804"
3020 }
3021 func (*IPContainerProxyAddDelReply) GetMessageType() api.MessageType {
3022         return api.ReplyMessage
3023 }
3024 func NewIPContainerProxyAddDelReply() api.Message {
3025         return &IPContainerProxyAddDelReply{}
3026 }
3027
3028 // IPSourceAndPortRangeCheckAddDel represents the VPP binary API message 'ip_source_and_port_range_check_add_del'.
3029 // Generated from 'ip.api.json', line 1542:
3030 //
3031 //            "ip_source_and_port_range_check_add_del",
3032 //            [
3033 //                "u16",
3034 //                "_vl_msg_id"
3035 //            ],
3036 //            [
3037 //                "u32",
3038 //                "client_index"
3039 //            ],
3040 //            [
3041 //                "u32",
3042 //                "context"
3043 //            ],
3044 //            [
3045 //                "u8",
3046 //                "is_ipv6"
3047 //            ],
3048 //            [
3049 //                "u8",
3050 //                "is_add"
3051 //            ],
3052 //            [
3053 //                "u8",
3054 //                "mask_length"
3055 //            ],
3056 //            [
3057 //                "u8",
3058 //                "address",
3059 //                16
3060 //            ],
3061 //            [
3062 //                "u8",
3063 //                "number_of_ranges"
3064 //            ],
3065 //            [
3066 //                "u16",
3067 //                "low_ports",
3068 //                32
3069 //            ],
3070 //            [
3071 //                "u16",
3072 //                "high_ports",
3073 //                32
3074 //            ],
3075 //            [
3076 //                "u32",
3077 //                "vrf_id"
3078 //            ],
3079 //            {
3080 //                "crc": "0x03d6b03a"
3081 //            }
3082 //
3083 type IPSourceAndPortRangeCheckAddDel struct {
3084         IsIPv6         uint8
3085         IsAdd          uint8
3086         MaskLength     uint8
3087         Address        []byte `struc:"[16]byte"`
3088         NumberOfRanges uint8
3089         LowPorts       []uint16 `struc:"[32]uint16"`
3090         HighPorts      []uint16 `struc:"[32]uint16"`
3091         VrfID          uint32
3092 }
3093
3094 func (*IPSourceAndPortRangeCheckAddDel) GetMessageName() string {
3095         return "ip_source_and_port_range_check_add_del"
3096 }
3097 func (*IPSourceAndPortRangeCheckAddDel) GetCrcString() string {
3098         return "03d6b03a"
3099 }
3100 func (*IPSourceAndPortRangeCheckAddDel) GetMessageType() api.MessageType {
3101         return api.RequestMessage
3102 }
3103 func NewIPSourceAndPortRangeCheckAddDel() api.Message {
3104         return &IPSourceAndPortRangeCheckAddDel{}
3105 }
3106
3107 // IPSourceAndPortRangeCheckAddDelReply represents the VPP binary API message 'ip_source_and_port_range_check_add_del_reply'.
3108 // Generated from 'ip.api.json', line 1595:
3109 //
3110 //            "ip_source_and_port_range_check_add_del_reply",
3111 //            [
3112 //                "u16",
3113 //                "_vl_msg_id"
3114 //            ],
3115 //            [
3116 //                "u32",
3117 //                "context"
3118 //            ],
3119 //            [
3120 //                "i32",
3121 //                "retval"
3122 //            ],
3123 //            {
3124 //                "crc": "0xe8d4e804"
3125 //            }
3126 //
3127 type IPSourceAndPortRangeCheckAddDelReply struct {
3128         Retval int32
3129 }
3130
3131 func (*IPSourceAndPortRangeCheckAddDelReply) GetMessageName() string {
3132         return "ip_source_and_port_range_check_add_del_reply"
3133 }
3134 func (*IPSourceAndPortRangeCheckAddDelReply) GetCrcString() string {
3135         return "e8d4e804"
3136 }
3137 func (*IPSourceAndPortRangeCheckAddDelReply) GetMessageType() api.MessageType {
3138         return api.ReplyMessage
3139 }
3140 func NewIPSourceAndPortRangeCheckAddDelReply() api.Message {
3141         return &IPSourceAndPortRangeCheckAddDelReply{}
3142 }
3143
3144 // IPSourceAndPortRangeCheckInterfaceAddDel represents the VPP binary API message 'ip_source_and_port_range_check_interface_add_del'.
3145 // Generated from 'ip.api.json', line 1613:
3146 //
3147 //            "ip_source_and_port_range_check_interface_add_del",
3148 //            [
3149 //                "u16",
3150 //                "_vl_msg_id"
3151 //            ],
3152 //            [
3153 //                "u32",
3154 //                "client_index"
3155 //            ],
3156 //            [
3157 //                "u32",
3158 //                "context"
3159 //            ],
3160 //            [
3161 //                "u8",
3162 //                "is_add"
3163 //            ],
3164 //            [
3165 //                "u32",
3166 //                "sw_if_index"
3167 //            ],
3168 //            [
3169 //                "u32",
3170 //                "tcp_in_vrf_id"
3171 //            ],
3172 //            [
3173 //                "u32",
3174 //                "tcp_out_vrf_id"
3175 //            ],
3176 //            [
3177 //                "u32",
3178 //                "udp_in_vrf_id"
3179 //            ],
3180 //            [
3181 //                "u32",
3182 //                "udp_out_vrf_id"
3183 //            ],
3184 //            {
3185 //                "crc": "0x6966bc44"
3186 //            }
3187 //
3188 type IPSourceAndPortRangeCheckInterfaceAddDel struct {
3189         IsAdd       uint8
3190         SwIfIndex   uint32
3191         TCPInVrfID  uint32
3192         TCPOutVrfID uint32
3193         UDPInVrfID  uint32
3194         UDPOutVrfID uint32
3195 }
3196
3197 func (*IPSourceAndPortRangeCheckInterfaceAddDel) GetMessageName() string {
3198         return "ip_source_and_port_range_check_interface_add_del"
3199 }
3200 func (*IPSourceAndPortRangeCheckInterfaceAddDel) GetCrcString() string {
3201         return "6966bc44"
3202 }
3203 func (*IPSourceAndPortRangeCheckInterfaceAddDel) GetMessageType() api.MessageType {
3204         return api.RequestMessage
3205 }
3206 func NewIPSourceAndPortRangeCheckInterfaceAddDel() api.Message {
3207         return &IPSourceAndPortRangeCheckInterfaceAddDel{}
3208 }
3209
3210 // IPSourceAndPortRangeCheckInterfaceAddDelReply represents the VPP binary API message 'ip_source_and_port_range_check_interface_add_del_reply'.
3211 // Generated from 'ip.api.json', line 1655:
3212 //
3213 //            "ip_source_and_port_range_check_interface_add_del_reply",
3214 //            [
3215 //                "u16",
3216 //                "_vl_msg_id"
3217 //            ],
3218 //            [
3219 //                "u32",
3220 //                "context"
3221 //            ],
3222 //            [
3223 //                "i32",
3224 //                "retval"
3225 //            ],
3226 //            {
3227 //                "crc": "0xe8d4e804"
3228 //            }
3229 //
3230 type IPSourceAndPortRangeCheckInterfaceAddDelReply struct {
3231         Retval int32
3232 }
3233
3234 func (*IPSourceAndPortRangeCheckInterfaceAddDelReply) GetMessageName() string {
3235         return "ip_source_and_port_range_check_interface_add_del_reply"
3236 }
3237 func (*IPSourceAndPortRangeCheckInterfaceAddDelReply) GetCrcString() string {
3238         return "e8d4e804"
3239 }
3240 func (*IPSourceAndPortRangeCheckInterfaceAddDelReply) GetMessageType() api.MessageType {
3241         return api.ReplyMessage
3242 }
3243 func NewIPSourceAndPortRangeCheckInterfaceAddDelReply() api.Message {
3244         return &IPSourceAndPortRangeCheckInterfaceAddDelReply{}
3245 }
3246
3247 // IPScanNeighborEnableDisable represents the VPP binary API message 'ip_scan_neighbor_enable_disable'.
3248 // Generated from 'ip.api.json', line 1673:
3249 //
3250 //            "ip_scan_neighbor_enable_disable",
3251 //            [
3252 //                "u16",
3253 //                "_vl_msg_id"
3254 //            ],
3255 //            [
3256 //                "u32",
3257 //                "client_index"
3258 //            ],
3259 //            [
3260 //                "u32",
3261 //                "context"
3262 //            ],
3263 //            [
3264 //                "u8",
3265 //                "mode"
3266 //            ],
3267 //            [
3268 //                "u8",
3269 //                "scan_interval"
3270 //            ],
3271 //            [
3272 //                "u8",
3273 //                "max_proc_time"
3274 //            ],
3275 //            [
3276 //                "u8",
3277 //                "max_update"
3278 //            ],
3279 //            [
3280 //                "u8",
3281 //                "scan_int_delay"
3282 //            ],
3283 //            [
3284 //                "u8",
3285 //                "stale_threshold"
3286 //            ],
3287 //            {
3288 //                "crc": "0x0a6bf57a"
3289 //            }
3290 //
3291 type IPScanNeighborEnableDisable struct {
3292         Mode           uint8
3293         ScanInterval   uint8
3294         MaxProcTime    uint8
3295         MaxUpdate      uint8
3296         ScanIntDelay   uint8
3297         StaleThreshold uint8
3298 }
3299
3300 func (*IPScanNeighborEnableDisable) GetMessageName() string {
3301         return "ip_scan_neighbor_enable_disable"
3302 }
3303 func (*IPScanNeighborEnableDisable) GetCrcString() string {
3304         return "0a6bf57a"
3305 }
3306 func (*IPScanNeighborEnableDisable) GetMessageType() api.MessageType {
3307         return api.RequestMessage
3308 }
3309 func NewIPScanNeighborEnableDisable() api.Message {
3310         return &IPScanNeighborEnableDisable{}
3311 }
3312
3313 // IPScanNeighborEnableDisableReply represents the VPP binary API message 'ip_scan_neighbor_enable_disable_reply'.
3314 // Generated from 'ip.api.json', line 1715:
3315 //
3316 //            "ip_scan_neighbor_enable_disable_reply",
3317 //            [
3318 //                "u16",
3319 //                "_vl_msg_id"
3320 //            ],
3321 //            [
3322 //                "u32",
3323 //                "context"
3324 //            ],
3325 //            [
3326 //                "i32",
3327 //                "retval"
3328 //            ],
3329 //            {
3330 //                "crc": "0xe8d4e804"
3331 //            }
3332 //
3333 type IPScanNeighborEnableDisableReply struct {
3334         Retval int32
3335 }
3336
3337 func (*IPScanNeighborEnableDisableReply) GetMessageName() string {
3338         return "ip_scan_neighbor_enable_disable_reply"
3339 }
3340 func (*IPScanNeighborEnableDisableReply) GetCrcString() string {
3341         return "e8d4e804"
3342 }
3343 func (*IPScanNeighborEnableDisableReply) GetMessageType() api.MessageType {
3344         return api.ReplyMessage
3345 }
3346 func NewIPScanNeighborEnableDisableReply() api.Message {
3347         return &IPScanNeighborEnableDisableReply{}
3348 }
3349
3350 // IPProbeNeighbor represents the VPP binary API message 'ip_probe_neighbor'.
3351 // Generated from 'ip.api.json', line 1733:
3352 //
3353 //            "ip_probe_neighbor",
3354 //            [
3355 //                "u16",
3356 //                "_vl_msg_id"
3357 //            ],
3358 //            [
3359 //                "u32",
3360 //                "client_index"
3361 //            ],
3362 //            [
3363 //                "u32",
3364 //                "context"
3365 //            ],
3366 //            [
3367 //                "u32",
3368 //                "sw_if_index"
3369 //            ],
3370 //            [
3371 //                "u8",
3372 //                "dst_address",
3373 //                16
3374 //            ],
3375 //            [
3376 //                "u8",
3377 //                "is_ipv6"
3378 //            ],
3379 //            {
3380 //                "crc": "0x1e44bfd7"
3381 //            }
3382 //
3383 type IPProbeNeighbor struct {
3384         SwIfIndex  uint32
3385         DstAddress []byte `struc:"[16]byte"`
3386         IsIPv6     uint8
3387 }
3388
3389 func (*IPProbeNeighbor) GetMessageName() string {
3390         return "ip_probe_neighbor"
3391 }
3392 func (*IPProbeNeighbor) GetCrcString() string {
3393         return "1e44bfd7"
3394 }
3395 func (*IPProbeNeighbor) GetMessageType() api.MessageType {
3396         return api.RequestMessage
3397 }
3398 func NewIPProbeNeighbor() api.Message {
3399         return &IPProbeNeighbor{}
3400 }
3401
3402 // IPProbeNeighborReply represents the VPP binary API message 'ip_probe_neighbor_reply'.
3403 // Generated from 'ip.api.json', line 1764:
3404 //
3405 //            "ip_probe_neighbor_reply",
3406 //            [
3407 //                "u16",
3408 //                "_vl_msg_id"
3409 //            ],
3410 //            [
3411 //                "u32",
3412 //                "context"
3413 //            ],
3414 //            [
3415 //                "i32",
3416 //                "retval"
3417 //            ],
3418 //            {
3419 //                "crc": "0xe8d4e804"
3420 //            }
3421 //
3422 type IPProbeNeighborReply struct {
3423         Retval int32
3424 }
3425
3426 func (*IPProbeNeighborReply) GetMessageName() string {
3427         return "ip_probe_neighbor_reply"
3428 }
3429 func (*IPProbeNeighborReply) GetCrcString() string {
3430         return "e8d4e804"
3431 }
3432 func (*IPProbeNeighborReply) GetMessageType() api.MessageType {
3433         return api.ReplyMessage
3434 }
3435 func NewIPProbeNeighborReply() api.Message {
3436         return &IPProbeNeighborReply{}
3437 }
3438
3439 // WantIP4ArpEvents represents the VPP binary API message 'want_ip4_arp_events'.
3440 // Generated from 'ip.api.json', line 1782:
3441 //
3442 //            "want_ip4_arp_events",
3443 //            [
3444 //                "u16",
3445 //                "_vl_msg_id"
3446 //            ],
3447 //            [
3448 //                "u32",
3449 //                "client_index"
3450 //            ],
3451 //            [
3452 //                "u32",
3453 //                "context"
3454 //            ],
3455 //            [
3456 //                "u8",
3457 //                "enable_disable"
3458 //            ],
3459 //            [
3460 //                "u32",
3461 //                "pid"
3462 //            ],
3463 //            [
3464 //                "u32",
3465 //                "address"
3466 //            ],
3467 //            {
3468 //                "crc": "0x77e06379"
3469 //            }
3470 //
3471 type WantIP4ArpEvents struct {
3472         EnableDisable uint8
3473         PID           uint32
3474         Address       uint32
3475 }
3476
3477 func (*WantIP4ArpEvents) GetMessageName() string {
3478         return "want_ip4_arp_events"
3479 }
3480 func (*WantIP4ArpEvents) GetCrcString() string {
3481         return "77e06379"
3482 }
3483 func (*WantIP4ArpEvents) GetMessageType() api.MessageType {
3484         return api.RequestMessage
3485 }
3486 func NewWantIP4ArpEvents() api.Message {
3487         return &WantIP4ArpEvents{}
3488 }
3489
3490 // WantIP4ArpEventsReply represents the VPP binary API message 'want_ip4_arp_events_reply'.
3491 // Generated from 'ip.api.json', line 1812:
3492 //
3493 //            "want_ip4_arp_events_reply",
3494 //            [
3495 //                "u16",
3496 //                "_vl_msg_id"
3497 //            ],
3498 //            [
3499 //                "u32",
3500 //                "context"
3501 //            ],
3502 //            [
3503 //                "i32",
3504 //                "retval"
3505 //            ],
3506 //            {
3507 //                "crc": "0xe8d4e804"
3508 //            }
3509 //
3510 type WantIP4ArpEventsReply struct {
3511         Retval int32
3512 }
3513
3514 func (*WantIP4ArpEventsReply) GetMessageName() string {
3515         return "want_ip4_arp_events_reply"
3516 }
3517 func (*WantIP4ArpEventsReply) GetCrcString() string {
3518         return "e8d4e804"
3519 }
3520 func (*WantIP4ArpEventsReply) GetMessageType() api.MessageType {
3521         return api.ReplyMessage
3522 }
3523 func NewWantIP4ArpEventsReply() api.Message {
3524         return &WantIP4ArpEventsReply{}
3525 }
3526
3527 // IP4ArpEvent represents the VPP binary API message 'ip4_arp_event'.
3528 // Generated from 'ip.api.json', line 1830:
3529 //
3530 //            "ip4_arp_event",
3531 //            [
3532 //                "u16",
3533 //                "_vl_msg_id"
3534 //            ],
3535 //            [
3536 //                "u32",
3537 //                "client_index"
3538 //            ],
3539 //            [
3540 //                "u32",
3541 //                "address"
3542 //            ],
3543 //            [
3544 //                "u32",
3545 //                "pid"
3546 //            ],
3547 //            [
3548 //                "u32",
3549 //                "sw_if_index"
3550 //            ],
3551 //            [
3552 //                "u8",
3553 //                "new_mac",
3554 //                6
3555 //            ],
3556 //            [
3557 //                "u8",
3558 //                "mac_ip"
3559 //            ],
3560 //            {
3561 //                "crc": "0xef7235f7"
3562 //            }
3563 //
3564 type IP4ArpEvent struct {
3565         Address   uint32
3566         PID       uint32
3567         SwIfIndex uint32
3568         NewMac    []byte `struc:"[6]byte"`
3569         MacIP     uint8
3570 }
3571
3572 func (*IP4ArpEvent) GetMessageName() string {
3573         return "ip4_arp_event"
3574 }
3575 func (*IP4ArpEvent) GetCrcString() string {
3576         return "ef7235f7"
3577 }
3578 func (*IP4ArpEvent) GetMessageType() api.MessageType {
3579         return api.EventMessage
3580 }
3581 func NewIP4ArpEvent() api.Message {
3582         return &IP4ArpEvent{}
3583 }
3584
3585 // WantIP6NdEvents represents the VPP binary API message 'want_ip6_nd_events'.
3586 // Generated from 'ip.api.json', line 1865:
3587 //
3588 //            "want_ip6_nd_events",
3589 //            [
3590 //                "u16",
3591 //                "_vl_msg_id"
3592 //            ],
3593 //            [
3594 //                "u32",
3595 //                "client_index"
3596 //            ],
3597 //            [
3598 //                "u32",
3599 //                "context"
3600 //            ],
3601 //            [
3602 //                "u8",
3603 //                "enable_disable"
3604 //            ],
3605 //            [
3606 //                "u32",
3607 //                "pid"
3608 //            ],
3609 //            [
3610 //                "u8",
3611 //                "address",
3612 //                16
3613 //            ],
3614 //            {
3615 //                "crc": "0x1cf65fbb"
3616 //            }
3617 //
3618 type WantIP6NdEvents struct {
3619         EnableDisable uint8
3620         PID           uint32
3621         Address       []byte `struc:"[16]byte"`
3622 }
3623
3624 func (*WantIP6NdEvents) GetMessageName() string {
3625         return "want_ip6_nd_events"
3626 }
3627 func (*WantIP6NdEvents) GetCrcString() string {
3628         return "1cf65fbb"
3629 }
3630 func (*WantIP6NdEvents) GetMessageType() api.MessageType {
3631         return api.RequestMessage
3632 }
3633 func NewWantIP6NdEvents() api.Message {
3634         return &WantIP6NdEvents{}
3635 }
3636
3637 // WantIP6NdEventsReply represents the VPP binary API message 'want_ip6_nd_events_reply'.
3638 // Generated from 'ip.api.json', line 1896:
3639 //
3640 //            "want_ip6_nd_events_reply",
3641 //            [
3642 //                "u16",
3643 //                "_vl_msg_id"
3644 //            ],
3645 //            [
3646 //                "u32",
3647 //                "context"
3648 //            ],
3649 //            [
3650 //                "i32",
3651 //                "retval"
3652 //            ],
3653 //            {
3654 //                "crc": "0xe8d4e804"
3655 //            }
3656 //
3657 type WantIP6NdEventsReply struct {
3658         Retval int32
3659 }
3660
3661 func (*WantIP6NdEventsReply) GetMessageName() string {
3662         return "want_ip6_nd_events_reply"
3663 }
3664 func (*WantIP6NdEventsReply) GetCrcString() string {
3665         return "e8d4e804"
3666 }
3667 func (*WantIP6NdEventsReply) GetMessageType() api.MessageType {
3668         return api.ReplyMessage
3669 }
3670 func NewWantIP6NdEventsReply() api.Message {
3671         return &WantIP6NdEventsReply{}
3672 }
3673
3674 // IP6NdEvent represents the VPP binary API message 'ip6_nd_event'.
3675 // Generated from 'ip.api.json', line 1914:
3676 //
3677 //            "ip6_nd_event",
3678 //            [
3679 //                "u16",
3680 //                "_vl_msg_id"
3681 //            ],
3682 //            [
3683 //                "u32",
3684 //                "client_index"
3685 //            ],
3686 //            [
3687 //                "u32",
3688 //                "pid"
3689 //            ],
3690 //            [
3691 //                "u32",
3692 //                "sw_if_index"
3693 //            ],
3694 //            [
3695 //                "u8",
3696 //                "address",
3697 //                16
3698 //            ],
3699 //            [
3700 //                "u8",
3701 //                "new_mac",
3702 //                6
3703 //            ],
3704 //            [
3705 //                "u8",
3706 //                "mac_ip"
3707 //            ],
3708 //            {
3709 //                "crc": "0x96ab2fdd"
3710 //            }
3711 //
3712 type IP6NdEvent struct {
3713         PID       uint32
3714         SwIfIndex uint32
3715         Address   []byte `struc:"[16]byte"`
3716         NewMac    []byte `struc:"[6]byte"`
3717         MacIP     uint8
3718 }
3719
3720 func (*IP6NdEvent) GetMessageName() string {
3721         return "ip6_nd_event"
3722 }
3723 func (*IP6NdEvent) GetCrcString() string {
3724         return "96ab2fdd"
3725 }
3726 func (*IP6NdEvent) GetMessageType() api.MessageType {
3727         return api.EventMessage
3728 }
3729 func NewIP6NdEvent() api.Message {
3730         return &IP6NdEvent{}
3731 }
3732
3733 // WantIP6RaEvents represents the VPP binary API message 'want_ip6_ra_events'.
3734 // Generated from 'ip.api.json', line 1950:
3735 //
3736 //            "want_ip6_ra_events",
3737 //            [
3738 //                "u16",
3739 //                "_vl_msg_id"
3740 //            ],
3741 //            [
3742 //                "u32",
3743 //                "client_index"
3744 //            ],
3745 //            [
3746 //                "u32",
3747 //                "context"
3748 //            ],
3749 //            [
3750 //                "u8",
3751 //                "enable_disable"
3752 //            ],
3753 //            [
3754 //                "u32",
3755 //                "pid"
3756 //            ],
3757 //            {
3758 //                "crc": "0x05b454b5"
3759 //            }
3760 //
3761 type WantIP6RaEvents struct {
3762         EnableDisable uint8
3763         PID           uint32
3764 }
3765
3766 func (*WantIP6RaEvents) GetMessageName() string {
3767         return "want_ip6_ra_events"
3768 }
3769 func (*WantIP6RaEvents) GetCrcString() string {
3770         return "05b454b5"
3771 }
3772 func (*WantIP6RaEvents) GetMessageType() api.MessageType {
3773         return api.RequestMessage
3774 }
3775 func NewWantIP6RaEvents() api.Message {
3776         return &WantIP6RaEvents{}
3777 }
3778
3779 // WantIP6RaEventsReply represents the VPP binary API message 'want_ip6_ra_events_reply'.
3780 // Generated from 'ip.api.json', line 1976:
3781 //
3782 //            "want_ip6_ra_events_reply",
3783 //            [
3784 //                "u16",
3785 //                "_vl_msg_id"
3786 //            ],
3787 //            [
3788 //                "u32",
3789 //                "context"
3790 //            ],
3791 //            [
3792 //                "i32",
3793 //                "retval"
3794 //            ],
3795 //            {
3796 //                "crc": "0xe8d4e804"
3797 //            }
3798 //
3799 type WantIP6RaEventsReply struct {
3800         Retval int32
3801 }
3802
3803 func (*WantIP6RaEventsReply) GetMessageName() string {
3804         return "want_ip6_ra_events_reply"
3805 }
3806 func (*WantIP6RaEventsReply) GetCrcString() string {
3807         return "e8d4e804"
3808 }
3809 func (*WantIP6RaEventsReply) GetMessageType() api.MessageType {
3810         return api.ReplyMessage
3811 }
3812 func NewWantIP6RaEventsReply() api.Message {
3813         return &WantIP6RaEventsReply{}
3814 }
3815
3816 // IP6RaEvent represents the VPP binary API message 'ip6_ra_event'.
3817 // Generated from 'ip.api.json', line 1994:
3818 //
3819 //            "ip6_ra_event",
3820 //            [
3821 //                "u16",
3822 //                "_vl_msg_id"
3823 //            ],
3824 //            [
3825 //                "u32",
3826 //                "client_index"
3827 //            ],
3828 //            [
3829 //                "u32",
3830 //                "pid"
3831 //            ],
3832 //            [
3833 //                "u32",
3834 //                "sw_if_index"
3835 //            ],
3836 //            [
3837 //                "u8",
3838 //                "router_address",
3839 //                16
3840 //            ],
3841 //            [
3842 //                "u8",
3843 //                "current_hop_limit"
3844 //            ],
3845 //            [
3846 //                "u8",
3847 //                "flags"
3848 //            ],
3849 //            [
3850 //                "u16",
3851 //                "router_lifetime_in_sec"
3852 //            ],
3853 //            [
3854 //                "u32",
3855 //                "neighbor_reachable_time_in_msec"
3856 //            ],
3857 //            [
3858 //                "u32",
3859 //                "time_in_msec_between_retransmitted_neighbor_solicitations"
3860 //            ],
3861 //            [
3862 //                "u32",
3863 //                "n_prefixes"
3864 //            ],
3865 //            [
3866 //                "vl_api_ip6_ra_prefix_info_t",
3867 //                "prefixes",
3868 //                0,
3869 //                "n_prefixes"
3870 //            ],
3871 //            {
3872 //                "crc": "0xc5e54257"
3873 //            }
3874 //
3875 type IP6RaEvent struct {
3876         PID                                                 uint32
3877         SwIfIndex                                           uint32
3878         RouterAddress                                       []byte `struc:"[16]byte"`
3879         CurrentHopLimit                                     uint8
3880         Flags                                               uint8
3881         RouterLifetimeInSec                                 uint16
3882         NeighborReachableTimeInMsec                         uint32
3883         TimeInMsecBetweenRetransmittedNeighborSolicitations uint32
3884         NPrefixes                                           uint32 `struc:"sizeof=Prefixes"`
3885         Prefixes                                            []IP6RaPrefixInfo
3886 }
3887
3888 func (*IP6RaEvent) GetMessageName() string {
3889         return "ip6_ra_event"
3890 }
3891 func (*IP6RaEvent) GetCrcString() string {
3892         return "c5e54257"
3893 }
3894 func (*IP6RaEvent) GetMessageType() api.MessageType {
3895         return api.EventMessage
3896 }
3897 func NewIP6RaEvent() api.Message {
3898         return &IP6RaEvent{}
3899 }
3900
3901 // ProxyArpAddDel represents the VPP binary API message 'proxy_arp_add_del'.
3902 // Generated from 'ip.api.json', line 2051:
3903 //
3904 //            "proxy_arp_add_del",
3905 //            [
3906 //                "u16",
3907 //                "_vl_msg_id"
3908 //            ],
3909 //            [
3910 //                "u32",
3911 //                "client_index"
3912 //            ],
3913 //            [
3914 //                "u32",
3915 //                "context"
3916 //            ],
3917 //            [
3918 //                "u8",
3919 //                "is_add"
3920 //            ],
3921 //            [
3922 //                "vl_api_proxy_arp_t",
3923 //                "proxy"
3924 //            ],
3925 //            {
3926 //                "crc": "0x227988d9"
3927 //            }
3928 //
3929 type ProxyArpAddDel struct {
3930         IsAdd uint8
3931         Proxy ProxyArp
3932 }
3933
3934 func (*ProxyArpAddDel) GetMessageName() string {
3935         return "proxy_arp_add_del"
3936 }
3937 func (*ProxyArpAddDel) GetCrcString() string {
3938         return "227988d9"
3939 }
3940 func (*ProxyArpAddDel) GetMessageType() api.MessageType {
3941         return api.RequestMessage
3942 }
3943 func NewProxyArpAddDel() api.Message {
3944         return &ProxyArpAddDel{}
3945 }
3946
3947 // ProxyArpAddDelReply represents the VPP binary API message 'proxy_arp_add_del_reply'.
3948 // Generated from 'ip.api.json', line 2077:
3949 //
3950 //            "proxy_arp_add_del_reply",
3951 //            [
3952 //                "u16",
3953 //                "_vl_msg_id"
3954 //            ],
3955 //            [
3956 //                "u32",
3957 //                "context"
3958 //            ],
3959 //            [
3960 //                "i32",
3961 //                "retval"
3962 //            ],
3963 //            {
3964 //                "crc": "0xe8d4e804"
3965 //            }
3966 //
3967 type ProxyArpAddDelReply struct {
3968         Retval int32
3969 }
3970
3971 func (*ProxyArpAddDelReply) GetMessageName() string {
3972         return "proxy_arp_add_del_reply"
3973 }
3974 func (*ProxyArpAddDelReply) GetCrcString() string {
3975         return "e8d4e804"
3976 }
3977 func (*ProxyArpAddDelReply) GetMessageType() api.MessageType {
3978         return api.ReplyMessage
3979 }
3980 func NewProxyArpAddDelReply() api.Message {
3981         return &ProxyArpAddDelReply{}
3982 }
3983
3984 // ProxyArpDump represents the VPP binary API message 'proxy_arp_dump'.
3985 // Generated from 'ip.api.json', line 2095:
3986 //
3987 //            "proxy_arp_dump",
3988 //            [
3989 //                "u16",
3990 //                "_vl_msg_id"
3991 //            ],
3992 //            [
3993 //                "u32",
3994 //                "client_index"
3995 //            ],
3996 //            [
3997 //                "u32",
3998 //                "context"
3999 //            ],
4000 //            {
4001 //                "crc": "0x51077d14"
4002 //            }
4003 //
4004 type ProxyArpDump struct{}
4005
4006 func (*ProxyArpDump) GetMessageName() string {
4007         return "proxy_arp_dump"
4008 }
4009 func (*ProxyArpDump) GetCrcString() string {
4010         return "51077d14"
4011 }
4012 func (*ProxyArpDump) GetMessageType() api.MessageType {
4013         return api.RequestMessage
4014 }
4015 func NewProxyArpDump() api.Message {
4016         return &ProxyArpDump{}
4017 }
4018
4019 // ProxyArpDetails represents the VPP binary API message 'proxy_arp_details'.
4020 // Generated from 'ip.api.json', line 2113:
4021 //
4022 //            "proxy_arp_details",
4023 //            [
4024 //                "u16",
4025 //                "_vl_msg_id"
4026 //            ],
4027 //            [
4028 //                "u32",
4029 //                "context"
4030 //            ],
4031 //            [
4032 //                "vl_api_proxy_arp_t",
4033 //                "proxy"
4034 //            ],
4035 //            {
4036 //                "crc": "0x9b707c77"
4037 //            }
4038 //
4039 type ProxyArpDetails struct {
4040         Proxy ProxyArp
4041 }
4042
4043 func (*ProxyArpDetails) GetMessageName() string {
4044         return "proxy_arp_details"
4045 }
4046 func (*ProxyArpDetails) GetCrcString() string {
4047         return "9b707c77"
4048 }
4049 func (*ProxyArpDetails) GetMessageType() api.MessageType {
4050         return api.ReplyMessage
4051 }
4052 func NewProxyArpDetails() api.Message {
4053         return &ProxyArpDetails{}
4054 }
4055
4056 // ProxyArpIntfcEnableDisable represents the VPP binary API message 'proxy_arp_intfc_enable_disable'.
4057 // Generated from 'ip.api.json', line 2131:
4058 //
4059 //            "proxy_arp_intfc_enable_disable",
4060 //            [
4061 //                "u16",
4062 //                "_vl_msg_id"
4063 //            ],
4064 //            [
4065 //                "u32",
4066 //                "client_index"
4067 //            ],
4068 //            [
4069 //                "u32",
4070 //                "context"
4071 //            ],
4072 //            [
4073 //                "u32",
4074 //                "sw_if_index"
4075 //            ],
4076 //            [
4077 //                "u8",
4078 //                "enable_disable"
4079 //            ],
4080 //            {
4081 //                "crc": "0x69d24598"
4082 //            }
4083 //
4084 type ProxyArpIntfcEnableDisable struct {
4085         SwIfIndex     uint32
4086         EnableDisable uint8
4087 }
4088
4089 func (*ProxyArpIntfcEnableDisable) GetMessageName() string {
4090         return "proxy_arp_intfc_enable_disable"
4091 }
4092 func (*ProxyArpIntfcEnableDisable) GetCrcString() string {
4093         return "69d24598"
4094 }
4095 func (*ProxyArpIntfcEnableDisable) GetMessageType() api.MessageType {
4096         return api.RequestMessage
4097 }
4098 func NewProxyArpIntfcEnableDisable() api.Message {
4099         return &ProxyArpIntfcEnableDisable{}
4100 }
4101
4102 // ProxyArpIntfcEnableDisableReply represents the VPP binary API message 'proxy_arp_intfc_enable_disable_reply'.
4103 // Generated from 'ip.api.json', line 2157:
4104 //
4105 //            "proxy_arp_intfc_enable_disable_reply",
4106 //            [
4107 //                "u16",
4108 //                "_vl_msg_id"
4109 //            ],
4110 //            [
4111 //                "u32",
4112 //                "context"
4113 //            ],
4114 //            [
4115 //                "i32",
4116 //                "retval"
4117 //            ],
4118 //            {
4119 //                "crc": "0xe8d4e804"
4120 //            }
4121 //
4122 type ProxyArpIntfcEnableDisableReply struct {
4123         Retval int32
4124 }
4125
4126 func (*ProxyArpIntfcEnableDisableReply) GetMessageName() string {
4127         return "proxy_arp_intfc_enable_disable_reply"
4128 }
4129 func (*ProxyArpIntfcEnableDisableReply) GetCrcString() string {
4130         return "e8d4e804"
4131 }
4132 func (*ProxyArpIntfcEnableDisableReply) GetMessageType() api.MessageType {
4133         return api.ReplyMessage
4134 }
4135 func NewProxyArpIntfcEnableDisableReply() api.Message {
4136         return &ProxyArpIntfcEnableDisableReply{}
4137 }
4138
4139 // ProxyArpIntfcDump represents the VPP binary API message 'proxy_arp_intfc_dump'.
4140 // Generated from 'ip.api.json', line 2175:
4141 //
4142 //            "proxy_arp_intfc_dump",
4143 //            [
4144 //                "u16",
4145 //                "_vl_msg_id"
4146 //            ],
4147 //            [
4148 //                "u32",
4149 //                "client_index"
4150 //            ],
4151 //            [
4152 //                "u32",
4153 //                "context"
4154 //            ],
4155 //            {
4156 //                "crc": "0x51077d14"
4157 //            }
4158 //
4159 type ProxyArpIntfcDump struct{}
4160
4161 func (*ProxyArpIntfcDump) GetMessageName() string {
4162         return "proxy_arp_intfc_dump"
4163 }
4164 func (*ProxyArpIntfcDump) GetCrcString() string {
4165         return "51077d14"
4166 }
4167 func (*ProxyArpIntfcDump) GetMessageType() api.MessageType {
4168         return api.RequestMessage
4169 }
4170 func NewProxyArpIntfcDump() api.Message {
4171         return &ProxyArpIntfcDump{}
4172 }
4173
4174 // ProxyArpIntfcDetails represents the VPP binary API message 'proxy_arp_intfc_details'.
4175 // Generated from 'ip.api.json', line 2193:
4176 //
4177 //            "proxy_arp_intfc_details",
4178 //            [
4179 //                "u16",
4180 //                "_vl_msg_id"
4181 //            ],
4182 //            [
4183 //                "u32",
4184 //                "context"
4185 //            ],
4186 //            [
4187 //                "u32",
4188 //                "sw_if_index"
4189 //            ],
4190 //            {
4191 //                "crc": "0xf6458e5f"
4192 //            }
4193 //
4194 type ProxyArpIntfcDetails struct {
4195         SwIfIndex uint32
4196 }
4197
4198 func (*ProxyArpIntfcDetails) GetMessageName() string {
4199         return "proxy_arp_intfc_details"
4200 }
4201 func (*ProxyArpIntfcDetails) GetCrcString() string {
4202         return "f6458e5f"
4203 }
4204 func (*ProxyArpIntfcDetails) GetMessageType() api.MessageType {
4205         return api.ReplyMessage
4206 }
4207 func NewProxyArpIntfcDetails() api.Message {
4208         return &ProxyArpIntfcDetails{}
4209 }
4210
4211 // ResetFib represents the VPP binary API message 'reset_fib'.
4212 // Generated from 'ip.api.json', line 2211:
4213 //
4214 //            "reset_fib",
4215 //            [
4216 //                "u16",
4217 //                "_vl_msg_id"
4218 //            ],
4219 //            [
4220 //                "u32",
4221 //                "client_index"
4222 //            ],
4223 //            [
4224 //                "u32",
4225 //                "context"
4226 //            ],
4227 //            [
4228 //                "u32",
4229 //                "vrf_id"
4230 //            ],
4231 //            [
4232 //                "u8",
4233 //                "is_ipv6"
4234 //            ],
4235 //            {
4236 //                "crc": "0x8553ebd9"
4237 //            }
4238 //
4239 type ResetFib struct {
4240         VrfID  uint32
4241         IsIPv6 uint8
4242 }
4243
4244 func (*ResetFib) GetMessageName() string {
4245         return "reset_fib"
4246 }
4247 func (*ResetFib) GetCrcString() string {
4248         return "8553ebd9"
4249 }
4250 func (*ResetFib) GetMessageType() api.MessageType {
4251         return api.RequestMessage
4252 }
4253 func NewResetFib() api.Message {
4254         return &ResetFib{}
4255 }
4256
4257 // ResetFibReply represents the VPP binary API message 'reset_fib_reply'.
4258 // Generated from 'ip.api.json', line 2237:
4259 //
4260 //            "reset_fib_reply",
4261 //            [
4262 //                "u16",
4263 //                "_vl_msg_id"
4264 //            ],
4265 //            [
4266 //                "u32",
4267 //                "context"
4268 //            ],
4269 //            [
4270 //                "i32",
4271 //                "retval"
4272 //            ],
4273 //            {
4274 //                "crc": "0xe8d4e804"
4275 //            }
4276 //
4277 type ResetFibReply struct {
4278         Retval int32
4279 }
4280
4281 func (*ResetFibReply) GetMessageName() string {
4282         return "reset_fib_reply"
4283 }
4284 func (*ResetFibReply) GetCrcString() string {
4285         return "e8d4e804"
4286 }
4287 func (*ResetFibReply) GetMessageType() api.MessageType {
4288         return api.ReplyMessage
4289 }
4290 func NewResetFibReply() api.Message {
4291         return &ResetFibReply{}
4292 }
4293
4294 // SetArpNeighborLimit represents the VPP binary API message 'set_arp_neighbor_limit'.
4295 // Generated from 'ip.api.json', line 2255:
4296 //
4297 //            "set_arp_neighbor_limit",
4298 //            [
4299 //                "u16",
4300 //                "_vl_msg_id"
4301 //            ],
4302 //            [
4303 //                "u32",
4304 //                "client_index"
4305 //            ],
4306 //            [
4307 //                "u32",
4308 //                "context"
4309 //            ],
4310 //            [
4311 //                "u8",
4312 //                "is_ipv6"
4313 //            ],
4314 //            [
4315 //                "u32",
4316 //                "arp_neighbor_limit"
4317 //            ],
4318 //            {
4319 //                "crc": "0x97d01fd6"
4320 //            }
4321 //
4322 type SetArpNeighborLimit struct {
4323         IsIPv6           uint8
4324         ArpNeighborLimit uint32
4325 }
4326
4327 func (*SetArpNeighborLimit) GetMessageName() string {
4328         return "set_arp_neighbor_limit"
4329 }
4330 func (*SetArpNeighborLimit) GetCrcString() string {
4331         return "97d01fd6"
4332 }
4333 func (*SetArpNeighborLimit) GetMessageType() api.MessageType {
4334         return api.RequestMessage
4335 }
4336 func NewSetArpNeighborLimit() api.Message {
4337         return &SetArpNeighborLimit{}
4338 }
4339
4340 // SetArpNeighborLimitReply represents the VPP binary API message 'set_arp_neighbor_limit_reply'.
4341 // Generated from 'ip.api.json', line 2281:
4342 //
4343 //            "set_arp_neighbor_limit_reply",
4344 //            [
4345 //                "u16",
4346 //                "_vl_msg_id"
4347 //            ],
4348 //            [
4349 //                "u32",
4350 //                "context"
4351 //            ],
4352 //            [
4353 //                "i32",
4354 //                "retval"
4355 //            ],
4356 //            {
4357 //                "crc": "0xe8d4e804"
4358 //            }
4359 //
4360 type SetArpNeighborLimitReply struct {
4361         Retval int32
4362 }
4363
4364 func (*SetArpNeighborLimitReply) GetMessageName() string {
4365         return "set_arp_neighbor_limit_reply"
4366 }
4367 func (*SetArpNeighborLimitReply) GetCrcString() string {
4368         return "e8d4e804"
4369 }
4370 func (*SetArpNeighborLimitReply) GetMessageType() api.MessageType {
4371         return api.ReplyMessage
4372 }
4373 func NewSetArpNeighborLimitReply() api.Message {
4374         return &SetArpNeighborLimitReply{}
4375 }
4376
4377 // IoamEnable represents the VPP binary API message 'ioam_enable'.
4378 // Generated from 'ip.api.json', line 2299:
4379 //
4380 //            "ioam_enable",
4381 //            [
4382 //                "u16",
4383 //                "_vl_msg_id"
4384 //            ],
4385 //            [
4386 //                "u32",
4387 //                "client_index"
4388 //            ],
4389 //            [
4390 //                "u32",
4391 //                "context"
4392 //            ],
4393 //            [
4394 //                "u16",
4395 //                "id"
4396 //            ],
4397 //            [
4398 //                "u8",
4399 //                "seqno"
4400 //            ],
4401 //            [
4402 //                "u8",
4403 //                "analyse"
4404 //            ],
4405 //            [
4406 //                "u8",
4407 //                "pot_enable"
4408 //            ],
4409 //            [
4410 //                "u8",
4411 //                "trace_enable"
4412 //            ],
4413 //            [
4414 //                "u32",
4415 //                "node_id"
4416 //            ],
4417 //            {
4418 //                "crc": "0x9392e032"
4419 //            }
4420 //
4421 type IoamEnable struct {
4422         ID          uint16
4423         Seqno       uint8
4424         Analyse     uint8
4425         PotEnable   uint8
4426         TraceEnable uint8
4427         NodeID      uint32
4428 }
4429
4430 func (*IoamEnable) GetMessageName() string {
4431         return "ioam_enable"
4432 }
4433 func (*IoamEnable) GetCrcString() string {
4434         return "9392e032"
4435 }
4436 func (*IoamEnable) GetMessageType() api.MessageType {
4437         return api.RequestMessage
4438 }
4439 func NewIoamEnable() api.Message {
4440         return &IoamEnable{}
4441 }
4442
4443 // IoamEnableReply represents the VPP binary API message 'ioam_enable_reply'.
4444 // Generated from 'ip.api.json', line 2341:
4445 //
4446 //            "ioam_enable_reply",
4447 //            [
4448 //                "u16",
4449 //                "_vl_msg_id"
4450 //            ],
4451 //            [
4452 //                "u32",
4453 //                "context"
4454 //            ],
4455 //            [
4456 //                "i32",
4457 //                "retval"
4458 //            ],
4459 //            {
4460 //                "crc": "0xe8d4e804"
4461 //            }
4462 //
4463 type IoamEnableReply struct {
4464         Retval int32
4465 }
4466
4467 func (*IoamEnableReply) GetMessageName() string {
4468         return "ioam_enable_reply"
4469 }
4470 func (*IoamEnableReply) GetCrcString() string {
4471         return "e8d4e804"
4472 }
4473 func (*IoamEnableReply) GetMessageType() api.MessageType {
4474         return api.ReplyMessage
4475 }
4476 func NewIoamEnableReply() api.Message {
4477         return &IoamEnableReply{}
4478 }
4479
4480 // IoamDisable represents the VPP binary API message 'ioam_disable'.
4481 // Generated from 'ip.api.json', line 2359:
4482 //
4483 //            "ioam_disable",
4484 //            [
4485 //                "u16",
4486 //                "_vl_msg_id"
4487 //            ],
4488 //            [
4489 //                "u32",
4490 //                "client_index"
4491 //            ],
4492 //            [
4493 //                "u32",
4494 //                "context"
4495 //            ],
4496 //            [
4497 //                "u16",
4498 //                "id"
4499 //            ],
4500 //            {
4501 //                "crc": "0x6b16a45e"
4502 //            }
4503 //
4504 type IoamDisable struct {
4505         ID uint16
4506 }
4507
4508 func (*IoamDisable) GetMessageName() string {
4509         return "ioam_disable"
4510 }
4511 func (*IoamDisable) GetCrcString() string {
4512         return "6b16a45e"
4513 }
4514 func (*IoamDisable) GetMessageType() api.MessageType {
4515         return api.RequestMessage
4516 }
4517 func NewIoamDisable() api.Message {
4518         return &IoamDisable{}
4519 }
4520
4521 // IoamDisableReply represents the VPP binary API message 'ioam_disable_reply'.
4522 // Generated from 'ip.api.json', line 2381:
4523 //
4524 //            "ioam_disable_reply",
4525 //            [
4526 //                "u16",
4527 //                "_vl_msg_id"
4528 //            ],
4529 //            [
4530 //                "u32",
4531 //                "context"
4532 //            ],
4533 //            [
4534 //                "i32",
4535 //                "retval"
4536 //            ],
4537 //            {
4538 //                "crc": "0xe8d4e804"
4539 //            }
4540 //
4541 type IoamDisableReply struct {
4542         Retval int32
4543 }
4544
4545 func (*IoamDisableReply) GetMessageName() string {
4546         return "ioam_disable_reply"
4547 }
4548 func (*IoamDisableReply) GetCrcString() string {
4549         return "e8d4e804"
4550 }
4551 func (*IoamDisableReply) GetMessageType() api.MessageType {
4552         return api.ReplyMessage
4553 }
4554 func NewIoamDisableReply() api.Message {
4555         return &IoamDisableReply{}
4556 }
4557
4558 // IPReassemblySet represents the VPP binary API message 'ip_reassembly_set'.
4559 // Generated from 'ip.api.json', line 2399:
4560 //
4561 //            "ip_reassembly_set",
4562 //            [
4563 //                "u16",
4564 //                "_vl_msg_id"
4565 //            ],
4566 //            [
4567 //                "u32",
4568 //                "client_index"
4569 //            ],
4570 //            [
4571 //                "u32",
4572 //                "context"
4573 //            ],
4574 //            [
4575 //                "u32",
4576 //                "timeout_ms"
4577 //            ],
4578 //            [
4579 //                "u32",
4580 //                "max_reassemblies"
4581 //            ],
4582 //            [
4583 //                "u32",
4584 //                "expire_walk_interval_ms"
4585 //            ],
4586 //            [
4587 //                "u8",
4588 //                "is_ip6"
4589 //            ],
4590 //            {
4591 //                "crc": "0x1db184de"
4592 //            }
4593 //
4594 type IPReassemblySet struct {
4595         TimeoutMs            uint32
4596         MaxReassemblies      uint32
4597         ExpireWalkIntervalMs uint32
4598         IsIP6                uint8
4599 }
4600
4601 func (*IPReassemblySet) GetMessageName() string {
4602         return "ip_reassembly_set"
4603 }
4604 func (*IPReassemblySet) GetCrcString() string {
4605         return "1db184de"
4606 }
4607 func (*IPReassemblySet) GetMessageType() api.MessageType {
4608         return api.RequestMessage
4609 }
4610 func NewIPReassemblySet() api.Message {
4611         return &IPReassemblySet{}
4612 }
4613
4614 // IPReassemblySetReply represents the VPP binary API message 'ip_reassembly_set_reply'.
4615 // Generated from 'ip.api.json', line 2433:
4616 //
4617 //            "ip_reassembly_set_reply",
4618 //            [
4619 //                "u16",
4620 //                "_vl_msg_id"
4621 //            ],
4622 //            [
4623 //                "u32",
4624 //                "context"
4625 //            ],
4626 //            [
4627 //                "i32",
4628 //                "retval"
4629 //            ],
4630 //            {
4631 //                "crc": "0xe8d4e804"
4632 //            }
4633 //
4634 type IPReassemblySetReply struct {
4635         Retval int32
4636 }
4637
4638 func (*IPReassemblySetReply) GetMessageName() string {
4639         return "ip_reassembly_set_reply"
4640 }
4641 func (*IPReassemblySetReply) GetCrcString() string {
4642         return "e8d4e804"
4643 }
4644 func (*IPReassemblySetReply) GetMessageType() api.MessageType {
4645         return api.ReplyMessage
4646 }
4647 func NewIPReassemblySetReply() api.Message {
4648         return &IPReassemblySetReply{}
4649 }
4650
4651 // IPReassemblyGet represents the VPP binary API message 'ip_reassembly_get'.
4652 // Generated from 'ip.api.json', line 2451:
4653 //
4654 //            "ip_reassembly_get",
4655 //            [
4656 //                "u16",
4657 //                "_vl_msg_id"
4658 //            ],
4659 //            [
4660 //                "u32",
4661 //                "client_index"
4662 //            ],
4663 //            [
4664 //                "u32",
4665 //                "context"
4666 //            ],
4667 //            [
4668 //                "u8",
4669 //                "is_ip6"
4670 //            ],
4671 //            {
4672 //                "crc": "0x6fe91190"
4673 //            }
4674 //
4675 type IPReassemblyGet struct {
4676         IsIP6 uint8
4677 }
4678
4679 func (*IPReassemblyGet) GetMessageName() string {
4680         return "ip_reassembly_get"
4681 }
4682 func (*IPReassemblyGet) GetCrcString() string {
4683         return "6fe91190"
4684 }
4685 func (*IPReassemblyGet) GetMessageType() api.MessageType {
4686         return api.RequestMessage
4687 }
4688 func NewIPReassemblyGet() api.Message {
4689         return &IPReassemblyGet{}
4690 }
4691
4692 // IPReassemblyGetReply represents the VPP binary API message 'ip_reassembly_get_reply'.
4693 // Generated from 'ip.api.json', line 2473:
4694 //
4695 //            "ip_reassembly_get_reply",
4696 //            [
4697 //                "u16",
4698 //                "_vl_msg_id"
4699 //            ],
4700 //            [
4701 //                "u32",
4702 //                "client_index"
4703 //            ],
4704 //            [
4705 //                "u32",
4706 //                "context"
4707 //            ],
4708 //            [
4709 //                "i32",
4710 //                "retval"
4711 //            ],
4712 //            [
4713 //                "u32",
4714 //                "timeout_ms"
4715 //            ],
4716 //            [
4717 //                "u32",
4718 //                "max_reassemblies"
4719 //            ],
4720 //            [
4721 //                "u32",
4722 //                "expire_walk_interval_ms"
4723 //            ],
4724 //            [
4725 //                "u8",
4726 //                "is_ip6"
4727 //            ],
4728 //            {
4729 //                "crc": "0xd746fc57"
4730 //            }
4731 //
4732 type IPReassemblyGetReply struct {
4733         Retval               int32
4734         TimeoutMs            uint32
4735         MaxReassemblies      uint32
4736         ExpireWalkIntervalMs uint32
4737         IsIP6                uint8
4738 }
4739
4740 func (*IPReassemblyGetReply) GetMessageName() string {
4741         return "ip_reassembly_get_reply"
4742 }
4743 func (*IPReassemblyGetReply) GetCrcString() string {
4744         return "d746fc57"
4745 }
4746 func (*IPReassemblyGetReply) GetMessageType() api.MessageType {
4747         return api.RequestMessage
4748 }
4749 func NewIPReassemblyGetReply() api.Message {
4750         return &IPReassemblyGetReply{}
4751 }
4752
4753 // IPReassemblyEnableDisable represents the VPP binary API message 'ip_reassembly_enable_disable'.
4754 // Generated from 'ip.api.json', line 2511:
4755 //
4756 //            "ip_reassembly_enable_disable",
4757 //            [
4758 //                "u16",
4759 //                "_vl_msg_id"
4760 //            ],
4761 //            [
4762 //                "u32",
4763 //                "client_index"
4764 //            ],
4765 //            [
4766 //                "u32",
4767 //                "context"
4768 //            ],
4769 //            [
4770 //                "u32",
4771 //                "sw_if_index"
4772 //            ],
4773 //            [
4774 //                "u8",
4775 //                "enable_ip4"
4776 //            ],
4777 //            [
4778 //                "u8",
4779 //                "enable_ip6"
4780 //            ],
4781 //            {
4782 //                "crc": "0xbb8dc5d0"
4783 //            }
4784 //
4785 type IPReassemblyEnableDisable struct {
4786         SwIfIndex uint32
4787         EnableIP4 uint8
4788         EnableIP6 uint8
4789 }
4790
4791 func (*IPReassemblyEnableDisable) GetMessageName() string {
4792         return "ip_reassembly_enable_disable"
4793 }
4794 func (*IPReassemblyEnableDisable) GetCrcString() string {
4795         return "bb8dc5d0"
4796 }
4797 func (*IPReassemblyEnableDisable) GetMessageType() api.MessageType {
4798         return api.RequestMessage
4799 }
4800 func NewIPReassemblyEnableDisable() api.Message {
4801         return &IPReassemblyEnableDisable{}
4802 }
4803
4804 // IPReassemblyEnableDisableReply represents the VPP binary API message 'ip_reassembly_enable_disable_reply'.
4805 // Generated from 'ip.api.json', line 2541:
4806 //
4807 //            "ip_reassembly_enable_disable_reply",
4808 //            [
4809 //                "u16",
4810 //                "_vl_msg_id"
4811 //            ],
4812 //            [
4813 //                "u32",
4814 //                "context"
4815 //            ],
4816 //            [
4817 //                "i32",
4818 //                "retval"
4819 //            ],
4820 //            {
4821 //                "crc": "0xe8d4e804"
4822 //            }
4823 //
4824 type IPReassemblyEnableDisableReply struct {
4825         Retval int32
4826 }
4827
4828 func (*IPReassemblyEnableDisableReply) GetMessageName() string {
4829         return "ip_reassembly_enable_disable_reply"
4830 }
4831 func (*IPReassemblyEnableDisableReply) GetCrcString() string {
4832         return "e8d4e804"
4833 }
4834 func (*IPReassemblyEnableDisableReply) GetMessageType() api.MessageType {
4835         return api.ReplyMessage
4836 }
4837 func NewIPReassemblyEnableDisableReply() api.Message {
4838         return &IPReassemblyEnableDisableReply{}
4839 }
4840
4841 /* Services */
4842
4843 type Services interface {
4844         DumpIP6Fib(*IP6FibDump) (*IP6FibDetails, error)
4845         DumpIP6Mfib(*IP6MfibDump) (*IP6MfibDetails, error)
4846         DumpIP6ndProxy(*IP6ndProxyDump) (*IP6ndProxyDetails, error)
4847         DumpIPAddress(*IPAddressDump) (*IPAddressDetails, error)
4848         DumpIP(*IPDump) (*IPDetails, error)
4849         DumpIPFib(*IPFibDump) (*IPFibDetails, error)
4850         DumpIPMfib(*IPMfibDump) (*IPMfibDetails, error)
4851         DumpIPNeighbor(*IPNeighborDump) (*IPNeighborDetails, error)
4852         DumpIPUnnumbered(*IPUnnumberedDump) (*IPUnnumberedDetails, error)
4853         DumpMfibSignal(*MfibSignalDump) (*MfibSignalDetails, error)
4854         DumpProxyArp(*ProxyArpDump) (*ProxyArpDetails, error)
4855         DumpProxyArpIntfc(*ProxyArpIntfcDump) (*ProxyArpIntfcDetails, error)
4856         IoamDisable(*IoamDisable) (*IoamDisableReply, error)
4857         IoamEnable(*IoamEnable) (*IoamEnableReply, error)
4858         IP6ndProxyAddDel(*IP6ndProxyAddDel) (*IP6ndProxyAddDelReply, error)
4859         IP6ndSendRouterSolicitation(*IP6ndSendRouterSolicitation) (*IP6ndSendRouterSolicitationReply, error)
4860         IPAddDelRoute(*IPAddDelRoute) (*IPAddDelRouteReply, error)
4861         IPContainerProxyAddDel(*IPContainerProxyAddDel) (*IPContainerProxyAddDelReply, error)
4862         IPMrouteAddDel(*IPMrouteAddDel) (*IPMrouteAddDelReply, error)
4863         IPNeighborAddDel(*IPNeighborAddDel) (*IPNeighborAddDelReply, error)
4864         IPProbeNeighbor(*IPProbeNeighbor) (*IPProbeNeighborReply, error)
4865         IPPuntPolice(*IPPuntPolice) (*IPPuntPoliceReply, error)
4866         IPPuntRedirect(*IPPuntRedirect) (*IPPuntRedirectReply, error)
4867         IPReassemblyEnableDisable(*IPReassemblyEnableDisable) (*IPReassemblyEnableDisableReply, error)
4868         IPReassemblyGet(*IPReassemblyGet) (*IPReassemblyGetReply, error)
4869         IPReassemblySet(*IPReassemblySet) (*IPReassemblySetReply, error)
4870         IPScanNeighborEnableDisable(*IPScanNeighborEnableDisable) (*IPScanNeighborEnableDisableReply, error)
4871         IPSourceAndPortRangeCheckAddDel(*IPSourceAndPortRangeCheckAddDel) (*IPSourceAndPortRangeCheckAddDelReply, error)
4872         IPSourceAndPortRangeCheckInterfaceAddDel(*IPSourceAndPortRangeCheckInterfaceAddDel) (*IPSourceAndPortRangeCheckInterfaceAddDelReply, error)
4873         IPTableAddDel(*IPTableAddDel) (*IPTableAddDelReply, error)
4874         ProxyArpAddDel(*ProxyArpAddDel) (*ProxyArpAddDelReply, error)
4875         ProxyArpIntfcEnableDisable(*ProxyArpIntfcEnableDisable) (*ProxyArpIntfcEnableDisableReply, error)
4876         ResetFib(*ResetFib) (*ResetFibReply, error)
4877         SetArpNeighborLimit(*SetArpNeighborLimit) (*SetArpNeighborLimitReply, error)
4878         SetIPFlowHash(*SetIPFlowHash) (*SetIPFlowHashReply, error)
4879         SwInterfaceIP6EnableDisable(*SwInterfaceIP6EnableDisable) (*SwInterfaceIP6EnableDisableReply, error)
4880         SwInterfaceIP6SetLinkLocalAddress(*SwInterfaceIP6SetLinkLocalAddress) (*SwInterfaceIP6SetLinkLocalAddressReply, error)
4881         SwInterfaceIP6ndRaConfig(*SwInterfaceIP6ndRaConfig) (*SwInterfaceIP6ndRaConfigReply, error)
4882         SwInterfaceIP6ndRaPrefix(*SwInterfaceIP6ndRaPrefix) (*SwInterfaceIP6ndRaPrefixReply, error)
4883         WantIP4ArpEvents(*WantIP4ArpEvents) (*WantIP4ArpEventsReply, error)
4884         WantIP6NdEvents(*WantIP6NdEvents) (*WantIP6NdEventsReply, error)
4885         WantIP6RaEvents(*WantIP6RaEvents) (*WantIP6RaEventsReply, error)
4886 }
4887
4888 func init() {
4889         api.RegisterMessage((*IPTableAddDel)(nil), "ip.IPTableAddDel")
4890         api.RegisterMessage((*IPTableAddDelReply)(nil), "ip.IPTableAddDelReply")
4891         api.RegisterMessage((*IPFibDump)(nil), "ip.IPFibDump")
4892         api.RegisterMessage((*IPFibDetails)(nil), "ip.IPFibDetails")
4893         api.RegisterMessage((*IP6FibDump)(nil), "ip.IP6FibDump")
4894         api.RegisterMessage((*IP6FibDetails)(nil), "ip.IP6FibDetails")
4895         api.RegisterMessage((*IPNeighborDump)(nil), "ip.IPNeighborDump")
4896         api.RegisterMessage((*IPNeighborDetails)(nil), "ip.IPNeighborDetails")
4897         api.RegisterMessage((*IPNeighborAddDel)(nil), "ip.IPNeighborAddDel")
4898         api.RegisterMessage((*IPNeighborAddDelReply)(nil), "ip.IPNeighborAddDelReply")
4899         api.RegisterMessage((*SetIPFlowHash)(nil), "ip.SetIPFlowHash")
4900         api.RegisterMessage((*SetIPFlowHashReply)(nil), "ip.SetIPFlowHashReply")
4901         api.RegisterMessage((*SwInterfaceIP6ndRaConfig)(nil), "ip.SwInterfaceIP6ndRaConfig")
4902         api.RegisterMessage((*SwInterfaceIP6ndRaConfigReply)(nil), "ip.SwInterfaceIP6ndRaConfigReply")
4903         api.RegisterMessage((*SwInterfaceIP6ndRaPrefix)(nil), "ip.SwInterfaceIP6ndRaPrefix")
4904         api.RegisterMessage((*SwInterfaceIP6ndRaPrefixReply)(nil), "ip.SwInterfaceIP6ndRaPrefixReply")
4905         api.RegisterMessage((*IP6ndProxyAddDel)(nil), "ip.IP6ndProxyAddDel")
4906         api.RegisterMessage((*IP6ndProxyAddDelReply)(nil), "ip.IP6ndProxyAddDelReply")
4907         api.RegisterMessage((*IP6ndProxyDetails)(nil), "ip.IP6ndProxyDetails")
4908         api.RegisterMessage((*IP6ndProxyDump)(nil), "ip.IP6ndProxyDump")
4909         api.RegisterMessage((*IP6ndSendRouterSolicitation)(nil), "ip.IP6ndSendRouterSolicitation")
4910         api.RegisterMessage((*IP6ndSendRouterSolicitationReply)(nil), "ip.IP6ndSendRouterSolicitationReply")
4911         api.RegisterMessage((*SwInterfaceIP6EnableDisable)(nil), "ip.SwInterfaceIP6EnableDisable")
4912         api.RegisterMessage((*SwInterfaceIP6EnableDisableReply)(nil), "ip.SwInterfaceIP6EnableDisableReply")
4913         api.RegisterMessage((*SwInterfaceIP6SetLinkLocalAddress)(nil), "ip.SwInterfaceIP6SetLinkLocalAddress")
4914         api.RegisterMessage((*SwInterfaceIP6SetLinkLocalAddressReply)(nil), "ip.SwInterfaceIP6SetLinkLocalAddressReply")
4915         api.RegisterMessage((*IPAddDelRoute)(nil), "ip.IPAddDelRoute")
4916         api.RegisterMessage((*IPAddDelRouteReply)(nil), "ip.IPAddDelRouteReply")
4917         api.RegisterMessage((*IPMrouteAddDel)(nil), "ip.IPMrouteAddDel")
4918         api.RegisterMessage((*IPMrouteAddDelReply)(nil), "ip.IPMrouteAddDelReply")
4919         api.RegisterMessage((*IPMfibDump)(nil), "ip.IPMfibDump")
4920         api.RegisterMessage((*IPMfibDetails)(nil), "ip.IPMfibDetails")
4921         api.RegisterMessage((*IP6MfibDump)(nil), "ip.IP6MfibDump")
4922         api.RegisterMessage((*IP6MfibDetails)(nil), "ip.IP6MfibDetails")
4923         api.RegisterMessage((*IPAddressDetails)(nil), "ip.IPAddressDetails")
4924         api.RegisterMessage((*IPAddressDump)(nil), "ip.IPAddressDump")
4925         api.RegisterMessage((*IPUnnumberedDetails)(nil), "ip.IPUnnumberedDetails")
4926         api.RegisterMessage((*IPUnnumberedDump)(nil), "ip.IPUnnumberedDump")
4927         api.RegisterMessage((*IPDetails)(nil), "ip.IPDetails")
4928         api.RegisterMessage((*IPDump)(nil), "ip.IPDump")
4929         api.RegisterMessage((*MfibSignalDump)(nil), "ip.MfibSignalDump")
4930         api.RegisterMessage((*MfibSignalDetails)(nil), "ip.MfibSignalDetails")
4931         api.RegisterMessage((*IPPuntPolice)(nil), "ip.IPPuntPolice")
4932         api.RegisterMessage((*IPPuntPoliceReply)(nil), "ip.IPPuntPoliceReply")
4933         api.RegisterMessage((*IPPuntRedirect)(nil), "ip.IPPuntRedirect")
4934         api.RegisterMessage((*IPPuntRedirectReply)(nil), "ip.IPPuntRedirectReply")
4935         api.RegisterMessage((*IPContainerProxyAddDel)(nil), "ip.IPContainerProxyAddDel")
4936         api.RegisterMessage((*IPContainerProxyAddDelReply)(nil), "ip.IPContainerProxyAddDelReply")
4937         api.RegisterMessage((*IPSourceAndPortRangeCheckAddDel)(nil), "ip.IPSourceAndPortRangeCheckAddDel")
4938         api.RegisterMessage((*IPSourceAndPortRangeCheckAddDelReply)(nil), "ip.IPSourceAndPortRangeCheckAddDelReply")
4939         api.RegisterMessage((*IPSourceAndPortRangeCheckInterfaceAddDel)(nil), "ip.IPSourceAndPortRangeCheckInterfaceAddDel")
4940         api.RegisterMessage((*IPSourceAndPortRangeCheckInterfaceAddDelReply)(nil), "ip.IPSourceAndPortRangeCheckInterfaceAddDelReply")
4941         api.RegisterMessage((*IPScanNeighborEnableDisable)(nil), "ip.IPScanNeighborEnableDisable")
4942         api.RegisterMessage((*IPScanNeighborEnableDisableReply)(nil), "ip.IPScanNeighborEnableDisableReply")
4943         api.RegisterMessage((*IPProbeNeighbor)(nil), "ip.IPProbeNeighbor")
4944         api.RegisterMessage((*IPProbeNeighborReply)(nil), "ip.IPProbeNeighborReply")
4945         api.RegisterMessage((*WantIP4ArpEvents)(nil), "ip.WantIP4ArpEvents")
4946         api.RegisterMessage((*WantIP4ArpEventsReply)(nil), "ip.WantIP4ArpEventsReply")
4947         api.RegisterMessage((*IP4ArpEvent)(nil), "ip.IP4ArpEvent")
4948         api.RegisterMessage((*WantIP6NdEvents)(nil), "ip.WantIP6NdEvents")
4949         api.RegisterMessage((*WantIP6NdEventsReply)(nil), "ip.WantIP6NdEventsReply")
4950         api.RegisterMessage((*IP6NdEvent)(nil), "ip.IP6NdEvent")
4951         api.RegisterMessage((*WantIP6RaEvents)(nil), "ip.WantIP6RaEvents")
4952         api.RegisterMessage((*WantIP6RaEventsReply)(nil), "ip.WantIP6RaEventsReply")
4953         api.RegisterMessage((*IP6RaEvent)(nil), "ip.IP6RaEvent")
4954         api.RegisterMessage((*ProxyArpAddDel)(nil), "ip.ProxyArpAddDel")
4955         api.RegisterMessage((*ProxyArpAddDelReply)(nil), "ip.ProxyArpAddDelReply")
4956         api.RegisterMessage((*ProxyArpDump)(nil), "ip.ProxyArpDump")
4957         api.RegisterMessage((*ProxyArpDetails)(nil), "ip.ProxyArpDetails")
4958         api.RegisterMessage((*ProxyArpIntfcEnableDisable)(nil), "ip.ProxyArpIntfcEnableDisable")
4959         api.RegisterMessage((*ProxyArpIntfcEnableDisableReply)(nil), "ip.ProxyArpIntfcEnableDisableReply")
4960         api.RegisterMessage((*ProxyArpIntfcDump)(nil), "ip.ProxyArpIntfcDump")
4961         api.RegisterMessage((*ProxyArpIntfcDetails)(nil), "ip.ProxyArpIntfcDetails")
4962         api.RegisterMessage((*ResetFib)(nil), "ip.ResetFib")
4963         api.RegisterMessage((*ResetFibReply)(nil), "ip.ResetFibReply")
4964         api.RegisterMessage((*SetArpNeighborLimit)(nil), "ip.SetArpNeighborLimit")
4965         api.RegisterMessage((*SetArpNeighborLimitReply)(nil), "ip.SetArpNeighborLimitReply")
4966         api.RegisterMessage((*IoamEnable)(nil), "ip.IoamEnable")
4967         api.RegisterMessage((*IoamEnableReply)(nil), "ip.IoamEnableReply")
4968         api.RegisterMessage((*IoamDisable)(nil), "ip.IoamDisable")
4969         api.RegisterMessage((*IoamDisableReply)(nil), "ip.IoamDisableReply")
4970         api.RegisterMessage((*IPReassemblySet)(nil), "ip.IPReassemblySet")
4971         api.RegisterMessage((*IPReassemblySetReply)(nil), "ip.IPReassemblySetReply")
4972         api.RegisterMessage((*IPReassemblyGet)(nil), "ip.IPReassemblyGet")
4973         api.RegisterMessage((*IPReassemblyGetReply)(nil), "ip.IPReassemblyGetReply")
4974         api.RegisterMessage((*IPReassemblyEnableDisable)(nil), "ip.IPReassemblyEnableDisable")
4975         api.RegisterMessage((*IPReassemblyEnableDisableReply)(nil), "ip.IPReassemblyEnableDisableReply")
4976 }