FD.io VPP  v18.07-rc0-415-g6c78436
Vector Packet Processing
ip4_punt_drop.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015 Cisco and/or its affiliates.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <vnet/ip/ip.h>
17 #include <vnet/ip/ip_punt_drop.h>
18 #include <vnet/policer/policer.h>
20 
21 /* *INDENT-OFF* */
23 {
24  .arc_name = "ip4-punt",
25  .start_nodes = VNET_FEATURES ("ip4-punt"),
26 };
27 
29 {
30  .arc_name = "ip4-drop",
31  .start_nodes = VNET_FEATURES ("ip4-drop", "ip4-not-enabled"),
32 };
33 /* *INDENT-ON* */
34 
35 u8 *
36 format_ip_punt_policer_trace (u8 * s, va_list * args)
37 {
38  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
39  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
40  ip_punt_policer_trace_t *t = va_arg (*args, ip_punt_policer_trace_t *);
41 
42  s = format (s, "policer_index %d next %d", t->policer_index, t->next);
43  return s;
44 }
45 
46 ip_punt_policer_t ip4_punt_policer_cfg = {
47  .policer_index = ~0,
48 };
49 
51 #define _(sym,string) string,
53 #undef _
54 };
55 
56 static uword
58  vlib_node_runtime_t * node, vlib_frame_t * frame)
59 {
60  return (ip_punt_policer (vm, node, frame,
61  vnet_feat_arc_ip4_punt.feature_arc_index,
62  ip4_punt_policer_cfg.policer_index));
63 }
64 
65 /* *INDENT-OFF* */
67  .function = ip4_punt_policer,
68  .name = "ip4-punt-policer",
69  .vector_size = sizeof (u32),
70  .n_next_nodes = IP_PUNT_POLICER_N_NEXT,
71  .format_trace = format_ip_punt_policer_trace,
73  .error_strings = ip4_punt_policer_error_strings,
74 
75  .next_nodes = {
76  [IP_PUNT_POLICER_NEXT_DROP] = "ip4-drop",
77  },
78 };
79 
82 
84  .arc_name = "ip4-punt",
85  .node_name = "ip4-punt-policer",
86  .runs_before = VNET_FEATURES("ip4-punt-redirect"),
87 };
88 /* *INDENT-ON* */
89 
90 u8 *
91 format_ip_punt_redirect_trace (u8 * s, va_list * args)
92 {
93  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
94  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
96  vnet_main_t *vnm = vnet_get_main ();
98 
100 
101  if (NULL != si)
102  s = format (s, "via %U on %U using adj:%d",
105  t->redirect.adj_index);
106  else
107  s = format (s, "via %U on %d using adj:%d",
110 
111  return s;
112 }
113 
114 /* *INDENT-OFF* */
115 ip_punt_redirect_t ip4_punt_redirect_cfg = {
116  .any_rx_sw_if_index = {
117  .tx_sw_if_index = ~0,
118  .adj_index = ADJ_INDEX_INVALID,
119  },
120 };
121 /* *INDENT-ON* */
122 
123 
124 #define foreach_ip4_punt_redirect_error \
125 _(DROP, "ip4 punt redirect drop")
126 
127 typedef enum
128 {
129 #define _(sym,str) IP4_PUNT_REDIRECT_ERROR_##sym,
131 #undef _
134 
136 #define _(sym,string) string,
138 #undef _
139 };
140 
141 static uword
143  vlib_node_runtime_t * node, vlib_frame_t * frame)
144 {
145  return (ip_punt_redirect (vm, node, frame,
146  vnet_feat_arc_ip4_punt.feature_arc_index,
147  &ip4_punt_redirect_cfg));
148 }
149 
150 /* *INDENT-OFF* */
152  .function = ip4_punt_redirect,
153  .name = "ip4-punt-redirect",
154  .vector_size = sizeof (u32),
155  .n_next_nodes = IP_PUNT_REDIRECT_N_NEXT,
156  .format_trace = format_ip_punt_redirect_trace,
158  .error_strings = ip4_punt_redirect_error_strings,
159 
160  /* edit / add dispositions here */
161  .next_nodes = {
162  [IP_PUNT_REDIRECT_NEXT_DROP] = "ip4-drop",
163  [IP_PUNT_REDIRECT_NEXT_TX] = "ip4-rewrite",
164  [IP_PUNT_REDIRECT_NEXT_ARP] = "ip4-arp",
165  },
166 };
167 
170 
172  .arc_name = "ip4-punt",
173  .node_name = "ip4-punt-redirect",
174  .runs_before = VNET_FEATURES("error-punt"),
175 };
176 /* *INDENT-ON* */
177 
178 static uword
180 {
181  if (node->flags & VLIB_NODE_FLAG_TRACE)
182  ip4_forward_next_trace (vm, node, frame, VLIB_TX);
183 
184  return ip_drop_or_punt (vm, node, frame,
185  vnet_feat_arc_ip4_drop.feature_arc_index);
186 
187 }
188 
189 static uword
191  vlib_node_runtime_t * node, vlib_frame_t * frame)
192 {
193  if (node->flags & VLIB_NODE_FLAG_TRACE)
194  ip4_forward_next_trace (vm, node, frame, VLIB_TX);
195 
196  return ip_drop_or_punt (vm, node, frame,
197  vnet_feat_arc_ip4_drop.feature_arc_index);
198 }
199 
200 static uword
202 {
203  if (node->flags & VLIB_NODE_FLAG_TRACE)
204  ip4_forward_next_trace (vm, node, frame, VLIB_TX);
205 
206  return ip_drop_or_punt (vm, node, frame,
207  vnet_feat_arc_ip4_punt.feature_arc_index);
208 }
209 
210 /* *INDENT-OFF* */
212 {
213  .function = ip4_drop,
214  .name = "ip4-drop",
215  .vector_size = sizeof (u32),
216  .format_trace = format_ip4_forward_next_trace,
217  .n_next_nodes = 1,
218  .next_nodes = {
219  [0] = "error-drop",
220  },
221 };
222 
224 
226 {
227  .function = ip4_not_enabled,
228  .name = "ip4-not-enabled",
229  .vector_size = sizeof (u32),
230  .format_trace = format_ip4_forward_next_trace,
231  .n_next_nodes = 1,
232  .next_nodes = {
233  [0] = "error-drop",
234  },
235 };
236 
238 
240 {
241  .function = ip4_punt,
242  .name = "ip4-punt",
243  .vector_size = sizeof (u32),
244  .format_trace = format_ip4_forward_next_trace,
245  .n_next_nodes = 1,
246  .next_nodes = {
247  [0] = "error-punt",
248  },
249 };
250 
251 VNET_FEATURE_INIT (ip4_punt_end_of_arc, static) = {
252  .arc_name = "ip4-punt",
253  .node_name = "error-punt",
254  .runs_before = 0, /* not before any other features */
255 };
256 
257 VNET_FEATURE_INIT (ip4_drop_end_of_arc, static) = {
258  .arc_name = "ip4-drop",
259  .node_name = "error-drop",
260  .runs_before = 0, /* not before any other features */
261 };
262 /* *INDENT-ON */
263 
264 void
265 ip4_punt_policer_add_del (u8 is_add, u32 policer_index)
266 {
267  ip4_punt_policer_cfg.policer_index = policer_index;
268 
269  vnet_feature_enable_disable ("ip4-punt", "ip4-punt-policer",
270  0, is_add, 0, 0);
271 }
272 
273 static clib_error_t *
275  unformat_input_t * main_input,
276  vlib_cli_command_t * cmd)
277 {
278  unformat_input_t _line_input, *line_input = &_line_input;
279  clib_error_t *error = 0;
280  u32 policer_index;
281  u8 is_add = 1;
282 
283  policer_index = ~0;
284 
285  if (!unformat_user (main_input, unformat_line_input, line_input))
286  return 0;
287 
288  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
289  {
290  if (unformat (line_input, "%d", &policer_index))
291  ;
292  else if (unformat (line_input, "del"))
293  is_add = 0;
294  else if (unformat (line_input, "add"))
295  is_add = 1;
296  else
297  {
298  error = unformat_parse_error (line_input);
299  goto done;
300  }
301  }
302 
303  if (is_add && ~0 == policer_index)
304  {
305  error = clib_error_return (0, "expected policer index `%U'",
306  format_unformat_error, line_input);
307  goto done;
308  }
309  if (!is_add)
310  policer_index = ~0;
311 
312  ip4_punt_policer_add_del(is_add, policer_index);
313 
314 done:
315  unformat_free (line_input);
316  return (error);
317 }
318 
319 /*?
320  *
321  * @cliexpar
322  * @cliexcmd{set ip punt policer <INDEX>}
323  ?*/
324 /* *INDENT-OFF* */
325 VLIB_CLI_COMMAND (ip4_punt_policer_command, static) =
326 {
327  .path = "ip punt policer",
328  .function = ip4_punt_police_cmd,
329  .short_help = "ip punt policer [add|del] <index>",
330 };
331 /* *INDENT-ON* */
332 
333 /*
334  * an uninitalised rx-redirect strcut used to pad the vector
335  */
336 ip_punt_redirect_rx_t uninit_rx_redirect = {
337  .tx_sw_if_index = ~0,
338  .adj_index = ADJ_INDEX_INVALID,
339 };
340 
341 void
343  u32 rx_sw_if_index,
344  ip_punt_redirect_rx_t * redirect,
345  fib_protocol_t fproto, vnet_link_t linkt)
346 {
348 
349  if (~0 == rx_sw_if_index)
350  {
351  cfg->any_rx_sw_if_index = *redirect;
352  new = &cfg->any_rx_sw_if_index;
353  }
354  else
355  {
357  rx_sw_if_index, uninit_rx_redirect);
358  cfg->redirect_by_rx_sw_if_index[rx_sw_if_index] = *redirect;
359  new = &cfg->redirect_by_rx_sw_if_index[rx_sw_if_index];
360  }
361 
362  new->adj_index = adj_nbr_add_or_lock (fproto, linkt,
363  &redirect->nh,
364  redirect->tx_sw_if_index);
365 }
366 
367 void
369 {
371 
372  if (~0 == rx_sw_if_index)
373  {
374  old = &cfg->any_rx_sw_if_index;
375  }
376  else
377  {
378  old = &cfg->redirect_by_rx_sw_if_index[rx_sw_if_index];
379  }
380 
381  if ((old == NULL) || (old->adj_index == ADJ_INDEX_INVALID))
382  return;
383 
384  adj_unlock (old->adj_index);
385  *old = uninit_rx_redirect;
386 }
387 
388 void
389 ip4_punt_redirect_add (u32 rx_sw_if_index,
390  u32 tx_sw_if_index, ip46_address_t * nh)
391 {
392  ip_punt_redirect_rx_t rx = {
393  .tx_sw_if_index = tx_sw_if_index,
394  .nh = *nh,
395  };
396 
397  ip_punt_redirect_add (&ip4_punt_redirect_cfg,
398  rx_sw_if_index, &rx, FIB_PROTOCOL_IP4, VNET_LINK_IP4);
399 
400  vnet_feature_enable_disable ("ip4-punt", "ip4-punt-redirect", 0, 1, 0, 0);
401 }
402 
403 void
404 ip4_punt_redirect_del (u32 rx_sw_if_index)
405 {
406  vnet_feature_enable_disable ("ip4-punt", "ip4-punt-redirect", 0, 0, 0, 0);
407 
408  ip_punt_redirect_del (&ip4_punt_redirect_cfg, rx_sw_if_index);
409 }
410 
411 static clib_error_t *
413  unformat_input_t * main_input,
414  vlib_cli_command_t * cmd)
415 {
416  unformat_input_t _line_input, *line_input = &_line_input;
417  clib_error_t *error = 0;
418  u32 rx_sw_if_index = 0;
419  u32 tx_sw_if_index = 0;
420  ip46_address_t nh;
421  vnet_main_t *vnm;
422  u8 is_add;
423 
424  is_add = 1;
425  vnm = vnet_get_main ();
426 
427  if (!unformat_user (main_input, unformat_line_input, line_input))
428  return 0;
429 
430  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
431  {
432  if (unformat (line_input, "del"))
433  is_add = 0;
434  else if (unformat (line_input, "add"))
435  is_add = 1;
436  else if (unformat (line_input, "rx all"))
437  rx_sw_if_index = ~0;
438  else if (unformat (line_input, "rx %U",
439  unformat_vnet_sw_interface, vnm, &rx_sw_if_index))
440  ;
441  else if (unformat (line_input, "via %U %U",
443  &nh.ip4,
444  unformat_vnet_sw_interface, vnm, &tx_sw_if_index))
445  ;
446  else if (unformat (line_input, "via %U",
447  unformat_vnet_sw_interface, vnm, &tx_sw_if_index))
448  memset (&nh, 0, sizeof (nh));
449  else
450  {
451  error = unformat_parse_error (line_input);
452  goto done;
453  }
454  }
455 
456  if (is_add)
457  {
458  if (rx_sw_if_index && tx_sw_if_index)
459  {
460  ip4_punt_redirect_add (rx_sw_if_index, tx_sw_if_index, &nh);
461  }
462  }
463  else
464  {
465  if (rx_sw_if_index)
466  {
467  ip4_punt_redirect_del (rx_sw_if_index);
468  }
469  }
470 
471 done:
472  unformat_free (line_input);
473  return (error);
474 }
475 
476 /*?
477  *
478  * @cliexpar
479  * @cliexcmd{set ip punt policer}
480  ?*/
481 /* *INDENT-OFF* */
482 VLIB_CLI_COMMAND (ip4_punt_redirect_command, static) =
483 {
484  .path = "ip punt redirect",
485  .function = ip4_punt_redirect_cmd,
486  .short_help = "ip punt redirect [add|del] rx [<interface>|all] via [<nh>] <tx_interface>",
487 };
488 /* *INDENT-ON* */
489 
490 u8 *
491 format_ip_punt_redirect (u8 * s, va_list * args)
492 {
493  ip_punt_redirect_t *cfg = va_arg (*args, ip_punt_redirect_t *);
495  u32 rx_sw_if_index;
496  vnet_main_t *vnm = vnet_get_main ();
497 
498  vec_foreach_index (rx_sw_if_index, cfg->redirect_by_rx_sw_if_index)
499  {
500  rx = &cfg->redirect_by_rx_sw_if_index[rx_sw_if_index];
501  if (~0 != rx->tx_sw_if_index)
502  {
503  s = format (s, " rx %U redirect via %U %U\n",
505  vnet_get_sw_interface (vnm, rx_sw_if_index),
509  }
510  }
511  if (~0 != cfg->any_rx_sw_if_index.tx_sw_if_index)
512  {
513  s = format (s, " rx all redirect via %U %U\n",
517  cfg->
518  any_rx_sw_if_index.tx_sw_if_index));
519  }
520 
521  return (s);
522 }
523 
524 static clib_error_t *
526  unformat_input_t * main_input,
527  vlib_cli_command_t * cmd)
528 {
529  vlib_cli_output (vm, "%U", format_ip_punt_redirect, &ip4_punt_redirect_cfg);
530 
531  return (NULL);
532 }
533 
534 /*?
535  *
536  * @cliexpar
537  * @cliexcmd{set ip punt redierect}
538  ?*/
539 /* *INDENT-OFF* */
540 VLIB_CLI_COMMAND (show_ip4_punt_redirect_command, static) =
541 {
542  .path = "show ip punt redirect",
543  .function = ip4_punt_redirect_show_cmd,
544  .short_help = "show ip punt redirect",
545  .is_mp_safe = 1,
546 };
547 /* *INDENT-ON* */
548 
549 /*
550  * fd.io coding-style-patch-verification: ON
551  *
552  * Local Variables:
553  * eval: (c-set-style "gnu")
554  * End:
555  */
#define vec_foreach_index(var, v)
Iterate over vector indices.
#define CLIB_UNUSED(x)
Definition: clib.h:79
VLIB_NODE_FUNCTION_MULTIARCH(ip4_punt_policer_node, ip4_punt_policer)
static clib_error_t * ip4_punt_redirect_show_cmd(vlib_main_t *vm, unformat_input_t *main_input, vlib_cli_command_t *cmd)
vnet_main_t * vnet_get_main(void)
Definition: misc.c:47
ip4_punt_redirect_error_t
static uword ip4_not_enabled(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
static vlib_node_registration_t ip4_drop_node
(constructor) VLIB_REGISTER_NODE (ip4_drop_node)
#define NULL
Definition: clib.h:55
ip_punt_redirect_rx_t uninit_rx_redirect
ip_punt_redirect_rx_t * redirect_by_rx_sw_if_index
per-RX interface configuration
Definition: ip_punt_drop.h:225
static uword ip4_punt_policer(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
Definition: ip4_punt_drop.c:57
static uword ip_drop_or_punt(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, u8 arc_index)
Definition: ip_punt_drop.h:367
void ip_punt_redirect_del(ip_punt_redirect_t *cfg, u32 rx_sw_if_index)
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:983
format_function_t format_ip46_address
Definition: format.h:61
static vnet_sw_interface_t * vnet_get_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
unformat_function_t unformat_vnet_sw_interface
void ip4_punt_policer_add_del(u8 is_add, u32 policer_index)
unsigned char u8
Definition: types.h:56
#define foreach_ip4_punt_redirect_error
enum fib_protocol_t_ fib_protocol_t
Protocol Type.
u8 * format_ip_punt_redirect_trace(u8 *s, va_list *args)
Definition: ip4_punt_drop.c:91
unformat_function_t unformat_ip4_address
Definition: format.h:76
static vlib_node_registration_t ip4_punt_policer_node
(constructor) VLIB_REGISTER_NODE (ip4_punt_policer_node)
Definition: ip4_punt_drop.c:66
static vlib_node_registration_t ip4_not_enabled_node
(constructor) VLIB_REGISTER_NODE (ip4_not_enabled_node)
#define clib_error_return(e, args...)
Definition: error.h:99
void adj_unlock(adj_index_t adj_index)
Release a reference counting lock on the adjacency.
Definition: adj.c:240
ip46_address_t nh
The next-hop to send redirected packets to.
Definition: ip_punt_drop.h:199
unsigned int u32
Definition: types.h:88
#define foreach_ip_punt_policer_error
Definition: ip_punt_drop.h:44
static char * ip4_punt_redirect_error_strings[]
IP punt redirect configuration.
Definition: ip_punt_drop.h:215
static uword ip_punt_policer(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, u8 arc_index, u32 policer_index)
IP punt policing node function.
Definition: ip_punt_drop.h:61
unformat_function_t unformat_line_input
Definition: format.h:281
u8 * format_ip_punt_policer_trace(u8 *s, va_list *args)
Definition: ip4_punt_drop.c:36
format_function_t format_vnet_sw_interface_name
ip_punt_redirect_rx_t redirect
Definition: ip_punt_drop.h:244
#define ADJ_INDEX_INVALID
Invalid ADJ index - used when no adj is known likewise blazoned capitals INVALID speak volumes where ...
Definition: adj_types.h:36
static char * ip4_punt_policer_error_strings[]
Definition: ip4_punt_drop.c:50
struct _unformat_input_t unformat_input_t
static clib_error_t * ip4_punt_redirect_cmd(vlib_main_t *vm, unformat_input_t *main_input, vlib_cli_command_t *cmd)
static uword ip_punt_redirect(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, u8 arc_index, ip_punt_redirect_t *redirect)
Definition: ip_punt_drop.h:286
IP Punt redirect trace.
Definition: ip_punt_drop.h:242
static vlib_node_registration_t ip4_punt_node
(constructor) VLIB_REGISTER_NODE (ip4_punt_node)
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:153
#define UNFORMAT_END_OF_INPUT
Definition: format.h:143
ip_punt_redirect_rx_t any_rx_sw_if_index
any RX interface redirect
Definition: ip_punt_drop.h:220
vlib_main_t * vm
Definition: buffer.c:294
static uword ip4_punt_redirect(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
IP4 punt redirect per-rx interface configuration redirect punted traffic to another location...
Definition: ip_punt_drop.h:194
static vnet_sw_interface_t * vnet_get_sw_interface_safe(vnet_main_t *vnm, u32 sw_if_index)
static vlib_node_registration_t ip4_punt_redirect_node
(constructor) VLIB_REGISTER_NODE (ip4_punt_redirect_node)
u32 tx_sw_if_index
the TX interface to send redirected packets
Definition: ip_punt_drop.h:204
#define ARRAY_LEN(x)
Definition: clib.h:59
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:154
static uword ip4_punt(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
static uword ip4_drop(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
enum vnet_link_t_ vnet_link_t
Link Type: A description of the protocol of packets on the link.
IP4 punt policer configuration we police the punt rate to prevent overloading the host...
Definition: ip_punt_drop.h:27
static clib_error_t * ip4_punt_police_cmd(vlib_main_t *vm, unformat_input_t *main_input, vlib_cli_command_t *cmd)
void ip4_punt_redirect_del(u32 rx_sw_if_index)
#define VNET_FEATURES(...)
Definition: feature.h:391
#define unformat_parse_error(input)
Definition: format.h:267
Definition: defs.h:47
void ip4_punt_redirect_add(u32 rx_sw_if_index, u32 tx_sw_if_index, ip46_address_t *nh)
void ip_punt_redirect_add(ip_punt_redirect_t *cfg, u32 rx_sw_if_index, ip_punt_redirect_rx_t *redirect, fib_protocol_t fproto, vnet_link_t linkt)
Add a punt redirect entry.
void ip4_forward_next_trace(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, vlib_rx_or_tx_t which_adj_index)
Definition: ip4_forward.c:967
u64 uword
Definition: types.h:112
static void unformat_free(unformat_input_t *i)
Definition: format.h:161
u8 * format_ip4_forward_next_trace(u8 *s, va_list *args)
Definition: ip4_forward.c:919
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
adj_index_t adj_nbr_add_or_lock(fib_protocol_t nh_proto, vnet_link_t link_type, const ip46_address_t *nh_addr, u32 sw_if_index)
Neighbour Adjacency sub-type.
Definition: adj_nbr.c:214
u8 * format_ip_punt_redirect(u8 *s, va_list *args)
u16 flags
Copy of main node flags.
Definition: node.h:486
#define VLIB_NODE_FLAG_TRACE
Definition: node.h:295
#define vec_validate_init_empty(V, I, INIT)
Make sure vector is long enough for given index and initialize empty space (no header, unspecified alignment)
Definition: vec.h:486
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:681
VNET_FEATURE_INIT(ip4_punt_policer_node, static)
adj_index_t adj_index
redirect forwarding adjacency
Definition: ip_punt_drop.h:209
VNET_FEATURE_ARC_INIT(ip4_punt)
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
int vnet_feature_enable_disable(const char *arc_name, const char *node_name, u32 sw_if_index, int enable_disable, void *feature_config, u32 n_feature_config_bytes)
Definition: feature.c:233
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:169