Merge "Add support for jumbo frames to libmemif"
[govpp.git] / core / bin_api / vpe / vpe.go
1 // Code generated by govpp binapi-generator DO NOT EDIT.
2 // Package vpe represents the VPP binary API of the 'vpe' VPP module.
3 // Generated from 'bin_api/vpe.api.json'
4 package vpe
5
6 import "git.fd.io/govpp.git/api"
7
8 // VlApiVersion contains version of the API.
9 const VlAPIVersion = 0xe02a02b0
10
11 // ControlPing represents the VPP binary API message 'control_ping'.
12 // Generated from 'bin_api/vpe.api.json', line 48:
13 //
14 //            "control_ping",
15 //            [
16 //                "u16",
17 //                "_vl_msg_id"
18 //            ],
19 //            [
20 //                "u32",
21 //                "client_index"
22 //            ],
23 //            [
24 //                "u32",
25 //                "context"
26 //            ],
27 //            {
28 //                "crc": "0x51077d14"
29 //            }
30 //
31 type ControlPing struct {
32 }
33
34 func (*ControlPing) GetMessageName() string {
35         return "control_ping"
36 }
37 func (*ControlPing) GetMessageType() api.MessageType {
38         return api.RequestMessage
39 }
40 func (*ControlPing) GetCrcString() string {
41         return "51077d14"
42 }
43 func NewControlPing() api.Message {
44         return &ControlPing{}
45 }
46
47 // ControlPingReply represents the VPP binary API message 'control_ping_reply'.
48 // Generated from 'bin_api/vpe.api.json', line 66:
49 //
50 //            "control_ping_reply",
51 //            [
52 //                "u16",
53 //                "_vl_msg_id"
54 //            ],
55 //            [
56 //                "u32",
57 //                "context"
58 //            ],
59 //            [
60 //                "i32",
61 //                "retval"
62 //            ],
63 //            [
64 //                "u32",
65 //                "client_index"
66 //            ],
67 //            [
68 //                "u32",
69 //                "vpe_pid"
70 //            ],
71 //            {
72 //                "crc": "0xf6b0b8ca"
73 //            }
74 //
75 type ControlPingReply struct {
76         Retval      int32
77         ClientIndex uint32
78         VpePid      uint32
79 }
80
81 func (*ControlPingReply) GetMessageName() string {
82         return "control_ping_reply"
83 }
84 func (*ControlPingReply) GetMessageType() api.MessageType {
85         return api.ReplyMessage
86 }
87 func (*ControlPingReply) GetCrcString() string {
88         return "f6b0b8ca"
89 }
90 func NewControlPingReply() api.Message {
91         return &ControlPingReply{}
92 }
93
94 // Cli represents the VPP binary API message 'cli'.
95 // Generated from 'bin_api/vpe.api.json', line 92:
96 //
97 //            "cli",
98 //            [
99 //                "u16",
100 //                "_vl_msg_id"
101 //            ],
102 //            [
103 //                "u32",
104 //                "client_index"
105 //            ],
106 //            [
107 //                "u32",
108 //                "context"
109 //            ],
110 //            [
111 //                "u64",
112 //                "cmd_in_shmem"
113 //            ],
114 //            {
115 //                "crc": "0x23bfbfff"
116 //            }
117 //
118 type Cli struct {
119         CmdInShmem uint64
120 }
121
122 func (*Cli) GetMessageName() string {
123         return "cli"
124 }
125 func (*Cli) GetMessageType() api.MessageType {
126         return api.RequestMessage
127 }
128 func (*Cli) GetCrcString() string {
129         return "23bfbfff"
130 }
131 func NewCli() api.Message {
132         return &Cli{}
133 }
134
135 // CliInband represents the VPP binary API message 'cli_inband'.
136 // Generated from 'bin_api/vpe.api.json', line 114:
137 //
138 //            "cli_inband",
139 //            [
140 //                "u16",
141 //                "_vl_msg_id"
142 //            ],
143 //            [
144 //                "u32",
145 //                "client_index"
146 //            ],
147 //            [
148 //                "u32",
149 //                "context"
150 //            ],
151 //            [
152 //                "u32",
153 //                "length"
154 //            ],
155 //            [
156 //                "u8",
157 //                "cmd",
158 //                0,
159 //                "length"
160 //            ],
161 //            {
162 //                "crc": "0x74e00a49"
163 //            }
164 //
165 type CliInband struct {
166         Length uint32 `struc:"sizeof=Cmd"`
167         Cmd    []byte
168 }
169
170 func (*CliInband) GetMessageName() string {
171         return "cli_inband"
172 }
173 func (*CliInband) GetMessageType() api.MessageType {
174         return api.RequestMessage
175 }
176 func (*CliInband) GetCrcString() string {
177         return "74e00a49"
178 }
179 func NewCliInband() api.Message {
180         return &CliInband{}
181 }
182
183 // CliReply represents the VPP binary API message 'cli_reply'.
184 // Generated from 'bin_api/vpe.api.json', line 142:
185 //
186 //            "cli_reply",
187 //            [
188 //                "u16",
189 //                "_vl_msg_id"
190 //            ],
191 //            [
192 //                "u32",
193 //                "context"
194 //            ],
195 //            [
196 //                "i32",
197 //                "retval"
198 //            ],
199 //            [
200 //                "u64",
201 //                "reply_in_shmem"
202 //            ],
203 //            {
204 //                "crc": "0x06d68297"
205 //            }
206 //
207 type CliReply struct {
208         Retval       int32
209         ReplyInShmem uint64
210 }
211
212 func (*CliReply) GetMessageName() string {
213         return "cli_reply"
214 }
215 func (*CliReply) GetMessageType() api.MessageType {
216         return api.ReplyMessage
217 }
218 func (*CliReply) GetCrcString() string {
219         return "06d68297"
220 }
221 func NewCliReply() api.Message {
222         return &CliReply{}
223 }
224
225 // CliInbandReply represents the VPP binary API message 'cli_inband_reply'.
226 // Generated from 'bin_api/vpe.api.json', line 164:
227 //
228 //            "cli_inband_reply",
229 //            [
230 //                "u16",
231 //                "_vl_msg_id"
232 //            ],
233 //            [
234 //                "u32",
235 //                "context"
236 //            ],
237 //            [
238 //                "i32",
239 //                "retval"
240 //            ],
241 //            [
242 //                "u32",
243 //                "length"
244 //            ],
245 //            [
246 //                "u8",
247 //                "reply",
248 //                0,
249 //                "length"
250 //            ],
251 //            {
252 //                "crc": "0x1f22bbb8"
253 //            }
254 //
255 type CliInbandReply struct {
256         Retval int32
257         Length uint32 `struc:"sizeof=Reply"`
258         Reply  []byte
259 }
260
261 func (*CliInbandReply) GetMessageName() string {
262         return "cli_inband_reply"
263 }
264 func (*CliInbandReply) GetMessageType() api.MessageType {
265         return api.ReplyMessage
266 }
267 func (*CliInbandReply) GetCrcString() string {
268         return "1f22bbb8"
269 }
270 func NewCliInbandReply() api.Message {
271         return &CliInbandReply{}
272 }
273
274 // GetNodeIndex represents the VPP binary API message 'get_node_index'.
275 // Generated from 'bin_api/vpe.api.json', line 192:
276 //
277 //            "get_node_index",
278 //            [
279 //                "u16",
280 //                "_vl_msg_id"
281 //            ],
282 //            [
283 //                "u32",
284 //                "client_index"
285 //            ],
286 //            [
287 //                "u32",
288 //                "context"
289 //            ],
290 //            [
291 //                "u8",
292 //                "node_name",
293 //                64
294 //            ],
295 //            {
296 //                "crc": "0x6c9a495d"
297 //            }
298 //
299 type GetNodeIndex struct {
300         NodeName []byte `struc:"[64]byte"`
301 }
302
303 func (*GetNodeIndex) GetMessageName() string {
304         return "get_node_index"
305 }
306 func (*GetNodeIndex) GetMessageType() api.MessageType {
307         return api.RequestMessage
308 }
309 func (*GetNodeIndex) GetCrcString() string {
310         return "6c9a495d"
311 }
312 func NewGetNodeIndex() api.Message {
313         return &GetNodeIndex{}
314 }
315
316 // GetNodeIndexReply represents the VPP binary API message 'get_node_index_reply'.
317 // Generated from 'bin_api/vpe.api.json', line 215:
318 //
319 //            "get_node_index_reply",
320 //            [
321 //                "u16",
322 //                "_vl_msg_id"
323 //            ],
324 //            [
325 //                "u32",
326 //                "context"
327 //            ],
328 //            [
329 //                "i32",
330 //                "retval"
331 //            ],
332 //            [
333 //                "u32",
334 //                "node_index"
335 //            ],
336 //            {
337 //                "crc": "0xa8600b89"
338 //            }
339 //
340 type GetNodeIndexReply struct {
341         Retval    int32
342         NodeIndex uint32
343 }
344
345 func (*GetNodeIndexReply) GetMessageName() string {
346         return "get_node_index_reply"
347 }
348 func (*GetNodeIndexReply) GetMessageType() api.MessageType {
349         return api.ReplyMessage
350 }
351 func (*GetNodeIndexReply) GetCrcString() string {
352         return "a8600b89"
353 }
354 func NewGetNodeIndexReply() api.Message {
355         return &GetNodeIndexReply{}
356 }
357
358 // AddNodeNext represents the VPP binary API message 'add_node_next'.
359 // Generated from 'bin_api/vpe.api.json', line 237:
360 //
361 //            "add_node_next",
362 //            [
363 //                "u16",
364 //                "_vl_msg_id"
365 //            ],
366 //            [
367 //                "u32",
368 //                "client_index"
369 //            ],
370 //            [
371 //                "u32",
372 //                "context"
373 //            ],
374 //            [
375 //                "u8",
376 //                "node_name",
377 //                64
378 //            ],
379 //            [
380 //                "u8",
381 //                "next_name",
382 //                64
383 //            ],
384 //            {
385 //                "crc": "0x9ab92f7a"
386 //            }
387 //
388 type AddNodeNext struct {
389         NodeName []byte `struc:"[64]byte"`
390         NextName []byte `struc:"[64]byte"`
391 }
392
393 func (*AddNodeNext) GetMessageName() string {
394         return "add_node_next"
395 }
396 func (*AddNodeNext) GetMessageType() api.MessageType {
397         return api.RequestMessage
398 }
399 func (*AddNodeNext) GetCrcString() string {
400         return "9ab92f7a"
401 }
402 func NewAddNodeNext() api.Message {
403         return &AddNodeNext{}
404 }
405
406 // AddNodeNextReply represents the VPP binary API message 'add_node_next_reply'.
407 // Generated from 'bin_api/vpe.api.json', line 265:
408 //
409 //            "add_node_next_reply",
410 //            [
411 //                "u16",
412 //                "_vl_msg_id"
413 //            ],
414 //            [
415 //                "u32",
416 //                "context"
417 //            ],
418 //            [
419 //                "i32",
420 //                "retval"
421 //            ],
422 //            [
423 //                "u32",
424 //                "next_index"
425 //            ],
426 //            {
427 //                "crc": "0x2ed75f32"
428 //            }
429 //
430 type AddNodeNextReply struct {
431         Retval    int32
432         NextIndex uint32
433 }
434
435 func (*AddNodeNextReply) GetMessageName() string {
436         return "add_node_next_reply"
437 }
438 func (*AddNodeNextReply) GetMessageType() api.MessageType {
439         return api.ReplyMessage
440 }
441 func (*AddNodeNextReply) GetCrcString() string {
442         return "2ed75f32"
443 }
444 func NewAddNodeNextReply() api.Message {
445         return &AddNodeNextReply{}
446 }
447
448 // ShowVersion represents the VPP binary API message 'show_version'.
449 // Generated from 'bin_api/vpe.api.json', line 287:
450 //
451 //            "show_version",
452 //            [
453 //                "u16",
454 //                "_vl_msg_id"
455 //            ],
456 //            [
457 //                "u32",
458 //                "client_index"
459 //            ],
460 //            [
461 //                "u32",
462 //                "context"
463 //            ],
464 //            {
465 //                "crc": "0x51077d14"
466 //            }
467 //
468 type ShowVersion struct {
469 }
470
471 func (*ShowVersion) GetMessageName() string {
472         return "show_version"
473 }
474 func (*ShowVersion) GetMessageType() api.MessageType {
475         return api.RequestMessage
476 }
477 func (*ShowVersion) GetCrcString() string {
478         return "51077d14"
479 }
480 func NewShowVersion() api.Message {
481         return &ShowVersion{}
482 }
483
484 // ShowVersionReply represents the VPP binary API message 'show_version_reply'.
485 // Generated from 'bin_api/vpe.api.json', line 305:
486 //
487 //            "show_version_reply",
488 //            [
489 //                "u16",
490 //                "_vl_msg_id"
491 //            ],
492 //            [
493 //                "u32",
494 //                "context"
495 //            ],
496 //            [
497 //                "i32",
498 //                "retval"
499 //            ],
500 //            [
501 //                "u8",
502 //                "program",
503 //                32
504 //            ],
505 //            [
506 //                "u8",
507 //                "version",
508 //                32
509 //            ],
510 //            [
511 //                "u8",
512 //                "build_date",
513 //                32
514 //            ],
515 //            [
516 //                "u8",
517 //                "build_directory",
518 //                256
519 //            ],
520 //            {
521 //                "crc": "0x8b5a13b4"
522 //            }
523 //
524 type ShowVersionReply struct {
525         Retval         int32
526         Program        []byte `struc:"[32]byte"`
527         Version        []byte `struc:"[32]byte"`
528         BuildDate      []byte `struc:"[32]byte"`
529         BuildDirectory []byte `struc:"[256]byte"`
530 }
531
532 func (*ShowVersionReply) GetMessageName() string {
533         return "show_version_reply"
534 }
535 func (*ShowVersionReply) GetMessageType() api.MessageType {
536         return api.ReplyMessage
537 }
538 func (*ShowVersionReply) GetCrcString() string {
539         return "8b5a13b4"
540 }
541 func NewShowVersionReply() api.Message {
542         return &ShowVersionReply{}
543 }
544
545 // GetNodeGraph represents the VPP binary API message 'get_node_graph'.
546 // Generated from 'bin_api/vpe.api.json', line 343:
547 //
548 //            "get_node_graph",
549 //            [
550 //                "u16",
551 //                "_vl_msg_id"
552 //            ],
553 //            [
554 //                "u32",
555 //                "client_index"
556 //            ],
557 //            [
558 //                "u32",
559 //                "context"
560 //            ],
561 //            {
562 //                "crc": "0x51077d14"
563 //            }
564 //
565 type GetNodeGraph struct {
566 }
567
568 func (*GetNodeGraph) GetMessageName() string {
569         return "get_node_graph"
570 }
571 func (*GetNodeGraph) GetMessageType() api.MessageType {
572         return api.RequestMessage
573 }
574 func (*GetNodeGraph) GetCrcString() string {
575         return "51077d14"
576 }
577 func NewGetNodeGraph() api.Message {
578         return &GetNodeGraph{}
579 }
580
581 // GetNodeGraphReply represents the VPP binary API message 'get_node_graph_reply'.
582 // Generated from 'bin_api/vpe.api.json', line 361:
583 //
584 //            "get_node_graph_reply",
585 //            [
586 //                "u16",
587 //                "_vl_msg_id"
588 //            ],
589 //            [
590 //                "u32",
591 //                "context"
592 //            ],
593 //            [
594 //                "i32",
595 //                "retval"
596 //            ],
597 //            [
598 //                "u64",
599 //                "reply_in_shmem"
600 //            ],
601 //            {
602 //                "crc": "0x06d68297"
603 //            }
604 //
605 type GetNodeGraphReply struct {
606         Retval       int32
607         ReplyInShmem uint64
608 }
609
610 func (*GetNodeGraphReply) GetMessageName() string {
611         return "get_node_graph_reply"
612 }
613 func (*GetNodeGraphReply) GetMessageType() api.MessageType {
614         return api.ReplyMessage
615 }
616 func (*GetNodeGraphReply) GetCrcString() string {
617         return "06d68297"
618 }
619 func NewGetNodeGraphReply() api.Message {
620         return &GetNodeGraphReply{}
621 }
622
623 // GetNextIndex represents the VPP binary API message 'get_next_index'.
624 // Generated from 'bin_api/vpe.api.json', line 383:
625 //
626 //            "get_next_index",
627 //            [
628 //                "u16",
629 //                "_vl_msg_id"
630 //            ],
631 //            [
632 //                "u32",
633 //                "client_index"
634 //            ],
635 //            [
636 //                "u32",
637 //                "context"
638 //            ],
639 //            [
640 //                "u8",
641 //                "node_name",
642 //                64
643 //            ],
644 //            [
645 //                "u8",
646 //                "next_name",
647 //                64
648 //            ],
649 //            {
650 //                "crc": "0x9ab92f7a"
651 //            }
652 //
653 type GetNextIndex struct {
654         NodeName []byte `struc:"[64]byte"`
655         NextName []byte `struc:"[64]byte"`
656 }
657
658 func (*GetNextIndex) GetMessageName() string {
659         return "get_next_index"
660 }
661 func (*GetNextIndex) GetMessageType() api.MessageType {
662         return api.RequestMessage
663 }
664 func (*GetNextIndex) GetCrcString() string {
665         return "9ab92f7a"
666 }
667 func NewGetNextIndex() api.Message {
668         return &GetNextIndex{}
669 }
670
671 // GetNextIndexReply represents the VPP binary API message 'get_next_index_reply'.
672 // Generated from 'bin_api/vpe.api.json', line 411:
673 //
674 //            "get_next_index_reply",
675 //            [
676 //                "u16",
677 //                "_vl_msg_id"
678 //            ],
679 //            [
680 //                "u32",
681 //                "context"
682 //            ],
683 //            [
684 //                "i32",
685 //                "retval"
686 //            ],
687 //            [
688 //                "u32",
689 //                "next_index"
690 //            ],
691 //            {
692 //                "crc": "0x2ed75f32"
693 //            }
694 //
695 type GetNextIndexReply struct {
696         Retval    int32
697         NextIndex uint32
698 }
699
700 func (*GetNextIndexReply) GetMessageName() string {
701         return "get_next_index_reply"
702 }
703 func (*GetNextIndexReply) GetMessageType() api.MessageType {
704         return api.ReplyMessage
705 }
706 func (*GetNextIndexReply) GetCrcString() string {
707         return "2ed75f32"
708 }
709 func NewGetNextIndexReply() api.Message {
710         return &GetNextIndexReply{}
711 }