src/vnet/session/session_lookup.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 /** Generate typed init functions for multiple hash table styles... */
  17 #include <vppinfra/bihash_16_8.h>
  18 #include <vppinfra/bihash_template.h>
  19
  20 #include <vppinfra/bihash_template.c>
  21
  22 #undef __included_bihash_template_h__
  23
  24 #include <vppinfra/bihash_48_8.h>
  25 #include <vppinfra/bihash_template.h>
  26
  27 #include <vppinfra/bihash_template.c>
  28 #include <vnet/session/session_lookup.h>
  29 #include <vnet/session/session.h>
  30 #include <vnet/session/application.h>
  31
  32 /**
  33  * External vector of per transport virtual functions table
  34  */
  35 extern transport_proto_vft_t *tp_vfts;
  36
  37 /**
  38  * Network namespace index (i.e., fib index) to session lookup table. We
  39  * should have one per network protocol type but for now we only support IP4/6
  40  */
  41 static u32 *fib_index_to_table_index[2];
  42
  43 /* *INDENT-OFF* */
  44 /* 16 octets */
  45 typedef CLIB_PACKED (struct {
  46   union
  47     {
  48       struct
  49         {
  50           ip4_address_t src;
  51           ip4_address_t dst;
  52           u16 src_port;
  53           u16 dst_port;
  54           /* align by making this 4 octets even though its a 1-bit field
  55            * NOTE: avoid key overlap with other transports that use 5 tuples for
  56            * session identification.
  57            */
  58           u32 proto;
  59         };
  60       u64 as_u64[2];
  61     };
  62 }) v4_connection_key_t;
  63
  64 typedef CLIB_PACKED (struct {
  65   union
  66     {
  67       struct
  68         {
  69           /* 48 octets */
  70           ip6_address_t src;
  71           ip6_address_t dst;
  72           u16 src_port;
  73           u16 dst_port;
  74           u32 proto;
  75           u64 unused;
  76         };
  77       u64 as_u64[6];
  78     };
  79 }) v6_connection_key_t;
  80 /* *INDENT-ON* */
  81
  82 typedef clib_bihash_kv_16_8_t session_kv4_t;
  83 typedef clib_bihash_kv_48_8_t session_kv6_t;
  84
  85 always_inline void
  86 make_v4_ss_kv (session_kv4_t * kv, ip4_address_t * lcl, ip4_address_t * rmt,
  87                u16 lcl_port, u16 rmt_port, u8 proto)
  88 {
  89   v4_connection_key_t *key = (v4_connection_key_t *) kv->key;
  90
  91   key->src.as_u32 = lcl->as_u32;
  92   key->dst.as_u32 = rmt->as_u32;
  93   key->src_port = lcl_port;
  94   key->dst_port = rmt_port;
  95   key->proto = proto;
  96
  97   kv->value = ~0ULL;
  98 }
  99
 100 always_inline void
 101 make_v4_listener_kv (session_kv4_t * kv, ip4_address_t * lcl, u16 lcl_port,
 102                      u8 proto)
 103 {
 104   v4_connection_key_t *key = (v4_connection_key_t *) kv->key;
 105
 106   key->src.as_u32 = lcl->as_u32;
 107   key->dst.as_u32 = 0;
 108   key->src_port = lcl_port;
 109   key->dst_port = 0;
 110   key->proto = proto;
 111
 112   kv->value = ~0ULL;
 113 }
 114
 115 always_inline void
 116 make_v4_ss_kv_from_tc (session_kv4_t * kv, transport_connection_t * t)
 117 {
 118   make_v4_ss_kv (kv, &t->lcl_ip.ip4, &t->rmt_ip.ip4, t->lcl_port, t->rmt_port,
 119                  session_type_from_proto_and_ip (t->proto, 1));
 120 }
 121
 122 always_inline void
 123 make_v6_ss_kv (session_kv6_t * kv, ip6_address_t * lcl, ip6_address_t * rmt,
 124                u16 lcl_port, u16 rmt_port, u8 proto)
 125 {
 126   v6_connection_key_t *key = (v6_connection_key_t *) kv->key;
 127
 128   key->src.as_u64[0] = lcl->as_u64[0];
 129   key->src.as_u64[1] = lcl->as_u64[1];
 130   key->dst.as_u64[0] = rmt->as_u64[0];
 131   key->dst.as_u64[1] = rmt->as_u64[1];
 132   key->src_port = lcl_port;
 133   key->dst_port = rmt_port;
 134   key->proto = proto;
 135   key->unused = 0;
 136
 137   kv->value = ~0ULL;
 138 }
 139
 140 always_inline void
 141 make_v6_listener_kv (session_kv6_t * kv, ip6_address_t * lcl, u16 lcl_port,
 142                      u8 proto)
 143 {
 144   v6_connection_key_t *key = (v6_connection_key_t *) kv->key;
 145
 146   key->src.as_u64[0] = lcl->as_u64[0];
 147   key->src.as_u64[1] = lcl->as_u64[1];
 148   key->dst.as_u64[0] = 0;
 149   key->dst.as_u64[1] = 0;
 150   key->src_port = lcl_port;
 151   key->dst_port = 0;
 152   key->proto = proto;
 153   key->unused = 0;
 154
 155   kv->value = ~0ULL;
 156 }
 157
 158 always_inline void
 159 make_v6_ss_kv_from_tc (session_kv6_t * kv, transport_connection_t * t)
 160 {
 161   make_v6_ss_kv (kv, &t->lcl_ip.ip6, &t->rmt_ip.ip6, t->lcl_port, t->rmt_port,
 162                  session_type_from_proto_and_ip (t->proto, 0));
 163 }
 164
 165
 166 static session_table_t *
 167 session_table_get_or_alloc_for_connection (transport_connection_t * tc)
 168 {
 169   session_table_t *st;
 170   u32 table_index, fib_proto = transport_connection_fib_proto (tc);
 171   if (vec_len (fib_index_to_table_index[fib_proto]) <= tc->fib_index)
 172     {
 173       st = session_table_alloc ();
 174       table_index = session_table_index (st);
 175       vec_validate (fib_index_to_table_index[fib_proto], tc->fib_index);
 176       fib_index_to_table_index[fib_proto][tc->fib_index] = table_index;
 177       return st;
 178     }
 179   else
 180     {
 181       table_index = fib_index_to_table_index[fib_proto][tc->fib_index];
 182       return session_table_get (table_index);
 183     }
 184 }
 185
 186 static session_table_t *
 187 session_table_get_for_connection (transport_connection_t * tc)
 188 {
 189   u32 fib_proto = transport_connection_fib_proto (tc);
 190   if (vec_len (fib_index_to_table_index[fib_proto]) <= tc->fib_index)
 191     return 0;
 192   return
 193     session_table_get (fib_index_to_table_index[fib_proto][tc->fib_index]);
 194 }
 195
 196 static session_table_t *
 197 session_table_get_for_fib_index (u32 fib_proto, u32 fib_index)
 198 {
 199   if (vec_len (fib_index_to_table_index[fib_proto]) <= fib_index)
 200     return 0;
 201   return session_table_get (fib_index_to_table_index[fib_proto][fib_index]);
 202 }
 203
 204 u32
 205 session_lookup_get_index_for_fib (u32 fib_proto, u32 fib_index)
 206 {
 207   if (vec_len (fib_index_to_table_index[fib_proto]) <= fib_index)
 208     return SESSION_TABLE_INVALID_INDEX;
 209   return fib_index_to_table_index[fib_proto][fib_index];
 210 }
 211
 212 /**
 213  * Add transport connection to a session table
 214  *
 215  * Session lookup 5-tuple (src-ip, dst-ip, src-port, dst-port, session-type)
 216  * is added to requested session table.
 217  *
 218  * @param tc            transport connection to be added
 219  * @param value         value to be stored
 220  *
 221  * @return non-zero if failure
 222  */
 223 int
 224 session_lookup_add_connection (transport_connection_t * tc, u64 value)
 225 {
 226   session_table_t *st;
 227   session_kv4_t kv4;
 228   session_kv6_t kv6;
 229
 230   st = session_table_get_or_alloc_for_connection (tc);
 231   if (!st)
 232     return -1;
 233   if (tc->is_ip4)
 234     {
 235       make_v4_ss_kv_from_tc (&kv4, tc);
 236       kv4.value = value;
 237       return clib_bihash_add_del_16_8 (&st->v4_session_hash, &kv4,
 238                                        1 /* is_add */ );
 239     }
 240   else
 241     {
 242       make_v6_ss_kv_from_tc (&kv6, tc);
 243       kv6.value = value;
 244       return clib_bihash_add_del_48_8 (&st->v6_session_hash, &kv6,
 245                                        1 /* is_add */ );
 246     }
 247 }
 248
 249 int
 250 session_lookup_add_session_endpoint (u32 table_index,
 251                                      session_endpoint_t * sep, u64 value)
 252 {
 253   session_table_t *st;
 254   session_kv4_t kv4;
 255   session_kv6_t kv6;
 256
 257   st = session_table_get (table_index);
 258   if (!st)
 259     return -1;
 260   if (sep->is_ip4)
 261     {
 262       make_v4_listener_kv (&kv4, &sep->ip.ip4, sep->port,
 263                            sep->transport_proto);
 264       kv4.value = value;
 265       return clib_bihash_add_del_16_8 (&st->v4_session_hash, &kv4, 1);
 266     }
 267   else
 268     {
 269       make_v6_listener_kv (&kv6, &sep->ip.ip6, sep->port,
 270                            sep->transport_proto);
 271       kv6.value = value;
 272       return clib_bihash_add_del_48_8 (&st->v6_session_hash, &kv6, 1);
 273     }
 274 }
 275
 276 int
 277 session_lookup_del_session_endpoint (u32 table_index,
 278                                      session_endpoint_t * sep)
 279 {
 280   session_table_t *st;
 281   session_kv4_t kv4;
 282   session_kv6_t kv6;
 283
 284   st = session_table_get (table_index);
 285   if (!st)
 286     return -1;
 287   if (sep->is_ip4)
 288     {
 289       make_v4_listener_kv (&kv4, &sep->ip.ip4, sep->port,
 290                            sep->transport_proto);
 291       return clib_bihash_add_del_16_8 (&st->v4_session_hash, &kv4, 0);
 292     }
 293   else
 294     {
 295       make_v6_listener_kv (&kv6, &sep->ip.ip6, sep->port,
 296                            sep->transport_proto);
 297       return clib_bihash_add_del_48_8 (&st->v6_session_hash, &kv6, 0);
 298     }
 299 }
 300
 301 /**
 302  * Delete transport connection from session table
 303  *
 304  * @param table_index   session table index
 305  * @param tc            transport connection to be removed
 306  *
 307  * @return non-zero if failure
 308  */
 309 int
 310 session_lookup_del_connection (transport_connection_t * tc)
 311 {
 312   session_table_t *st;
 313   session_kv4_t kv4;
 314   session_kv6_t kv6;
 315
 316   st = session_table_get_for_connection (tc);
 317   if (!st)
 318     return -1;
 319   if (tc->is_ip4)
 320     {
 321       make_v4_ss_kv_from_tc (&kv4, tc);
 322       return clib_bihash_add_del_16_8 (&st->v4_session_hash, &kv4,
 323                                        0 /* is_add */ );
 324     }
 325   else
 326     {
 327       make_v6_ss_kv_from_tc (&kv6, tc);
 328       return clib_bihash_add_del_48_8 (&st->v6_session_hash, &kv6,
 329                                        0 /* is_add */ );
 330     }
 331 }
 332
 333 int
 334 session_lookup_del_session (stream_session_t * s)
 335 {
 336   transport_connection_t *ts;
 337   ts = tp_vfts[s->session_type].get_connection (s->connection_index,
 338                                                 s->thread_index);
 339   return session_lookup_del_connection (ts);
 340 }
 341
 342 static stream_session_t *
 343 session_lookup_app_listen_session (u32 app_index)
 344 {
 345   application_t *app;
 346   app = application_get (app_index);
 347   if (!app)
 348     return 0;
 349
 350   if (application_n_listeners (app) != 1)
 351     {
 352       clib_warning ("there should be one and only one listener %d",
 353                     hash_elts (app->listeners_table));
 354       return 0;
 355     }
 356
 357   return application_first_listener (app);
 358 }
 359
 360 stream_session_t *
 361 session_lookup_rules_table4 (session_rules_table_t * srt, u8 proto,
 362                              ip4_address_t * lcl, u16 lcl_port,
 363                              ip4_address_t * rmt, u16 rmt_port)
 364 {
 365   u32 action_index;
 366   action_index = session_rules_table_lookup4 (srt, proto, lcl, rmt, lcl_port,
 367                                               rmt_port);
 368   /* Nothing sophisticated for now, action index is app index */
 369   return session_lookup_app_listen_session (action_index);
 370 }
 371
 372 stream_session_t *
 373 session_lookup_rules_table6 (session_rules_table_t * srt, u8 proto,
 374                              ip6_address_t * lcl, u16 lcl_port,
 375                              ip6_address_t * rmt, u16 rmt_port)
 376 {
 377   u32 action_index;
 378   action_index = session_rules_table_lookup6 (srt, proto, lcl, rmt, lcl_port,
 379                                               rmt_port);
 380   return session_lookup_app_listen_session (action_index);
 381 }
 382
 383 u64
 384 session_lookup_session_endpoint (u32 table_index, session_endpoint_t * sep)
 385 {
 386   session_table_t *st;
 387   session_kv4_t kv4;
 388   session_kv6_t kv6;
 389   ip4_address_t lcl4;
 390   ip6_address_t lcl6;
 391   u32 si;
 392   int rv;
 393
 394   st = session_table_get (table_index);
 395   if (!st)
 396     return SESSION_INVALID_HANDLE;
 397   if (sep->is_ip4)
 398     {
 399       make_v4_listener_kv (&kv4, &sep->ip.ip4, sep->port,
 400                            sep->transport_proto);
 401       rv = clib_bihash_search_inline_16_8 (&st->v4_session_hash, &kv4);
 402       if (rv == 0)
 403         return kv4.value;
 404
 405       memset (&lcl4, 0, sizeof (lcl4));
 406       si =
 407         session_rules_table_lookup4 (&st->session_rules, sep->transport_proto,
 408                                      &lcl4, &sep->ip.ip4, 0, sep->port);
 409       if (si != SESSION_RULES_TABLE_INVALID_INDEX)
 410         return si;
 411     }
 412   else
 413     {
 414       make_v6_listener_kv (&kv6, &sep->ip.ip6, sep->port,
 415                            sep->transport_proto);
 416       rv = clib_bihash_search_inline_48_8 (&st->v6_session_hash, &kv6);
 417       if (rv == 0)
 418         return kv6.value;
 419
 420       memset (&lcl6, 0, sizeof (lcl6));
 421       si =
 422         session_rules_table_lookup6 (&st->session_rules, sep->transport_proto,
 423                                      &lcl6, &sep->ip.ip6, 0, sep->port);
 424       if (si != SESSION_RULES_TABLE_INVALID_INDEX)
 425         return si;
 426     }
 427   return SESSION_INVALID_HANDLE;
 428 }
 429
 430 stream_session_t *
 431 session_lookup_global_session_endpoint (session_endpoint_t * sep)
 432 {
 433   session_table_t *st;
 434   session_kv4_t kv4;
 435   session_kv6_t kv6;
 436   ip4_address_t lcl4;
 437   ip6_address_t lcl6;
 438   u8 fib_proto;
 439   u32 table_index;
 440   int rv;
 441
 442   fib_proto = session_endpoint_fib_proto (sep);
 443   table_index = session_lookup_get_index_for_fib (fib_proto, sep->fib_index);
 444   st = session_table_get (table_index);
 445   if (!st)
 446     return 0;
 447   if (sep->is_ip4)
 448     {
 449       make_v4_listener_kv (&kv4, &sep->ip.ip4, sep->port,
 450                            sep->transport_proto);
 451       rv = clib_bihash_search_inline_16_8 (&st->v4_session_hash, &kv4);
 452       if (rv == 0)
 453         return session_get_from_handle (kv4.value);
 454       memset (&lcl4, 0, sizeof (lcl4));
 455       return session_lookup_rules_table4 (&st->session_rules,
 456                                           sep->transport_proto, &lcl4, 0,
 457                                           &sep->ip.ip4, sep->port);
 458     }
 459   else
 460     {
 461       make_v6_listener_kv (&kv6, &sep->ip.ip6, sep->port,
 462                            sep->transport_proto);
 463       rv = clib_bihash_search_inline_48_8 (&st->v6_session_hash, &kv6);
 464       if (rv == 0)
 465         return session_get_from_handle (kv6.value);
 466       memset (&lcl6, 0, sizeof (lcl6));
 467       return session_lookup_rules_table6 (&st->session_rules,
 468                                           sep->transport_proto, &lcl6, 0,
 469                                           &sep->ip.ip6, sep->port);
 470     }
 471 }
 472
 473 u32
 474 session_lookup_local_session_endpoint (u32 table_index,
 475                                        session_endpoint_t * sep)
 476 {
 477   session_table_t *st;
 478   session_kv4_t kv4;
 479   session_kv6_t kv6;
 480   ip4_address_t lcl4;
 481   ip6_address_t lcl6;
 482   u32 si;
 483   int rv;
 484
 485   st = session_table_get (table_index);
 486   if (!st)
 487     return SESSION_INVALID_INDEX;
 488   if (sep->is_ip4)
 489     {
 490       make_v4_listener_kv (&kv4, &sep->ip.ip4, sep->port,
 491                            sep->transport_proto);
 492       rv = clib_bihash_search_inline_16_8 (&st->v4_session_hash, &kv4);
 493       if (rv == 0)
 494         return (u32) kv4.value;
 495
 496       /*
 497        * Zero out the ip. Logic is that connect to local ips, say
 498        * 127.0.0.1:port, can match 0.0.0.0:port
 499        */
 500       kv4.key[0] = 0;
 501       rv = clib_bihash_search_inline_16_8 (&st->v4_session_hash, &kv4);
 502       if (rv == 0)
 503         return (u32) kv4.value;
 504
 505       memset (&lcl4, 0, sizeof (lcl4));
 506       si =
 507         session_rules_table_lookup4 (&st->session_rules, sep->transport_proto,
 508                                      &lcl4, &sep->ip.ip4, 0, sep->port);
 509       if (si != SESSION_RULES_TABLE_INVALID_INDEX)
 510         return si;
 511     }
 512   else
 513     {
 514       make_v6_listener_kv (&kv6, &sep->ip.ip6, sep->port,
 515                            sep->transport_proto);
 516       rv = clib_bihash_search_inline_48_8 (&st->v6_session_hash, &kv6);
 517       if (rv == 0)
 518         return (u32) kv6.value;
 519
 520       /*
 521        * Zero out the ip. Same logic as above.
 522        */
 523       kv6.key[0] = kv6.key[1] = 0;
 524       rv = clib_bihash_search_inline_48_8 (&st->v6_session_hash, &kv6);
 525       if (rv == 0)
 526         return (u32) kv6.value;
 527
 528       memset (&lcl6, 0, sizeof (lcl6));
 529       si =
 530         session_rules_table_lookup6 (&st->session_rules, sep->transport_proto,
 531                                      &lcl6, &sep->ip.ip6, 0, sep->port);
 532       if (si != SESSION_RULES_TABLE_INVALID_INDEX)
 533         return si;
 534     }
 535   return SESSION_INVALID_INDEX;
 536 }
 537
 538 static stream_session_t *
 539 session_lookup_listener4_i (session_table_t * st, ip4_address_t * lcl,
 540                             u16 lcl_port, u8 proto)
 541 {
 542   session_kv4_t kv4;
 543   int rv;
 544
 545   make_v4_listener_kv (&kv4, lcl, lcl_port, proto);
 546   rv = clib_bihash_search_inline_16_8 (&st->v4_session_hash, &kv4);
 547   if (rv == 0)
 548     return session_manager_get_listener (proto, (u32) kv4.value);
 549
 550   /* Zero out the lcl ip */
 551   kv4.key[0] = 0;
 552   rv = clib_bihash_search_inline_16_8 (&st->v4_session_hash, &kv4);
 553   if (rv == 0)
 554     return session_manager_get_listener (proto, (u32) kv4.value);
 555
 556   return 0;
 557 }
 558
 559 stream_session_t *
 560 session_lookup_listener4 (u32 fib_index, ip4_address_t * lcl, u16 lcl_port,
 561                           u8 proto)
 562 {
 563   session_table_t *st;
 564   st = session_table_get_for_fib_index (FIB_PROTOCOL_IP4, fib_index);
 565   if (!st)
 566     return 0;
 567   return session_lookup_listener4_i (st, lcl, lcl_port, proto);
 568 }
 569
 570 static stream_session_t *
 571 session_lookup_listener6_i (session_table_t * st, ip6_address_t * lcl,
 572                             u16 lcl_port, u8 proto)
 573 {
 574   session_kv6_t kv6;
 575   int rv;
 576
 577   make_v6_listener_kv (&kv6, lcl, lcl_port, proto);
 578   rv = clib_bihash_search_inline_48_8 (&st->v6_session_hash, &kv6);
 579   if (rv == 0)
 580     return session_manager_get_listener (proto, (u32) kv6.value);
 581
 582   /* Zero out the lcl ip */
 583   kv6.key[0] = kv6.key[1] = 0;
 584   rv = clib_bihash_search_inline_48_8 (&st->v6_session_hash, &kv6);
 585   if (rv == 0)
 586     return session_manager_get_listener (proto, (u32) kv6.value);
 587
 588   return 0;
 589 }
 590
 591 stream_session_t *
 592 session_lookup_listener6 (u32 fib_index, ip6_address_t * lcl, u16 lcl_port,
 593                           u8 proto)
 594 {
 595   session_table_t *st;
 596   st = session_table_get_for_fib_index (FIB_PROTOCOL_IP6, fib_index);
 597   if (!st)
 598     return 0;
 599   return session_lookup_listener6_i (st, lcl, lcl_port, proto);
 600 }
 601
 602 stream_session_t *
 603 session_lookup_listener (u32 table_index, session_endpoint_t * sep)
 604 {
 605   session_table_t *st;
 606   st = session_table_get (table_index);
 607   if (!st)
 608     return 0;
 609   if (sep->is_ip4)
 610     return session_lookup_listener4_i (st, &sep->ip.ip4, sep->port,
 611                                        sep->transport_proto);
 612   else
 613     return session_lookup_listener6_i (st, &sep->ip.ip6, sep->port,
 614                                        sep->transport_proto);
 615   return 0;
 616 }
 617
 618 int
 619 session_lookup_add_half_open (transport_connection_t * tc, u64 value)
 620 {
 621   session_table_t *st;
 622   session_kv4_t kv4;
 623   session_kv6_t kv6;
 624
 625   st = session_table_get_or_alloc_for_connection (tc);
 626   if (!st)
 627     return 0;
 628   if (tc->is_ip4)
 629     {
 630       make_v4_ss_kv_from_tc (&kv4, tc);
 631       kv4.value = value;
 632       return clib_bihash_add_del_16_8 (&st->v4_half_open_hash, &kv4,
 633                                        1 /* is_add */ );
 634     }
 635   else
 636     {
 637       make_v6_ss_kv_from_tc (&kv6, tc);
 638       kv6.value = value;
 639       return clib_bihash_add_del_48_8 (&st->v6_half_open_hash, &kv6,
 640                                        1 /* is_add */ );
 641     }
 642 }
 643
 644 int
 645 session_lookup_del_half_open (transport_connection_t * tc)
 646 {
 647   session_table_t *st;
 648   session_kv4_t kv4;
 649   session_kv6_t kv6;
 650
 651   st = session_table_get_for_connection (tc);
 652   if (!st)
 653     return -1;
 654   if (tc->is_ip4)
 655     {
 656       make_v4_ss_kv_from_tc (&kv4, tc);
 657       return clib_bihash_add_del_16_8 (&st->v4_half_open_hash, &kv4,
 658                                        0 /* is_add */ );
 659     }
 660   else
 661     {
 662       make_v6_ss_kv_from_tc (&kv6, tc);
 663       return clib_bihash_add_del_48_8 (&st->v6_half_open_hash, &kv6,
 664                                        0 /* is_add */ );
 665     }
 666 }
 667
 668 u64
 669 session_lookup_half_open_handle (transport_connection_t * tc)
 670 {
 671   session_table_t *st;
 672   session_kv4_t kv4;
 673   session_kv6_t kv6;
 674   int rv;
 675
 676   st = session_table_get_for_fib_index (transport_connection_fib_proto (tc),
 677                                         tc->fib_index);
 678   if (!st)
 679     return HALF_OPEN_LOOKUP_INVALID_VALUE;
 680   if (tc->is_ip4)
 681     {
 682       make_v4_ss_kv (&kv4, &tc->lcl_ip.ip4, &tc->rmt_ip.ip4, tc->lcl_port,
 683                      tc->rmt_port, tc->proto);
 684       rv = clib_bihash_search_inline_16_8 (&st->v4_half_open_hash, &kv4);
 685       if (rv == 0)
 686         return kv4.value;
 687     }
 688   else
 689     {
 690       make_v6_ss_kv (&kv6, &tc->lcl_ip.ip6, &tc->rmt_ip.ip6, tc->lcl_port,
 691                      tc->rmt_port, tc->proto);
 692       rv = clib_bihash_search_inline_48_8 (&st->v6_half_open_hash, &kv6);
 693       if (rv == 0)
 694         return kv6.value;
 695     }
 696   return HALF_OPEN_LOOKUP_INVALID_VALUE;
 697 }
 698
 699 transport_connection_t *
 700 session_lookup_half_open_connection (u64 handle, u8 proto, u8 is_ip4)
 701 {
 702   u32 sst;
 703
 704   if (handle != HALF_OPEN_LOOKUP_INVALID_VALUE)
 705     {
 706       sst = session_type_from_proto_and_ip (proto, is_ip4);
 707       return tp_vfts[sst].get_half_open (handle & 0xFFFFFFFF);
 708     }
 709   return 0;
 710 }
 711
 712 transport_connection_t *
 713 session_lookup_rules_table_connection4 (session_rules_table_t * srt, u8 proto,
 714                                         ip4_address_t * lcl, u16 lcl_port,
 715                                         ip4_address_t * rmt, u16 rmt_port)
 716 {
 717   stream_session_t *s;
 718   s = session_lookup_rules_table4 (srt, proto, lcl, lcl_port, rmt, rmt_port);
 719   if (s)
 720     return tp_vfts[s->session_type].get_listener (s->connection_index);
 721   return 0;
 722 }
 723
 724 transport_connection_t *
 725 session_lookup_rules_table_connection6 (session_rules_table_t * srt, u8 proto,
 726                                         ip6_address_t * lcl, u16 lcl_port,
 727                                         ip6_address_t * rmt, u16 rmt_port)
 728 {
 729   stream_session_t *s;
 730   s = session_lookup_rules_table6 (srt, proto, lcl, lcl_port, rmt, rmt_port);
 731   if (s)
 732     return tp_vfts[s->session_type].get_listener (s->connection_index);
 733   return 0;
 734 }
 735
 736 /**
 737  * Lookup connection with ip4 and transport layer information
 738  *
 739  * This is used on the fast path so it needs to be fast. Thereby,
 740  * duplication of code and 'hacks' allowed.
 741  *
 742  * The lookup is incremental and returns whenever something is matched. The
 743  * steps are:
 744  * - Try to find an established session
 745  * - Try to find a fully-formed or local source wildcarded (listener bound to
 746  *   all interfaces) listener session
 747  * - Try to find a half-open connection
 748  * - Try session rules table
 749  * - return 0
 750  *
 751  * @param fib_index     index of fib wherein the connection was received
 752  * @param lcl           local ip4 address
 753  * @param rmt           remote ip4 address
 754  * @param lcl_port      local port
 755  * @param rmt_port      remote port
 756  * @param proto         transport protocol (e.g., tcp, udp)
 757  * @param thread_index  thread index for request
 758  *
 759  * @return pointer to transport connection, if one is found, 0 otherwise
 760  */
 761 transport_connection_t *
 762 session_lookup_connection_wt4 (u32 fib_index, ip4_address_t * lcl,
 763                                ip4_address_t * rmt, u16 lcl_port,
 764                                u16 rmt_port, u8 proto, u32 thread_index)
 765 {
 766   session_table_t *st;
 767   session_kv4_t kv4;
 768   stream_session_t *s;
 769   int rv;
 770
 771   st = session_table_get_for_fib_index (FIB_PROTOCOL_IP4, fib_index);
 772   if (PREDICT_FALSE (!st))
 773     return 0;
 774
 775   /* Lookup session amongst established ones */
 776   make_v4_ss_kv (&kv4, lcl, rmt, lcl_port, rmt_port, proto);
 777   rv = clib_bihash_search_inline_16_8 (&st->v4_session_hash, &kv4);
 778   if (rv == 0)
 779     {
 780       ASSERT ((u32) (kv4.value >> 32) == thread_index);
 781       s = session_get (kv4.value & 0xFFFFFFFFULL, thread_index);
 782       return tp_vfts[s->session_type].get_connection (s->connection_index,
 783                                                       thread_index);
 784     }
 785
 786   /* If nothing is found, check if any listener is available */
 787   s = session_lookup_listener4_i (st, lcl, lcl_port, proto);
 788   if (s)
 789     return tp_vfts[s->session_type].get_listener (s->connection_index);
 790
 791   /* Try half-open connections */
 792   rv = clib_bihash_search_inline_16_8 (&st->v4_half_open_hash, &kv4);
 793   if (rv == 0)
 794     {
 795       u32 sst = session_type_from_proto_and_ip (proto, 1);
 796       return tp_vfts[sst].get_half_open (kv4.value & 0xFFFFFFFF);
 797     }
 798
 799   /* Check the session rules table */
 800   return session_lookup_rules_table_connection4 (&st->session_rules, proto,
 801                                                  lcl, lcl_port, rmt,
 802                                                  rmt_port);
 803 }
 804
 805 /**
 806  * Lookup connection with ip4 and transport layer information
 807  *
 808  * Not optimized. This is used on the fast path so it needs to be fast.
 809  * Thereby, duplication of code and 'hacks' allowed. Lookup logic is identical
 810  * to that of @ref session_lookup_connection_wt4
 811  *
 812  * @param fib_index     index of the fib wherein the connection was received
 813  * @param lcl           local ip4 address
 814  * @param rmt           remote ip4 address
 815  * @param lcl_port      local port
 816  * @param rmt_port      remote port
 817  * @param proto         transport protocol (e.g., tcp, udp)
 818  *
 819  * @return pointer to transport connection, if one is found, 0 otherwise
 820  */
 821 transport_connection_t *
 822 session_lookup_connection4 (u32 fib_index, ip4_address_t * lcl,
 823                             ip4_address_t * rmt, u16 lcl_port, u16 rmt_port,
 824                             u8 proto)
 825 {
 826   session_table_t *st;
 827   session_kv4_t kv4;
 828   stream_session_t *s;
 829   int rv;
 830
 831   st = session_table_get_for_fib_index (FIB_PROTOCOL_IP4, fib_index);
 832   if (PREDICT_FALSE (!st))
 833     return 0;
 834
 835   /* Lookup session amongst established ones */
 836   make_v4_ss_kv (&kv4, lcl, rmt, lcl_port, rmt_port, proto);
 837   rv = clib_bihash_search_inline_16_8 (&st->v4_session_hash, &kv4);
 838   if (rv == 0)
 839     {
 840       s = session_get_from_handle (kv4.value);
 841       return tp_vfts[s->session_type].get_connection (s->connection_index,
 842                                                       s->thread_index);
 843     }
 844
 845   /* If nothing is found, check if any listener is available */
 846   s = session_lookup_listener4_i (st, lcl, lcl_port, proto);
 847   if (s)
 848     return tp_vfts[s->session_type].get_listener (s->connection_index);
 849
 850   /* Finally, try half-open connections */
 851   rv = clib_bihash_search_inline_16_8 (&st->v4_half_open_hash, &kv4);
 852   if (rv == 0)
 853     {
 854       u32 sst = session_type_from_proto_and_ip (proto, 1);
 855       return tp_vfts[sst].get_half_open (kv4.value & 0xFFFFFFFF);
 856     }
 857   /* Check the session rules table */
 858   return session_lookup_rules_table_connection4 (&st->session_rules, proto,
 859                                                  lcl, lcl_port, rmt,
 860                                                  rmt_port);
 861 }
 862
 863 /**
 864  * Lookup session with ip4 and transport layer information
 865  *
 866  * Important note: this may look into another thread's pool table and
 867  * register as 'peeker'. Caller should call @ref session_pool_remove_peeker as
 868  * if needed as soon as possible.
 869  *
 870  * Lookup logic is similar to that of @ref session_lookup_connection_wt4 but
 871  * this returns a session as opposed to a transport connection and it does not
 872  * try to lookup half-open sessions.
 873  *
 874  * Typically used by dgram connections
 875  */
 876 stream_session_t *
 877 session_lookup_safe4 (u32 fib_index, ip4_address_t * lcl, ip4_address_t * rmt,
 878                       u16 lcl_port, u16 rmt_port, u8 proto)
 879 {
 880   session_table_t *st;
 881   session_kv4_t kv4;
 882   stream_session_t *s;
 883   int rv;
 884
 885   st = session_table_get_for_fib_index (FIB_PROTOCOL_IP4, fib_index);
 886   if (PREDICT_FALSE (!st))
 887     return 0;
 888
 889   /* Lookup session amongst established ones */
 890   make_v4_ss_kv (&kv4, lcl, rmt, lcl_port, rmt_port, proto);
 891   rv = clib_bihash_search_inline_16_8 (&st->v4_session_hash, &kv4);
 892   if (rv == 0)
 893     return session_get_from_handle_safe (kv4.value);
 894
 895   /* If nothing is found, check if any listener is available */
 896   if ((s = session_lookup_listener4_i (st, lcl, lcl_port, proto)))
 897     return s;
 898   return session_lookup_rules_table4 (&st->session_rules, proto, lcl,
 899                                       lcl_port, rmt, rmt_port);
 900 }
 901
 902 /**
 903  * Lookup connection with ip6 and transport layer information
 904  *
 905  * This is used on the fast path so it needs to be fast. Thereby,
 906  * duplication of code and 'hacks' allowed.
 907  *
 908  * The lookup is incremental and returns whenever something is matched. The
 909  * steps are:
 910  * - Try to find an established session
 911  * - Try to find a fully-formed or local source wildcarded (listener bound to
 912  *   all interfaces) listener session
 913  * - Try to find a half-open connection
 914  * - Try session rules table
 915  * - return 0
 916  *
 917  * @param fib_index     index of the fib wherein the connection was received
 918  * @param lcl           local ip6 address
 919  * @param rmt           remote ip6 address
 920  * @param lcl_port      local port
 921  * @param rmt_port      remote port
 922  * @param proto         transport protocol (e.g., tcp, udp)
 923  * @param thread_index  thread index for request
 924  *
 925  * @return pointer to transport connection, if one is found, 0 otherwise
 926  */
 927 transport_connection_t *
 928 session_lookup_connection_wt6 (u32 fib_index, ip6_address_t * lcl,
 929                                ip6_address_t * rmt, u16 lcl_port,
 930                                u16 rmt_port, u8 proto, u32 thread_index)
 931 {
 932   session_table_t *st;
 933   stream_session_t *s;
 934   session_kv6_t kv6;
 935   int rv;
 936
 937   st = session_table_get_for_fib_index (FIB_PROTOCOL_IP6, fib_index);
 938   if (PREDICT_FALSE (!st))
 939     return 0;
 940
 941   make_v6_ss_kv (&kv6, lcl, rmt, lcl_port, rmt_port, proto);
 942   rv = clib_bihash_search_inline_48_8 (&st->v6_session_hash, &kv6);
 943   if (rv == 0)
 944     {
 945       ASSERT ((u32) (kv6.value >> 32) == thread_index);
 946       s = session_get (kv6.value & 0xFFFFFFFFULL, thread_index);
 947       return tp_vfts[s->session_type].get_connection (s->connection_index,
 948                                                       thread_index);
 949     }
 950
 951   /* If nothing is found, check if any listener is available */
 952   s = session_lookup_listener6_i (st, lcl, lcl_port, proto);
 953   if (s)
 954     return tp_vfts[s->session_type].get_listener (s->connection_index);
 955
 956   /* Finally, try half-open connections */
 957   rv = clib_bihash_search_inline_48_8 (&st->v6_half_open_hash, &kv6);
 958   if (rv == 0)
 959     {
 960       u32 sst = session_type_from_proto_and_ip (proto, 1);
 961       return tp_vfts[sst].get_half_open (kv6.value & 0xFFFFFFFF);
 962     }
 963
 964   return session_lookup_rules_table_connection6 (&st->session_rules, proto,
 965                                                  lcl, lcl_port, rmt,
 966                                                  rmt_port);
 967 }
 968
 969 /**
 970  * Lookup connection with ip6 and transport layer information
 971  *
 972  * Not optimized. This is used on the fast path so it needs to be fast.
 973  * Thereby, duplication of code and 'hacks' allowed. Lookup logic is identical
 974  * to that of @ref session_lookup_connection_wt4
 975  *
 976  * @param fib_index     index of the fib wherein the connection was received
 977  * @param lcl           local ip6 address
 978  * @param rmt           remote ip6 address
 979  * @param lcl_port      local port
 980  * @param rmt_port      remote port
 981  * @param proto         transport protocol (e.g., tcp, udp)
 982  *
 983  * @return pointer to transport connection, if one is found, 0 otherwise
 984  */
 985 transport_connection_t *
 986 session_lookup_connection6 (u32 fib_index, ip6_address_t * lcl,
 987                             ip6_address_t * rmt, u16 lcl_port, u16 rmt_port,
 988                             u8 proto)
 989 {
 990   session_table_t *st;
 991   stream_session_t *s;
 992   session_kv6_t kv6;
 993   int rv;
 994
 995   st = session_table_get_for_fib_index (FIB_PROTOCOL_IP6, fib_index);
 996   if (PREDICT_FALSE (!st))
 997     return 0;
 998
 999   make_v6_ss_kv (&kv6, lcl, rmt, lcl_port, rmt_port, proto);
1000   rv = clib_bihash_search_inline_48_8 (&st->v6_session_hash, &kv6);
1001   if (rv == 0)
1002     {
1003       s = session_get_from_handle (kv6.value);
1004       return tp_vfts[s->session_type].get_connection (s->connection_index,
1005                                                       s->thread_index);
1006     }
1007
1008   /* If nothing is found, check if any listener is available */
1009   s = session_lookup_listener6 (fib_index, lcl, lcl_port, proto);
1010   if (s)
1011     return tp_vfts[s->session_type].get_listener (s->connection_index);
1012
1013   /* Finally, try half-open connections */
1014   rv = clib_bihash_search_inline_48_8 (&st->v6_half_open_hash, &kv6);
1015   if (rv == 0)
1016     {
1017       u32 sst = session_type_from_proto_and_ip (proto, 1);
1018       return tp_vfts[sst].get_half_open (kv6.value & 0xFFFFFFFF);
1019     }
1020
1021   return session_lookup_rules_table_connection6 (&st->session_rules, proto,
1022                                                  lcl, lcl_port, rmt,
1023                                                  rmt_port);
1024 }
1025
1026 /**
1027  * Lookup session with ip6 and transport layer information
1028  *
1029  * Important note: this may look into another thread's pool table and
1030  * register as 'peeker'. Caller should call @ref session_pool_remove_peeker as
1031  * if needed as soon as possible.
1032  *
1033  * Lookup logic is similar to that of @ref session_lookup_connection_wt6 but
1034  * this returns a session as opposed to a transport connection and it does not
1035  * try to lookup half-open sessions.
1036  *
1037  * Typically used by dgram connections
1038  */
1039 stream_session_t *
1040 session_lookup_safe6 (u32 fib_index, ip6_address_t * lcl, ip6_address_t * rmt,
1041                       u16 lcl_port, u16 rmt_port, u8 proto)
1042 {
1043   session_table_t *st;
1044   session_kv6_t kv6;
1045   stream_session_t *s;
1046   int rv;
1047
1048   st = session_table_get_for_fib_index (FIB_PROTOCOL_IP6, fib_index);
1049   if (PREDICT_FALSE (!st))
1050     return 0;
1051
1052   make_v6_ss_kv (&kv6, lcl, rmt, lcl_port, rmt_port, proto);
1053   rv = clib_bihash_search_inline_48_8 (&st->v6_session_hash, &kv6);
1054   if (rv == 0)
1055     return session_get_from_handle_safe (kv6.value);
1056
1057   /* If nothing is found, check if any listener is available */
1058   if ((s = session_lookup_listener6_i (st, lcl, lcl_port, proto)))
1059     return s;
1060   return session_lookup_rules_table6 (&st->session_rules, proto, lcl,
1061                                       lcl_port, rmt, rmt_port);
1062 }
1063
1064 u64
1065 session_lookup_local_listener_make_handle (session_endpoint_t * sep)
1066 {
1067   return ((u64) SESSION_LOCAL_TABLE_PREFIX << 32
1068           | (u32) sep->port << 16 | (u32) sep->transport_proto << 8
1069           | (u32) sep->is_ip4);
1070 }
1071
1072 u8
1073 session_lookup_local_is_handle (u64 handle)
1074 {
1075   if (handle >> 32 == SESSION_LOCAL_TABLE_PREFIX)
1076     return 1;
1077   return 0;
1078 }
1079
1080 int
1081 session_lookup_local_listener_parse_handle (u64 handle,
1082                                             session_endpoint_t * sep)
1083 {
1084   u32 local_table_handle;
1085   if (handle >> 32 != SESSION_LOCAL_TABLE_PREFIX)
1086     return -1;
1087   local_table_handle = handle & 0xFFFFFFFFULL;
1088   sep->is_ip4 = local_table_handle & 0xff;
1089   local_table_handle >>= 8;
1090   sep->transport_proto = local_table_handle & 0xff;
1091   sep->port = local_table_handle >> 8;
1092   return 0;
1093 }
1094
1095 clib_error_t *
1096 vnet_session_rule_add_del (session_rule_add_del_args_t * args)
1097 {
1098   app_namespace_t *app_ns = app_namespace_get (args->appns_index);
1099   session_table_t *st;
1100   u32 fib_index;
1101   u8 fib_proto;
1102   clib_error_t *error;
1103
1104   if (!app_ns)
1105     return clib_error_return_code (0, VNET_API_ERROR_APP_INVALID_NS, 0,
1106                                    "invalid app ns");
1107   if (args->scope > 3)
1108     return clib_error_return_code (0, VNET_API_ERROR_INVALID_VALUE, 0,
1109                                    "invalid scope");
1110   if ((args->scope & SESSION_RULE_SCOPE_GLOBAL) || args->scope == 0)
1111     {
1112       fib_proto = args->table_args.rmt.fp_proto;
1113       fib_index = app_namespace_get_fib_index (app_ns, fib_proto);
1114       st = session_table_get_for_fib_index (fib_proto, fib_index);
1115       if ((error = session_rules_table_add_del (&st->session_rules,
1116                                                 &args->table_args)))
1117         return error;
1118     }
1119   if (args->scope & SESSION_RULE_SCOPE_LOCAL)
1120     {
1121       st = app_namespace_get_local_table (app_ns);
1122       error =
1123         session_rules_table_add_del (&st->session_rules, &args->table_args);
1124     }
1125   return error;
1126 }
1127
1128 u8 *
1129 format_ip4_session_lookup_kvp (u8 * s, va_list * args)
1130 {
1131   clib_bihash_kv_16_8_t *kvp = va_arg (*args, clib_bihash_kv_16_8_t *);
1132   u32 is_local = va_arg (*args, u32);
1133   u8 *app_name, *str = 0;
1134   stream_session_t *session;
1135   v4_connection_key_t *key = (v4_connection_key_t *) kvp->key;
1136
1137   char *proto = key->proto == TRANSPORT_PROTO_TCP ? "T" : "U";
1138   if (!is_local)
1139     {
1140       session = session_get_from_handle (kvp->value);
1141       app_name = application_name_from_index (session->app_index);
1142       str = format (0, "[%s] %U:%d->%U:%d", proto, format_ip4_address,
1143                     &key->src, clib_net_to_host_u16 (key->src_port),
1144                     format_ip4_address, &key->dst,
1145                     clib_net_to_host_u16 (key->dst_port));
1146       s = format (s, "%-40v%-30v", str, app_name);
1147     }
1148   else
1149     {
1150       app_name = application_name_from_index (kvp->value);
1151       str = format (0, "[%s] %U:%d", proto, format_ip4_address,
1152                     &key->src, clib_net_to_host_u16 (key->src_port));
1153       s = format (s, "%-30v%-30v", str, app_name);
1154     }
1155   vec_free (app_name);
1156   return s;
1157 }
1158
1159 typedef struct _ip4_session_table_show_ctx_t
1160 {
1161   vlib_main_t *vm;
1162   u8 is_local;
1163 } ip4_session_table_show_ctx_t;
1164
1165 static int
1166 ip4_session_table_show (clib_bihash_kv_16_8_t * kvp, void *arg)
1167 {
1168   ip4_session_table_show_ctx_t *ctx = arg;
1169   vlib_cli_output (ctx->vm, "%U", format_ip4_session_lookup_kvp, kvp,
1170                    ctx->is_local);
1171   return 1;
1172 }
1173
1174 void
1175 session_lookup_show_table_entries (vlib_main_t * vm, session_table_t * table,
1176                                    u8 type, u8 is_local)
1177 {
1178   ip4_session_table_show_ctx_t ctx = {
1179     .vm = vm,
1180     .is_local = is_local,
1181   };
1182   if (!is_local)
1183     vlib_cli_output (vm, "%-40s%-30s", "Session", "Application");
1184   else
1185     vlib_cli_output (vm, "%-30s%-30s", "Listener", "Application");
1186   switch (type)
1187     {
1188       /* main table v4 */
1189     case 0:
1190       ip4_session_table_walk (&table->v4_session_hash, ip4_session_table_show,
1191                               &ctx);
1192       break;
1193     default:
1194       clib_warning ("not supported");
1195     }
1196 }
1197
1198 static clib_error_t *
1199 session_rule_command_fn (vlib_main_t * vm, unformat_input_t * input,
1200                          vlib_cli_command_t * cmd)
1201 {
1202   u32 proto = ~0, lcl_port, rmt_port, action = 0, lcl_plen, rmt_plen;
1203   u32 appns_index, scope = 0;
1204   ip46_address_t lcl_ip, rmt_ip;
1205   u8 is_ip4 = 1, conn_set = 0;
1206   u8 fib_proto, is_add = 1, *ns_id = 0;
1207   app_namespace_t *app_ns;
1208
1209   memset (&lcl_ip, 0, sizeof (lcl_ip));
1210   memset (&rmt_ip, 0, sizeof (rmt_ip));
1211   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1212     {
1213       if (unformat (input, "del"))
1214         is_add = 0;
1215       else if (unformat (input, "add"))
1216         ;
1217       else if (unformat (input, "appns %_%v%_", &ns_id))
1218         ;
1219       else if (unformat (input, "scope global"))
1220         scope = SESSION_RULE_SCOPE_GLOBAL;
1221       else if (unformat (input, "scope local"))
1222         scope = SESSION_RULE_SCOPE_LOCAL;
1223       else if (unformat (input, "scope all"))
1224         scope = SESSION_RULE_SCOPE_LOCAL | SESSION_RULE_SCOPE_GLOBAL;
1225       else if (unformat (input, "proto %U", unformat_transport_proto, &proto))
1226         ;
1227       else if (unformat (input, "%U/%d %d %U/%d %d", unformat_ip4_address,
1228                          &lcl_ip.ip4, &lcl_plen, &lcl_port,
1229                          unformat_ip4_address, &rmt_ip.ip4, &rmt_plen,
1230                          &rmt_port))
1231         {
1232           is_ip4 = 1;
1233           conn_set = 1;
1234         }
1235       else if (unformat (input, "%U/%d %d %U/%d %d", unformat_ip6_address,
1236                          &lcl_ip.ip6, &lcl_plen, &lcl_port,
1237                          unformat_ip6_address, &rmt_ip.ip6, &rmt_plen,
1238                          &rmt_port))
1239         {
1240           is_ip4 = 0;
1241           conn_set = 1;
1242         }
1243       else if (unformat (input, "action %d", &action))
1244         ;
1245       else
1246         return clib_error_return (0, "unknown input `%U'",
1247                                   format_unformat_error, input);
1248     }
1249
1250   if (proto == ~0 || !conn_set || action == ~0)
1251     return clib_error_return (0, "proto, connection and action must be set");
1252
1253   if (ns_id)
1254     {
1255       app_ns = app_namespace_get_from_id (ns_id);
1256       if (!app_ns)
1257         return clib_error_return (0, "namespace %v does not exist", ns_id);
1258     }
1259   else
1260     {
1261       app_ns = app_namespace_get_default ();
1262     }
1263   appns_index = app_namespace_index (app_ns);
1264
1265   fib_proto = is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6;
1266   session_rule_add_del_args_t args = {
1267     .table_args.lcl.fp_addr = lcl_ip,
1268     .table_args.lcl.fp_len = lcl_plen,
1269     .table_args.lcl.fp_proto = fib_proto,
1270     .table_args.rmt.fp_addr = rmt_ip,
1271     .table_args.rmt.fp_len = rmt_plen,
1272     .table_args.rmt.fp_proto = fib_proto,
1273     .table_args.lcl_port = lcl_port,
1274     .table_args.rmt_port = rmt_port,
1275     .table_args.action_index = action,
1276     .table_args.is_add = is_add,
1277     .appns_index = appns_index,
1278     .scope = scope,
1279   };
1280   return vnet_session_rule_add_del (&args);
1281 }
1282
1283 /* *INDENT-OFF* */
1284 VLIB_CLI_COMMAND (session_rule_command, static) =
1285 {
1286   .path = "session rule",
1287   .short_help = "session rule [add|del] appns <ns_id> proto <proto> "
1288       "<lcl-ip/plen> <lcl-port> <rmt-ip/plen> <rmt-port> action <action>",
1289   .function = session_rule_command_fn,
1290 };
1291 /* *INDENT-ON* */
1292
1293 static clib_error_t *
1294 show_session_rules_command_fn (vlib_main_t * vm, unformat_input_t * input,
1295                                vlib_cli_command_t * cmd)
1296 {
1297   u32 transport_proto = ~0, lcl_port, rmt_port, lcl_plen, rmt_plen;
1298   u32 fib_index, scope = 0;
1299   ip46_address_t lcl_ip, rmt_ip;
1300   u8 is_ip4 = 1, show_one = 0;
1301   app_namespace_t *app_ns;
1302   session_table_t *st;
1303   u8 *ns_id = 0, fib_proto;
1304
1305   memset (&lcl_ip, 0, sizeof (lcl_ip));
1306   memset (&rmt_ip, 0, sizeof (rmt_ip));
1307   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1308     {
1309       if (unformat (input, "%U", unformat_transport_proto, &transport_proto))
1310         ;
1311       else if (unformat (input, "appns %_%v%_", &ns_id))
1312         ;
1313       else if (unformat (input, "scope global"))
1314         scope = 1;
1315       else if (unformat (input, "scope local"))
1316         scope = 2;
1317       else if (unformat (input, "%U/%d %d %U/%d %d", unformat_ip4_address,
1318                          &lcl_ip.ip4, &lcl_plen, &lcl_port,
1319                          unformat_ip4_address, &rmt_ip.ip4, &rmt_plen,
1320                          &rmt_port))
1321         {
1322           is_ip4 = 1;
1323           show_one = 1;
1324         }
1325       else if (unformat (input, "%U/%d %d %U/%d %d", unformat_ip6_address,
1326                          &lcl_ip.ip6, &lcl_plen, &lcl_port,
1327                          unformat_ip6_address, &rmt_ip.ip6, &rmt_plen,
1328                          &rmt_port))
1329         {
1330           is_ip4 = 0;
1331           show_one = 1;
1332         }
1333       else
1334         return clib_error_return (0, "unknown input `%U'",
1335                                   format_unformat_error, input);
1336     }
1337
1338   if (transport_proto == ~0)
1339     {
1340       vlib_cli_output (vm, "transport proto must be set");
1341       return 0;
1342     }
1343
1344   if (ns_id)
1345     {
1346       app_ns = app_namespace_get_from_id (ns_id);
1347       if (!app_ns)
1348         {
1349           vlib_cli_output (vm, "appns %v doesn't exist", ns_id);
1350           return 0;
1351         }
1352     }
1353   else
1354     {
1355       app_ns = app_namespace_get_default ();
1356     }
1357
1358   if (scope == 1 || scope == 0)
1359     {
1360       fib_proto = is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6;
1361       fib_index = is_ip4 ? app_ns->ip4_fib_index : app_ns->ip6_fib_index;
1362       st = session_table_get_for_fib_index (fib_proto, fib_index);
1363     }
1364   else
1365     {
1366       st = app_namespace_get_local_table (app_ns);
1367     }
1368
1369   if (show_one)
1370     {
1371       session_rules_table_show_rule (vm, &st->session_rules, transport_proto,
1372                                      &lcl_ip, lcl_port, &rmt_ip, rmt_port,
1373                                      is_ip4);
1374       return 0;
1375     }
1376
1377   session_rules_table_cli_dump (vm, &st->session_rules, FIB_PROTOCOL_IP4,
1378                                 transport_proto);
1379   session_rules_table_cli_dump (vm, &st->session_rules, FIB_PROTOCOL_IP6,
1380                                 transport_proto);
1381
1382   vec_free (ns_id);
1383   return 0;
1384 }
1385
1386 /* *INDENT-OFF* */
1387 VLIB_CLI_COMMAND (show_session_rules_command, static) =
1388 {
1389   .path = "show session rules",
1390   .short_help = "show session rules [appns <id> proto <proto> <lcl-ip/plen>"
1391       " <lcl-port> <rmt-ip/plen> <rmt-port>]",
1392   .function = show_session_rules_command_fn,
1393 };
1394 /* *INDENT-ON* */
1395
1396 void
1397 session_lookup_init (void)
1398 {
1399   /*
1400    * Allocate default table and map it to fib_index 0
1401    */
1402   session_table_t *st = session_table_alloc ();
1403   vec_validate (fib_index_to_table_index[FIB_PROTOCOL_IP4], 0);
1404   fib_index_to_table_index[FIB_PROTOCOL_IP4][0] = session_table_index (st);
1405   session_table_init (st);
1406   st = session_table_alloc ();
1407   vec_validate (fib_index_to_table_index[FIB_PROTOCOL_IP6], 0);
1408   fib_index_to_table_index[FIB_PROTOCOL_IP6][0] = session_table_index (st);
1409   session_table_init (st);
1410 }
1411
1412 /*
1413  * fd.io coding-style-patch-verification: ON
1414  *
1415  * Local Variables:
1416  * eval: (c-set-style "gnu")
1417  * End:
1418  */