ipsec: show fast path flag in cli
[vpp.git] / src / vnet / ipsec / ipsec_format.c
1 /*
2  * decap.c : IPSec tunnel support
3  *
4  * Copyright (c) 2015 Cisco and/or its affiliates.
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at:
8  *
9  *     http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17
18 #include <vnet/vnet.h>
19 #include <vnet/api_errno.h>
20 #include <vnet/ip/ip.h>
21 #include <vnet/interface.h>
22 #include <vnet/fib/fib_table.h>
23
24 #include <vnet/ipsec/ipsec.h>
25 #include <vnet/ipsec/ipsec_tun.h>
26 #include <vnet/ipsec/ipsec_itf.h>
27
28 u8 *
29 format_ipsec_policy_action (u8 * s, va_list * args)
30 {
31   u32 i = va_arg (*args, u32);
32   char *t = 0;
33
34   switch (i)
35     {
36 #define _(v,f,str) case IPSEC_POLICY_ACTION_##f: t = str; break;
37       foreach_ipsec_policy_action
38 #undef _
39     default:
40       s = format (s, "unknown");
41     }
42   s = format (s, "%s", t);
43   return s;
44 }
45
46 u8 *
47 format_ipsec_policy_type (u8 * s, va_list * args)
48 {
49   u32 i = va_arg (*args, u32);
50   char *t = 0;
51
52   switch (i)
53     {
54 #define _(f,str) case IPSEC_SPD_POLICY_##f: t = str; break;
55       foreach_ipsec_spd_policy_type
56 #undef _
57     default:
58       s = format (s, "unknown");
59     }
60   s = format (s, "%s", t);
61   return s;
62 }
63
64 uword
65 unformat_ipsec_policy_action (unformat_input_t * input, va_list * args)
66 {
67   u32 *r = va_arg (*args, u32 *);
68
69   if (0);
70 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_POLICY_ACTION_##f;
71   foreach_ipsec_policy_action
72 #undef _
73     else
74     return 0;
75   return 1;
76 }
77
78 u8 *
79 format_ipsec_crypto_alg (u8 * s, va_list * args)
80 {
81   u32 i = va_arg (*args, u32);
82   u8 *t = 0;
83
84   switch (i)
85     {
86 #define _(v,f,str) case IPSEC_CRYPTO_ALG_##f: t = (u8 *) str; break;
87       foreach_ipsec_crypto_alg
88 #undef _
89     default:
90       s = format (s, "unknown");
91     }
92   s = format (s, "%s", t);
93   return s;
94 }
95
96 uword
97 unformat_ipsec_crypto_alg (unformat_input_t * input, va_list * args)
98 {
99   ipsec_crypto_alg_t *r = va_arg (*args, ipsec_crypto_alg_t *);
100
101   if (0);
102 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_CRYPTO_ALG_##f;
103   foreach_ipsec_crypto_alg
104 #undef _
105     else
106     return 0;
107   return 1;
108 }
109
110 u8 *
111 format_ipsec_integ_alg (u8 * s, va_list * args)
112 {
113   u32 i = va_arg (*args, u32);
114   u8 *t = 0;
115
116   switch (i)
117     {
118 #define _(v,f,str) case IPSEC_INTEG_ALG_##f: t = (u8 *) str; break;
119       foreach_ipsec_integ_alg
120 #undef _
121     default:
122       s = format (s, "unknown");
123     }
124   s = format (s, "%s", t);
125   return s;
126 }
127
128 uword
129 unformat_ipsec_integ_alg (unformat_input_t * input, va_list * args)
130 {
131   ipsec_integ_alg_t *r = va_arg (*args, ipsec_integ_alg_t *);
132
133   if (0);
134 #define _(v,f,s) else if (unformat (input, s)) *r = IPSEC_INTEG_ALG_##f;
135   foreach_ipsec_integ_alg
136 #undef _
137     else
138     return 0;
139   return 1;
140 }
141
142 u8 *
143 format_ipsec_replay_window (u8 * s, va_list * args)
144 {
145   u64 w = va_arg (*args, u64);
146   u8 i;
147
148   for (i = 0; i < 64; i++)
149     {
150       s = format (s, "%u", w & (1ULL << i) ? 1 : 0);
151     }
152
153   return s;
154 }
155
156 static u8 *
157 format_ipsec_policy_with_suffix (u8 *s, va_list *args, u8 *suffix)
158 {
159   u32 pi = va_arg (*args, u32);
160   ip46_type_t ip_type = IP46_TYPE_IP4;
161   ipsec_main_t *im = &ipsec_main;
162   ipsec_policy_t *p;
163   vlib_counter_t counts;
164
165   p = pool_elt_at_index (im->policies, pi);
166
167   s = format (s, "  [%d] priority %d action %U type %U protocol ",
168               pi, p->priority,
169               format_ipsec_policy_action, p->policy,
170               format_ipsec_policy_type, p->type);
171   if (p->protocol != IPSEC_POLICY_PROTOCOL_ANY)
172     {
173       s = format (s, "%U", format_ip_protocol, p->protocol);
174     }
175   else
176     {
177       s = format (s, "any");
178     }
179   if (p->policy == IPSEC_POLICY_ACTION_PROTECT)
180     {
181       s = format (s, " sa %u", p->sa_id);
182     }
183   if (suffix)
184     s = format (s, " %s", suffix);
185
186   if (p->is_ipv6)
187     {
188       ip_type = IP46_TYPE_IP6;
189     }
190
191   s = format (s, "\n     local addr range %U - %U port range %u - %u",
192               format_ip46_address, &p->laddr.start, ip_type,
193               format_ip46_address, &p->laddr.stop, ip_type,
194               p->lport.start, p->lport.stop);
195   s = format (s, "\n     remote addr range %U - %U port range %u - %u",
196               format_ip46_address, &p->raddr.start, ip_type,
197               format_ip46_address, &p->raddr.stop, ip_type,
198               p->rport.start, p->rport.stop);
199
200   vlib_get_combined_counter (&ipsec_spd_policy_counters, pi, &counts);
201   s = format (s, "\n     packets %u bytes %u", counts.packets, counts.bytes);
202
203   return (s);
204 }
205
206 u8 *
207 format_ipsec_policy (u8 *s, va_list *args)
208 {
209   return format_ipsec_policy_with_suffix (s, args, 0);
210 }
211
212 u8 *
213 format_ipsec_policy_fp (u8 *s, va_list *args)
214 {
215   return format_ipsec_policy_with_suffix (s, args, (u8 *) "<fast-path>");
216 }
217
218 u8 *
219 format_ipsec_spd (u8 * s, va_list * args)
220 {
221   u32 si = va_arg (*args, u32);
222   ipsec_main_t *im = &ipsec_main;
223   ipsec_spd_t *spd;
224   u32 *i;
225
226   if (pool_is_free_index (im->spds, si))
227     {
228       s = format (s, "No such SPD index: %d", si);
229       goto done;
230     }
231
232   spd = pool_elt_at_index (im->spds, si);
233
234   s = format (s, "spd %u", spd->id);
235
236 #define _(v, n)                                                               \
237   s = format (s, "\n %s:", n);                                                \
238   vec_foreach (i, spd->policies[IPSEC_SPD_POLICY_##v])                        \
239     {                                                                         \
240       s = format (s, "\n %U", format_ipsec_policy, *i);                       \
241     }                                                                         \
242   vec_foreach (i, spd->fp_spd.fp_policies[IPSEC_SPD_POLICY_##v])              \
243     {                                                                         \
244       s = format (s, "\n %U", format_ipsec_policy_fp, *i);                    \
245     }
246   foreach_ipsec_spd_policy_type;
247 #undef _
248
249 done:
250   return (s);
251 }
252
253 u8 *
254 format_ipsec_out_spd_flow_cache (u8 *s, va_list *args)
255 {
256   ipsec_main_t *im = &ipsec_main;
257
258   s = format (s, "\nipv4-outbound-spd-flow-cache-entries: %u",
259               im->ipsec4_out_spd_flow_cache_entries);
260
261   return (s);
262 }
263
264 u8 *
265 format_ipsec_in_spd_flow_cache (u8 *s, va_list *args)
266 {
267   ipsec_main_t *im = &ipsec_main;
268
269   s = format (s, "\nipv4-inbound-spd-flow-cache-entries: %u",
270               im->ipsec4_in_spd_flow_cache_entries);
271
272   return (s);
273 }
274
275 u8 *
276 format_ipsec_key (u8 * s, va_list * args)
277 {
278   ipsec_key_t *key = va_arg (*args, ipsec_key_t *);
279
280   return (format (s, "%U", format_hex_bytes, key->data, key->len));
281 }
282
283 uword
284 unformat_ipsec_key (unformat_input_t * input, va_list * args)
285 {
286   ipsec_key_t *key = va_arg (*args, ipsec_key_t *);
287   u8 *data;
288
289   if (unformat (input, "%U", unformat_hex_string, &data))
290     {
291       ipsec_mk_key (key, data, vec_len (data));
292       vec_free (data);
293     }
294   else
295     return 0;
296   return 1;
297 }
298
299 u8 *
300 format_ipsec_sa_flags (u8 * s, va_list * args)
301 {
302   ipsec_sa_flags_t flags = va_arg (*args, int);
303
304 #define _(v, f, str) if (flags & IPSEC_SA_FLAG_##f) s = format(s, "%s ", str);
305   foreach_ipsec_sa_flags
306 #undef _
307     return (s);
308 }
309
310 u8 *
311 format_ipsec_sa (u8 * s, va_list * args)
312 {
313   u32 sai = va_arg (*args, u32);
314   ipsec_format_flags_t flags = va_arg (*args, ipsec_format_flags_t);
315   vlib_counter_t counts;
316   counter_t lost;
317   ipsec_sa_t *sa;
318
319   if (pool_is_free_index (ipsec_sa_pool, sai))
320     {
321       s = format (s, "No such SA index: %d", sai);
322       goto done;
323     }
324
325   sa = ipsec_sa_get (sai);
326
327   s = format (s, "[%d] sa %u (0x%x) spi %u (0x%08x) protocol:%s flags:[%U]",
328               sai, sa->id, sa->id, sa->spi, sa->spi,
329               sa->protocol ? "esp" : "ah", format_ipsec_sa_flags, sa->flags);
330
331   if (!(flags & IPSEC_FORMAT_DETAIL))
332     goto done;
333
334   s = format (s, "\n   locks %d", sa->node.fn_locks);
335   s = format (s, "\n   salt 0x%x", clib_net_to_host_u32 (sa->salt));
336   s = format (s, "\n   thread-index:%d", sa->thread_index);
337   s = format (s, "\n   seq %u seq-hi %u", sa->seq, sa->seq_hi);
338   s = format (s, "\n   window %U", format_ipsec_replay_window,
339               sa->replay_window);
340   s = format (s, "\n   crypto alg %U",
341               format_ipsec_crypto_alg, sa->crypto_alg);
342   if (sa->crypto_alg && (flags & IPSEC_FORMAT_INSECURE))
343     s = format (s, " key %U", format_ipsec_key, &sa->crypto_key);
344   else
345     s = format (s, " key [redacted]");
346   s = format (s, "\n   integrity alg %U",
347               format_ipsec_integ_alg, sa->integ_alg);
348   if (sa->integ_alg && (flags & IPSEC_FORMAT_INSECURE))
349     s = format (s, " key %U", format_ipsec_key, &sa->integ_key);
350   else
351     s = format (s, " key [redacted]");
352   s = format (s, "\n   UDP:[src:%d dst:%d]",
353               clib_host_to_net_u16 (sa->udp_hdr.src_port),
354               clib_host_to_net_u16 (sa->udp_hdr.dst_port));
355
356   vlib_get_combined_counter (&ipsec_sa_counters, sai, &counts);
357   lost = vlib_get_simple_counter (&ipsec_sa_lost_counters, sai);
358   s = format (s, "\n   tx/rx:[packets:%Ld bytes:%Ld], lost:[packets:%Ld]",
359               counts.packets, counts.bytes, lost);
360
361   if (ipsec_sa_is_set_IS_TUNNEL (sa))
362     s = format (s, "\n%U", format_tunnel, &sa->tunnel, 3);
363
364 done:
365   return (s);
366 }
367
368 u8 *
369 format_ipsec_tun_protect_index (u8 * s, va_list * args)
370 {
371   u32 itpi = va_arg (*args, index_t);
372   ipsec_tun_protect_t *itp;
373
374   if (pool_is_free_index (ipsec_tun_protect_pool, itpi))
375     return (format (s, "No such tunnel index: %d", itpi));
376
377   itp = pool_elt_at_index (ipsec_tun_protect_pool, itpi);
378
379   return (format (s, "%U", format_ipsec_tun_protect, itp));
380 }
381
382 u8 *
383 format_ipsec_tun_protect_flags (u8 * s, va_list * args)
384 {
385   ipsec_protect_flags_t flags = va_arg (*args, int);
386
387   if (IPSEC_PROTECT_NONE == flags)
388     s = format (s, "none");
389 #define _(a,b,c)                                \
390   else if (flags & IPSEC_PROTECT_##a)           \
391     s = format (s, "%s", c);                    \
392   foreach_ipsec_protect_flags
393 #undef _
394
395   return (s);
396 }
397
398 u8 *
399 format_ipsec_tun_protect (u8 * s, va_list * args)
400 {
401   ipsec_tun_protect_t *itp = va_arg (*args, ipsec_tun_protect_t *);
402   u32 sai;
403
404   s = format (s, "%U flags:[%U]", format_vnet_sw_if_index_name,
405               vnet_get_main (), itp->itp_sw_if_index,
406               format_ipsec_tun_protect_flags, itp->itp_flags);
407   if (!ip_address_is_zero (itp->itp_key))
408     s = format (s, ": %U", format_ip_address, itp->itp_key);
409   s = format (s, "\n output-sa:");
410   s = format (s, "\n  %U", format_ipsec_sa, itp->itp_out_sa,
411               IPSEC_FORMAT_BRIEF);
412
413   s = format (s, "\n input-sa:");
414   /* *INDENT-OFF* */
415   FOR_EACH_IPSEC_PROTECT_INPUT_SAI(itp, sai,
416   ({
417   s = format (s, "\n  %U", format_ipsec_sa, sai, IPSEC_FORMAT_BRIEF);
418   }));
419   /* *INDENT-ON* */
420
421   return (s);
422 }
423
424 u8 *
425 format_ipsec4_tunnel_kv (u8 * s, va_list * args)
426 {
427   ipsec4_tunnel_kv_t *kv = va_arg (*args, ipsec4_tunnel_kv_t *);
428   ip4_address_t ip;
429   u32 spi;
430
431   ipsec4_tunnel_extract_key (kv, &ip, &spi);
432
433   s = format (s, "remote:%U spi:%u (0x%08x) sa:%d tun:%d",
434               format_ip4_address, &ip,
435               clib_net_to_host_u32 (spi),
436               clib_net_to_host_u32 (spi),
437               kv->value.sa_index, kv->value.tun_index);
438
439   return (s);
440 }
441
442 u8 *
443 format_ipsec6_tunnel_kv (u8 * s, va_list * args)
444 {
445   ipsec6_tunnel_kv_t *kv = va_arg (*args, ipsec6_tunnel_kv_t *);
446
447   s = format (s, "remote:%U spi:%u (0x%08x) sa:%d tun:%d",
448               format_ip6_address, &kv->key.remote_ip,
449               clib_net_to_host_u32 (kv->key.spi),
450               clib_net_to_host_u32 (kv->key.spi),
451               kv->value.sa_index, kv->value.tun_index);
452
453   return (s);
454 }
455
456 u8 *
457 format_ipsec_itf (u8 * s, va_list * a)
458 {
459   index_t ii = va_arg (*a, index_t);
460   ipsec_itf_t *itf;
461
462   itf = ipsec_itf_get (ii);
463   s = format (s, "[%d] %U %U",
464               ii, format_vnet_sw_if_index_name, vnet_get_main (),
465               itf->ii_sw_if_index, format_tunnel_mode, itf->ii_mode);
466
467   return (s);
468 }
469
470 /*
471  * fd.io coding-style-patch-verification: ON
472  *
473  * Local Variables:
474  * eval: (c-set-style "gnu")
475  * End:
476  */