src/plugins/nat/nat_format.c

   1 /*
   2  * Copyright (c) 2018 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 NAT formatting
  18  */
  19
  20 #include <nat/nat.h>
  21 #include <nat/nat_inlines.h>
  22 #include <nat/nat_det.h>
  23
  24 uword
  25 unformat_snat_protocol (unformat_input_t * input, va_list * args)
  26 {
  27   u32 *r = va_arg (*args, u32 *);
  28
  29   if (0);
  30 #define _(N, i, n, s) else if (unformat (input, s)) *r = SNAT_PROTOCOL_##N;
  31   foreach_snat_protocol
  32 #undef _
  33     else
  34     return 0;
  35   return 1;
  36 }
  37
  38 u8 *
  39 format_snat_protocol (u8 * s, va_list * args)
  40 {
  41   u32 i = va_arg (*args, u32);
  42   u8 *t = 0;
  43
  44   switch (i)
  45     {
  46 #define _(N, j, n, str) case SNAT_PROTOCOL_##N: t = (u8 *) str; break;
  47       foreach_snat_protocol
  48 #undef _
  49     default:
  50       s = format (s, "unknown");
  51       return s;
  52     }
  53   s = format (s, "%s", t);
  54   return s;
  55 }
  56
  57 u8 *
  58 format_nat_addr_and_port_alloc_alg (u8 * s, va_list * args)
  59 {
  60   u32 i = va_arg (*args, u32);
  61   u8 *t = 0;
  62
  63   switch (i)
  64     {
  65 #define _(v, N, s) case NAT_ADDR_AND_PORT_ALLOC_ALG_##N: t = (u8 *) s; break;
  66       foreach_nat_addr_and_port_alloc_alg
  67 #undef _
  68     default:
  69       s = format (s, "unknown");
  70       return s;
  71     }
  72   s = format (s, "%s", t);
  73   return s;
  74 }
  75
  76 u8 *
  77 format_snat_key (u8 * s, va_list * args)
  78 {
  79   snat_session_key_t *key = va_arg (*args, snat_session_key_t *);
  80
  81   s = format (s, "%U proto %U port %d fib %d",
  82               format_ip4_address, &key->addr,
  83               format_snat_protocol, key->protocol,
  84               clib_net_to_host_u16 (key->port), key->fib_index);
  85   return s;
  86 }
  87
  88 u8 *
  89 format_static_mapping_key (u8 * s, va_list * args)
  90 {
  91   snat_session_key_t *key = va_arg (*args, snat_session_key_t *);
  92
  93   s = format (s, "%U proto %U port %d fib %d",
  94               format_ip4_address, &key->addr,
  95               format_snat_protocol, key->protocol, key->port, key->fib_index);
  96   return s;
  97 }
  98
  99 u8 *
 100 format_snat_session_state (u8 * s, va_list * args)
 101 {
 102   u32 i = va_arg (*args, u32);
 103   u8 *t = 0;
 104
 105   switch (i)
 106     {
 107 #define _(v, N, str) case SNAT_SESSION_##N: t = (u8 *) str; break;
 108       foreach_snat_session_state
 109 #undef _
 110     default:
 111       t = format (t, "unknown");
 112     }
 113   s = format (s, "%s", t);
 114   return s;
 115 }
 116
 117 u8 *
 118 format_snat_session (u8 * s, va_list * args)
 119 {
 120   snat_main_per_thread_data_t *tsm =
 121     va_arg (*args, snat_main_per_thread_data_t *);
 122   snat_session_t *sess = va_arg (*args, snat_session_t *);
 123
 124   if (snat_is_unk_proto_session (sess))
 125     {
 126       s = format (s, "  i2o %U proto %u fib %u\n",
 127                   format_ip4_address, &sess->in2out.addr,
 128                   sess->in2out.port, sess->in2out.fib_index);
 129       s = format (s, "    o2i %U proto %u fib %u\n",
 130                   format_ip4_address, &sess->out2in.addr,
 131                   sess->out2in.port, sess->out2in.fib_index);
 132     }
 133   else
 134     {
 135       s = format (s, "  i2o %U\n", format_snat_key, &sess->in2out);
 136       s = format (s, "    o2i %U\n", format_snat_key, &sess->out2in);
 137     }
 138   if (is_ed_session (sess) || is_fwd_bypass_session (sess))
 139     {
 140       if (is_twice_nat_session (sess))
 141         {
 142           s = format (s, "       external host o2i %U:%d i2o %U:%d\n",
 143                       format_ip4_address, &sess->ext_host_addr,
 144                       clib_net_to_host_u16 (sess->ext_host_port),
 145                       format_ip4_address, &sess->ext_host_nat_addr,
 146                       clib_net_to_host_u16 (sess->ext_host_nat_port));
 147         }
 148       else
 149         {
 150           if (sess->ext_host_addr.as_u32)
 151             s = format (s, "       external host %U:%u\n",
 152                         format_ip4_address, &sess->ext_host_addr,
 153                         clib_net_to_host_u16 (sess->ext_host_port));
 154         }
 155     }
 156   s = format (s, "       index %llu\n", sess - tsm->sessions);
 157   s = format (s, "       last heard %.2f\n", sess->last_heard);
 158   s = format (s, "       total pkts %d, total bytes %lld\n",
 159               sess->total_pkts, sess->total_bytes);
 160   if (snat_is_session_static (sess))
 161     s = format (s, "       static translation\n");
 162   else
 163     s = format (s, "       dynamic translation\n");
 164   if (is_fwd_bypass_session (sess))
 165     s = format (s, "       forwarding-bypass\n");
 166   if (is_lb_session (sess))
 167     s = format (s, "       load-balancing\n");
 168   if (is_twice_nat_session (sess))
 169     s = format (s, "       twice-nat\n");
 170
 171   return s;
 172 }
 173
 174 u8 *
 175 format_snat_user (u8 * s, va_list * args)
 176 {
 177   snat_main_per_thread_data_t *tsm =
 178     va_arg (*args, snat_main_per_thread_data_t *);
 179   snat_user_t *u = va_arg (*args, snat_user_t *);
 180   int verbose = va_arg (*args, int);
 181   dlist_elt_t *head, *elt;
 182   u32 elt_index, head_index;
 183   u32 session_index;
 184   snat_session_t *sess;
 185
 186   s = format (s, "%U: %d dynamic translations, %d static translations\n",
 187               format_ip4_address, &u->addr, u->nsessions, u->nstaticsessions);
 188
 189   if (verbose == 0)
 190     return s;
 191
 192   if (u->nsessions || u->nstaticsessions)
 193     {
 194       head_index = u->sessions_per_user_list_head_index;
 195       head = pool_elt_at_index (tsm->list_pool, head_index);
 196
 197       elt_index = head->next;
 198       elt = pool_elt_at_index (tsm->list_pool, elt_index);
 199       session_index = elt->value;
 200
 201       while (session_index != ~0)
 202         {
 203           sess = pool_elt_at_index (tsm->sessions, session_index);
 204
 205           s = format (s, "  %U\n", format_snat_session, tsm, sess);
 206
 207           elt_index = elt->next;
 208           elt = pool_elt_at_index (tsm->list_pool, elt_index);
 209           session_index = elt->value;
 210         }
 211     }
 212
 213   return s;
 214 }
 215
 216 u8 *
 217 format_snat_static_mapping (u8 * s, va_list * args)
 218 {
 219   snat_static_mapping_t *m = va_arg (*args, snat_static_mapping_t *);
 220   nat44_lb_addr_port_t *local;
 221
 222   if (is_identity_static_mapping (m))
 223     {
 224       if (is_addr_only_static_mapping (m))
 225         s = format (s, "identity mapping %U",
 226                     format_ip4_address, &m->local_addr);
 227       else
 228         s = format (s, "identity mapping %U %U:%d",
 229                     format_snat_protocol, m->proto,
 230                     format_ip4_address, &m->local_addr, m->local_port);
 231
 232       /* *INDENT-OFF* */
 233       pool_foreach (local, m->locals,
 234       ({
 235         s = format (s, " vrf %d", local->vrf_id);
 236       }));
 237       /* *INDENT-ON* */
 238
 239       return s;
 240     }
 241
 242   if (is_addr_only_static_mapping (m))
 243     s = format (s, "local %U external %U vrf %d %s %s",
 244                 format_ip4_address, &m->local_addr,
 245                 format_ip4_address, &m->external_addr,
 246                 m->vrf_id,
 247                 m->twice_nat == TWICE_NAT ? "twice-nat" :
 248                 m->twice_nat == TWICE_NAT_SELF ? "self-twice-nat" : "",
 249                 is_out2in_only_static_mapping (m) ? "out2in-only" : "");
 250   else
 251     {
 252       if (is_lb_static_mapping (m))
 253         {
 254           s = format (s, "%U external %U:%d %s %s",
 255                       format_snat_protocol, m->proto,
 256                       format_ip4_address, &m->external_addr, m->external_port,
 257                       m->twice_nat == TWICE_NAT ? "twice-nat" :
 258                       m->twice_nat == TWICE_NAT_SELF ? "self-twice-nat" : "",
 259                       is_out2in_only_static_mapping (m) ? "out2in-only" : "");
 260
 261           /* *INDENT-OFF* */
 262           pool_foreach (local, m->locals,
 263           ({
 264             s = format (s, "\n  local %U:%d vrf %d probability %d\%",
 265                         format_ip4_address, &local->addr, local->port,
 266                         local->vrf_id, local->probability);
 267           }));
 268           /* *INDENT-ON* */
 269
 270         }
 271       else
 272         s = format (s, "%U local %U:%d external %U:%d vrf %d %s %s",
 273                     format_snat_protocol, m->proto,
 274                     format_ip4_address, &m->local_addr, m->local_port,
 275                     format_ip4_address, &m->external_addr, m->external_port,
 276                     m->vrf_id,
 277                     m->twice_nat == TWICE_NAT ? "twice-nat" :
 278                     m->twice_nat == TWICE_NAT_SELF ? "self-twice-nat" : "",
 279                     is_out2in_only_static_mapping (m) ? "out2in-only" : "");
 280     }
 281   return s;
 282 }
 283
 284 u8 *
 285 format_snat_static_map_to_resolve (u8 * s, va_list * args)
 286 {
 287   snat_static_map_resolve_t *m = va_arg (*args, snat_static_map_resolve_t *);
 288   vnet_main_t *vnm = vnet_get_main ();
 289
 290   if (m->addr_only)
 291     s = format (s, "local %U external %U vrf %d",
 292                 format_ip4_address, &m->l_addr,
 293                 format_vnet_sw_if_index_name, vnm, m->sw_if_index, m->vrf_id);
 294   else
 295     s = format (s, "%U local %U:%d external %U:%d vrf %d",
 296                 format_snat_protocol, m->proto,
 297                 format_ip4_address, &m->l_addr, m->l_port,
 298                 format_vnet_sw_if_index_name, vnm, m->sw_if_index,
 299                 m->e_port, m->vrf_id);
 300
 301   return s;
 302 }
 303
 304 u8 *
 305 format_det_map_ses (u8 * s, va_list * args)
 306 {
 307   snat_det_map_t *det_map = va_arg (*args, snat_det_map_t *);
 308   ip4_address_t in_addr, out_addr;
 309   u32 in_offset, out_offset;
 310   snat_det_session_t *ses = va_arg (*args, snat_det_session_t *);
 311   u32 *i = va_arg (*args, u32 *);
 312
 313   u32 user_index = *i / SNAT_DET_SES_PER_USER;
 314   in_addr.as_u32 =
 315     clib_host_to_net_u32 (clib_net_to_host_u32 (det_map->in_addr.as_u32) +
 316                           user_index);
 317   in_offset =
 318     clib_net_to_host_u32 (in_addr.as_u32) -
 319     clib_net_to_host_u32 (det_map->in_addr.as_u32);
 320   out_offset = in_offset / det_map->sharing_ratio;
 321   out_addr.as_u32 =
 322     clib_host_to_net_u32 (clib_net_to_host_u32 (det_map->out_addr.as_u32) +
 323                           out_offset);
 324   s =
 325     format (s,
 326             "in %U:%d out %U:%d external host %U:%d state: %U expire: %d\n",
 327             format_ip4_address, &in_addr, clib_net_to_host_u16 (ses->in_port),
 328             format_ip4_address, &out_addr,
 329             clib_net_to_host_u16 (ses->out.out_port), format_ip4_address,
 330             &ses->out.ext_host_addr,
 331             clib_net_to_host_u16 (ses->out.ext_host_port),
 332             format_snat_session_state, ses->state, ses->expire);
 333
 334   return s;
 335 }
 336
 337 /*
 338  * fd.io coding-style-patch-verification: ON
 339  *
 340  * Local Variables:
 341  * eval: (c-set-style "gnu")
 342  * End:
 343  */