aboutsummaryrefslogtreecommitdiffstats
path: root/src/vnet/ip/ip.api
blob: 8a6ecc8da2f8819862adf0d2ab8452c67cabe90b (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
/* Hey Emacs use -*- mode: C -*- */
/*
 * Copyright (c) 2018 Cisco and/or its affiliates.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/** \file

    This file defines vpp IP control-plane API messages which are generally
    called through a shared memory interface.
*/

option version = "3.2.0";

import "vnet/interface_types.api";
import "vnet/fib/fib_types.api";
import "vnet/ethernet/ethernet_types.api";
import "vnet/mfib/mfib_types.api";
import "vnet/interface_types.api";

/** \brief An IP table
    @param is_ipv6 - V4 or V6 table
    @param table_id - table ID associated with the route
                     This table ID will apply to both the unicast
		      and multicast FIBs
    @param name - A client provided name/tag for the table. If this is
                  not set by the client, then VPP will generate something
		  meaningful.
*/
typedef ip_table
{
  u32 table_id;
  bool is_ip6;
  string name[64];
};

/** \brief Add / del table request
           A table can be added multiple times, but need be deleted only once.
    @param client_index - opaque cookie to identify the sender
    @param context - sender context, to match reply w/ request
*/
autoreply define ip_table_add_del
{
  u32 client_index;
  u32 context;
  bool is_add [default=true];
  vl_api_ip_table_t table;
};

/** \brief Allocate an unused table
           A table can be added multiple times.
           If a large number of tables are in use (millions), this API might
           fail to find a free ID with very low probability, and will return
           EAGAIN. A subsequent attempt may be successful.
  @param client_index - opaque cookie to identify the sender
  @param context - sender context, to match reply w/ request
  @param table - if table.table_id == ~0, vpp allocates an unused table_id and
                    proceeds as in ip_table_add_del with is_add = true
                 if table.table_id != ~0, vpp uses the table.table_id and
                    proceeds as in ip_table_add_del with is_add = true
                 table.table_id should never be 0
*/
define ip_table_allocate
{
  u32 client_index;
  u32 context;

  vl_api_ip_table_t table;
};

define ip_table_allocate_reply
{
  u32 context;
  i32 retval;

  vl_api_ip_table_t table;
};

/** \brief Dump IP all fib tables
    @param client_index - opaque cookie to identify the sender
    @param context - sender context, to match reply w/ request
*/
define ip_table_dump
{
  u32 client_index;
  u32 context;
};

/** \brief IP table replace being

    The use-case is that, for some unspecified reason, the control plane
    has a very different set of entries it wants in the table than VPP
    currently has. The CP would thus like to 'replace' VPP's current table
    only by specifying what the new set of entries shall be, i.e. it is not
    going to delete anything that already exists.
    the CP declares the start of this procedure with this begin_replace
    API Call, and when it has populated all the entries it wants, it calls
    the below end_replace API. From this point on it is of course free
    to add and delete entries as usual.
    The underlying mechanism by which VPP implements this replace is
    purposefully left unspecified.

    @param client_index - opaque cookie to identify the sender
    @param context - sender context, to match reply w/ request
    @param table - The table to resync
*/
autoreply define ip_table_replace_begin
{
  u32 client_index;
  u32 context;
  vl_api_ip_table_t table;
};

/** \brief IP table replace end

    see replace start/

    @param client_index - opaque cookie to identify the sender
    @param context - sender context, to match reply w/ request
    @param table - The table that has converged
*/
autoreply define ip_table_replace_end
{
  u32 client_index;
  u32 context;
  vl_api_ip_table_t table;
};

/** \brief IP table flush
    Flush a table of all routes
    @param client_index - opaque cookie to identify the sender
    @param context - sender context, to match reply w/ request
    @param table - The table to flush
*/
autoreply define ip_table_flush
{
  u32 client_index;
  u32 context;
  vl_api_ip_table_t table;
};

/** \brief IP FIB table response
    @param context - sender context
    @param table - description of the table
*/
define ip_table_details
{
  u32 context;
  vl_api_ip_table_t table;
};

/** \brief An IP route
  @param table_id The IP table the route is in
  @param stats_index The index of the route in the stats segment
  @param prefix the prefix for the route
  @param n_paths The number of paths the route has
  @param src The entity adding the route. either 0 for default
             or a value returned from fib_source_sdd.
  @param paths The paths of the route
*/
typedef ip_route
{
  u32 table_id;
  u32 stats_index;
  vl_api_prefix_t prefix;
  u8 n_paths;
  vl_api_fib_path_t paths[n_paths];
};
typedef ip_route_v2
{
  u32 table_id;
  u32 stats_index;
  vl_api_prefix_t prefix;
  u8 n_paths;
  u8 src;
  vl_api_fib_path_t paths[n_paths];
};

/** \brief Add / del route request
    @param client_index - opaque cookie to identify the sender
    @param context - sender context, to match reply w/ request
    @param is_multipath - Set to 1 if these paths will be added/removed
                          to/from the existing set, or 0 to replace
			  the existing set.
                          is_add=0 & is_multipath=0 implies delete all paths
    @param is_add - Are the paths being added or removed
*/
define ip_route_add_del
{
  u32 client_index;
  u32 context;
  bool is_add [default=true];
  bool is_multipath;
  vl_api_ip_route_t route;
};
define ip_route_add_del_v2
{
  option in_progress;
  u32 client_index;
  u32 context;
  bool is_add [default=true];
  bool is_multipath;
  vl_api_ip_route_v2_t route;
};
define ip_route_add_del_reply
{
  u32 context;
  i32 retval;
  u32 stats_index;
};
define ip_route_add_del_v2_reply
{
  option in_progress;
  u32 context;
  i32 retval;
  u32 stats_index;
};

/** \brief Dump IP routes from a table
    @param client_index - opaque cookie to identify the sender
    @param src The entity adding the route. either 0 for default
               or a value returned from fib_source_sdd.
    @param table - The table from which to dump routes (ony ID an AF are needed)
*/
define ip_route_dump
{
  u32 client_index;
  u32 context;
  vl_api_ip_table_t table;
};
define ip_route_v2_dump
{
  option in_progress;
  u32 client_index;
  u32 context;
  /* vl_api_fib_source_t src; */
  u8 src;
  vl_api_ip_table_t table;
};

/** \brief IP FIB table entry response
    @param route The route entry in the table
*/
define ip_route_details
{
  u32 context;
  vl_api_ip_route_t route;
};
define ip_route_v2_details
{
  option in_progress;
  u32 context;
  vl_api_ip_route_v2_t route;
};

/** \brief Lookup IP route from a table
    @param client_index - opaque cookie to identify the sender
    @param table_id - The IP table to look the route up in
    @param exact - 0 for normal route lookup, 1 for exact match only
    @param prefix - The prefix (or host) for route lookup.
*/
define ip_route_lookup
{
  u32 client_index;
  u32 context;
  u32 table_id;
  u8 exact;
  vl_api_prefix_t prefix;
};
define ip_route_lookup_v2
{
  option in_progress;
  u32 client_index;
  u32 context;
  u32 table_id;
  u8 exact;
  vl_api_prefix_t prefix;
};

/** \brief IP FIB table lookup response
    @param retval - return code of the lookup
    @param route - The route entry in the table if found
*/
define ip_route_lookup_reply
{
  u32 context;
  i32 retval;
  vl_api_ip_route_t route;
};
define ip_route_lookup_v2_reply
{
  option in_progress;
  u32 context;
  i32 retval;
  vl_api_ip_route_v2_t route;
};

/** \brief Set the ip flow hash config for a fib request
    @param client_index - opaque cookie to identify the sender
    @param context - sender context, to match reply w/ request
    @param vrf_id - vrf/fib id
    @param is_ipv6 - if non-zero the fib is ip6, else ip4
    @param src - if non-zero include src in flow hash
    @param dst - if non-zero include dst in flow hash
    @param sport - if non-zero include sport in flow hash
    @param dport - if non-zero include dport in flow hash
    @param proto -if non-zero include proto in flow hash
    @param reverse - if non-zero include reverse in flow hash
    @param symmetric - if non-zero include symmetry in flow hash
*/
autoreply define set_ip_flow_hash
{
  option deprecated;
  u32 client_index;
  u32 context;
  u32 vrf_id;
  bool is_ipv6;
  bool src;
  bool dst;
  bool sport;
  bool dport;
  bool proto;
  bool reverse;
  bool symmetric;
};

/**
    @brief flow hash settings for an IP table
    @param src - include src in flow hash
    @param dst - include dst in flow hash
    @param sport - include sport in flow hash
    @param dport - include dport in flow hash
    @param proto - include proto in flow hash
    @param reverse - include reverse in flow hash
    @param symmetric - include symmetry in flow hash
    @param flowlabel - include flowlabel in flow hash
*/
enumflag ip_flow_hash_config
{
  IP_API_FLOW_HASH_SRC_IP = 0x01,
  IP_API_FLOW_HASH_DST_IP = 0x02,
  IP_API_FLOW_HASH_SRC_PORT = 0x04,
  IP_API_FLOW_HASH_DST_PORT = 0x08,
  IP_API_FLOW_HASH_PROTO = 0x10,
  IP_API_FLOW_HASH_REVERSE = 0x20,
  IP_API_FLOW_HASH_SYMETRIC = 0x40,
  IP_API_FLOW_HASH_FLOW_LABEL = 0x80,
};

autoreply define set_ip_flow_hash_v2
{
  u32 client_index;
  u32 context;
  u32 table_id;
  vl_api_address_family_t af;
  vl_api_ip_flow_hash_config_t flow_hash_config;
};

/** \brief Set the ip flow hash router ID
    @param client_index - opaque cookie to identify the sender
    @param context - sender context, to match reply w/ request
    @param router_id - The ID of the router. Mixed into the hash.
                       Used to prevent polarisation across a network,
                       since each router is assumed to have a different ID
*/
autoreply define set_ip_flow_hash_router_id
{
  u32 client_index;
  u32 context;
  u32 router_id;
};

/** \brief IPv6 interface enable / disable request
    @param client_index - opaque cookie to identify the sender
    @param context - sender context, to match reply w/ request
    @param sw_if_index - interface used to reach neighbor
    @param enable - if non-zero enable ip6 on interface, else disable
*/
autoreply define sw_interface_ip6_enable_disable
{
  u32 client_index;
  u32 context;
  vl_api_interface_index_t sw_if_index;
  bool enable;			/* set to true if enable */
};

/** \brief Dump IP multicast fib table
    @param client_index - opaque cookie to identify the sender
*/
define ip_mtable_dump
{
  u32 client_index;
  u32 context;
};
define ip_mtable_details
{
  u32 client_index;
  u32 context;
  vl_api_ip_table_t table;
};

/** \brief Add / del route request

    Adds a route, consisting both of the MFIB entry to match packets
    (which may already exist) and a path to send those packets down.
    Routes can be entered repeatedly to add multiple paths.  Deletions are
    per-path.

    @param client_index - opaque cookie to identify the sender
    @param context - sender context, to match reply w/ request
    @param table_id - fib table /vrf associated with the route
    @param is_add - true if adding a route; false if deleting one
    @param is_ipv6 - true iff all the addresses are v6
    @param entry_flags - see fib_entry_flag_t
    @param itf_flags - see mfib_entry_flags_t
    @param next_hop_afi - see dpo_proto_t; the type of destination description
    @param src_address - the source of the packet
    @param grp_address - the group the packet is destined to
    @param nh_address - the nexthop to forward the packet to
    @param next_hop_sw_if_index - interface to emit packet on

    BIER AFIs use the BIER imposition ID.  v4 and v6 AFIs use either the
    interface or the nexthop address.

    Note that if the route is source-specific (S is supplied, not all 0s),
    the prefix match is treated as exact (prefixlen /32 or /128).

    FIXME not complete yet
*/
typedef ip_mroute
{
  u32 table_id;
  vl_api_mfib_entry_flags_t entry_flags;
  u32 rpf_id;
  vl_api_mprefix_t prefix;
  u8 n_paths;
  vl_api_mfib_path_t paths[n_paths];
};

define ip_mroute_add_del
{
  u32 client_index;
  u32 context;
  bool is_add [default=true];
  bool is_multipath;
  vl_api_ip_mroute_t route;
};
define ip_mroute_add_del_reply
{
  u32 context;
  i32 retval;
  u32 stats_index;
};

/** \brief Dump IP multicast fib table
    @param table - The table from which to dump routes (ony ID an AF are needed)
*/
define ip_mroute_dump
{
  u32 client_index;
  u32 context;
  vl_api_ip_table_t table;
};

/** \brief IP Multicast Route Details
    @param route - Details of the route
*/
define ip_mroute_details
{
  u32 context;
  vl_api_ip_mroute_t route;
};

define ip_address_details
{
  u32 context;
  vl_api_interface_index_t sw_if_index;
  vl_api_address_with_prefix_t prefix;
};

define ip_address_dump
{
  u32 client_index;
  u32 context;
  vl_api_interface_index_t sw_if_index;
  bool is_ipv6;
};

/** \brief IP unnumbered configurations
    @param sw_if_index The interface that has unnumbered configuration
    @param ip_sw_if_index The IP interface that it is unnumbered to
*/
define ip_unnumbered_details
{
  u32 context;
  vl_api_interface_index_t sw_if_index;
  vl_api_interface_index_t ip_sw_if_index;
};

/** \brief Dump IP unnumbered configurations
    @param sw_if_index ~0 for all interfaces, else the interface desired
*/
define ip_unnumbered_dump
{
  u32 client_index;
  u32 context;
  vl_api_interface_index_t sw_if_index [default=0xffffffff];
};

define ip_details
{
  u32 context;
  vl_api_interface_index_t sw_if_index;
  bool is_ipv6;
};

define ip_dump
{
  u32 client_index;
  u32 context;
  bool is_ipv6;
};

define mfib_signal_dump
{
  u32 client_index;
  u32 context;
};

define mfib_signal_details
{
  u32 context;
  vl_api_interface_index_t sw_if_index;
  u32 table_id;
  vl_api_mprefix_t prefix;
  u16 ip_packet_len;
  u8 ip_packet_data[256];
};

/** \brief IP punt policer
    @param client_index - opaque cookie to identify the sender
    @param context - sender context, to match reply w/ request
    @param is_add - 1 to add neighbor, 0 to delete
    @param is_ipv6 - 1 for IPv6 neighbor, 0 for IPv4
    @param policer_index - Index of policer to use
*/
autoreply define ip_punt_police
{
  u32 client_index;
  u32 context;
  u32 policer_index;
  bool is_add [default=true];
  bool is_ip6;
};

/** \brief Punt redirect type
    @param rx_sw_if_index - specify the original RX interface of traffic
                            that should be redirected. ~0 means any interface.
    @param tx_sw_if_index - the TX interface to which traffic should be
                            redirected.
    @param nh - the next-hop to redirect the traffic to.
    @param is_ipv6 - 1 for IPv6 neighbor, 0 for IPv4
*/
typedef punt_redirect
{
  vl_api_interface_index_t rx_sw_if_index;
  vl_api_interface_index_t tx_sw_if_index;
  vl_api_address_t nh;
};

/** \brief IP punt redirect
    @param client_index - opaque cookie to identify the sender
    @param context - sender context, to match reply w/ request
    @param punt - punt definition
    @param is_add - 1 to add neighbor, 0 to delete
*/
autoreply define ip_punt_redirect
{
  option deprecated;
  u32 client_index;
  u32 context;
  vl_api_punt_redirect_t punt;
  bool is_add [default=true];
};

define ip_punt_redirect_dump
{
  u32 client_index;
  u32 context;
  vl_api_interface_index_t sw_if_index;
  bool is_ipv6;
};

define ip_punt_redirect_details
{
  u32 context;
  vl_api_punt_redirect_t punt;
};

/** \brief Punt redirect type
    @param rx_sw_if_index - specify the original RX interface of traffic
                            that should be redirected. ~0 means any interface.
    @param af - Address family (ip4 or ip6)
    @param paths - the TX paths to which traffic should be redirected.
*/
typedef punt_redirect_v2
{
  vl_api_interface_index_t rx_sw_if_index [default=0xffffffff];
  vl_api_address_family_t af;
  u32 n_paths;
  vl_api_fib_path_t paths[n_paths];
};

/** \brief Add IP punt redirect rule
    @param client_index - opaque cookie to identify the sender
    @param context - sender context, to match reply w/ request
    @param punt - punt definition
    @param is_add - 1 to add punt_redirect rule, 0 to delete
*/
autoreply define add_del_ip_punt_redirect_v2
{
  u32 client_index;
  u32 context;
  bool is_add [default=true];
  vl_api_punt_redirect_v2_t punt;
};

define ip_punt_redirect_v2_dump
{
  u32 client_index;
  u32 context;
  vl_api_interface_index_t sw_if_index;
  vl_api_address_family_t af;
};

define ip_punt_redirect_v2_details
{
  u32 context;
  vl_api_punt_redirect_v2_t punt;
};

autoreply define ip_container_proxy_add_del
{
  u32 client_index;
  u32 context;
  vl_api_prefix_t pfx;
  vl_api_interface_index_t sw_if_index;
  bool is_add [default=true];
};

define ip_container_proxy_dump
{
  u32 client_index;
  u32 context;
};

define ip_container_proxy_details
{
  u32 context;
  vl_api_interface_index_t sw_if_index;
  vl_api_prefix_t prefix;
};

/** \brief Configure IP source and L4 port-range check
    @param client_index - opaque cookie to identify the sender
    @param context - sender context, to match reply w/ request
    @param is_ip6 - 1 if source address type is IPv6
    @param is_add - 1 if add, 0 if delete
    @param ip - prefix to match
    @param number_of_ranges - length of low_port and high_port arrays (must match)
    @param low_ports[32] - up to 32 low end of port range entries (must have corresponding high_ports entry)
    @param high_ports[32] - up to 32 high end of port range entries (must have corresponding low_ports entry)
    @param vrf_id - fib table/vrf id to associate the source and port-range check with
    @note To specify a single port set low_port and high_port entry the same
*/
autoreply define ip_source_and_port_range_check_add_del
{
  u32 client_index;
  u32 context;
  bool is_add [default=true];
  vl_api_prefix_t prefix;
  u8 number_of_ranges;
  u16 low_ports[32];
  u16 high_ports[32];
  u32 vrf_id;
};

/** \brief Set interface source and L4 port-range request
    @param client_index - opaque cookie to identify the sender
    @param context - sender context, to match reply w/ request
    @param interface_id - interface index
    @param tcp_vrf_id - VRF associated with source and TCP port-range check
    @param udp_vrf_id - VRF associated with source and TCP port-range check
*/
autoreply define ip_source_and_port_range_check_interface_add_del
{
  u32 client_index;
  u32 context;
  bool is_add [default=true];
  vl_api_interface_index_t sw_if_index;
  u32 tcp_in_vrf_id;
  u32 tcp_out_vrf_id;
  u32 udp_in_vrf_id;
  u32 udp_out_vrf_id;
};

/** \brief IPv6 set link local address on interface request
    @param client_index - opaque cookie to identify the sender
    @param context - sender context, to match reply w/ request
    @param sw_if_index - interface to set link local on
    @param ip - the new link local address
*/
autoreply define sw_interface_ip6_set_link_local_address
{
  u32 client_index;
  u32 context;
  vl_api_interface_index_t sw_if_index;
  vl_api_ip6_address_t ip;
};

/** \brief IPv6 get link local address on interface request
    @param client_index - opaque cookie to identify the sender
    @param context - sender context, to match reply w/ request
    @param sw_if_index - interface to set link local on
*/
define sw_interface_ip6_get_link_local_address
{
  u32 client_index;
  u32 context;
  vl_api_interface_index_t sw_if_index;
};

/** \brief IPv6 link local address detail
    @param context - sender context, to match reply w/ request
    @param ip - the link local address
*/
define sw_interface_ip6_get_link_local_address_reply
{
  u32 context;
  i32 retval;
  vl_api_ip6_address_t ip;
};

/** \brief IOAM enable : Enable in-band OAM
    @param id - profile id
    @param seqno - To enable Seqno Processing
    @param analyse - Enabling analysis of iOAM at decap node
    @param pow_enable - Proof of Work enabled or not flag
    @param trace_enable - iOAM Trace enabled or not flag
*/
autoreply define ioam_enable
{
  u32 client_index;
  u32 context;
  u16 id;
  bool seqno;
  bool analyse;
  bool pot_enable;
  bool trace_enable;
  u32 node_id;
};

/** \brief iOAM disable
    @param client_index - opaque cookie to identify the sender
    @param context - sender context, to match reply w/ request
    @param index - MAP Domain index
*/
autoreply define ioam_disable
{
  u32 client_index;
  u32 context;
  u16 id;
};

enum ip_reass_type
{
  IP_REASS_TYPE_FULL = 0,
  IP_REASS_TYPE_SHALLOW_VIRTUAL = 0x1,
};

autoreply define ip_reassembly_set
{
  u32 client_index;
  u32 context;
  u32 timeout_ms;
  u32 max_reassemblies;
  u32 max_reassembly_length;
  u32 expire_walk_interval_ms;
  bool is_ip6;
  vl_api_ip_reass_type_t type;
};

define ip_reassembly_get
{
  u32 client_index;
  u32 context;
  bool is_ip6;
  vl_api_ip_reass_type_t type;
};

define ip_reassembly_get_reply
{
  u32 context;
  i32 retval;
  u32 timeout_ms;
  u32 max_reassemblies;
  u32 max_reassembly_length;
  u32 expire_walk_interval_ms;
  bool is_ip6;
};

/** \brief Enable/disable reassembly feature
    @param client_index - opaque cookie to identify the sender
    @param context - sender context, to match reply w/ request
    @param sw_if_index - interface to enable/disable feature on
    @param enable_ip4 - enable ip4 reassembly if non-zero, disable if 0
    @param enable_ip6 - enable ip6 reassembly if non-zero, disable if 0
*/
autoreply define ip_reassembly_enable_disable
{
  u32 client_index;
  u32 context;
  vl_api_interface_index_t sw_if_index;
  bool enable_ip4;
  bool enable_ip6;
  vl_api_ip_reass_type_t type;
};

/** enable/disable full reassembly of packets aimed at our addresses */
autoreply define ip_local_reass_enable_disable
{
  u32 client_index;
  u32 context;
  bool enable_ip4;
  bool enable_ip6;
};

/** get status of local reassembly */
define ip_local_reass_get
{
  u32 client_index;
  u32 context;
};

define ip_local_reass_get_reply
{
  u32 context;
  i32 retval;
  bool ip4_is_enabled;
  bool ip6_is_enabled;
};

/**
    @brief Set a Path MTU value. i.e. a MTU value for a given neighbour.
           The neighbour can be described as attached (w/ interface and next-hop)
           or remote (w/ table_id and next-hop);
    @param client_index - opaque cookie to identify the sender
    @param context - sender context, to match reply w/ request
    @param table_id - table-ID for next-hop
    @param nh - Next hop
    @param path_mtu - value to set, 0 is disable.
*/
typedef ip_path_mtu
{
  u32 client_index;
  u32 context;
  u32 table_id;
  vl_api_address_t nh;
  u16 path_mtu;
};
autoreply define ip_path_mtu_update
{
  u32 client_index;
  u32 context;
  vl_api_ip_path_mtu_t pmtu;
};
define ip_path_mtu_get
{
  u32 client_index;
  u32 context;
  u32 cursor;
};
define ip_path_mtu_get_reply
{
  u32 context;
  i32 retval;
  u32 cursor;
};
define ip_path_mtu_details
{
  u32 context;
  vl_api_ip_path_mtu_t pmtu;
};
service {
  rpc ip_path_mtu_get returns ip_path_mtu_get_reply
    stream ip_path_mtu_details;
};

autoreply define ip_path_mtu_replace_begin
{
  u32 client_index;
  u32 context;
};
autoreply define ip_path_mtu_replace_end
{
  u32 client_index;
  u32 context;
};

counters ip_frag {
  none {
    severity info;
    type counter64;
    units "packets";
    description "packet fragmented";
  };
  small_packet {
    severity error;
    type counter64;
    units "packets";
    description "packet smaller than MTU";
  };
  fragment_sent {
    severity info;
    type counter64;
    units "packets";
    description "number of sent fragments";
  };
  cant_fragment_header {
    severity error;
    type counter64;
    units "packets";
    description "can't fragment header";
  };
  dont_fragment_set {
    severity error;
    type counter64;
    units "packets";
    description "can't fragment this packet";
  };
  malformed {
    severity error;
    type counter64;
    units "packets";
    description "malformed packet";
  };
  memory {
    severity error;
    type counter64;
    units "packets";
    description "could not allocate buffer";
  };
  unknown {
    severity error;
    type counter64;
    units "packets";
    description "unknown error";
  };
};

counters ip4 {
  /* Must be first. */
  none {
    severity info;
    type counter64;
    units "packets";
    description "valid ip4 packets";
  };

  /* Errors signalled by ip4-input */
  too_short {
    severity error;
    type counter64;
    units "packets";
    description "ip4 length < 20 bytes";
  };
  bad_length {
    severity error;
    type counter64;
    units "packets";
    description "ip4 length > l2 length";
  };
  bad_checksum {
    severity error;
    type counter64;
    units "packets";
    description "bad ip4 checksum";
  };
  version {
    severity error;
    type counter64;
    units "packets";
    description "ip4 version != 4";
  };
  options {
    severity info;
    type counter64;
    units "packets";
    description "ip4 options present";
  };
  fragment_offset_one {
    severity error;
    type counter64;
    units "packets";
    description "ip4 fragment offset == 1";
  };
  time_expired {
    severity error;
    type counter64;
    units "packets";
    description "ip4 ttl <= 1";
  };
  hdr_too_short {
    severity error;
    type counter64;
    units "packets";
    description "ip4 IHL < 5";
  };

  /* Errors signalled by ip4-rewrite. */
  mtu_exceeded {
    severity error;
    type counter64;
    units "packets";
    description "ip4 MTU exceeded and DF set";
  };
  dst_lookup_miss {
    severity error;
    type counter64;
    units "packets";
    description "ip4 destination lookup miss";
  };
  src_lookup_miss {
    severity error;
    type counter64;
    units "packets";
    description "ip4 source lookup miss";
  };
  drop {
    severity error;
    type counter64;
    units "packets";
    description "ip4 drop";
  };
  punt {
    severity error;
    type counter64;
    units "packets";
    description "ip4 punt";
  };
  same_interface {
    severity error;
    type counter64;
    units "packets";
    description "ip4 egress interface same as ingress";
  };

  /* errors signalled by ip4-local. */
  unknown_protocol {
    severity error;
    type counter64;
    units "packets";
    description "unknown ip protocol";
  };
  tcp_checksum {
    severity error;
    type counter64;
    units "packets";
    description "bad tcp checksum";
  };
  udp_checksum {
    severity error;
    type counter64;
    units "packets";
    description "bad udp checksum";
  };
  udp_length {
    severity error;
    type counter64;
    units "packets";
    description "inconsistent udp/ip lengths";
  };

  /* spoofed packets in ip4-rewrite-local */
  spoofed_local_packets {
    severity error;
    type counter64;
    units "packets";
    description "ip4 spoofed local-address packet drops";
  };

  /* Errors signalled by ip4-inacl */
  inacl_table_miss {
    severity error;
    type counter64;
    units "packets";
    description "input ACL table-miss drops";
  };
  inacl_session_deny {
    severity error;
    type counter64;
    units "packets";
    description "input ACL session deny drops";
  };

  /* Errors singalled by ip4-outacl */
  outacl_table_miss {
    severity error;
    type counter64;
    units "packets";
    description "output ACL table-miss drops";
  };
  outacl_session_deny {
    severity error;
    type counter64;
    units "packets";
    description "output ACL session deny drops";
  };

  /* Errors from mfib-forward */
  rpf_failure {
    severity error;
    type counter64;
    units "packets";
    description "Multicast RPF check failed";
  };

  /* Errors signalled by ip4-reassembly */
  reass_duplicate_fragment {
    severity error;
    type counter64;
    units "packets";
    description "duplicate/overlapping fragments";
  };
  reass_limit_reached {
    severity error;
    type counter64;
    units "packets";
    description "drops due to concurrent reassemblies limit";
  };
  reass_fragment_chain_too_long {
    severity error;
    type counter64;
    units "packets";
    description "fragment chain too long (drop)";
  };
  reass_no_buf {
    severity error;
    type counter64;
    units "packets";
    description "out of buffers (drop)";
  };
  reass_malformed_packet {
    severity error;
    type counter64;
    units "packets";
    description "malformed packets";
  };
  reass_internal_error {
    severity error;
    type counter64;
    units "packets";
    description "drops due to internal reassembly error";
  };
  reass_timeout {
    severity error;
    type counter64;
    units "packets";
    description "fragments dropped due to reassembly timeout";
  };
  reass_to_custom_app {
    severity error;
    type counter64;
    units "packets";
    description "send to custom drop app";
  };
  reass_success {
    severity info;
    type counter64;
    units "packets";
    description "successful reassemblies";
  };
  reass_fragments_reassembled {
    severity info;
    type counter64;
    units "packets";
    description "fragments reassembled";
  };
  reass_fragments_rcvd {
    severity info;
    type counter64;
    units "packets";
    description "fragments received";
  };
  reass_unsupp_ip_prot {
    severity error;
    type counter64;
    units "packets";
    description "unsupported ip protocol";
  };
};

/**
 * IPv6 Error/info counters
 */
counters ip6 {
  /* Must be first. */
  none {
    severity info;
    type counter64;
    units "packets";
    description "valid ip6 packets";
  };

  /* Errors signalled by ip6-input */
  too_short {
    severity error;
    type counter64;
    units "packets";
    description "ip6 length < 40 bytes";
  };
  bad_length {
    severity error;
    type counter64;
    units "packets";
    description "ip6 length > l2 length";
  };
  version {
    severity error;
    type counter64;
    units "packets";
    description "ip6 version != 6";
  };
  time_expired {
    severity error;
    type counter64;
    units "packets";
    description "ip6 ttl <= 1";
  };

  /* Errors signalled by ip6-rewrite. */
  mtu_exceeded {
    severity error;
    type counter64;
    units "packets";
    description "ip6 MTU exceeded";
  };
  dst_lookup_miss {
    severity error;
    type counter64;
    units "packets";
    description "ip6 destination lookup miss";
  };
  src_lookup_miss {
    severity error;
    type counter64;
    units "packets";
    description "ip6 source lookup miss";
  };
  drop {
    severity error;
    type counter64;
    units "packets";
    description "ip6 drop";
  };
  punt {
    severity error;
    type counter64;
    units "packets";
    description "ip6 punt";
  };

  /* errors signalled by ip6-local. */
  unknown_protocol {
    severity error;
    type counter64;
    units "packets";
    description "unknown ip protocol";
  };
  udp_checksum {
    severity error;
    type counter64;
    units "packets";
    description "bad udp checksum";
  };
  icmp_checksum {
    severity error;
    type counter64;
    units "packets";
    description "bad icmp checksum";
  };
  udp_length {
    severity error;
    type counter64;
    units "packets";
    description "inconsistent udp/ip lengths";
  };
  /* Errors signalled by udp6-lookup. */
  unknown_udp_port {
    severity error;
    type counter64;
    units "packets";
    description "no listener for udp port";
  };

  /* spoofed packets in ip6-rewrite-local */
  spoofed_local_packets {
    severity error;
    type counter64;
    units "packets";
    description "ip6 spoofed local-address packet drops";
  };

  /* Errors signalled by ip6-inacl */
  inacl_table_miss {
    severity error;
    type counter64;
    units "packets";
    description "input ACL table-miss drops";
  };
  inacl_session_deny {
    severity error;
    type counter64;
    units "packets";
    description "input ACL session deny drops";
  };

  /* Errors singalled by ip6-outacl */
  outacl_table_miss {
    severity error;
    type counter64;
    units "packets";
    description "output ACL table-miss drops";
  };
  outacl_session_deny {
    severity error;
    type counter64;
    units "packets";
    description "output ACL session deny drops";
  };

  /* Errors from mfib-forward */
  rpf_failure {
    severity error;
    type counter64;
    units "packets";
    description "Multicast RPF check failed";
  };

  /* Errors signalled by ip6-reassembly */
  reass_missing_upper {
    severity error;
    type counter64;
    units "packets";
    description "missing-upper layer drops";
  };
  reass_duplicate_fragment {
    severity error;
    type counter64;
    units "packets";
    description "duplicate fragments";
  };
  reass_overlapping_fragment {
    severity error;
    type counter64;
    units "packets";
    description "overlapping fragments";
  };
  reass_limit_reached {
    severity error;
    type counter64;
    units "packets";
    description "drops due to concurrent reassemblies limit";
  };
  reass_fragment_chain_too_long {
    severity error;
    type counter64;
    units "packets";
    description "fragment chain too long (drop)";
  };
  reass_no_buf {
    severity error;
    type counter64;
    units "packets";
    description "out of buffers (drop)";
  };
  reass_timeout {
    severity error;
    type counter64;
    units "packets";
    description "fragments dropped due to reassembly timeout";
  };
  reass_internal_error {
    severity error;
    type counter64;
    units "packets";
    description "drops due to internal reassembly error";
  };
  reass_invalid_frag_len {
    severity error;
    type counter64;
    units "packets";
    description "invalid fragment length";
  };
  reass_to_custom_app {
    severity error;
    type counter64;
    units "packets";
    description "send to custom drop app";
  };
  reass_no_frag_hdr {
    severity error;
    type counter64;
    units "packets";
    description "no fragmentation header";
  };
  reass_invalid_frag_size {
    severity error;
    type counter64;
    units "packets";
    description "drop due to invalid fragment size";
  };
  reass_success {
    severity info;
    type counter64;
    units "packets";
    description "successful reassemblies";
  };
  reass_fragments_reassembled {
    severity info;
    type counter64;
    units "packets";
    description "fragments reassembled";
  };
  reass_fragments_rcvd {
    severity info;
    type counter64;
    units "packets";
    description "fragments received";
  };
  reass_unsupp_ip_proto {
    severity error;
    type counter64;
    units "packets";
    description "unsupported ip protocol";
  };
};

counters icmp4 {
  none {
    severity info;
    type counter64;
    units "packets";
    description "valid packets";
  };
  unknown_type {
    severity error;
    type counter64;
    units "packets";
    description "unknown type";
  };
  invalid_code_for_type {
    severity error;
    type counter64;
    units "packets";
    description "invalid code for type";
  };
  invalid_hop_limit_for_type {
    severity error;
    type counter64;
    units "packets";
    description "hop_limit != 255";
  };
  length_too_small_for_type {
    severity error;
    type counter64;
    units "packets";
    description "payload length too small for type";
  };
  options_with_odd_length {
    severity error;
    type counter64;
    units "packets";
    description "total option length not multiple of 8 bytes";
  };
  option_with_zero_length {
    severity error;
    type counter64;
    units "packets";
    description "option has zero length";
  };
  echo_replies_sent {
    severity info;
    type counter64;
    units "packets";
    description "echo replies sent";
  };
  dst_lookup_miss {
    severity error;
    type counter64;
    units "packets";
    description "icmp6 dst address lookup misses";
  };
  dest_unreach_sent {
    severity info;
    type counter64;
    units "packets";
    description "destination unreachable response sent";
  };
  ttl_expire_sent {
    severity info;
    type counter64;
    units "packets";
    description "hop limit exceeded response sent";
  };
  param_problem_sent {
    severity info;
    type counter64;
    units "packets";
    description "parameter problem response sent";
  };
  drop {
    severity error;
    type counter64;
    units "packets";
    description "error message dropped";
  };
};

counters icmp6 {
  none {
    severity info;
    type counter64;
    units "packets";
    description "valid packets";
  };
  unknown_type {
    severity error;
    type counter64;
    units "packets";
    description "unknown type";
  };
  invalid_code_for_type {
    severity error;
    type counter64;
    units "packets";
    description "invalid code for type";
  };
  invalid_hop_limit_for_type {
    severity error;
    type counter64;
    units "packets";
    description "hop_limit != 255";
  };
  length_too_small_for_type {
    severity error;
    type counter64;
    units "packets";
    description "payload length too small for type";
  };
  options_with_odd_length {
    severity error;
    type counter64;
    units "packets";
    description "total option length not multiple of 8 bytes";
  };
  option_with_zero_length {
    severity error;
    type counter64;
    units "packets";
    description "option has zero length";
  };
  echo_replies_sent {
    severity info;
    type counter64;
    units "packets";
    description "echo replies sent";
  };
  neighbor_solicitation_source_not_on_link {
    severity error;
    type counter64;
    units "packets";
    description "neighbor solicitations from source not on link";
  };
  neighbor_solicitation_source_unknown {
    severity error;
    type counter64;
    units "packets";
    description "neighbor solicitations for unknown targets";
  };
  neighbor_advertisements_tx {
    severity info;
    type counter64;
    units "packets";
    description "neighbor advertisements sent";
  };
  neighbor_advertisements_rx {
    severity info;
    type counter64;
    units "packets";
    description "neighbor advertisements received";
  };
  router_solicitation_source_not_on_link {
    severity error;
    type counter64;
    units "packets";
    description "router solicitations from source not on link";
  };
  router_solicitation_unsupported_intf {
    severity error;
    type counter64;
    units "packets";
    description "neighbor discovery unsupported interface";
  };
  router_solicitation_radv_not_config {
    severity error;
    type counter64;
    units "packets";
    description "neighbor discovery not configured";
  };
  router_advertisement_source_not_link_local {
    severity error;
    type counter64;
    units "packets";
    description "router advertisement source not link local";
  };
  router_advertisements_tx {
    severity info;
    type counter64;
    units "packets";
    description "router advertisements sent";
  };
  router_advertisements_rx {
    severity info;
    type counter64;
    units "packets";
    description "router advertisements received";
  };
  dst_lookup_miss {
    severity error;
    type counter64;
    units "packets";
    description "icmp6 dst address lookup misses";
  };
  dest_unreach_sent {
    severity info;
    type counter64;
    units "packets";
    description "destination unreachable response sent";
  };
  packet_too_big_sent {
    severity info;
    type counter64;
    units "packets";
    description "packet too big response sent";
  };
  ttl_expire_sent {
    severity info;
    type counter64;
    units "packets";
    description "hop limit exceeded response sent";
  };
  param_problem_sent {
    severity info;
    type counter64;
    units "packets";
    description "parameter problem response sent";
  };
  drop {
    severity error;
    type counter64;
    units "packets";
    description "error message dropped";
  };
  alloc_failure {
    severity error;
    type counter64;
    units "packets";
    description "buffer allocation failure";
  };
};

paths {
  "/err/ip-frag" "ip_frag";
  "/err/mpls-frag" "ip_frag";
  "/err/ip4-mpls-label-disposition-pipe" "ip4";
  "/err/ip4-mpls-label-disposition-uniform" "ip4";
  "/err/ip4-local" "ip4";
  "/err/ip4-input" "ip4";
  "/err/ip4-full-reassembly" "ip4";
  "/err/ip4-local-full-reassembly" "ip4";
  "/err/ip4-full-reassembly-feature" "ip4";
  "/err/ip4-full-reassembly-custom" "ip4";
  "/err/ip4-full-reassembly-expire-walk" "ip4";
  "/err/ip4-sv-reassembly" "ip4";
  "/err/ip4-sv-reassembly-feature" "ip4";
  "/err/ip4-sv-reassembly-output-feature" "ip4";
  "/err/ip4-sv-reassembly-custom-next" "ip4";
  "/err/ip4-sv-reassembly-expire-walk" "ip4";
  "/err/ip6-mpls-label-disposition-pipe" "ip6";
  "/err/ip6-mpls-label-disposition-uniform" "ip6";
  "/err/ip6-local" "ip6";
  "/err/ip6-input" "ip6";
  "/err/ip6-full-reassembly" "ip6";
  "/err/ip6-local-full-reassembly" "ip6";
  "/err/ip6-full-reassembly-feature" "ip6";
  "/err/ip6-full-reassembly-custom" "ip6";
  "/err/ip6-full-reassembly-expire-walk" "ip6";
  "/err/ip6-sv-reassembly" "ip6";
  "/err/ip6-sv-reassembly-feature" "ip6";
  "/err/ip6-sv-reassembly-output-feature" "ip6";
  "/err/ip6-sv-reassembly-custom-next" "ip6";
  "/err/ip6-sv-reassembly-expire-walk" "ip6";
  "/err/ip4-icmp-input" "icmp4";
  "/err/ip4-icmp-error" "icmp4";
  "/err/ip6-icmp-input" "icmp6";
  "/err/ip6-icmp-error" "icmp6";
};

/*
 * Local Variables:
 * eval: (c-set-style "gnu")
 * End:
 */