thread: Add show threads api
[vpp.git] / src / plugins / nat / nat64_cli.c
1 /*
2  * Copyright (c) 2017 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  * @file
17  * @brief NAT64 CLI
18  */
19
20 #include <nat/nat64.h>
21 #include <nat/nat.h>
22 #include <nat/nat_inlines.h>
23 #include <vnet/fib/fib_table.h>
24
25 static clib_error_t *
26 nat64_add_del_pool_addr_command_fn (vlib_main_t * vm,
27                                     unformat_input_t * input,
28                                     vlib_cli_command_t * cmd)
29 {
30   unformat_input_t _line_input, *line_input = &_line_input;
31   ip4_address_t start_addr, end_addr, this_addr;
32   u32 start_host_order, end_host_order;
33   int i, count, rv;
34   u32 vrf_id = ~0;
35   u8 is_add = 1;
36   clib_error_t *error = 0;
37
38   /* Get a line of input. */
39   if (!unformat_user (input, unformat_line_input, line_input))
40     return 0;
41
42   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
43     {
44       if (unformat (line_input, "%U - %U",
45                     unformat_ip4_address, &start_addr,
46                     unformat_ip4_address, &end_addr))
47         ;
48       else if (unformat (line_input, "tenant-vrf %u", &vrf_id))
49         ;
50       else if (unformat (line_input, "%U", unformat_ip4_address, &start_addr))
51         end_addr = start_addr;
52       else if (unformat (line_input, "del"))
53         is_add = 0;
54       else
55         {
56           error = clib_error_return (0, "unknown input '%U'",
57                                      format_unformat_error, line_input);
58           goto done;
59         }
60     }
61
62   start_host_order = clib_host_to_net_u32 (start_addr.as_u32);
63   end_host_order = clib_host_to_net_u32 (end_addr.as_u32);
64
65   if (end_host_order < start_host_order)
66     {
67       error = clib_error_return (0, "end address less than start address");
68       goto done;
69     }
70
71   count = (end_host_order - start_host_order) + 1;
72   this_addr = start_addr;
73
74   for (i = 0; i < count; i++)
75     {
76       rv = nat64_add_del_pool_addr (&this_addr, vrf_id, is_add);
77
78       switch (rv)
79         {
80         case VNET_API_ERROR_NO_SUCH_ENTRY:
81           error =
82             clib_error_return (0, "NAT64 pool address %U not exist.",
83                                format_ip4_address, &this_addr);
84           goto done;
85         case VNET_API_ERROR_VALUE_EXIST:
86           error =
87             clib_error_return (0, "NAT64 pool address %U exist.",
88                                format_ip4_address, &this_addr);
89           goto done;
90         default:
91           break;
92
93         }
94       increment_v4_address (&this_addr);
95     }
96
97 done:
98   unformat_free (line_input);
99
100   return error;
101 }
102
103 static int
104 nat64_cli_pool_walk (snat_address_t * ap, void *ctx)
105 {
106   vlib_main_t *vm = ctx;
107
108   if (ap->fib_index != ~0)
109     {
110       fib_table_t *fib;
111       fib = fib_table_get (ap->fib_index, FIB_PROTOCOL_IP6);
112       if (!fib)
113         return -1;
114       vlib_cli_output (vm, " %U tenant VRF: %u", format_ip4_address,
115                        &ap->addr, fib->ft_table_id);
116     }
117   else
118     vlib_cli_output (vm, " %U", format_ip4_address, &ap->addr);
119
120 #define _(N, i, n, s) \
121   vlib_cli_output (vm, "  %d busy %s ports", ap->busy_##n##_ports, s);
122   foreach_snat_protocol
123 #undef _
124     return 0;
125 }
126
127 static clib_error_t *
128 nat64_show_pool_command_fn (vlib_main_t * vm,
129                             unformat_input_t * input,
130                             vlib_cli_command_t * cmd)
131 {
132   vlib_cli_output (vm, "NAT64 pool:");
133   nat64_pool_addr_walk (nat64_cli_pool_walk, vm);
134
135   return 0;
136 }
137
138 static clib_error_t *
139 nat64_interface_feature_command_fn (vlib_main_t * vm,
140                                     unformat_input_t *
141                                     input, vlib_cli_command_t * cmd)
142 {
143   unformat_input_t _line_input, *line_input = &_line_input;
144   vnet_main_t *vnm = vnet_get_main ();
145   clib_error_t *error = 0;
146   u32 sw_if_index;
147   u32 *inside_sw_if_indices = 0;
148   u32 *outside_sw_if_indices = 0;
149   u8 is_add = 1;
150   int i, rv;
151
152   /* Get a line of input. */
153   if (!unformat_user (input, unformat_line_input, line_input))
154     return 0;
155
156   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
157     {
158       if (unformat (line_input, "in %U", unformat_vnet_sw_interface,
159                     vnm, &sw_if_index))
160         vec_add1 (inside_sw_if_indices, sw_if_index);
161       else if (unformat (line_input, "out %U", unformat_vnet_sw_interface,
162                          vnm, &sw_if_index))
163         vec_add1 (outside_sw_if_indices, sw_if_index);
164       else if (unformat (line_input, "del"))
165         is_add = 0;
166       else
167         {
168           error = clib_error_return (0, "unknown input '%U'",
169                                      format_unformat_error, line_input);
170           goto done;
171         }
172     }
173
174   if (vec_len (inside_sw_if_indices))
175     {
176       for (i = 0; i < vec_len (inside_sw_if_indices); i++)
177         {
178           sw_if_index = inside_sw_if_indices[i];
179           rv = nat64_add_del_interface (sw_if_index, 1, is_add);
180           switch (rv)
181             {
182             case VNET_API_ERROR_NO_SUCH_ENTRY:
183               error =
184                 clib_error_return (0, "%U NAT64 feature not enabled.",
185                                    format_vnet_sw_if_index_name, vnm,
186                                    sw_if_index);
187               goto done;
188             case VNET_API_ERROR_VALUE_EXIST:
189               error =
190                 clib_error_return (0, "%U NAT64 feature already enabled.",
191                                    format_vnet_sw_if_index_name, vnm,
192                                    vnm, sw_if_index);
193               goto done;
194             case VNET_API_ERROR_INVALID_VALUE:
195             case VNET_API_ERROR_INVALID_VALUE_2:
196               error =
197                 clib_error_return (0,
198                                    "%U NAT64 feature enable/disable failed.",
199                                    format_vnet_sw_if_index_name, vnm,
200                                    sw_if_index);
201               goto done;
202             default:
203               break;
204
205             }
206         }
207     }
208
209   if (vec_len (outside_sw_if_indices))
210     {
211       for (i = 0; i < vec_len (outside_sw_if_indices); i++)
212         {
213           sw_if_index = outside_sw_if_indices[i];
214           rv = nat64_add_del_interface (sw_if_index, 0, is_add);
215           switch (rv)
216             {
217             case VNET_API_ERROR_NO_SUCH_ENTRY:
218               error =
219                 clib_error_return (0, "%U NAT64 feature not enabled.",
220                                    format_vnet_sw_if_index_name, vnm,
221                                    sw_if_index);
222               goto done;
223             case VNET_API_ERROR_VALUE_EXIST:
224               error =
225                 clib_error_return (0, "%U NAT64 feature already enabled.",
226                                    format_vnet_sw_if_index_name, vnm,
227                                    sw_if_index);
228               goto done;
229             case VNET_API_ERROR_INVALID_VALUE:
230             case VNET_API_ERROR_INVALID_VALUE_2:
231               error =
232                 clib_error_return (0,
233                                    "%U NAT64 feature enable/disable failed.",
234                                    format_vnet_sw_if_index_name, vnm,
235                                    sw_if_index);
236               goto done;
237             default:
238               break;
239
240             }
241         }
242     }
243
244 done:
245   unformat_free (line_input);
246   vec_free (inside_sw_if_indices);
247   vec_free (outside_sw_if_indices);
248
249   return error;
250 }
251
252 static int
253 nat64_cli_interface_walk (snat_interface_t * i, void *ctx)
254 {
255   vlib_main_t *vm = ctx;
256   vnet_main_t *vnm = vnet_get_main ();
257
258   vlib_cli_output (vm, " %U %s", format_vnet_sw_if_index_name, vnm,
259                    i->sw_if_index,
260                    (nat_interface_is_inside (i)
261                     && nat_interface_is_outside (i)) ? "in out" :
262                    nat_interface_is_inside (i) ? "in" : "out");
263   return 0;
264 }
265
266 static clib_error_t *
267 nat64_show_interfaces_command_fn (vlib_main_t * vm,
268                                   unformat_input_t *
269                                   input, vlib_cli_command_t * cmd)
270 {
271   vlib_cli_output (vm, "NAT64 interfaces:");
272   nat64_interfaces_walk (nat64_cli_interface_walk, vm);
273
274   return 0;
275 }
276
277 static clib_error_t *
278 nat64_add_del_static_bib_command_fn (vlib_main_t *
279                                      vm,
280                                      unformat_input_t
281                                      * input, vlib_cli_command_t * cmd)
282 {
283   unformat_input_t _line_input, *line_input = &_line_input;
284   clib_error_t *error = 0;
285   u8 is_add = 1;
286   ip6_address_t in_addr;
287   ip4_address_t out_addr;
288   u32 in_port = 0;
289   u32 out_port = 0;
290   u32 vrf_id = 0, protocol;
291   snat_protocol_t proto = 0;
292   u8 p = 0;
293   int rv;
294
295   if (!unformat_user (input, unformat_line_input, line_input))
296     return 0;
297
298   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
299     {
300       if (unformat (line_input, "%U %u", unformat_ip6_address,
301                     &in_addr, &in_port))
302         ;
303       else if (unformat (line_input, "%U %u", unformat_ip4_address,
304                          &out_addr, &out_port))
305         ;
306       else if (unformat (line_input, "vrf %u", &vrf_id))
307         ;
308       else if (unformat (line_input, "%U", unformat_snat_protocol, &proto))
309         ;
310       else
311         if (unformat
312             (line_input, "%U %U %u", unformat_ip6_address, &in_addr,
313              unformat_ip4_address, &out_addr, &protocol))
314         p = (u8) protocol;
315       else if (unformat (line_input, "del"))
316         is_add = 0;
317       else
318         {
319           error = clib_error_return (0, "unknown input: '%U'",
320                                      format_unformat_error, line_input);
321           goto done;
322         }
323     }
324
325   if (!p)
326     {
327       if (!in_port)
328         {
329           error =
330             clib_error_return (0, "inside port and address  must be set");
331           goto done;
332         }
333
334       if (!out_port)
335         {
336           error =
337             clib_error_return (0, "outside port and address  must be set");
338           goto done;
339         }
340
341       p = snat_proto_to_ip_proto (proto);
342     }
343
344   rv =
345     nat64_add_del_static_bib_entry (&in_addr, &out_addr, (u16) in_port,
346                                     (u16) out_port, p, vrf_id, is_add);
347
348   switch (rv)
349     {
350     case VNET_API_ERROR_NO_SUCH_ENTRY:
351       error = clib_error_return (0, "NAT64 BIB entry not exist.");
352       goto done;
353     case VNET_API_ERROR_VALUE_EXIST:
354       error = clib_error_return (0, "NAT64 BIB entry exist.");
355       goto done;
356     case VNET_API_ERROR_UNSPECIFIED:
357       error = clib_error_return (0, "Crerate NAT64 BIB entry failed.");
358       goto done;
359     case VNET_API_ERROR_INVALID_VALUE:
360       error =
361         clib_error_return (0, "Outside addres %U and port %u already in use.",
362                            format_ip4_address, &out_addr, out_port);
363       goto done;
364     case VNET_API_ERROR_INVALID_VALUE_2:
365       error = clib_error_return (0, "Invalid outside port.");
366     default:
367       break;
368     }
369
370 done:
371   unformat_free (line_input);
372
373   return error;
374 }
375
376 static int
377 nat64_cli_bib_walk (nat64_db_bib_entry_t * bibe, void *ctx)
378 {
379   vlib_main_t *vm = ctx;
380   fib_table_t *fib;
381
382   fib = fib_table_get (bibe->fib_index, FIB_PROTOCOL_IP6);
383   if (!fib)
384     return -1;
385
386   switch (bibe->proto)
387     {
388     case IP_PROTOCOL_ICMP:
389     case IP_PROTOCOL_TCP:
390     case IP_PROTOCOL_UDP:
391       vlib_cli_output (vm, " %U %u %U %u protocol %U vrf %u %s %u sessions",
392                        format_ip6_address, &bibe->in_addr,
393                        clib_net_to_host_u16 (bibe->in_port),
394                        format_ip4_address, &bibe->out_addr,
395                        clib_net_to_host_u16 (bibe->out_port),
396                        format_snat_protocol,
397                        ip_proto_to_snat_proto (bibe->proto), fib->ft_table_id,
398                        bibe->is_static ? "static" : "dynamic", bibe->ses_num);
399       break;
400     default:
401       vlib_cli_output (vm, " %U %U protocol %u vrf %u %s %u sessions",
402                        format_ip6_address, &bibe->in_addr,
403                        format_ip4_address, &bibe->out_addr,
404                        bibe->proto, fib->ft_table_id,
405                        bibe->is_static ? "static" : "dynamic", bibe->ses_num);
406     }
407   return 0;
408 }
409
410 static clib_error_t *
411 nat64_show_bib_command_fn (vlib_main_t * vm,
412                            unformat_input_t * input, vlib_cli_command_t * cmd)
413 {
414   nat64_main_t *nm = &nat64_main;
415   unformat_input_t _line_input, *line_input = &_line_input;
416   clib_error_t *error = 0;
417   u32 proto = ~0;
418   u8 p = 255;
419   nat64_db_t *db;
420
421   if (!unformat_user (input, unformat_line_input, line_input))
422     return 0;
423
424   if (unformat (line_input, "%U", unformat_snat_protocol, &proto))
425     p = snat_proto_to_ip_proto (proto);
426   else if (unformat (line_input, "unknown"))
427     p = 0;
428   else if (unformat (line_input, "all"))
429     ;
430   else
431     {
432       error = clib_error_return (0, "unknown input: '%U'",
433                                  format_unformat_error, line_input);
434       goto done;
435     }
436
437   if (p == 255)
438     vlib_cli_output (vm, "NAT64 BIB entries:");
439   else
440     vlib_cli_output (vm, "NAT64 %U BIB entries:", format_snat_protocol,
441                      proto);
442
443   /* *INDENT-OFF* */
444   vec_foreach (db, nm->db)
445     nat64_db_bib_walk (db, p, nat64_cli_bib_walk, vm);
446   /* *INDENT-ON* */
447
448 done:
449   unformat_free (line_input);
450
451   return error;
452 }
453
454 typedef struct nat64_cli_st_walk_ctx_t_
455 {
456   vlib_main_t *vm;
457   nat64_db_t *db;
458 } nat64_cli_st_walk_ctx_t;
459
460 static int
461 nat64_cli_st_walk (nat64_db_st_entry_t * ste, void *arg)
462 {
463   nat64_cli_st_walk_ctx_t *ctx = arg;
464   vlib_main_t *vm = ctx->vm;
465   nat64_db_bib_entry_t *bibe;
466   fib_table_t *fib;
467
468   bibe = nat64_db_bib_entry_by_index (ctx->db, ste->proto, ste->bibe_index);
469   if (!bibe)
470     return -1;
471
472   fib = fib_table_get (bibe->fib_index, FIB_PROTOCOL_IP6);
473   if (!fib)
474     return -1;
475
476   u32 vrf_id = fib->ft_table_id;
477
478   if (ste->proto == IP_PROTOCOL_ICMP)
479     vlib_cli_output (vm, " %U %U %u %U %U %u protocol %U vrf %u",
480                      format_ip6_address, &bibe->in_addr,
481                      format_ip6_address, &ste->in_r_addr,
482                      clib_net_to_host_u16 (bibe->in_port),
483                      format_ip4_address, &bibe->out_addr,
484                      format_ip4_address, &ste->out_r_addr,
485                      clib_net_to_host_u16 (bibe->out_port),
486                      format_snat_protocol,
487                      ip_proto_to_snat_proto (bibe->proto), vrf_id);
488   else if (ste->proto == IP_PROTOCOL_TCP || ste->proto == IP_PROTOCOL_UDP)
489     vlib_cli_output (vm, " %U %u %U %u %U %u %U %u protcol %U vrf %u",
490                      format_ip6_address, &bibe->in_addr,
491                      clib_net_to_host_u16 (bibe->in_port),
492                      format_ip6_address, &ste->in_r_addr,
493                      clib_net_to_host_u16 (ste->r_port),
494                      format_ip4_address, &bibe->out_addr,
495                      clib_net_to_host_u16 (bibe->out_port),
496                      format_ip4_address, &ste->out_r_addr,
497                      clib_net_to_host_u16 (ste->r_port),
498                      format_snat_protocol,
499                      ip_proto_to_snat_proto (bibe->proto), vrf_id);
500   else
501     vlib_cli_output (vm, " %U %U %U %U protocol %u vrf %u",
502                      format_ip6_address, &bibe->in_addr,
503                      format_ip6_address, &ste->in_r_addr,
504                      format_ip4_address, &bibe->out_addr,
505                      format_ip4_address, &ste->out_r_addr,
506                      bibe->proto, vrf_id);
507
508   return 0;
509 }
510
511 static clib_error_t *
512 nat64_show_st_command_fn (vlib_main_t * vm,
513                           unformat_input_t * input, vlib_cli_command_t * cmd)
514 {
515   nat64_main_t *nm = &nat64_main;
516   unformat_input_t _line_input, *line_input = &_line_input;
517   clib_error_t *error = 0;
518   u32 proto = ~0;
519   u8 p = 255;
520   nat64_db_t *db;
521   nat64_cli_st_walk_ctx_t ctx = {
522     .vm = vm,
523   };
524
525   if (!unformat_user (input, unformat_line_input, line_input))
526     return 0;
527
528   if (unformat (line_input, "%U", unformat_snat_protocol, &proto))
529     p = snat_proto_to_ip_proto (proto);
530   else if (unformat (line_input, "unknown"))
531     p = 0;
532   else if (unformat (line_input, "all"))
533     ;
534   else
535     {
536       error = clib_error_return (0, "unknown input: '%U'",
537                                  format_unformat_error, line_input);
538       goto done;
539     }
540
541   if (p == 255)
542     vlib_cli_output (vm, "NAT64 sessions:");
543   else
544     vlib_cli_output (vm, "NAT64 %U sessions:", format_snat_protocol, proto);
545   /* *INDENT-OFF* */
546   vec_foreach (db, nm->db)
547     {
548       ctx.db = db;
549       nat64_db_st_walk (db, p, nat64_cli_st_walk, &ctx);
550     }
551   /* *INDENT-ON* */
552
553 done:
554   unformat_free (line_input);
555
556   return error;
557 }
558
559 static clib_error_t *
560 nat64_add_del_prefix_command_fn (vlib_main_t * vm, unformat_input_t * input,
561                                  vlib_cli_command_t * cmd)
562 {
563   vnet_main_t *vnm = vnet_get_main ();
564   clib_error_t *error = 0;
565   unformat_input_t _line_input, *line_input = &_line_input;
566   u8 is_add = 1;
567   u32 vrf_id = 0, sw_if_index = ~0;
568   ip6_address_t prefix;
569   u32 plen = 0;
570   int rv;
571
572   if (!unformat_user (input, unformat_line_input, line_input))
573     return 0;
574
575   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
576     {
577       if (unformat
578           (line_input, "%U/%u", unformat_ip6_address, &prefix, &plen))
579         ;
580       else if (unformat (line_input, "tenant-vrf %u", &vrf_id))
581         ;
582       else if (unformat (line_input, "del"))
583         is_add = 0;
584       else
585         if (unformat
586             (line_input, "interface %U", unformat_vnet_sw_interface, vnm,
587              &sw_if_index))
588         ;
589       else
590         {
591           error = clib_error_return (0, "unknown input: '%U'",
592                                      format_unformat_error, line_input);
593           goto done;
594         }
595     }
596
597   if (!plen)
598     {
599       error = clib_error_return (0, "NAT64 prefix must be set.");
600       goto done;
601     }
602
603   rv = nat64_add_del_prefix (&prefix, (u8) plen, vrf_id, is_add);
604
605   switch (rv)
606     {
607     case VNET_API_ERROR_NO_SUCH_ENTRY:
608       error = clib_error_return (0, "NAT64 prefix not exist.");
609       goto done;
610     case VNET_API_ERROR_INVALID_VALUE:
611       error = clib_error_return (0, "Invalid prefix length.");
612       goto done;
613     default:
614       break;
615     }
616
617   /*
618    * Add RX interface route, whenNAT isn't running on the real input
619    * interface
620    */
621   if (sw_if_index != ~0)
622     {
623       u32 fib_index;
624       fib_prefix_t fibpfx = {
625         .fp_len = plen,
626         .fp_proto = FIB_PROTOCOL_IP6,
627         .fp_addr = {
628                     .ip6 = prefix}
629       };
630
631       if (is_add)
632         {
633           fib_index =
634             fib_table_find_or_create_and_lock (FIB_PROTOCOL_IP6,
635                                                vrf_id, FIB_SOURCE_PLUGIN_HI);
636           fib_table_entry_update_one_path (fib_index, &fibpfx,
637                                            FIB_SOURCE_PLUGIN_HI,
638                                            FIB_ENTRY_FLAG_NONE,
639                                            DPO_PROTO_IP6, NULL,
640                                            sw_if_index, ~0, 0,
641                                            NULL, FIB_ROUTE_PATH_INTF_RX);
642         }
643       else
644         {
645           fib_index = fib_table_find (FIB_PROTOCOL_IP6, vrf_id);
646           fib_table_entry_path_remove (fib_index, &fibpfx,
647                                        FIB_SOURCE_PLUGIN_HI,
648                                        DPO_PROTO_IP6, NULL,
649                                        sw_if_index, ~0, 1,
650                                        FIB_ROUTE_PATH_INTF_RX);
651           fib_table_unlock (fib_index, FIB_PROTOCOL_IP6,
652                             FIB_SOURCE_PLUGIN_HI);
653         }
654     }
655
656 done:
657   unformat_free (line_input);
658
659   return error;
660 }
661
662 static int
663 nat64_cli_prefix_walk (nat64_prefix_t * p, void *ctx)
664 {
665   vlib_main_t *vm = ctx;
666
667   vlib_cli_output (vm, " %U/%u tenant-vrf %u",
668                    format_ip6_address, &p->prefix, p->plen, p->vrf_id);
669
670   return 0;
671 }
672
673 static clib_error_t *
674 nat64_show_prefix_command_fn (vlib_main_t * vm,
675                               unformat_input_t * input,
676                               vlib_cli_command_t * cmd)
677 {
678   vlib_cli_output (vm, "NAT64 prefix:");
679   nat64_prefix_walk (nat64_cli_prefix_walk, vm);
680
681   return 0;
682 }
683
684 static clib_error_t *
685 nat64_add_interface_address_command_fn (vlib_main_t * vm,
686                                         unformat_input_t * input,
687                                         vlib_cli_command_t * cmd)
688 {
689   vnet_main_t *vnm = vnet_get_main ();
690   unformat_input_t _line_input, *line_input = &_line_input;
691   u32 sw_if_index;
692   int rv;
693   int is_add = 1;
694   clib_error_t *error = 0;
695
696   /* Get a line of input. */
697   if (!unformat_user (input, unformat_line_input, line_input))
698     return 0;
699
700   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
701     {
702       if (unformat
703           (line_input, "%U", unformat_vnet_sw_interface, vnm, &sw_if_index));
704       else if (unformat (line_input, "del"))
705         is_add = 0;
706       else
707         {
708           error = clib_error_return (0, "unknown input '%U'",
709                                      format_unformat_error, line_input);
710           goto done;
711         }
712     }
713
714   rv = nat64_add_interface_address (sw_if_index, is_add);
715
716   switch (rv)
717     {
718     case VNET_API_ERROR_NO_SUCH_ENTRY:
719       error = clib_error_return (0, "entry not exist");
720       break;
721     case VNET_API_ERROR_VALUE_EXIST:
722       error = clib_error_return (0, "entry exist");
723       break;
724     default:
725       break;
726     }
727
728 done:
729   unformat_free (line_input);
730
731   return error;
732 }
733
734 /* *INDENT-OFF* */
735
736 /*?
737  * @cliexpar
738  * @cliexstart{nat64 add pool address}
739  * Add/delete NAT64 pool address.
740  * To add single NAT64 pool address use:
741  *  vpp# nat64 add pool address 10.1.1.10
742  * To add NAT64 pool address range use:
743  *  vpp# nat64 add pool address 10.1.1.2 - 10.1.1.5
744  * To add NAT64 pool address for specific tenant use:
745  *  vpp# nat64 add pool address 10.1.1.100 tenant-vrf 100
746  * @cliexend
747 ?*/
748 VLIB_CLI_COMMAND (nat64_add_pool_address_command, static) = {
749   .path = "nat64 add pool address",
750   .short_help = "nat64 add pool address <ip4-range-start> [- <ip4-range-end>] "
751                 "[tenant-vrf <vrf-id>] [del]",
752   .function = nat64_add_del_pool_addr_command_fn,
753 };
754
755 /*?
756  * @cliexpar
757  * @cliexstart{show nat64 pool}
758  * Show NAT64 pool.
759  *  vpp# show nat64 pool
760  *  NAT64 pool:
761  *   10.1.1.3 tenant VRF: 0
762  *   10.1.1.10 tenant VRF: 10
763  * @cliexend
764 ?*/
765 VLIB_CLI_COMMAND (show_nat64_pool_command, static) = {
766   .path = "show nat64 pool",
767   .short_help = "show nat64 pool",
768   .function = nat64_show_pool_command_fn,
769 };
770
771 /*?
772  * @cliexpar
773  * @cliexstart{set interface nat64}
774  * Enable/disable NAT64 feature on the interface.
775  * To enable NAT64 feature with local (IPv6) network interface
776  * GigabitEthernet0/8/0 and external (IPv4) network interface
777  * GigabitEthernet0/a/0 use:
778  *  vpp# set interface nat64 in GigabitEthernet0/8/0 out GigabitEthernet0/a/0
779  * @cliexend
780 ?*/
781 VLIB_CLI_COMMAND (set_interface_nat64_command, static) = {
782   .path = "set interface nat64",
783   .short_help = "set interface nat64 in|out <intfc> [del]",
784   .function = nat64_interface_feature_command_fn,
785 };
786
787 /*?
788  * @cliexpar
789  * @cliexstart{show nat64 interfaces}
790  * Show interfaces with NAT64 feature.
791  * To show interfaces with NAT64 feature use:
792  *  vpp# show nat64 interfaces
793  *  NAT64 interfaces:
794  *   GigabitEthernet0/8/0 in
795  *   GigabitEthernet0/a/0 out
796  * @cliexend
797 ?*/
798 VLIB_CLI_COMMAND (show_nat64_interfaces_command, static) = {
799   .path = "show nat64 interfaces",
800   .short_help = "show nat64 interfaces",
801   .function = nat64_show_interfaces_command_fn,
802 };
803
804 /*?
805  * @cliexpar
806  * @cliexstart{nat64 add static bib}
807  * Add/delete NAT64 static BIB entry.
808  * To create NAT64 satatic BIB entry use:
809  *  vpp# nat64 add static bib 2001:db8:c000:221:: 1234 10.1.1.3 5678 tcp
810  *  vpp# nat64 add static bib 2001:db8:c000:221:: 1234 10.1.1.3 5678 udp vrf 10
811  * @cliexend
812 ?*/
813 VLIB_CLI_COMMAND (nat64_add_del_static_bib_command, static) = {
814   .path = "nat64 add static bib",
815   .short_help = "nat64 add static bib <ip6-addr> <port> <ip4-addr> <port> "
816                 "tcp|udp|icmp [vfr <table-id>] [del]",
817   .function = nat64_add_del_static_bib_command_fn,
818 };
819
820 /*?
821  * @cliexpar
822  * @cliexstart{show nat64 bib}
823  * Show NAT64 BIB entries.
824  * To show NAT64 TCP BIB entries use:
825  *  vpp# show nat64 bib tcp
826  *  NAT64 tcp BIB:
827  *   fd01:1::2 6303 10.0.0.3 62303 tcp vrf 0 dynamic 1 sessions
828  *   2001:db8:c000:221:: 1234 10.1.1.3 5678 tcp vrf 0 static 2 sessions
829  * To show NAT64 UDP BIB entries use:
830  *  vpp# show nat64 bib udp
831  *  NAT64 udp BIB:
832  *   fd01:1::2 6304 10.0.0.3 10546 udp vrf 0 dynamic 10 sessions
833  *   2001:db8:c000:221:: 1234 10.1.1.3 5678 udp vrf 10 static 0 sessions
834  * To show NAT64 ICMP BIB entries use:
835  *  vpp# show nat64 bib icmp
836  *  NAT64 icmp BIB:
837  *   fd01:1::2 6305 10.0.0.3 63209 icmp vrf 10 dynamic 1 sessions
838  * @cliexend
839 ?*/
840 VLIB_CLI_COMMAND (show_nat64_bib_command, static) = {
841   .path = "show nat64 bib",
842   .short_help = "show nat64 bib all|tcp|udp|icmp|unknown",
843   .function = nat64_show_bib_command_fn,
844 };
845
846 /*?
847  * @cliexpar
848  * @cliexstart{show nat64 session table}
849  * Show NAT64 session table.
850  * To show NAT64 TCP session table use:
851  *  vpp# show nat64 session table tcp
852  *  NAT64 tcp session table:
853  *   fd01:1::2 6303 64:ff9b::ac10:202 20 10.0.0.3 62303 172.16.2.2 20 tcp vrf 0
854  *   fd01:3::2 6303 64:ff9b::ac10:202 20 10.0.10.3 21300 172.16.2.2 20 tcp vrf 10
855  * To show NAT64 UDP session table use:
856  * #vpp show nat64 session table udp
857  * NAT64 udp session table:
858  *  fd01:1::2 6304 64:ff9b::ac10:202 20 10.0.0.3 10546 172.16.2.2 20 udp vrf 0
859  *  fd01:3::2 6304 64:ff9b::ac10:202 20 10.0.10.3 58627 172.16.2.2 20 udp vrf 10
860  *  fd01:1::2 1235 64:ff9b::a00:3 4023 10.0.0.3 24488 10.0.0.3 4023 udp vrf 0
861  *  fd01:1::3 23 64:ff9b::a00:3 24488 10.0.0.3 4023 10.0.0.3 24488 udp vrf 0
862  * To show NAT64 ICMP session table use:
863  * #vpp show nat64 session table icmp
864  * NAT64 icmp session table:
865  *  fd01:1::2 64:ff9b::ac10:202 6305 10.0.0.3 172.16.2.2 63209 icmp vrf 0
866  * @cliexend
867 ?*/
868 VLIB_CLI_COMMAND (show_nat64_st_command, static) = {
869   .path = "show nat64 session table",
870   .short_help = "show nat64 session table all|tcp|udp|icmp|unknown",
871   .function = nat64_show_st_command_fn,
872 };
873
874 /*?
875  * @cliexpar
876  * @cliexstart{nat64 add prefix}
877  * Set NAT64 prefix for generating IPv6 representations of IPv4 addresses.
878  * To set NAT64 global prefix use:
879  *  vpp# nat64 add prefix 2001:db8::/32
880  * To set NAT64 prefix for specific tenant use:
881  *  vpp# nat64 add prefix 2001:db8:122:300::/56 tenant-vrf 10
882  * @cliexend
883 ?*/
884 VLIB_CLI_COMMAND (nat64_add_del_prefix_command, static) = {
885   .path = "nat64 add prefix",
886   .short_help = "nat64 add prefix <ip6-prefix>/<plen> [tenant-vrf <vrf-id>] "
887                 "[del] [interface <interface]",
888   .function = nat64_add_del_prefix_command_fn,
889 };
890
891 /*?
892  * @cliexpar
893  * @cliexstart{show nat64 prefix}
894  * Show NAT64 prefix.
895  * To show NAT64 prefix use:
896  *  vpp# show nat64 prefix
897  *  NAT64 prefix:
898  *   2001:db8::/32 tenant-vrf 0
899  *   2001:db8:122:300::/56 tenant-vrf 10
900  * @cliexend
901 ?*/
902 VLIB_CLI_COMMAND (show_nat64_prefix_command, static) = {
903   .path = "show nat64 prefix",
904   .short_help = "show nat64 prefix",
905   .function = nat64_show_prefix_command_fn,
906 };
907
908 /*?
909  * @cliexpar
910  * @cliexstart{nat64 add interface address}
911  * Add/delete NAT64 pool address from specific (DHCP addressed) interface.
912  * To add NAT64 pool address from specific interface use:
913  *  vpp# nat64 add interface address GigabitEthernet0/8/0
914  * @cliexend
915 ?*/
916 VLIB_CLI_COMMAND (nat64_add_interface_address_command, static) = {
917     .path = "nat64 add interface address",
918     .short_help = "nat64 add interface address <interface> [del]",
919     .function = nat64_add_interface_address_command_fn,
920 };
921 /* *INDENT-ON* */
922
923 /*
924  * fd.io coding-style-patch-verification: ON
925  *
926  * Local Variables:
927  * eval: (c-set-style "gnu")
928  * End:
929  */