src/vnet/tcp/tcp.c

   1 /*
   2  * Copyright (c) 2016 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <vnet/tcp/tcp.h>
  17 #include <vnet/session/session.h>
  18 #include <vnet/fib/fib.h>
  19 #include <math.h>
  20
  21 tcp_main_t tcp_main;
  22
  23 static u32
  24 tcp_connection_bind (u32 session_index, ip46_address_t * ip,
  25                      u16 port_host_byte_order, u8 is_ip4)
  26 {
  27   tcp_main_t *tm = &tcp_main;
  28   tcp_connection_t *listener;
  29
  30   pool_get (tm->listener_pool, listener);
  31   memset (listener, 0, sizeof (*listener));
  32
  33   listener->c_c_index = listener - tm->listener_pool;
  34   listener->c_lcl_port = clib_host_to_net_u16 (port_host_byte_order);
  35
  36   if (is_ip4)
  37     listener->c_lcl_ip4.as_u32 = ip->ip4.as_u32;
  38   else
  39     clib_memcpy (&listener->c_lcl_ip6, &ip->ip6, sizeof (ip6_address_t));
  40
  41   listener->c_s_index = session_index;
  42   listener->c_proto = SESSION_TYPE_IP4_TCP;
  43   listener->state = TCP_STATE_LISTEN;
  44   listener->c_is_ip4 = 1;
  45
  46   tcp_connection_timers_init (listener);
  47
  48   TCP_EVT_DBG (TCP_EVT_BIND, listener);
  49
  50   return listener->c_c_index;
  51 }
  52
  53 u32
  54 tcp_session_bind_ip4 (u32 session_index, ip46_address_t * ip,
  55                       u16 port_host_byte_order)
  56 {
  57   return tcp_connection_bind (session_index, ip, port_host_byte_order, 1);
  58 }
  59
  60 u32
  61 tcp_session_bind_ip6 (u32 session_index, ip46_address_t * ip,
  62                       u16 port_host_byte_order)
  63 {
  64   return tcp_connection_bind (session_index, ip, port_host_byte_order, 0);
  65
  66 }
  67
  68 static void
  69 tcp_connection_unbind (u32 listener_index)
  70 {
  71   tcp_main_t *tm = vnet_get_tcp_main ();
  72   TCP_EVT_DBG (TCP_EVT_UNBIND,
  73                pool_elt_at_index (tm->listener_pool, listener_index));
  74   pool_put_index (tm->listener_pool, listener_index);
  75 }
  76
  77 u32
  78 tcp_session_unbind (u32 listener_index)
  79 {
  80   tcp_connection_unbind (listener_index);
  81   return 0;
  82 }
  83
  84 transport_connection_t *
  85 tcp_session_get_listener (u32 listener_index)
  86 {
  87   tcp_main_t *tm = vnet_get_tcp_main ();
  88   tcp_connection_t *tc;
  89   tc = pool_elt_at_index (tm->listener_pool, listener_index);
  90   return &tc->connection;
  91 }
  92
  93 /**
  94  * Cleans up connection state.
  95  *
  96  * No notifications.
  97  */
  98 void
  99 tcp_connection_cleanup (tcp_connection_t * tc)
 100 {
 101   tcp_main_t *tm = &tcp_main;
 102   u32 tepi;
 103   transport_endpoint_t *tep;
 104
 105   /* Cleanup local endpoint if this was an active connect */
 106   tepi = transport_endpoint_lookup (&tm->local_endpoints_table, &tc->c_lcl_ip,
 107                                     tc->c_lcl_port);
 108
 109   /*XXX lock */
 110   if (tepi != TRANSPORT_ENDPOINT_INVALID_INDEX)
 111     {
 112       tep = pool_elt_at_index (tm->local_endpoints, tepi);
 113       transport_endpoint_table_del (&tm->local_endpoints_table, tep);
 114       pool_put (tm->local_endpoints, tep);
 115     }
 116
 117   /* Make sure all timers are cleared */
 118   tcp_connection_timers_reset (tc);
 119
 120   /* Check if half-open */
 121   if (tc->state == TCP_STATE_SYN_SENT)
 122     pool_put (tm->half_open_connections, tc);
 123   else
 124     pool_put (tm->connections[tc->c_thread_index], tc);
 125 }
 126
 127 /**
 128  * Connection removal.
 129  *
 130  * This should be called only once connection enters CLOSED state. Note
 131  * that it notifies the session of the removal event, so if the goal is to
 132  * just remove the connection, call tcp_connection_cleanup instead.
 133  */
 134 void
 135 tcp_connection_del (tcp_connection_t * tc)
 136 {
 137   TCP_EVT_DBG (TCP_EVT_DELETE, tc);
 138   stream_session_delete_notify (&tc->connection);
 139   tcp_connection_cleanup (tc);
 140 }
 141
 142 /** Notify session that connection has been reset.
 143  *
 144  * Switch state to closed and wait for session to call cleanup.
 145  */
 146 void
 147 tcp_connection_reset (tcp_connection_t * tc)
 148 {
 149   if (tc->state == TCP_STATE_CLOSED)
 150     return;
 151
 152   tc->state = TCP_STATE_CLOSED;
 153   stream_session_reset_notify (&tc->connection);
 154 }
 155
 156 /**
 157  * Begin connection closing procedure.
 158  *
 159  * If at the end the connection is not in CLOSED state, it is not removed.
 160  * Instead, we rely on on TCP to advance through state machine to either
 161  * 1) LAST_ACK (passive close) whereby when the last ACK is received
 162  * tcp_connection_del is called. This notifies session of the delete and
 163  * calls cleanup.
 164  * 2) TIME_WAIT (active close) whereby after 2MSL the 2MSL timer triggers
 165  * and cleanup is called.
 166  *
 167  * N.B. Half-close connections are not supported
 168  */
 169 void
 170 tcp_connection_close (tcp_connection_t * tc)
 171 {
 172   TCP_EVT_DBG (TCP_EVT_CLOSE, tc);
 173
 174   /* Send FIN if needed */
 175   if (tc->state == TCP_STATE_ESTABLISHED || tc->state == TCP_STATE_SYN_RCVD
 176       || tc->state == TCP_STATE_CLOSE_WAIT)
 177     tcp_send_fin (tc);
 178
 179   /* Switch state */
 180   if (tc->state == TCP_STATE_ESTABLISHED || tc->state == TCP_STATE_SYN_RCVD)
 181     tc->state = TCP_STATE_FIN_WAIT_1;
 182   else if (tc->state == TCP_STATE_SYN_SENT)
 183     tc->state = TCP_STATE_CLOSED;
 184   else if (tc->state == TCP_STATE_CLOSE_WAIT)
 185     tc->state = TCP_STATE_LAST_ACK;
 186
 187   /* If in CLOSED and WAITCLOSE timer is not set, delete connection now */
 188   if (tc->timers[TCP_TIMER_WAITCLOSE] == TCP_TIMER_HANDLE_INVALID
 189       && tc->state == TCP_STATE_CLOSED)
 190     tcp_connection_del (tc);
 191 }
 192
 193 void
 194 tcp_session_close (u32 conn_index, u32 thread_index)
 195 {
 196   tcp_connection_t *tc;
 197   tc = tcp_connection_get (conn_index, thread_index);
 198   tcp_connection_close (tc);
 199 }
 200
 201 void
 202 tcp_session_cleanup (u32 conn_index, u32 thread_index)
 203 {
 204   tcp_connection_t *tc;
 205   tc = tcp_connection_get (conn_index, thread_index);
 206
 207   /* Wait for the session tx events to clear */
 208   tc->state = TCP_STATE_CLOSED;
 209   tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, TCP_CLEANUP_TIME);
 210 }
 211
 212 void *
 213 ip_interface_get_first_ip (u32 sw_if_index, u8 is_ip4)
 214 {
 215   ip_lookup_main_t *lm4 = &ip4_main.lookup_main;
 216   ip_lookup_main_t *lm6 = &ip6_main.lookup_main;
 217   ip_interface_address_t *ia = 0;
 218
 219   if (is_ip4)
 220     {
 221       /* *INDENT-OFF* */
 222       foreach_ip_interface_address (lm4, ia, sw_if_index, 1 /* unnumbered */ ,
 223       ({
 224         return ip_interface_address_get_address (lm4, ia);
 225       }));
 226       /* *INDENT-ON* */
 227     }
 228   else
 229     {
 230       /* *INDENT-OFF* */
 231       foreach_ip_interface_address (lm6, ia, sw_if_index, 1 /* unnumbered */ ,
 232       ({
 233         return ip_interface_address_get_address (lm6, ia);
 234       }));
 235       /* *INDENT-ON* */
 236     }
 237
 238   return 0;
 239 }
 240
 241 #define PORT_MASK ((1 << 16)- 1)
 242 /**
 243  * Allocate local port and add if successful add entry to local endpoint
 244  * table to mark the pair as used.
 245  */
 246 u16
 247 tcp_allocate_local_port (tcp_main_t * tm, ip46_address_t * ip)
 248 {
 249   transport_endpoint_t *tep;
 250   u32 time_now, tei;
 251   u16 min = 1024, max = 65535;  /* XXX configurable ? */
 252   int tries;
 253
 254   tries = max - min;
 255   time_now = tcp_time_now ();
 256
 257   /* Start at random point or max */
 258   pool_get (tm->local_endpoints, tep);
 259   clib_memcpy (&tep->ip, ip, sizeof (*ip));
 260
 261   /* Search for first free slot */
 262   for (; tries >= 0; tries--)
 263     {
 264       u16 port = 0;
 265
 266       /* Find a port in the specified range */
 267       while (1)
 268         {
 269           port = random_u32 (&time_now) & PORT_MASK;
 270           if (PREDICT_TRUE (port >= min && port < max))
 271             break;
 272         }
 273
 274       tep->port = port;
 275
 276       /* Look it up */
 277       tei = transport_endpoint_lookup (&tm->local_endpoints_table, &tep->ip,
 278                                        tep->port);
 279       /* If not found, we're done */
 280       if (tei == TRANSPORT_ENDPOINT_INVALID_INDEX)
 281         {
 282           transport_endpoint_table_add (&tm->local_endpoints_table, tep,
 283                                         tep - tm->local_endpoints);
 284           return tep->port;
 285         }
 286     }
 287   /* No free ports */
 288   pool_put (tm->local_endpoints, tep);
 289   return -1;
 290 }
 291
 292 /**
 293  * Initialize all connection timers as invalid
 294  */
 295 void
 296 tcp_connection_timers_init (tcp_connection_t * tc)
 297 {
 298   int i;
 299
 300   /* Set all to invalid */
 301   for (i = 0; i < TCP_N_TIMERS; i++)
 302     {
 303       tc->timers[i] = TCP_TIMER_HANDLE_INVALID;
 304     }
 305
 306   tc->rto = TCP_RTO_INIT;
 307 }
 308
 309 /**
 310  * Stop all connection timers
 311  */
 312 void
 313 tcp_connection_timers_reset (tcp_connection_t * tc)
 314 {
 315   int i;
 316   for (i = 0; i < TCP_N_TIMERS; i++)
 317     {
 318       tcp_timer_reset (tc, i);
 319     }
 320 }
 321
 322 /** Initialize tcp connection variables
 323  *
 324  * Should be called after having received a msg from the peer, i.e., a SYN or
 325  * a SYNACK, such that connection options have already been exchanged. */
 326 void
 327 tcp_connection_init_vars (tcp_connection_t * tc)
 328 {
 329   tcp_connection_timers_init (tc);
 330   tcp_set_snd_mss (tc);
 331   scoreboard_init (&tc->sack_sb);
 332   tcp_cc_init (tc);
 333 }
 334
 335 int
 336 tcp_connection_open (ip46_address_t * rmt_addr, u16 rmt_port, u8 is_ip4)
 337 {
 338   tcp_main_t *tm = vnet_get_tcp_main ();
 339   tcp_connection_t *tc;
 340   fib_prefix_t prefix;
 341   u32 fei, sw_if_index;
 342   ip46_address_t lcl_addr;
 343   u16 lcl_port;
 344
 345   /*
 346    * Find the local address and allocate port
 347    */
 348   memset (&lcl_addr, 0, sizeof (lcl_addr));
 349
 350   /* Find a FIB path to the destination */
 351   clib_memcpy (&prefix.fp_addr, rmt_addr, sizeof (*rmt_addr));
 352   prefix.fp_proto = is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6;
 353   prefix.fp_len = is_ip4 ? 32 : 128;
 354
 355   fei = fib_table_lookup (0, &prefix);
 356
 357   /* Couldn't find route to destination. Bail out. */
 358   if (fei == FIB_NODE_INDEX_INVALID)
 359     return -1;
 360
 361   sw_if_index = fib_entry_get_resolving_interface (fei);
 362
 363   if (sw_if_index == (u32) ~ 0)
 364     return -1;
 365
 366   if (is_ip4)
 367     {
 368       ip4_address_t *ip4;
 369       ip4 = ip_interface_get_first_ip (sw_if_index, 1);
 370       lcl_addr.ip4.as_u32 = ip4->as_u32;
 371     }
 372   else
 373     {
 374       ip6_address_t *ip6;
 375       ip6 = ip_interface_get_first_ip (sw_if_index, 0);
 376       clib_memcpy (&lcl_addr.ip6, ip6, sizeof (*ip6));
 377     }
 378
 379   /* Allocate source port */
 380   lcl_port = tcp_allocate_local_port (tm, &lcl_addr);
 381   if (lcl_port < 1)
 382     {
 383       clib_warning ("Failed to allocate src port");
 384       return -1;
 385     }
 386
 387   /*
 388    * Create connection and send SYN
 389    */
 390
 391   pool_get (tm->half_open_connections, tc);
 392   memset (tc, 0, sizeof (*tc));
 393
 394   clib_memcpy (&tc->c_rmt_ip, rmt_addr, sizeof (ip46_address_t));
 395   clib_memcpy (&tc->c_lcl_ip, &lcl_addr, sizeof (ip46_address_t));
 396   tc->c_rmt_port = clib_host_to_net_u16 (rmt_port);
 397   tc->c_lcl_port = clib_host_to_net_u16 (lcl_port);
 398   tc->c_c_index = tc - tm->half_open_connections;
 399   tc->c_is_ip4 = is_ip4;
 400
 401   /* The other connection vars will be initialized after SYN ACK */
 402   tcp_connection_timers_init (tc);
 403
 404   tcp_send_syn (tc);
 405
 406   tc->state = TCP_STATE_SYN_SENT;
 407
 408   TCP_EVT_DBG (TCP_EVT_OPEN, tc);
 409
 410   return tc->c_c_index;
 411 }
 412
 413 int
 414 tcp_session_open_ip4 (ip46_address_t * addr, u16 port)
 415 {
 416   return tcp_connection_open (addr, port, 1);
 417 }
 418
 419 int
 420 tcp_session_open_ip6 (ip46_address_t * addr, u16 port)
 421 {
 422   return tcp_connection_open (addr, port, 0);
 423 }
 424
 425 const char *tcp_dbg_evt_str[] = {
 426 #define _(sym, str) str,
 427   foreach_tcp_dbg_evt
 428 #undef _
 429 };
 430
 431 const char *tcp_fsm_states[] = {
 432 #define _(sym, str) str,
 433   foreach_tcp_fsm_state
 434 #undef _
 435 };
 436
 437 u8 *
 438 format_tcp_state (u8 * s, va_list * args)
 439 {
 440   tcp_state_t *state = va_arg (*args, tcp_state_t *);
 441
 442   if (*state < TCP_N_STATES)
 443     s = format (s, "%s", tcp_fsm_states[*state]);
 444   else
 445     s = format (s, "UNKNOWN");
 446
 447   return s;
 448 }
 449
 450 const char *tcp_conn_timers[] = {
 451 #define _(sym, str) str,
 452   foreach_tcp_timer
 453 #undef _
 454 };
 455
 456 u8 *
 457 format_tcp_timers (u8 * s, va_list * args)
 458 {
 459   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
 460   int i, last = 0;
 461
 462   for (i = 0; i < TCP_N_TIMERS; i++)
 463     if (tc->timers[i] != TCP_TIMER_HANDLE_INVALID)
 464       last = i;
 465
 466   s = format (s, "[");
 467   for (i = 0; i < last; i++)
 468     {
 469       if (tc->timers[i] != TCP_TIMER_HANDLE_INVALID)
 470         s = format (s, "%s,", tcp_conn_timers[i]);
 471     }
 472
 473   if (last > 0)
 474     s = format (s, "%s]", tcp_conn_timers[i]);
 475   else
 476     s = format (s, "]");
 477
 478   return s;
 479 }
 480
 481 u8 *
 482 format_tcp_connection (u8 * s, va_list * args)
 483 {
 484   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
 485
 486   if (tc->c_is_ip4)
 487     {
 488       s = format (s, "[#%d][%s] %U:%d->%U:%d", tc->c_thread_index, "T",
 489                   format_ip4_address, &tc->c_lcl_ip4,
 490                   clib_net_to_host_u16 (tc->c_lcl_port), format_ip4_address,
 491                   &tc->c_rmt_ip4, clib_net_to_host_u16 (tc->c_rmt_port));
 492     }
 493   else
 494     {
 495       s = format (s, "[#%d][%s] %U:%d->%U:%d", tc->c_thread_index, "T",
 496                   format_ip6_address, &tc->c_lcl_ip6,
 497                   clib_net_to_host_u16 (tc->c_lcl_port), format_ip6_address,
 498                   &tc->c_rmt_ip6, clib_net_to_host_u16 (tc->c_rmt_port));
 499     }
 500
 501   return s;
 502 }
 503
 504 u8 *
 505 format_tcp_connection_verbose (u8 * s, va_list * args)
 506 {
 507   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
 508   s = format (s, "%U %U %U", format_tcp_connection, tc, format_tcp_state,
 509               &tc->state, format_tcp_timers, tc);
 510   return s;
 511 }
 512
 513 u8 *
 514 format_tcp_session (u8 * s, va_list * args)
 515 {
 516   u32 tci = va_arg (*args, u32);
 517   u32 thread_index = va_arg (*args, u32);
 518   tcp_connection_t *tc;
 519
 520   tc = tcp_connection_get (tci, thread_index);
 521   return format (s, "%U", format_tcp_connection, tc);
 522 }
 523
 524 u8 *
 525 format_tcp_listener_session (u8 * s, va_list * args)
 526 {
 527   u32 tci = va_arg (*args, u32);
 528   tcp_connection_t *tc = tcp_listener_get (tci);
 529   return format (s, "%U", format_tcp_connection, tc);
 530 }
 531
 532 u8 *
 533 format_tcp_half_open_session (u8 * s, va_list * args)
 534 {
 535   u32 tci = va_arg (*args, u32);
 536   tcp_connection_t *tc = tcp_half_open_connection_get (tci);
 537   return format (s, "%U", format_tcp_connection, tc);
 538 }
 539
 540 transport_connection_t *
 541 tcp_session_get_transport (u32 conn_index, u32 thread_index)
 542 {
 543   tcp_connection_t *tc = tcp_connection_get (conn_index, thread_index);
 544   return &tc->connection;
 545 }
 546
 547 transport_connection_t *
 548 tcp_half_open_session_get_transport (u32 conn_index)
 549 {
 550   tcp_connection_t *tc = tcp_half_open_connection_get (conn_index);
 551   return &tc->connection;
 552 }
 553
 554 u16
 555 tcp_session_send_mss (transport_connection_t * trans_conn)
 556 {
 557   tcp_connection_t *tc = (tcp_connection_t *) trans_conn;
 558   return tc->snd_mss;
 559 }
 560
 561 /**
 562  * Compute tx window session is allowed to fill.
 563  */
 564 u32
 565 tcp_session_send_space (transport_connection_t * trans_conn)
 566 {
 567   u32 snd_space;
 568   tcp_connection_t *tc = (tcp_connection_t *) trans_conn;
 569
 570   /* If we haven't gotten dupacks or if we did and have gotten sacked bytes
 571    * then we can still send */
 572   if (PREDICT_TRUE (tcp_in_fastrecovery (tc) == 0
 573                     && (tc->rcv_dupacks == 0
 574                         || tc->sack_sb.last_sacked_bytes)))
 575     {
 576       snd_space = tcp_available_snd_space (tc);
 577
 578       /* If we can't write at least a segment, don't try at all */
 579       if (snd_space < tc->snd_mss)
 580         return 0;
 581       return snd_space;
 582     }
 583
 584   /* If in fast recovery, send 1 SMSS if wnd allows */
 585   if (tcp_in_fastrecovery (tc) && tcp_available_snd_space (tc)
 586       && tcp_fastrecovery_sent_1_smss (tc))
 587     {
 588       tcp_fastrecovery_1_smss_on (tc);
 589       return tc->snd_mss;
 590     }
 591
 592   return 0;
 593 }
 594
 595 u32
 596 tcp_session_tx_fifo_offset (transport_connection_t * trans_conn)
 597 {
 598   tcp_connection_t *tc = (tcp_connection_t *) trans_conn;
 599
 600   ASSERT (seq_geq (tc->snd_nxt, tc->snd_una));
 601
 602   /* This still works if fast retransmit is on */
 603   return (tc->snd_nxt - tc->snd_una);
 604 }
 605
 606 /* *INDENT-OFF* */
 607 const static transport_proto_vft_t tcp4_proto = {
 608   .bind = tcp_session_bind_ip4,
 609   .unbind = tcp_session_unbind,
 610   .push_header = tcp_push_header,
 611   .get_connection = tcp_session_get_transport,
 612   .get_listener = tcp_session_get_listener,
 613   .get_half_open = tcp_half_open_session_get_transport,
 614   .open = tcp_session_open_ip4,
 615   .close = tcp_session_close,
 616   .cleanup = tcp_session_cleanup,
 617   .send_mss = tcp_session_send_mss,
 618   .send_space = tcp_session_send_space,
 619   .tx_fifo_offset = tcp_session_tx_fifo_offset,
 620   .format_connection = format_tcp_session,
 621   .format_listener = format_tcp_listener_session,
 622   .format_half_open = format_tcp_half_open_session,
 623 };
 624
 625 const static transport_proto_vft_t tcp6_proto = {
 626   .bind = tcp_session_bind_ip6,
 627   .unbind = tcp_session_unbind,
 628   .push_header = tcp_push_header,
 629   .get_connection = tcp_session_get_transport,
 630   .get_listener = tcp_session_get_listener,
 631   .get_half_open = tcp_half_open_session_get_transport,
 632   .open = tcp_session_open_ip6,
 633   .close = tcp_session_close,
 634   .cleanup = tcp_session_cleanup,
 635   .send_mss = tcp_session_send_mss,
 636   .send_space = tcp_session_send_space,
 637   .tx_fifo_offset = tcp_session_tx_fifo_offset,
 638   .format_connection = format_tcp_session,
 639   .format_listener = format_tcp_listener_session,
 640   .format_half_open = format_tcp_half_open_session,
 641 };
 642 /* *INDENT-ON* */
 643
 644 void
 645 tcp_timer_keep_handler (u32 conn_index)
 646 {
 647   u32 cpu_index = os_get_cpu_number ();
 648   tcp_connection_t *tc;
 649
 650   tc = tcp_connection_get (conn_index, cpu_index);
 651   tc->timers[TCP_TIMER_KEEP] = TCP_TIMER_HANDLE_INVALID;
 652
 653   tcp_connection_close (tc);
 654 }
 655
 656 void
 657 tcp_timer_establish_handler (u32 conn_index)
 658 {
 659   tcp_connection_t *tc;
 660   u8 sst;
 661
 662   tc = tcp_half_open_connection_get (conn_index);
 663   tc->timers[TCP_TIMER_ESTABLISH] = TCP_TIMER_HANDLE_INVALID;
 664
 665   ASSERT (tc->state == TCP_STATE_SYN_SENT);
 666
 667   sst = tc->c_is_ip4 ? SESSION_TYPE_IP4_TCP : SESSION_TYPE_IP6_TCP;
 668   stream_session_connect_notify (&tc->connection, sst, 1 /* fail */ );
 669
 670   tcp_connection_cleanup (tc);
 671 }
 672
 673 void
 674 tcp_timer_waitclose_handler (u32 conn_index)
 675 {
 676   u32 cpu_index = os_get_cpu_number ();
 677   tcp_connection_t *tc;
 678
 679   tc = tcp_connection_get (conn_index, cpu_index);
 680   tc->timers[TCP_TIMER_WAITCLOSE] = TCP_TIMER_HANDLE_INVALID;
 681
 682   /* Session didn't come back with a close(). Send FIN either way
 683    * and switch to LAST_ACK. */
 684   if (tc->state == TCP_STATE_CLOSE_WAIT)
 685     {
 686       if (tc->flags & TCP_CONN_FINSNT)
 687         {
 688           clib_warning ("FIN was sent and still in CLOSE WAIT. Weird!");
 689         }
 690
 691       tcp_send_fin (tc);
 692       tc->state = TCP_STATE_LAST_ACK;
 693
 694       /* Make sure we don't wait in LAST ACK forever */
 695       tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, TCP_2MSL_TIME);
 696
 697       /* Don't delete the connection yet */
 698       return;
 699     }
 700
 701   tcp_connection_del (tc);
 702 }
 703
 704 /* *INDENT-OFF* */
 705 static timer_expiration_handler *timer_expiration_handlers[TCP_N_TIMERS] =
 706 {
 707     tcp_timer_retransmit_handler,
 708     tcp_timer_delack_handler,
 709     0,
 710     tcp_timer_keep_handler,
 711     tcp_timer_waitclose_handler,
 712     tcp_timer_retransmit_syn_handler,
 713     tcp_timer_establish_handler
 714 };
 715 /* *INDENT-ON* */
 716
 717 static void
 718 tcp_expired_timers_dispatch (u32 * expired_timers)
 719 {
 720   int i;
 721   u32 connection_index, timer_id;
 722
 723   for (i = 0; i < vec_len (expired_timers); i++)
 724     {
 725       /* Get session index and timer id */
 726       connection_index = expired_timers[i] & 0x0FFFFFFF;
 727       timer_id = expired_timers[i] >> 28;
 728
 729       TCP_EVT_DBG (TCP_EVT_TIMER_POP, connection_index, timer_id);
 730
 731       /* Handle expiration */
 732       (*timer_expiration_handlers[timer_id]) (connection_index);
 733     }
 734 }
 735
 736 void
 737 tcp_initialize_timer_wheels (tcp_main_t * tm)
 738 {
 739   tw_timer_wheel_16t_2w_512sl_t *tw;
 740   vec_foreach (tw, tm->timer_wheels)
 741   {
 742     tw_timer_wheel_init_16t_2w_512sl (tw, tcp_expired_timers_dispatch,
 743                                       100e-3 /* timer period 100ms */ , ~0);
 744     tw->last_run_time = vlib_time_now (tm->vlib_main);
 745   }
 746 }
 747
 748 clib_error_t *
 749 tcp_main_enable (vlib_main_t * vm)
 750 {
 751   tcp_main_t *tm = vnet_get_tcp_main ();
 752   ip_protocol_info_t *pi;
 753   ip_main_t *im = &ip_main;
 754   vlib_thread_main_t *vtm = vlib_get_thread_main ();
 755   clib_error_t *error = 0;
 756   u32 num_threads;
 757
 758   if ((error = vlib_call_init_function (vm, ip_main_init)))
 759     return error;
 760   if ((error = vlib_call_init_function (vm, ip4_lookup_init)))
 761     return error;
 762   if ((error = vlib_call_init_function (vm, ip6_lookup_init)))
 763     return error;
 764
 765   /*
 766    * Registrations
 767    */
 768
 769   /* Register with IP */
 770   pi = ip_get_protocol_info (im, IP_PROTOCOL_TCP);
 771   if (pi == 0)
 772     return clib_error_return (0, "TCP protocol info AWOL");
 773   pi->format_header = format_tcp_header;
 774   pi->unformat_pg_edit = unformat_pg_tcp_header;
 775
 776   ip4_register_protocol (IP_PROTOCOL_TCP, tcp4_input_node.index);
 777
 778   /* Register as transport with URI */
 779   session_register_transport (SESSION_TYPE_IP4_TCP, &tcp4_proto);
 780   session_register_transport (SESSION_TYPE_IP6_TCP, &tcp6_proto);
 781
 782   /*
 783    * Initialize data structures
 784    */
 785
 786   num_threads = 1 /* main thread */  + vtm->n_threads;
 787   vec_validate (tm->connections, num_threads - 1);
 788
 789   /* Initialize per worker thread tx buffers (used for control messages) */
 790   vec_validate (tm->tx_buffers, num_threads - 1);
 791
 792   /* Initialize timer wheels */
 793   vec_validate (tm->timer_wheels, num_threads - 1);
 794   tcp_initialize_timer_wheels (tm);
 795
 796 //  vec_validate (tm->delack_connections, num_threads - 1);
 797
 798   /* Initialize clocks per tick for TCP timestamp. Used to compute
 799    * monotonically increasing timestamps. */
 800   tm->tstamp_ticks_per_clock = vm->clib_time.seconds_per_clock
 801     / TCP_TSTAMP_RESOLUTION;
 802
 803   clib_bihash_init_24_8 (&tm->local_endpoints_table, "local endpoint table",
 804                          200000 /* $$$$ config parameter nbuckets */ ,
 805                          (64 << 20) /*$$$ config parameter table size */ );
 806
 807   return error;
 808 }
 809
 810 clib_error_t *
 811 vnet_tcp_enable_disable (vlib_main_t * vm, u8 is_en)
 812 {
 813   if (is_en)
 814     {
 815       if (tcp_main.is_enabled)
 816         return 0;
 817
 818       return tcp_main_enable (vm);
 819     }
 820   else
 821     {
 822       tcp_main.is_enabled = 0;
 823     }
 824
 825   return 0;
 826 }
 827
 828 clib_error_t *
 829 tcp_init (vlib_main_t * vm)
 830 {
 831   tcp_main_t *tm = vnet_get_tcp_main ();
 832
 833   tm->vlib_main = vm;
 834   tm->vnet_main = vnet_get_main ();
 835   tm->is_enabled = 0;
 836
 837   return 0;
 838 }
 839
 840 VLIB_INIT_FUNCTION (tcp_init);
 841
 842 /*
 843  * fd.io coding-style-patch-verification: ON
 844  *
 845  * Local Variables:
 846  * eval: (c-set-style "gnu")
 847  * End:
 848  */