src/vnet/sctp/sctp_output.c

   1 /*
   2  * Copyright (c) 2017 SUSE LLC.
   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 #include <vnet/sctp/sctp.h>
  16 #include <vnet/sctp/sctp_debug.h>
  17 #include <vppinfra/random.h>
  18 #include <openssl/hmac.h>
  19
  20 vlib_node_registration_t sctp4_output_node;
  21 vlib_node_registration_t sctp6_output_node;
  22
  23 typedef enum _sctp_output_next
  24 {
  25   SCTP_OUTPUT_NEXT_DROP,
  26   SCTP_OUTPUT_NEXT_IP_LOOKUP,
  27   SCTP_OUTPUT_N_NEXT
  28 } sctp_output_next_t;
  29
  30 #define foreach_sctp4_output_next               \
  31   _ (DROP, "error-drop")                        \
  32   _ (IP_LOOKUP, "ip4-lookup")
  33
  34 #define foreach_sctp6_output_next               \
  35   _ (DROP, "error-drop")                        \
  36   _ (IP_LOOKUP, "ip6-lookup")
  37
  38 static char *sctp_error_strings[] = {
  39 #define sctp_error(n,s) s,
  40 #include <vnet/sctp/sctp_error.def>
  41 #undef sctp_error
  42 };
  43
  44 typedef struct
  45 {
  46   sctp_header_t sctp_header;
  47   sctp_connection_t sctp_connection;
  48 } sctp_tx_trace_t;
  49
  50 /**
  51  * Flush tx frame populated by retransmits and timer pops
  52  */
  53 void
  54 sctp_flush_frame_to_output (vlib_main_t * vm, u8 thread_index, u8 is_ip4)
  55 {
  56   if (sctp_main.tx_frames[!is_ip4][thread_index])
  57     {
  58       u32 next_index;
  59       next_index = is_ip4 ? sctp4_output_node.index : sctp6_output_node.index;
  60       vlib_put_frame_to_node (vm, next_index,
  61                               sctp_main.tx_frames[!is_ip4][thread_index]);
  62       sctp_main.tx_frames[!is_ip4][thread_index] = 0;
  63     }
  64 }
  65
  66 /**
  67  * Flush ip lookup tx frames populated by timer pops
  68  */
  69 always_inline void
  70 sctp_flush_frame_to_ip_lookup (vlib_main_t * vm, u8 thread_index, u8 is_ip4)
  71 {
  72   if (sctp_main.ip_lookup_tx_frames[!is_ip4][thread_index])
  73     {
  74       u32 next_index;
  75       next_index = is_ip4 ? ip4_lookup_node.index : ip6_lookup_node.index;
  76       vlib_put_frame_to_node (vm, next_index,
  77                               sctp_main.ip_lookup_tx_frames[!is_ip4]
  78                               [thread_index]);
  79       sctp_main.ip_lookup_tx_frames[!is_ip4][thread_index] = 0;
  80     }
  81 }
  82
  83 /**
  84  * Flush v4 and v6 sctp and ip-lookup tx frames for thread index
  85  */
  86 void
  87 sctp_flush_frames_to_output (u8 thread_index)
  88 {
  89   vlib_main_t *vm = vlib_get_main ();
  90   sctp_flush_frame_to_output (vm, thread_index, 1);
  91   sctp_flush_frame_to_output (vm, thread_index, 0);
  92   sctp_flush_frame_to_ip_lookup (vm, thread_index, 1);
  93   sctp_flush_frame_to_ip_lookup (vm, thread_index, 0);
  94 }
  95
  96 u32
  97 ip4_sctp_compute_checksum (vlib_main_t * vm, vlib_buffer_t * p0,
  98                            ip4_header_t * ip0)
  99 {
 100   ip_csum_t checksum;
 101   u32 ip_header_length, payload_length_host_byte_order;
 102   u32 n_this_buffer, n_bytes_left, n_ip_bytes_this_buffer;
 103   void *data_this_buffer;
 104
 105   /* Initialize checksum with ip header. */
 106   ip_header_length = ip4_header_bytes (ip0);
 107   payload_length_host_byte_order =
 108     clib_net_to_host_u16 (ip0->length) - ip_header_length;
 109   checksum =
 110     clib_host_to_net_u32 (payload_length_host_byte_order +
 111                           (ip0->protocol << 16));
 112
 113   if (BITS (uword) == 32)
 114     {
 115       checksum =
 116         ip_csum_with_carry (checksum,
 117                             clib_mem_unaligned (&ip0->src_address, u32));
 118       checksum =
 119         ip_csum_with_carry (checksum,
 120                             clib_mem_unaligned (&ip0->dst_address, u32));
 121     }
 122   else
 123     checksum =
 124       ip_csum_with_carry (checksum,
 125                           clib_mem_unaligned (&ip0->src_address, u64));
 126
 127   n_bytes_left = n_this_buffer = payload_length_host_byte_order;
 128   data_this_buffer = (void *) ip0 + ip_header_length;
 129   n_ip_bytes_this_buffer =
 130     p0->current_length - (((u8 *) ip0 - p0->data) - p0->current_data);
 131   if (n_this_buffer + ip_header_length > n_ip_bytes_this_buffer)
 132     {
 133       n_this_buffer = n_ip_bytes_this_buffer > ip_header_length ?
 134         n_ip_bytes_this_buffer - ip_header_length : 0;
 135     }
 136   while (1)
 137     {
 138       checksum =
 139         ip_incremental_checksum (checksum, data_this_buffer, n_this_buffer);
 140       n_bytes_left -= n_this_buffer;
 141       if (n_bytes_left == 0)
 142         break;
 143
 144       ASSERT (p0->flags & VLIB_BUFFER_NEXT_PRESENT);
 145       p0 = vlib_get_buffer (vm, p0->next_buffer);
 146       data_this_buffer = vlib_buffer_get_current (p0);
 147       n_this_buffer = p0->current_length;
 148     }
 149
 150   return checksum;
 151 }
 152
 153 u32
 154 ip6_sctp_compute_checksum (vlib_main_t * vm, vlib_buffer_t * p0,
 155                            ip6_header_t * ip0, int *bogus_lengthp)
 156 {
 157   ip_csum_t checksum;
 158   u16 payload_length_host_byte_order;
 159   u32 i, n_this_buffer, n_bytes_left;
 160   u32 headers_size = sizeof (ip0[0]);
 161   void *data_this_buffer;
 162
 163   ASSERT (bogus_lengthp);
 164   *bogus_lengthp = 0;
 165
 166   /* Initialize checksum with ip header. */
 167   checksum = ip0->payload_length + clib_host_to_net_u16 (ip0->protocol);
 168   payload_length_host_byte_order = clib_net_to_host_u16 (ip0->payload_length);
 169   data_this_buffer = (void *) (ip0 + 1);
 170
 171   for (i = 0; i < ARRAY_LEN (ip0->src_address.as_uword); i++)
 172     {
 173       checksum = ip_csum_with_carry (checksum,
 174                                      clib_mem_unaligned (&ip0->
 175                                                          src_address.as_uword
 176                                                          [i], uword));
 177       checksum =
 178         ip_csum_with_carry (checksum,
 179                             clib_mem_unaligned (&ip0->dst_address.as_uword[i],
 180                                                 uword));
 181     }
 182
 183   /* some icmp packets may come with a "router alert" hop-by-hop extension header (e.g., mldv2 packets)
 184    * or UDP-Ping packets */
 185   if (PREDICT_FALSE (ip0->protocol == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS))
 186     {
 187       u32 skip_bytes;
 188       ip6_hop_by_hop_ext_t *ext_hdr =
 189         (ip6_hop_by_hop_ext_t *) data_this_buffer;
 190
 191       /* validate really icmp6 next */
 192       ASSERT ((ext_hdr->next_hdr == IP_PROTOCOL_SCTP));
 193
 194       skip_bytes = 8 * (1 + ext_hdr->n_data_u64s);
 195       data_this_buffer = (void *) ((u8 *) data_this_buffer + skip_bytes);
 196
 197       payload_length_host_byte_order -= skip_bytes;
 198       headers_size += skip_bytes;
 199     }
 200
 201   n_bytes_left = n_this_buffer = payload_length_host_byte_order;
 202   if (p0 && n_this_buffer + headers_size > p0->current_length)
 203     n_this_buffer =
 204       p0->current_length >
 205       headers_size ? p0->current_length - headers_size : 0;
 206   while (1)
 207     {
 208       checksum =
 209         ip_incremental_checksum (checksum, data_this_buffer, n_this_buffer);
 210       n_bytes_left -= n_this_buffer;
 211       if (n_bytes_left == 0)
 212         break;
 213
 214       if (!(p0->flags & VLIB_BUFFER_NEXT_PRESENT))
 215         {
 216           *bogus_lengthp = 1;
 217           return 0xfefe;
 218         }
 219       p0 = vlib_get_buffer (vm, p0->next_buffer);
 220       data_this_buffer = vlib_buffer_get_current (p0);
 221       n_this_buffer = p0->current_length;
 222     }
 223
 224   return checksum;
 225 }
 226
 227 void
 228 sctp_push_ip_hdr (sctp_main_t * tm, sctp_sub_connection_t * sctp_sub_conn,
 229                   vlib_buffer_t * b)
 230 {
 231   sctp_header_t *th = vlib_buffer_get_current (b);
 232   vlib_main_t *vm = vlib_get_main ();
 233   if (sctp_sub_conn->c_is_ip4)
 234     {
 235       ip4_header_t *ih;
 236       ih = vlib_buffer_push_ip4 (vm, b, &sctp_sub_conn->c_lcl_ip4,
 237                                  &sctp_sub_conn->c_rmt_ip4, IP_PROTOCOL_SCTP,
 238                                  1);
 239       th->checksum = ip4_sctp_compute_checksum (vm, b, ih);
 240     }
 241   else
 242     {
 243       ip6_header_t *ih;
 244       int bogus = ~0;
 245
 246       ih = vlib_buffer_push_ip6 (vm, b, &sctp_sub_conn->c_lcl_ip6,
 247                                  &sctp_sub_conn->c_rmt_ip6, IP_PROTOCOL_SCTP);
 248       th->checksum = ip6_sctp_compute_checksum (vm, b, ih, &bogus);
 249       ASSERT (!bogus);
 250     }
 251 }
 252
 253 always_inline void *
 254 sctp_reuse_buffer (vlib_main_t * vm, vlib_buffer_t * b)
 255 {
 256   if (b->flags & VLIB_BUFFER_NEXT_PRESENT)
 257     vlib_buffer_free_one (vm, b->next_buffer);
 258   /* Zero all flags but free list index and trace flag */
 259   b->flags &= VLIB_BUFFER_NEXT_PRESENT - 1;
 260   b->current_data = 0;
 261   b->current_length = 0;
 262   b->total_length_not_including_first_buffer = 0;
 263   vnet_buffer (b)->sctp.flags = 0;
 264   vnet_buffer (b)->sctp.subconn_idx = MAX_SCTP_CONNECTIONS;
 265
 266   /* Leave enough space for headers */
 267   return vlib_buffer_make_headroom (b, MAX_HDRS_LEN);
 268 }
 269
 270 always_inline void *
 271 sctp_init_buffer (vlib_main_t * vm, vlib_buffer_t * b)
 272 {
 273   ASSERT ((b->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
 274   b->flags &= VLIB_BUFFER_NON_DEFAULT_FREELIST;
 275   b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
 276   b->total_length_not_including_first_buffer = 0;
 277   vnet_buffer (b)->sctp.flags = 0;
 278   vnet_buffer (b)->sctp.subconn_idx = MAX_SCTP_CONNECTIONS;
 279   VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b);
 280   /* Leave enough space for headers */
 281   return vlib_buffer_make_headroom (b, MAX_HDRS_LEN);
 282 }
 283
 284 always_inline int
 285 sctp_alloc_tx_buffers (sctp_main_t * tm, u8 thread_index, u32 n_free_buffers)
 286 {
 287   vlib_main_t *vm = vlib_get_main ();
 288   u32 current_length = vec_len (tm->tx_buffers[thread_index]);
 289   u32 n_allocated;
 290
 291   vec_validate (tm->tx_buffers[thread_index],
 292                 current_length + n_free_buffers - 1);
 293   n_allocated =
 294     vlib_buffer_alloc (vm, &tm->tx_buffers[thread_index][current_length],
 295                        n_free_buffers);
 296   _vec_len (tm->tx_buffers[thread_index]) = current_length + n_allocated;
 297   /* buffer shortage, report failure */
 298   if (vec_len (tm->tx_buffers[thread_index]) == 0)
 299     {
 300       clib_warning ("out of buffers");
 301       return -1;
 302     }
 303   return 0;
 304 }
 305
 306 always_inline int
 307 sctp_get_free_buffer_index (sctp_main_t * tm, u32 * bidx)
 308 {
 309   u32 *my_tx_buffers;
 310   u32 thread_index = vlib_get_thread_index ();
 311   if (PREDICT_FALSE (vec_len (tm->tx_buffers[thread_index]) == 0))
 312     {
 313       if (sctp_alloc_tx_buffers (tm, thread_index, VLIB_FRAME_SIZE))
 314         return -1;
 315     }
 316   my_tx_buffers = tm->tx_buffers[thread_index];
 317   *bidx = my_tx_buffers[vec_len (my_tx_buffers) - 1];
 318   _vec_len (my_tx_buffers) -= 1;
 319   return 0;
 320 }
 321
 322 always_inline void
 323 sctp_enqueue_to_output_i (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
 324                           u8 is_ip4, u8 flush)
 325 {
 326   sctp_main_t *tm = vnet_get_sctp_main ();
 327   u32 thread_index = vlib_get_thread_index ();
 328   u32 *to_next, next_index;
 329   vlib_frame_t *f;
 330
 331   b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
 332   b->error = 0;
 333
 334   /* Decide where to send the packet */
 335   next_index = is_ip4 ? sctp4_output_node.index : sctp6_output_node.index;
 336   sctp_trajectory_add_start (b, 2);
 337
 338   /* Get frame to v4/6 output node */
 339   f = tm->tx_frames[!is_ip4][thread_index];
 340   if (!f)
 341     {
 342       f = vlib_get_frame_to_node (vm, next_index);
 343       ASSERT (f);
 344       tm->tx_frames[!is_ip4][thread_index] = f;
 345     }
 346   to_next = vlib_frame_vector_args (f);
 347   to_next[f->n_vectors] = bi;
 348   f->n_vectors += 1;
 349   if (flush || f->n_vectors == VLIB_FRAME_SIZE)
 350     {
 351       vlib_put_frame_to_node (vm, next_index, f);
 352       tm->tx_frames[!is_ip4][thread_index] = 0;
 353     }
 354 }
 355
 356 always_inline void
 357 sctp_enqueue_to_output_now (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
 358                             u8 is_ip4)
 359 {
 360   sctp_enqueue_to_output_i (vm, b, bi, is_ip4, 1);
 361 }
 362
 363 always_inline void
 364 sctp_enqueue_to_ip_lookup_i (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
 365                              u8 is_ip4, u32 fib_index, u8 flush)
 366 {
 367   sctp_main_t *tm = vnet_get_sctp_main ();
 368   u32 thread_index = vlib_get_thread_index ();
 369   u32 *to_next, next_index;
 370   vlib_frame_t *f;
 371
 372   b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
 373   b->error = 0;
 374
 375   vnet_buffer (b)->sw_if_index[VLIB_TX] = fib_index;
 376   vnet_buffer (b)->sw_if_index[VLIB_RX] = 0;
 377
 378   /* Send to IP lookup */
 379   next_index = is_ip4 ? ip4_lookup_node.index : ip6_lookup_node.index;
 380   if (VLIB_BUFFER_TRACE_TRAJECTORY > 0)
 381     {
 382       b->pre_data[0] = 2;
 383       b->pre_data[1] = next_index;
 384     }
 385
 386   f = tm->ip_lookup_tx_frames[!is_ip4][thread_index];
 387   if (!f)
 388     {
 389       f = vlib_get_frame_to_node (vm, next_index);
 390       ASSERT (f);
 391       tm->ip_lookup_tx_frames[!is_ip4][thread_index] = f;
 392     }
 393
 394   to_next = vlib_frame_vector_args (f);
 395   to_next[f->n_vectors] = bi;
 396   f->n_vectors += 1;
 397   if (flush || f->n_vectors == VLIB_FRAME_SIZE)
 398     {
 399       vlib_put_frame_to_node (vm, next_index, f);
 400       tm->ip_lookup_tx_frames[!is_ip4][thread_index] = 0;
 401     }
 402 }
 403
 404 always_inline void
 405 sctp_enqueue_to_ip_lookup (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
 406                            u8 is_ip4, u32 fib_index)
 407 {
 408   sctp_enqueue_to_ip_lookup_i (vm, b, bi, is_ip4, fib_index, 0);
 409   if (vm->thread_index == 0 && vlib_num_workers ())
 410     session_flush_frames_main_thread (vm);
 411 }
 412
 413 /**
 414  * Convert buffer to INIT
 415  */
 416 void
 417 sctp_prepare_init_chunk (sctp_connection_t * sctp_conn, u8 idx,
 418                          vlib_buffer_t * b)
 419 {
 420   u32 random_seed = random_default_seed ();
 421   u16 alloc_bytes = sizeof (sctp_init_chunk_t);
 422   sctp_sub_connection_t *sub_conn = &sctp_conn->sub_conn[idx];
 423
 424   sctp_ipv4_addr_param_t *ip4_param = 0;
 425   sctp_ipv6_addr_param_t *ip6_param = 0;
 426
 427   if (sub_conn->c_is_ip4)
 428     alloc_bytes += sizeof (sctp_ipv4_addr_param_t);
 429   else
 430     alloc_bytes += sizeof (sctp_ipv6_addr_param_t);
 431
 432   /* As per RFC 4960 the chunk_length value does NOT contemplate
 433    * the size of the first header (see sctp_header_t) and any padding
 434    */
 435   u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
 436
 437   alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
 438
 439   sctp_init_chunk_t *init_chunk = vlib_buffer_push_uninit (b, alloc_bytes);
 440
 441   u16 pointer_offset = sizeof (init_chunk);
 442   if (sub_conn->c_is_ip4)
 443     {
 444       ip4_param = (sctp_ipv4_addr_param_t *) init_chunk + pointer_offset;
 445       ip4_param->address.as_u32 = sub_conn->c_lcl_ip.ip4.as_u32;
 446
 447       pointer_offset += sizeof (sctp_ipv4_addr_param_t);
 448     }
 449   else
 450     {
 451       ip6_param = (sctp_ipv6_addr_param_t *) init_chunk + pointer_offset;
 452       ip6_param->address.as_u64[0] = sub_conn->c_lcl_ip.ip6.as_u64[0];
 453       ip6_param->address.as_u64[1] = sub_conn->c_lcl_ip.ip6.as_u64[1];
 454
 455       pointer_offset += sizeof (sctp_ipv6_addr_param_t);
 456     }
 457
 458   init_chunk->sctp_hdr.src_port = sub_conn->c_lcl_port; /* No need of host_to_net conversion, already in net-byte order */
 459   init_chunk->sctp_hdr.dst_port = sub_conn->c_rmt_port; /* No need of host_to_net conversion, already in net-byte order */
 460   init_chunk->sctp_hdr.checksum = 0;
 461   /* The sender of an INIT must set the VERIFICATION_TAG to 0 as per RFC 4960 Section 8.5.1 */
 462   init_chunk->sctp_hdr.verification_tag = 0x0;
 463
 464   vnet_sctp_set_chunk_type (&init_chunk->chunk_hdr, INIT);
 465   vnet_sctp_set_chunk_length (&init_chunk->chunk_hdr, chunk_len);
 466   vnet_sctp_common_hdr_params_host_to_net (&init_chunk->chunk_hdr);
 467
 468   sctp_init_cwnd (sctp_conn);
 469
 470   init_chunk->a_rwnd = clib_host_to_net_u32 (sctp_conn->sub_conn[idx].cwnd);
 471   init_chunk->initiate_tag = clib_host_to_net_u32 (random_u32 (&random_seed));
 472   init_chunk->inboud_streams_count =
 473     clib_host_to_net_u16 (INBOUND_STREAMS_COUNT);
 474   init_chunk->outbound_streams_count =
 475     clib_host_to_net_u16 (OUTBOUND_STREAMS_COUNT);
 476
 477   init_chunk->initial_tsn =
 478     clib_host_to_net_u32 (sctp_conn->local_initial_tsn);
 479   SCTP_CONN_TRACKING_DBG ("sctp_conn->local_initial_tsn = %u",
 480                           sctp_conn->local_initial_tsn);
 481
 482   sctp_conn->local_tag = init_chunk->initiate_tag;
 483
 484   vnet_buffer (b)->sctp.connection_index = sub_conn->c_c_index;
 485   vnet_buffer (b)->sctp.subconn_idx = idx;
 486
 487   SCTP_DBG_STATE_MACHINE ("CONN_INDEX = %u, CURR_CONN_STATE = %u (%s), "
 488                           "CHUNK_TYPE = %s, "
 489                           "SRC_PORT = %u, DST_PORT = %u",
 490                           sub_conn->connection.c_index,
 491                           sctp_conn->state,
 492                           sctp_state_to_string (sctp_conn->state),
 493                           sctp_chunk_to_string (INIT),
 494                           init_chunk->sctp_hdr.src_port,
 495                           init_chunk->sctp_hdr.dst_port);
 496 }
 497
 498 void
 499 sctp_compute_mac (sctp_connection_t * sctp_conn,
 500                   sctp_state_cookie_param_t * state_cookie)
 501 {
 502 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
 503   HMAC_CTX *ctx;
 504 #else
 505   HMAC_CTX ctx;
 506 #endif
 507   unsigned int len = 0;
 508   const EVP_MD *md = EVP_sha1 ();
 509 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
 510   ctx = HMAC_CTX_new ();
 511   HMAC_Init_ex (ctx, &state_cookie->creation_time,
 512                 sizeof (state_cookie->creation_time), md, NULL);
 513   HMAC_Update (ctx, (const unsigned char *) &sctp_conn, sizeof (sctp_conn));
 514   HMAC_Final (ctx, state_cookie->mac, &len);
 515 #else
 516   HMAC_CTX_init (&ctx);
 517   HMAC_Init_ex (&ctx, &state_cookie->creation_time,
 518                 sizeof (state_cookie->creation_time), md, NULL);
 519   HMAC_Update (&ctx, (const unsigned char *) &sctp_conn, sizeof (sctp_conn));
 520   HMAC_Final (&ctx, state_cookie->mac, &len);
 521   HMAC_CTX_cleanup (&ctx);
 522 #endif
 523
 524   ENDIANESS_SWAP (state_cookie->mac);
 525 }
 526
 527 void
 528 sctp_prepare_cookie_ack_chunk (sctp_connection_t * sctp_conn, u8 idx,
 529                                vlib_buffer_t * b)
 530 {
 531   vlib_main_t *vm = vlib_get_main ();
 532
 533   sctp_reuse_buffer (vm, b);
 534
 535   u16 alloc_bytes = sizeof (sctp_cookie_ack_chunk_t);
 536
 537   /* As per RFC 4960 the chunk_length value does NOT contemplate
 538    * the size of the first header (see sctp_header_t) and any padding
 539    */
 540   u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
 541
 542   alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
 543
 544   sctp_cookie_ack_chunk_t *cookie_ack_chunk =
 545     vlib_buffer_push_uninit (b, alloc_bytes);
 546
 547   cookie_ack_chunk->sctp_hdr.checksum = 0;
 548   cookie_ack_chunk->sctp_hdr.src_port =
 549     sctp_conn->sub_conn[idx].connection.lcl_port;
 550   cookie_ack_chunk->sctp_hdr.dst_port =
 551     sctp_conn->sub_conn[idx].connection.rmt_port;
 552   cookie_ack_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
 553   vnet_sctp_set_chunk_type (&cookie_ack_chunk->chunk_hdr, COOKIE_ACK);
 554   vnet_sctp_set_chunk_length (&cookie_ack_chunk->chunk_hdr, chunk_len);
 555
 556   vnet_buffer (b)->sctp.connection_index =
 557     sctp_conn->sub_conn[idx].connection.c_index;
 558   vnet_buffer (b)->sctp.subconn_idx = idx;
 559 }
 560
 561 void
 562 sctp_prepare_cookie_echo_chunk (sctp_connection_t * sctp_conn, u8 idx,
 563                                 vlib_buffer_t * b, u8 reuse_buffer)
 564 {
 565   vlib_main_t *vm = vlib_get_main ();
 566
 567   if (reuse_buffer)
 568     sctp_reuse_buffer (vm, b);
 569
 570   /* The minimum size of the message is given by the sctp_init_ack_chunk_t */
 571   u16 alloc_bytes = sizeof (sctp_cookie_echo_chunk_t);
 572   /* As per RFC 4960 the chunk_length value does NOT contemplate
 573    * the size of the first header (see sctp_header_t) and any padding
 574    */
 575   u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
 576   alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
 577   sctp_cookie_echo_chunk_t *cookie_echo_chunk =
 578     vlib_buffer_push_uninit (b, alloc_bytes);
 579   cookie_echo_chunk->sctp_hdr.checksum = 0;
 580   cookie_echo_chunk->sctp_hdr.src_port =
 581     sctp_conn->sub_conn[idx].connection.lcl_port;
 582   cookie_echo_chunk->sctp_hdr.dst_port =
 583     sctp_conn->sub_conn[idx].connection.rmt_port;
 584   cookie_echo_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
 585   vnet_sctp_set_chunk_type (&cookie_echo_chunk->chunk_hdr, COOKIE_ECHO);
 586   vnet_sctp_set_chunk_length (&cookie_echo_chunk->chunk_hdr, chunk_len);
 587   clib_memcpy (&(cookie_echo_chunk->cookie), &sctp_conn->cookie_param,
 588                sizeof (sctp_state_cookie_param_t));
 589
 590   vnet_buffer (b)->sctp.connection_index =
 591     sctp_conn->sub_conn[idx].connection.c_index;
 592   vnet_buffer (b)->sctp.subconn_idx = idx;
 593 }
 594
 595
 596 /*
 597  *  Send COOKIE_ECHO
 598  */
 599 void
 600 sctp_send_cookie_echo (sctp_connection_t * sctp_conn)
 601 {
 602   vlib_buffer_t *b;
 603   u32 bi;
 604   sctp_main_t *tm = vnet_get_sctp_main ();
 605   vlib_main_t *vm = vlib_get_main ();
 606
 607   if (PREDICT_FALSE (sctp_conn->init_retransmit_err > SCTP_MAX_INIT_RETRANS))
 608     {
 609       clib_warning ("Reached MAX_INIT_RETRANS times. Aborting connection.");
 610
 611       session_stream_connect_notify (&sctp_conn->sub_conn
 612                                      [SCTP_PRIMARY_PATH_IDX].connection, 1);
 613
 614       sctp_connection_timers_reset (sctp_conn);
 615
 616       sctp_connection_cleanup (sctp_conn);
 617     }
 618
 619   if (PREDICT_FALSE (sctp_get_free_buffer_index (tm, &bi)))
 620     return;
 621
 622   b = vlib_get_buffer (vm, bi);
 623   u8 idx = SCTP_PRIMARY_PATH_IDX;
 624
 625   sctp_init_buffer (vm, b);
 626   sctp_prepare_cookie_echo_chunk (sctp_conn, idx, b, 0);
 627   sctp_enqueue_to_output_now (vm, b, bi, sctp_conn->sub_conn[idx].c_is_ip4);
 628
 629   /* Start the T1_INIT timer */
 630   sctp_timer_set (sctp_conn, idx, SCTP_TIMER_T1_INIT,
 631                   sctp_conn->sub_conn[idx].RTO);
 632
 633   /* Change state to COOKIE_WAIT */
 634   sctp_conn->state = SCTP_STATE_COOKIE_WAIT;
 635
 636   /* Measure RTT with this */
 637   sctp_conn->sub_conn[idx].rtt_ts = sctp_time_now ();
 638 }
 639
 640
 641 /**
 642  * Convert buffer to ERROR
 643  */
 644 void
 645 sctp_prepare_operation_error (sctp_connection_t * sctp_conn, u8 idx,
 646                               vlib_buffer_t * b, u8 err_cause)
 647 {
 648   vlib_main_t *vm = vlib_get_main ();
 649
 650   sctp_reuse_buffer (vm, b);
 651
 652   /* The minimum size of the message is given by the sctp_operation_error_t */
 653   u16 alloc_bytes =
 654     sizeof (sctp_operation_error_t) + sizeof (sctp_err_cause_param_t);
 655
 656   /* As per RFC 4960 the chunk_length value does NOT contemplate
 657    * the size of the first header (see sctp_header_t) and any padding
 658    */
 659   u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
 660
 661   alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
 662
 663   sctp_operation_error_t *err_chunk =
 664     vlib_buffer_push_uninit (b, alloc_bytes);
 665
 666   /* src_port & dst_port are already in network byte-order */
 667   err_chunk->sctp_hdr.checksum = 0;
 668   err_chunk->sctp_hdr.src_port = sctp_conn->sub_conn[idx].connection.lcl_port;
 669   err_chunk->sctp_hdr.dst_port = sctp_conn->sub_conn[idx].connection.rmt_port;
 670   /* As per RFC4960 Section 5.2.2: copy the INITIATE_TAG into the VERIFICATION_TAG of the ABORT chunk */
 671   err_chunk->sctp_hdr.verification_tag = sctp_conn->local_tag;
 672
 673   err_chunk->err_causes[0].param_hdr.length =
 674     clib_host_to_net_u16 (sizeof (err_chunk->err_causes[0].param_hdr.type) +
 675                           sizeof (err_chunk->err_causes[0].param_hdr.length));
 676   err_chunk->err_causes[0].param_hdr.type = clib_host_to_net_u16 (err_cause);
 677
 678   vnet_sctp_set_chunk_type (&err_chunk->chunk_hdr, OPERATION_ERROR);
 679   vnet_sctp_set_chunk_length (&err_chunk->chunk_hdr, chunk_len);
 680
 681   vnet_buffer (b)->sctp.connection_index =
 682     sctp_conn->sub_conn[idx].connection.c_index;
 683   vnet_buffer (b)->sctp.subconn_idx = idx;
 684 }
 685
 686 /**
 687  * Convert buffer to ABORT
 688  */
 689 void
 690 sctp_prepare_abort_for_collision (sctp_connection_t * sctp_conn, u8 idx,
 691                                   vlib_buffer_t * b, ip4_address_t * ip4_addr,
 692                                   ip6_address_t * ip6_addr)
 693 {
 694   vlib_main_t *vm = vlib_get_main ();
 695
 696   sctp_reuse_buffer (vm, b);
 697
 698   /* The minimum size of the message is given by the sctp_abort_chunk_t */
 699   u16 alloc_bytes = sizeof (sctp_abort_chunk_t);
 700
 701   /* As per RFC 4960 the chunk_length value does NOT contemplate
 702    * the size of the first header (see sctp_header_t) and any padding
 703    */
 704   u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
 705
 706   alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
 707
 708   sctp_abort_chunk_t *abort_chunk = vlib_buffer_push_uninit (b, alloc_bytes);
 709
 710   /* src_port & dst_port are already in network byte-order */
 711   abort_chunk->sctp_hdr.checksum = 0;
 712   abort_chunk->sctp_hdr.src_port =
 713     sctp_conn->sub_conn[idx].connection.lcl_port;
 714   abort_chunk->sctp_hdr.dst_port =
 715     sctp_conn->sub_conn[idx].connection.rmt_port;
 716   /* As per RFC4960 Section 5.2.2: copy the INITIATE_TAG into the VERIFICATION_TAG of the ABORT chunk */
 717   abort_chunk->sctp_hdr.verification_tag = sctp_conn->local_tag;
 718
 719   vnet_sctp_set_chunk_type (&abort_chunk->chunk_hdr, ABORT);
 720   vnet_sctp_set_chunk_length (&abort_chunk->chunk_hdr, chunk_len);
 721
 722   vnet_buffer (b)->sctp.connection_index =
 723     sctp_conn->sub_conn[idx].connection.c_index;
 724   vnet_buffer (b)->sctp.subconn_idx = idx;
 725 }
 726
 727 /**
 728  * Convert buffer to INIT-ACK
 729  */
 730 void
 731 sctp_prepare_initack_chunk_for_collision (sctp_connection_t * sctp_conn,
 732                                           u8 idx, vlib_buffer_t * b,
 733                                           ip4_address_t * ip4_addr,
 734                                           ip6_address_t * ip6_addr)
 735 {
 736   vlib_main_t *vm = vlib_get_main ();
 737   sctp_ipv4_addr_param_t *ip4_param = 0;
 738   sctp_ipv6_addr_param_t *ip6_param = 0;
 739
 740   sctp_reuse_buffer (vm, b);
 741
 742   /* The minimum size of the message is given by the sctp_init_ack_chunk_t */
 743   u16 alloc_bytes =
 744     sizeof (sctp_init_ack_chunk_t) + sizeof (sctp_state_cookie_param_t);
 745
 746   if (PREDICT_TRUE (ip4_addr != NULL))
 747     {
 748       /* Create room for variable-length fields in the INIT_ACK chunk */
 749       alloc_bytes += SCTP_IPV4_ADDRESS_TYPE_LENGTH;
 750     }
 751   if (PREDICT_TRUE (ip6_addr != NULL))
 752     {
 753       /* Create room for variable-length fields in the INIT_ACK chunk */
 754       alloc_bytes += SCTP_IPV6_ADDRESS_TYPE_LENGTH;
 755     }
 756
 757   if (sctp_conn->sub_conn[idx].connection.is_ip4)
 758     alloc_bytes += sizeof (sctp_ipv4_addr_param_t);
 759   else
 760     alloc_bytes += sizeof (sctp_ipv6_addr_param_t);
 761
 762   /* As per RFC 4960 the chunk_length value does NOT contemplate
 763    * the size of the first header (see sctp_header_t) and any padding
 764    */
 765   u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
 766
 767   alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
 768
 769   sctp_init_ack_chunk_t *init_ack_chunk =
 770     vlib_buffer_push_uninit (b, alloc_bytes);
 771
 772   u16 pointer_offset = sizeof (sctp_init_ack_chunk_t);
 773
 774   /* Create State Cookie parameter */
 775   sctp_state_cookie_param_t *state_cookie_param =
 776     (sctp_state_cookie_param_t *) ((char *) init_ack_chunk + pointer_offset);
 777
 778   state_cookie_param->param_hdr.type =
 779     clib_host_to_net_u16 (SCTP_STATE_COOKIE_TYPE);
 780   state_cookie_param->param_hdr.length =
 781     clib_host_to_net_u16 (sizeof (sctp_state_cookie_param_t));
 782   state_cookie_param->creation_time = clib_host_to_net_u64 (sctp_time_now ());
 783   state_cookie_param->cookie_lifespan =
 784     clib_host_to_net_u32 (SCTP_VALID_COOKIE_LIFE);
 785
 786   sctp_compute_mac (sctp_conn, state_cookie_param);
 787
 788   pointer_offset += sizeof (sctp_state_cookie_param_t);
 789
 790   if (PREDICT_TRUE (ip4_addr != NULL))
 791     {
 792       sctp_ipv4_addr_param_t *ipv4_addr =
 793         (sctp_ipv4_addr_param_t *) init_ack_chunk + pointer_offset;
 794
 795       ipv4_addr->param_hdr.type =
 796         clib_host_to_net_u16 (SCTP_IPV4_ADDRESS_TYPE);
 797       ipv4_addr->param_hdr.length =
 798         clib_host_to_net_u16 (SCTP_IPV4_ADDRESS_TYPE_LENGTH);
 799       ipv4_addr->address.as_u32 = ip4_addr->as_u32;
 800
 801       pointer_offset += SCTP_IPV4_ADDRESS_TYPE_LENGTH;
 802     }
 803   if (PREDICT_TRUE (ip6_addr != NULL))
 804     {
 805       sctp_ipv6_addr_param_t *ipv6_addr =
 806         (sctp_ipv6_addr_param_t *) init_ack_chunk + pointer_offset;
 807
 808       ipv6_addr->param_hdr.type =
 809         clib_host_to_net_u16 (SCTP_IPV6_ADDRESS_TYPE);
 810       ipv6_addr->param_hdr.length =
 811         clib_host_to_net_u16 (SCTP_IPV6_ADDRESS_TYPE_LENGTH);
 812       ipv6_addr->address.as_u64[0] = ip6_addr->as_u64[0];
 813       ipv6_addr->address.as_u64[1] = ip6_addr->as_u64[1];
 814
 815       pointer_offset += SCTP_IPV6_ADDRESS_TYPE_LENGTH;
 816     }
 817
 818   if (sctp_conn->sub_conn[idx].connection.is_ip4)
 819     {
 820       ip4_param = (sctp_ipv4_addr_param_t *) init_ack_chunk + pointer_offset;
 821       ip4_param->address.as_u32 =
 822         sctp_conn->sub_conn[idx].connection.lcl_ip.ip4.as_u32;
 823
 824       pointer_offset += sizeof (sctp_ipv4_addr_param_t);
 825     }
 826   else
 827     {
 828       ip6_param = (sctp_ipv6_addr_param_t *) init_ack_chunk + pointer_offset;
 829       ip6_param->address.as_u64[0] =
 830         sctp_conn->sub_conn[idx].connection.lcl_ip.ip6.as_u64[0];
 831       ip6_param->address.as_u64[1] =
 832         sctp_conn->sub_conn[idx].connection.lcl_ip.ip6.as_u64[1];
 833
 834       pointer_offset += sizeof (sctp_ipv6_addr_param_t);
 835     }
 836
 837   /* src_port & dst_port are already in network byte-order */
 838   init_ack_chunk->sctp_hdr.checksum = 0;
 839   init_ack_chunk->sctp_hdr.src_port =
 840     sctp_conn->sub_conn[idx].connection.lcl_port;
 841   init_ack_chunk->sctp_hdr.dst_port =
 842     sctp_conn->sub_conn[idx].connection.rmt_port;
 843   /* the sctp_conn->verification_tag is already in network byte-order (being a copy of the init_tag coming with the INIT chunk) */
 844   init_ack_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
 845   init_ack_chunk->initial_tsn =
 846     clib_host_to_net_u32 (sctp_conn->local_initial_tsn);
 847   SCTP_CONN_TRACKING_DBG ("init_ack_chunk->initial_tsn = %u",
 848                           init_ack_chunk->initial_tsn);
 849
 850   vnet_sctp_set_chunk_type (&init_ack_chunk->chunk_hdr, INIT_ACK);
 851   vnet_sctp_set_chunk_length (&init_ack_chunk->chunk_hdr, chunk_len);
 852
 853   init_ack_chunk->initiate_tag = sctp_conn->local_tag;
 854
 855   init_ack_chunk->a_rwnd =
 856     clib_host_to_net_u32 (sctp_conn->sub_conn[idx].cwnd);
 857   init_ack_chunk->inboud_streams_count =
 858     clib_host_to_net_u16 (INBOUND_STREAMS_COUNT);
 859   init_ack_chunk->outbound_streams_count =
 860     clib_host_to_net_u16 (OUTBOUND_STREAMS_COUNT);
 861
 862   vnet_buffer (b)->sctp.connection_index =
 863     sctp_conn->sub_conn[idx].connection.c_index;
 864   vnet_buffer (b)->sctp.subconn_idx = idx;
 865 }
 866
 867 /**
 868  * Convert buffer to INIT-ACK
 869  */
 870 void
 871 sctp_prepare_initack_chunk (sctp_connection_t * sctp_conn, u8 idx,
 872                             vlib_buffer_t * b, ip4_address_t * ip4_addr,
 873                             u8 add_ip4, ip6_address_t * ip6_addr, u8 add_ip6)
 874 {
 875   vlib_main_t *vm = vlib_get_main ();
 876   sctp_ipv4_addr_param_t *ip4_param = 0;
 877   sctp_ipv6_addr_param_t *ip6_param = 0;
 878   u32 random_seed = random_default_seed ();
 879
 880   sctp_reuse_buffer (vm, b);
 881
 882   /* The minimum size of the message is given by the sctp_init_ack_chunk_t */
 883   u16 alloc_bytes =
 884     sizeof (sctp_init_ack_chunk_t) + sizeof (sctp_state_cookie_param_t);
 885
 886   if (PREDICT_FALSE (add_ip4 == 1))
 887     {
 888       /* Create room for variable-length fields in the INIT_ACK chunk */
 889       alloc_bytes += SCTP_IPV4_ADDRESS_TYPE_LENGTH;
 890     }
 891   if (PREDICT_FALSE (add_ip6 == 1))
 892     {
 893       /* Create room for variable-length fields in the INIT_ACK chunk */
 894       alloc_bytes += SCTP_IPV6_ADDRESS_TYPE_LENGTH;
 895     }
 896
 897   if (sctp_conn->sub_conn[idx].connection.is_ip4)
 898     alloc_bytes += sizeof (sctp_ipv4_addr_param_t);
 899   else
 900     alloc_bytes += sizeof (sctp_ipv6_addr_param_t);
 901
 902   /* As per RFC 4960 the chunk_length value does NOT contemplate
 903    * the size of the first header (see sctp_header_t) and any padding
 904    */
 905   u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
 906
 907   alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
 908
 909   sctp_init_ack_chunk_t *init_ack_chunk =
 910     vlib_buffer_push_uninit (b, alloc_bytes);
 911
 912   u16 pointer_offset = sizeof (sctp_init_ack_chunk_t);
 913
 914   /* Create State Cookie parameter */
 915   sctp_state_cookie_param_t *state_cookie_param =
 916     (sctp_state_cookie_param_t *) ((char *) init_ack_chunk + pointer_offset);
 917
 918   state_cookie_param->param_hdr.type =
 919     clib_host_to_net_u16 (SCTP_STATE_COOKIE_TYPE);
 920   state_cookie_param->param_hdr.length =
 921     clib_host_to_net_u16 (sizeof (sctp_state_cookie_param_t));
 922   state_cookie_param->creation_time = clib_host_to_net_u64 (sctp_time_now ());
 923   state_cookie_param->cookie_lifespan =
 924     clib_host_to_net_u32 (SCTP_VALID_COOKIE_LIFE);
 925
 926   sctp_compute_mac (sctp_conn, state_cookie_param);
 927
 928   pointer_offset += sizeof (sctp_state_cookie_param_t);
 929
 930   if (PREDICT_TRUE (ip4_addr != NULL))
 931     {
 932       sctp_ipv4_addr_param_t *ipv4_addr =
 933         (sctp_ipv4_addr_param_t *) init_ack_chunk + pointer_offset;
 934
 935       ipv4_addr->param_hdr.type =
 936         clib_host_to_net_u16 (SCTP_IPV4_ADDRESS_TYPE);
 937       ipv4_addr->param_hdr.length =
 938         clib_host_to_net_u16 (SCTP_IPV4_ADDRESS_TYPE_LENGTH);
 939       ipv4_addr->address.as_u32 = ip4_addr->as_u32;
 940
 941       pointer_offset += SCTP_IPV4_ADDRESS_TYPE_LENGTH;
 942     }
 943   if (PREDICT_TRUE (ip6_addr != NULL))
 944     {
 945       sctp_ipv6_addr_param_t *ipv6_addr =
 946         (sctp_ipv6_addr_param_t *) init_ack_chunk + pointer_offset;
 947
 948       ipv6_addr->param_hdr.type =
 949         clib_host_to_net_u16 (SCTP_IPV6_ADDRESS_TYPE);
 950       ipv6_addr->param_hdr.length =
 951         clib_host_to_net_u16 (SCTP_IPV6_ADDRESS_TYPE_LENGTH);
 952       ipv6_addr->address.as_u64[0] = ip6_addr->as_u64[0];
 953       ipv6_addr->address.as_u64[1] = ip6_addr->as_u64[1];
 954
 955       pointer_offset += SCTP_IPV6_ADDRESS_TYPE_LENGTH;
 956     }
 957
 958   if (sctp_conn->sub_conn[idx].connection.is_ip4)
 959     {
 960       ip4_param = (sctp_ipv4_addr_param_t *) init_ack_chunk + pointer_offset;
 961       ip4_param->address.as_u32 =
 962         sctp_conn->sub_conn[idx].connection.lcl_ip.ip4.as_u32;
 963
 964       pointer_offset += sizeof (sctp_ipv4_addr_param_t);
 965     }
 966   else
 967     {
 968       ip6_param = (sctp_ipv6_addr_param_t *) init_ack_chunk + pointer_offset;
 969       ip6_param->address.as_u64[0] =
 970         sctp_conn->sub_conn[idx].connection.lcl_ip.ip6.as_u64[0];
 971       ip6_param->address.as_u64[1] =
 972         sctp_conn->sub_conn[idx].connection.lcl_ip.ip6.as_u64[1];
 973
 974       pointer_offset += sizeof (sctp_ipv6_addr_param_t);
 975     }
 976
 977   /* src_port & dst_port are already in network byte-order */
 978   init_ack_chunk->sctp_hdr.checksum = 0;
 979   init_ack_chunk->sctp_hdr.src_port =
 980     sctp_conn->sub_conn[idx].connection.lcl_port;
 981   init_ack_chunk->sctp_hdr.dst_port =
 982     sctp_conn->sub_conn[idx].connection.rmt_port;
 983   /* the sctp_conn->verification_tag is already in network byte-order (being a copy of the init_tag coming with the INIT chunk) */
 984   init_ack_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
 985   init_ack_chunk->initial_tsn =
 986     clib_host_to_net_u32 (sctp_conn->local_initial_tsn);
 987   SCTP_CONN_TRACKING_DBG ("init_ack_chunk->initial_tsn = %u",
 988                           init_ack_chunk->initial_tsn);
 989
 990   vnet_sctp_set_chunk_type (&init_ack_chunk->chunk_hdr, INIT_ACK);
 991   vnet_sctp_set_chunk_length (&init_ack_chunk->chunk_hdr, chunk_len);
 992
 993   init_ack_chunk->initiate_tag =
 994     clib_host_to_net_u32 (random_u32 (&random_seed));
 995
 996   init_ack_chunk->a_rwnd =
 997     clib_host_to_net_u32 (sctp_conn->sub_conn[idx].cwnd);
 998   init_ack_chunk->inboud_streams_count =
 999     clib_host_to_net_u16 (INBOUND_STREAMS_COUNT);
1000   init_ack_chunk->outbound_streams_count =
1001     clib_host_to_net_u16 (OUTBOUND_STREAMS_COUNT);
1002
1003   sctp_conn->local_tag = init_ack_chunk->initiate_tag;
1004
1005   vnet_buffer (b)->sctp.connection_index =
1006     sctp_conn->sub_conn[idx].connection.c_index;
1007   vnet_buffer (b)->sctp.subconn_idx = idx;
1008 }
1009
1010 /**
1011  * Convert buffer to SHUTDOWN
1012  */
1013 void
1014 sctp_prepare_shutdown_chunk (sctp_connection_t * sctp_conn, u8 idx,
1015                              vlib_buffer_t * b)
1016 {
1017   u16 alloc_bytes = sizeof (sctp_shutdown_association_chunk_t);
1018
1019   /* As per RFC 4960 the chunk_length value does NOT contemplate
1020    * the size of the first header (see sctp_header_t) and any padding
1021    */
1022   u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
1023
1024   alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
1025
1026   sctp_shutdown_association_chunk_t *shutdown_chunk =
1027     vlib_buffer_push_uninit (b, alloc_bytes);
1028
1029   shutdown_chunk->sctp_hdr.checksum = 0;
1030   /* No need of host_to_net conversion, already in net-byte order */
1031   shutdown_chunk->sctp_hdr.src_port =
1032     sctp_conn->sub_conn[idx].connection.lcl_port;
1033   shutdown_chunk->sctp_hdr.dst_port =
1034     sctp_conn->sub_conn[idx].connection.rmt_port;
1035   shutdown_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
1036   vnet_sctp_set_chunk_type (&shutdown_chunk->chunk_hdr, SHUTDOWN);
1037   vnet_sctp_set_chunk_length (&shutdown_chunk->chunk_hdr, chunk_len);
1038
1039   shutdown_chunk->cumulative_tsn_ack = sctp_conn->last_rcvd_tsn;
1040
1041   vnet_buffer (b)->sctp.connection_index =
1042     sctp_conn->sub_conn[idx].connection.c_index;
1043   vnet_buffer (b)->sctp.subconn_idx = idx;
1044 }
1045
1046 /*
1047  * Send SHUTDOWN
1048  */
1049 void
1050 sctp_send_shutdown (sctp_connection_t * sctp_conn)
1051 {
1052   vlib_buffer_t *b;
1053   u32 bi;
1054   sctp_main_t *tm = vnet_get_sctp_main ();
1055   vlib_main_t *vm = vlib_get_main ();
1056
1057   if (sctp_check_outstanding_data_chunks (sctp_conn) > 0)
1058     return;
1059
1060   if (PREDICT_FALSE (sctp_get_free_buffer_index (tm, &bi)))
1061     return;
1062
1063   u8 idx = SCTP_PRIMARY_PATH_IDX;
1064
1065   b = vlib_get_buffer (vm, bi);
1066   sctp_init_buffer (vm, b);
1067   sctp_prepare_shutdown_chunk (sctp_conn, idx, b);
1068
1069   sctp_enqueue_to_output_now (vm, b, bi,
1070                               sctp_conn->sub_conn[idx].connection.is_ip4);
1071 }
1072
1073 /**
1074  * Convert buffer to SHUTDOWN_ACK
1075  */
1076 void
1077 sctp_prepare_shutdown_ack_chunk (sctp_connection_t * sctp_conn, u8 idx,
1078                                  vlib_buffer_t * b)
1079 {
1080   u16 alloc_bytes = sizeof (sctp_shutdown_association_chunk_t);
1081   alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
1082
1083   u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
1084
1085   sctp_shutdown_ack_chunk_t *shutdown_ack_chunk =
1086     vlib_buffer_push_uninit (b, alloc_bytes);
1087
1088   shutdown_ack_chunk->sctp_hdr.checksum = 0;
1089   /* No need of host_to_net conversion, already in net-byte order */
1090   shutdown_ack_chunk->sctp_hdr.src_port =
1091     sctp_conn->sub_conn[idx].connection.lcl_port;
1092   shutdown_ack_chunk->sctp_hdr.dst_port =
1093     sctp_conn->sub_conn[idx].connection.rmt_port;
1094   shutdown_ack_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
1095
1096   vnet_sctp_set_chunk_type (&shutdown_ack_chunk->chunk_hdr, SHUTDOWN_ACK);
1097   vnet_sctp_set_chunk_length (&shutdown_ack_chunk->chunk_hdr, chunk_len);
1098
1099   vnet_buffer (b)->sctp.connection_index =
1100     sctp_conn->sub_conn[idx].connection.c_index;
1101   vnet_buffer (b)->sctp.subconn_idx = idx;
1102 }
1103
1104 /*
1105  * Send SHUTDOWN_ACK
1106  */
1107 void
1108 sctp_send_shutdown_ack (sctp_connection_t * sctp_conn, u8 idx,
1109                         vlib_buffer_t * b)
1110 {
1111   vlib_main_t *vm = vlib_get_main ();
1112
1113   if (sctp_check_outstanding_data_chunks (sctp_conn) > 0)
1114     return;
1115
1116   sctp_reuse_buffer (vm, b);
1117
1118   sctp_prepare_shutdown_ack_chunk (sctp_conn, idx, b);
1119 }
1120
1121 /**
1122  * Convert buffer to SACK
1123  */
1124 void
1125 sctp_prepare_sack_chunk (sctp_connection_t * sctp_conn, u8 idx,
1126                          vlib_buffer_t * b)
1127 {
1128   vlib_main_t *vm = vlib_get_main ();
1129
1130   sctp_reuse_buffer (vm, b);
1131
1132   u16 alloc_bytes = sizeof (sctp_selective_ack_chunk_t);
1133
1134   /* As per RFC 4960 the chunk_length value does NOT contemplate
1135    * the size of the first header (see sctp_header_t) and any padding
1136    */
1137   u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
1138
1139   alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
1140
1141   sctp_selective_ack_chunk_t *sack = vlib_buffer_push_uninit (b, alloc_bytes);
1142
1143   sack->sctp_hdr.checksum = 0;
1144   sack->sctp_hdr.src_port = sctp_conn->sub_conn[idx].connection.lcl_port;
1145   sack->sctp_hdr.dst_port = sctp_conn->sub_conn[idx].connection.rmt_port;
1146   sack->sctp_hdr.verification_tag = sctp_conn->remote_tag;
1147   vnet_sctp_set_chunk_type (&sack->chunk_hdr, SACK);
1148   vnet_sctp_set_chunk_length (&sack->chunk_hdr, chunk_len);
1149
1150   sack->cumulative_tsn_ack = sctp_conn->next_tsn_expected;
1151
1152   sctp_conn->ack_state = 0;
1153
1154   vnet_buffer (b)->sctp.connection_index =
1155     sctp_conn->sub_conn[idx].connection.c_index;
1156   vnet_buffer (b)->sctp.subconn_idx = idx;
1157 }
1158
1159 /**
1160  * Convert buffer to HEARTBEAT_ACK
1161  */
1162 void
1163 sctp_prepare_heartbeat_ack_chunk (sctp_connection_t * sctp_conn, u8 idx,
1164                                   vlib_buffer_t * b)
1165 {
1166   vlib_main_t *vm = vlib_get_main ();
1167
1168   u16 alloc_bytes = sizeof (sctp_hb_ack_chunk_t);
1169
1170   sctp_reuse_buffer (vm, b);
1171
1172   /* As per RFC 4960 the chunk_length value does NOT contemplate
1173    * the size of the first header (see sctp_header_t) and any padding
1174    */
1175   u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
1176
1177   alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
1178
1179   sctp_hb_ack_chunk_t *hb_ack = vlib_buffer_push_uninit (b, alloc_bytes);
1180
1181   hb_ack->sctp_hdr.checksum = 0;
1182   /* No need of host_to_net conversion, already in net-byte order */
1183   hb_ack->sctp_hdr.src_port = sctp_conn->sub_conn[idx].connection.lcl_port;
1184   hb_ack->sctp_hdr.dst_port = sctp_conn->sub_conn[idx].connection.rmt_port;
1185   hb_ack->sctp_hdr.verification_tag = sctp_conn->remote_tag;
1186   hb_ack->hb_info.param_hdr.type = clib_host_to_net_u16 (1);
1187   hb_ack->hb_info.param_hdr.length =
1188     clib_host_to_net_u16 (sizeof (hb_ack->hb_info.hb_info));
1189
1190   vnet_sctp_set_chunk_type (&hb_ack->chunk_hdr, HEARTBEAT_ACK);
1191   vnet_sctp_set_chunk_length (&hb_ack->chunk_hdr, chunk_len);
1192
1193   vnet_buffer (b)->sctp.connection_index =
1194     sctp_conn->sub_conn[idx].connection.c_index;
1195   vnet_buffer (b)->sctp.subconn_idx = idx;
1196 }
1197
1198 /**
1199  * Convert buffer to HEARTBEAT
1200  */
1201 void
1202 sctp_prepare_heartbeat_chunk (sctp_connection_t * sctp_conn, u8 idx,
1203                               vlib_buffer_t * b)
1204 {
1205   u16 alloc_bytes = sizeof (sctp_hb_req_chunk_t);
1206
1207   /* As per RFC 4960 the chunk_length value does NOT contemplate
1208    * the size of the first header (see sctp_header_t) and any padding
1209    */
1210   u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
1211
1212   alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
1213
1214   sctp_hb_req_chunk_t *hb_req = vlib_buffer_push_uninit (b, alloc_bytes);
1215
1216   hb_req->sctp_hdr.checksum = 0;
1217   /* No need of host_to_net conversion, already in net-byte order */
1218   hb_req->sctp_hdr.src_port = sctp_conn->sub_conn[idx].connection.lcl_port;
1219   hb_req->sctp_hdr.dst_port = sctp_conn->sub_conn[idx].connection.rmt_port;
1220   hb_req->sctp_hdr.verification_tag = sctp_conn->remote_tag;
1221   hb_req->hb_info.param_hdr.type = clib_host_to_net_u16 (1);
1222   hb_req->hb_info.param_hdr.length =
1223     clib_host_to_net_u16 (sizeof (hb_req->hb_info.hb_info));
1224
1225   vnet_sctp_set_chunk_type (&hb_req->chunk_hdr, HEARTBEAT);
1226   vnet_sctp_set_chunk_length (&hb_req->chunk_hdr, chunk_len);
1227
1228   vnet_buffer (b)->sctp.connection_index =
1229     sctp_conn->sub_conn[idx].connection.c_index;
1230   vnet_buffer (b)->sctp.subconn_idx = idx;
1231 }
1232
1233 void
1234 sctp_send_heartbeat (sctp_connection_t * sctp_conn)
1235 {
1236   vlib_buffer_t *b;
1237   u32 bi;
1238   sctp_main_t *tm = vnet_get_sctp_main ();
1239   vlib_main_t *vm = vlib_get_main ();
1240
1241   u8 i;
1242   u64 now = sctp_time_now ();
1243
1244   for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
1245     {
1246       if (sctp_conn->sub_conn[i].state == SCTP_SUBCONN_STATE_DOWN)
1247         continue;
1248
1249       if (now > (sctp_conn->sub_conn[i].last_seen + SCTP_HB_INTERVAL))
1250         {
1251           if (PREDICT_FALSE (sctp_get_free_buffer_index (tm, &bi)))
1252             return;
1253
1254           b = vlib_get_buffer (vm, bi);
1255           sctp_init_buffer (vm, b);
1256           sctp_prepare_heartbeat_chunk (sctp_conn, i, b);
1257
1258           sctp_enqueue_to_output_now (vm, b, bi,
1259                                       sctp_conn->sub_conn[i].
1260                                       connection.is_ip4);
1261
1262           sctp_conn->sub_conn[i].unacknowledged_hb += 1;
1263         }
1264     }
1265 }
1266
1267 /**
1268  * Convert buffer to SHUTDOWN_COMPLETE
1269  */
1270 void
1271 sctp_prepare_shutdown_complete_chunk (sctp_connection_t * sctp_conn, u8 idx,
1272                                       vlib_buffer_t * b)
1273 {
1274   u16 alloc_bytes = sizeof (sctp_shutdown_association_chunk_t);
1275   alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
1276
1277   u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
1278
1279   sctp_shutdown_complete_chunk_t *shutdown_complete =
1280     vlib_buffer_push_uninit (b, alloc_bytes);
1281
1282   shutdown_complete->sctp_hdr.checksum = 0;
1283   /* No need of host_to_net conversion, already in net-byte order */
1284   shutdown_complete->sctp_hdr.src_port =
1285     sctp_conn->sub_conn[idx].connection.lcl_port;
1286   shutdown_complete->sctp_hdr.dst_port =
1287     sctp_conn->sub_conn[idx].connection.rmt_port;
1288   shutdown_complete->sctp_hdr.verification_tag = sctp_conn->remote_tag;
1289
1290   vnet_sctp_set_chunk_type (&shutdown_complete->chunk_hdr, SHUTDOWN_COMPLETE);
1291   vnet_sctp_set_chunk_length (&shutdown_complete->chunk_hdr, chunk_len);
1292
1293   vnet_buffer (b)->sctp.connection_index =
1294     sctp_conn->sub_conn[idx].connection.c_index;
1295   vnet_buffer (b)->sctp.subconn_idx = idx;
1296 }
1297
1298 void
1299 sctp_send_shutdown_complete (sctp_connection_t * sctp_conn, u8 idx,
1300                              vlib_buffer_t * b0)
1301 {
1302   vlib_main_t *vm = vlib_get_main ();
1303
1304   if (sctp_check_outstanding_data_chunks (sctp_conn) > 0)
1305     return;
1306
1307   sctp_reuse_buffer (vm, b0);
1308
1309   sctp_prepare_shutdown_complete_chunk (sctp_conn, idx, b0);
1310 }
1311
1312 /*
1313  *  Send INIT
1314  */
1315 void
1316 sctp_send_init (sctp_connection_t * sctp_conn)
1317 {
1318   vlib_buffer_t *b;
1319   u32 bi;
1320   sctp_main_t *tm = vnet_get_sctp_main ();
1321   vlib_main_t *vm = vlib_get_main ();
1322
1323   if (PREDICT_FALSE (sctp_conn->init_retransmit_err > SCTP_MAX_INIT_RETRANS))
1324     {
1325       clib_warning ("Reached MAX_INIT_RETRANS times. Aborting connection.");
1326
1327       session_stream_connect_notify (&sctp_conn->sub_conn
1328                                      [SCTP_PRIMARY_PATH_IDX].connection, 1);
1329
1330       sctp_connection_timers_reset (sctp_conn);
1331
1332       sctp_connection_cleanup (sctp_conn);
1333
1334       return;
1335     }
1336
1337   if (PREDICT_FALSE (sctp_get_free_buffer_index (tm, &bi)))
1338     return;
1339
1340   b = vlib_get_buffer (vm, bi);
1341   u8 idx = SCTP_PRIMARY_PATH_IDX;
1342
1343   sctp_init_buffer (vm, b);
1344   sctp_prepare_init_chunk (sctp_conn, idx, b);
1345
1346   sctp_push_ip_hdr (tm, &sctp_conn->sub_conn[idx], b);
1347   sctp_enqueue_to_ip_lookup (vm, b, bi, sctp_conn->sub_conn[idx].c_is_ip4,
1348                              sctp_conn->sub_conn[idx].c_fib_index);
1349
1350   /* Start the T1_INIT timer */
1351   sctp_timer_set (sctp_conn, idx, SCTP_TIMER_T1_INIT,
1352                   sctp_conn->sub_conn[idx].RTO);
1353
1354   /* Change state to COOKIE_WAIT */
1355   sctp_conn->state = SCTP_STATE_COOKIE_WAIT;
1356
1357   /* Measure RTT with this */
1358   sctp_conn->sub_conn[idx].rtt_ts = sctp_time_now ();
1359 }
1360
1361 /**
1362  * Push SCTP header and update connection variables
1363  */
1364 static void
1365 sctp_push_hdr_i (sctp_connection_t * sctp_conn, vlib_buffer_t * b,
1366                  sctp_state_t next_state)
1367 {
1368   u16 data_len =
1369     b->current_length + b->total_length_not_including_first_buffer;
1370   ASSERT (!b->total_length_not_including_first_buffer
1371           || (b->flags & VLIB_BUFFER_NEXT_PRESENT));
1372
1373   SCTP_ADV_DBG_OUTPUT ("b->current_length = %u, "
1374                        "b->current_data = %p "
1375                        "data_len = %u",
1376                        b->current_length, b->current_data, data_len);
1377
1378   u16 bytes_to_add = sizeof (sctp_payload_data_chunk_t);
1379   u16 chunk_length = data_len + bytes_to_add - sizeof (sctp_header_t);
1380
1381   sctp_payload_data_chunk_t *data_chunk =
1382     vlib_buffer_push_uninit (b, bytes_to_add);
1383
1384   u8 idx = sctp_data_subconn_select (sctp_conn);
1385   SCTP_DBG_OUTPUT
1386     ("SCTP_CONN = %p, IDX = %u, S_INDEX = %u, C_INDEX = %u, sctp_conn->[...].LCL_PORT = %u, sctp_conn->[...].RMT_PORT = %u",
1387      sctp_conn, idx, sctp_conn->sub_conn[idx].connection.s_index,
1388      sctp_conn->sub_conn[idx].connection.c_index,
1389      sctp_conn->sub_conn[idx].connection.lcl_port,
1390      sctp_conn->sub_conn[idx].connection.rmt_port);
1391   data_chunk->sctp_hdr.checksum = 0;
1392   data_chunk->sctp_hdr.src_port =
1393     sctp_conn->sub_conn[idx].connection.lcl_port;
1394   data_chunk->sctp_hdr.dst_port =
1395     sctp_conn->sub_conn[idx].connection.rmt_port;
1396   data_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
1397
1398   data_chunk->tsn = clib_host_to_net_u32 (sctp_conn->next_tsn);
1399   data_chunk->stream_id = clib_host_to_net_u16 (0);
1400   data_chunk->stream_seq = clib_host_to_net_u16 (0);
1401
1402   vnet_sctp_set_chunk_type (&data_chunk->chunk_hdr, DATA);
1403   vnet_sctp_set_chunk_length (&data_chunk->chunk_hdr, chunk_length);
1404
1405   vnet_sctp_set_bbit (&data_chunk->chunk_hdr);
1406   vnet_sctp_set_ebit (&data_chunk->chunk_hdr);
1407
1408   SCTP_ADV_DBG_OUTPUT ("POINTER_WITH_DATA = %p, DATA_OFFSET = %u",
1409                        b->data, b->current_data);
1410
1411   if (sctp_conn->sub_conn[idx].state != SCTP_SUBCONN_AWAITING_SACK)
1412     {
1413       sctp_conn->sub_conn[idx].state = SCTP_SUBCONN_AWAITING_SACK;
1414       sctp_conn->last_unacked_tsn = sctp_conn->next_tsn;
1415     }
1416
1417   sctp_conn->next_tsn += data_len;
1418
1419   u32 inflight = sctp_conn->next_tsn - sctp_conn->last_unacked_tsn;
1420   /* Section 7.2.2; point (3) */
1421   if (sctp_conn->sub_conn[idx].partially_acked_bytes >=
1422       sctp_conn->sub_conn[idx].cwnd
1423       && inflight >= sctp_conn->sub_conn[idx].cwnd)
1424     {
1425       sctp_conn->sub_conn[idx].cwnd += sctp_conn->sub_conn[idx].PMTU;
1426       sctp_conn->sub_conn[idx].partially_acked_bytes -=
1427         sctp_conn->sub_conn[idx].cwnd;
1428     }
1429
1430   sctp_conn->sub_conn[idx].last_data_ts = sctp_time_now ();
1431
1432   vnet_buffer (b)->sctp.connection_index =
1433     sctp_conn->sub_conn[idx].connection.c_index;
1434
1435   vnet_buffer (b)->sctp.subconn_idx = idx;
1436 }
1437
1438 u32
1439 sctp_push_header (transport_connection_t * trans_conn, vlib_buffer_t * b)
1440 {
1441   sctp_connection_t *sctp_conn =
1442     sctp_get_connection_from_transport (trans_conn);
1443
1444   SCTP_DBG_OUTPUT ("TRANS_CONN = %p, SCTP_CONN = %p, "
1445                    "S_INDEX = %u, C_INDEX = %u,"
1446                    "trans_conn->LCL_PORT = %u, trans_conn->RMT_PORT = %u",
1447                    trans_conn,
1448                    sctp_conn,
1449                    trans_conn->s_index,
1450                    trans_conn->c_index,
1451                    trans_conn->lcl_port, trans_conn->rmt_port);
1452
1453   sctp_push_hdr_i (sctp_conn, b, SCTP_STATE_ESTABLISHED);
1454
1455   sctp_trajectory_add_start (b, 3);
1456
1457   return 0;
1458 }
1459
1460 u32
1461 sctp_prepare_data_retransmit (sctp_connection_t * sctp_conn,
1462                               u8 idx,
1463                               u32 offset,
1464                               u32 max_deq_bytes, vlib_buffer_t ** b)
1465 {
1466   sctp_main_t *tm = vnet_get_sctp_main ();
1467   vlib_main_t *vm = vlib_get_main ();
1468   int n_bytes = 0;
1469   u32 bi, available_bytes, seg_size;
1470   u8 *data;
1471
1472   ASSERT (sctp_conn->state >= SCTP_STATE_ESTABLISHED);
1473   ASSERT (max_deq_bytes != 0);
1474
1475   /*
1476    * Make sure we can retransmit something
1477    */
1478   available_bytes =
1479     session_tx_fifo_max_dequeue (&sctp_conn->sub_conn[idx].connection);
1480   ASSERT (available_bytes >= offset);
1481   available_bytes -= offset;
1482   if (!available_bytes)
1483     return 0;
1484   max_deq_bytes = clib_min (sctp_conn->sub_conn[idx].cwnd, max_deq_bytes);
1485   max_deq_bytes = clib_min (available_bytes, max_deq_bytes);
1486
1487   seg_size = max_deq_bytes;
1488
1489   /*
1490    * Allocate and fill in buffer(s)
1491    */
1492
1493   if (PREDICT_FALSE (sctp_get_free_buffer_index (tm, &bi)))
1494     return 0;
1495   *b = vlib_get_buffer (vm, bi);
1496   data = sctp_init_buffer (vm, *b);
1497
1498   /* Easy case, buffer size greater than mss */
1499   if (PREDICT_TRUE (seg_size <= tm->bytes_per_buffer))
1500     {
1501       n_bytes =
1502         stream_session_peek_bytes (&sctp_conn->sub_conn[idx].connection, data,
1503                                    offset, max_deq_bytes);
1504       ASSERT (n_bytes == max_deq_bytes);
1505       b[0]->current_length = n_bytes;
1506       sctp_push_hdr_i (sctp_conn, *b, sctp_conn->state);
1507     }
1508
1509   return n_bytes;
1510 }
1511
1512 void
1513 sctp_data_retransmit (sctp_connection_t * sctp_conn)
1514 {
1515   vlib_main_t *vm = vlib_get_main ();
1516   vlib_buffer_t *b = 0;
1517   u32 bi, n_bytes = 0;
1518
1519   u8 idx = sctp_data_subconn_select (sctp_conn);
1520
1521   SCTP_DBG_OUTPUT
1522     ("SCTP_CONN = %p, IDX = %u, S_INDEX = %u, C_INDEX = %u, sctp_conn->[...].LCL_PORT = %u, sctp_conn->[...].RMT_PORT = %u",
1523      sctp_conn, idx, sctp_conn->sub_conn[idx].connection.s_index,
1524      sctp_conn->sub_conn[idx].connection.c_index,
1525      sctp_conn->sub_conn[idx].connection.lcl_port,
1526      sctp_conn->sub_conn[idx].connection.rmt_port);
1527
1528   if (sctp_conn->state >= SCTP_STATE_ESTABLISHED)
1529     {
1530       return;
1531     }
1532
1533   n_bytes =
1534     sctp_prepare_data_retransmit (sctp_conn, idx, 0,
1535                                   sctp_conn->sub_conn[idx].cwnd, &b);
1536   if (n_bytes > 0)
1537     SCTP_DBG_OUTPUT ("We have data (%u bytes) to retransmit", n_bytes);
1538
1539   bi = vlib_get_buffer_index (vm, b);
1540
1541   sctp_enqueue_to_output_now (vm, b, bi,
1542                               sctp_conn->sub_conn[idx].connection.is_ip4);
1543
1544   return;
1545 }
1546
1547 #if SCTP_DEBUG_STATE_MACHINE
1548 always_inline u8
1549 sctp_validate_output_state_machine (sctp_connection_t * sctp_conn,
1550                                     u8 chunk_type)
1551 {
1552   u8 result = 0;
1553   switch (sctp_conn->state)
1554     {
1555     case SCTP_STATE_CLOSED:
1556       if (chunk_type != INIT && chunk_type != INIT_ACK)
1557         result = 1;
1558       break;
1559     case SCTP_STATE_ESTABLISHED:
1560       if (chunk_type != DATA && chunk_type != HEARTBEAT &&
1561           chunk_type != HEARTBEAT_ACK && chunk_type != SACK &&
1562           chunk_type != COOKIE_ACK && chunk_type != SHUTDOWN)
1563         result = 1;
1564       break;
1565     case SCTP_STATE_COOKIE_WAIT:
1566       if (chunk_type != COOKIE_ECHO)
1567         result = 1;
1568       break;
1569     case SCTP_STATE_SHUTDOWN_SENT:
1570       if (chunk_type != SHUTDOWN_COMPLETE)
1571         result = 1;
1572       break;
1573     case SCTP_STATE_SHUTDOWN_RECEIVED:
1574       if (chunk_type != SHUTDOWN_ACK)
1575         result = 1;
1576       break;
1577     }
1578   return result;
1579 }
1580 #endif
1581
1582 always_inline u8
1583 sctp_is_retransmitting (sctp_connection_t * sctp_conn, u8 idx)
1584 {
1585   return sctp_conn->sub_conn[idx].is_retransmitting;
1586 }
1587
1588 always_inline uword
1589 sctp46_output_inline (vlib_main_t * vm,
1590                       vlib_node_runtime_t * node,
1591                       vlib_frame_t * from_frame, int is_ip4)
1592 {
1593   u32 n_left_from, next_index, *from, *to_next;
1594   u32 my_thread_index = vm->thread_index;
1595
1596   from = vlib_frame_vector_args (from_frame);
1597   n_left_from = from_frame->n_vectors;
1598   next_index = node->cached_next_index;
1599   sctp_set_time_now (my_thread_index);
1600
1601   while (n_left_from > 0)
1602     {
1603       u32 n_left_to_next;
1604
1605       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1606
1607       while (n_left_from > 0 && n_left_to_next > 0)
1608         {
1609           u32 bi0;
1610           vlib_buffer_t *b0;
1611           sctp_header_t *sctp_hdr = 0;
1612           sctp_connection_t *sctp_conn;
1613           sctp_tx_trace_t *t0;
1614           sctp_header_t *th0 = 0;
1615           u32 error0 = SCTP_ERROR_PKTS_SENT, next0 =
1616             SCTP_OUTPUT_NEXT_IP_LOOKUP;
1617
1618 #if SCTP_DEBUG_STATE_MACHINE
1619           u16 packet_length = 0;
1620 #endif
1621
1622           bi0 = from[0];
1623           to_next[0] = bi0;
1624           from += 1;
1625           to_next += 1;
1626           n_left_from -= 1;
1627           n_left_to_next -= 1;
1628
1629           b0 = vlib_get_buffer (vm, bi0);
1630
1631           sctp_conn =
1632             sctp_connection_get (vnet_buffer (b0)->sctp.connection_index,
1633                                  my_thread_index);
1634
1635           if (PREDICT_FALSE (sctp_conn == 0))
1636             {
1637               error0 = SCTP_ERROR_INVALID_CONNECTION;
1638               next0 = SCTP_OUTPUT_NEXT_DROP;
1639               goto done;
1640             }
1641
1642           u8 idx = vnet_buffer (b0)->sctp.subconn_idx;
1643
1644           th0 = vlib_buffer_get_current (b0);
1645
1646           if (is_ip4)
1647             {
1648               ip4_header_t *iph4 = vlib_buffer_push_ip4 (vm,
1649                                                          b0,
1650                                                          &sctp_conn->sub_conn
1651                                                          [idx].connection.
1652                                                          lcl_ip.ip4,
1653                                                          &sctp_conn->
1654                                                          sub_conn
1655                                                          [idx].connection.
1656                                                          rmt_ip.ip4,
1657                                                          IP_PROTOCOL_SCTP, 1);
1658
1659               u32 checksum = ip4_sctp_compute_checksum (vm, b0, iph4);
1660
1661               sctp_hdr = ip4_next_header (iph4);
1662               sctp_hdr->checksum = checksum;
1663
1664               vnet_buffer (b0)->l4_hdr_offset = (u8 *) th0 - b0->data;
1665
1666 #if SCTP_DEBUG_STATE_MACHINE
1667               packet_length = clib_net_to_host_u16 (iph4->length);
1668 #endif
1669             }
1670           else
1671             {
1672               ip6_header_t *iph6 = vlib_buffer_push_ip6 (vm,
1673                                                          b0,
1674                                                          &sctp_conn->sub_conn
1675                                                          [idx].
1676                                                          connection.lcl_ip.
1677                                                          ip6,
1678                                                          &sctp_conn->sub_conn
1679                                                          [idx].
1680                                                          connection.rmt_ip.
1681                                                          ip6,
1682                                                          IP_PROTOCOL_SCTP);
1683
1684               int bogus = ~0;
1685               u32 checksum = ip6_sctp_compute_checksum (vm, b0, iph6, &bogus);
1686               ASSERT (!bogus);
1687
1688               sctp_hdr = ip6_next_header (iph6);
1689               sctp_hdr->checksum = checksum;
1690
1691               vnet_buffer (b0)->l3_hdr_offset = (u8 *) iph6 - b0->data;
1692               vnet_buffer (b0)->l4_hdr_offset = (u8 *) th0 - b0->data;
1693
1694 #if SCTP_DEBUG_STATE_MACHINE
1695               packet_length = clib_net_to_host_u16 (iph6->payload_length);
1696 #endif
1697             }
1698
1699           sctp_full_hdr_t *full_hdr = (sctp_full_hdr_t *) sctp_hdr;
1700           u8 chunk_type = vnet_sctp_get_chunk_type (&full_hdr->common_hdr);
1701           if (chunk_type >= UNKNOWN)
1702             {
1703               clib_warning
1704                 ("Trying to send an unrecognized chunk... something is really bad.");
1705               error0 = SCTP_ERROR_UNKNOWN_CHUNK;
1706               next0 = SCTP_OUTPUT_NEXT_DROP;
1707               goto done;
1708             }
1709
1710 #if SCTP_DEBUG_STATE_MACHINE
1711           u8 is_valid =
1712             (sctp_conn->sub_conn[idx].connection.lcl_port ==
1713              sctp_hdr->src_port
1714              || sctp_conn->sub_conn[idx].connection.lcl_port ==
1715              sctp_hdr->dst_port)
1716             && (sctp_conn->sub_conn[idx].connection.rmt_port ==
1717                 sctp_hdr->dst_port
1718                 || sctp_conn->sub_conn[idx].connection.rmt_port ==
1719                 sctp_hdr->src_port);
1720
1721           if (!is_valid)
1722             {
1723               SCTP_DBG_STATE_MACHINE ("BUFFER IS INCORRECT: conn_index = %u, "
1724                                       "packet_length = %u, "
1725                                       "chunk_type = %u [%s], "
1726                                       "connection.lcl_port = %u, sctp_hdr->src_port = %u, "
1727                                       "connection.rmt_port = %u, sctp_hdr->dst_port = %u",
1728                                       sctp_conn->sub_conn[idx].
1729                                       connection.c_index, packet_length,
1730                                       chunk_type,
1731                                       sctp_chunk_to_string (chunk_type),
1732                                       sctp_conn->sub_conn[idx].
1733                                       connection.lcl_port, sctp_hdr->src_port,
1734                                       sctp_conn->sub_conn[idx].
1735                                       connection.rmt_port,
1736                                       sctp_hdr->dst_port);
1737
1738               error0 = SCTP_ERROR_UNKNOWN_CHUNK;
1739               next0 = SCTP_OUTPUT_NEXT_DROP;
1740               goto done;
1741             }
1742 #endif
1743           SCTP_DBG_STATE_MACHINE
1744             ("SESSION_INDEX = %u, CONN_INDEX = %u, CURR_CONN_STATE = %u (%s), "
1745              "CHUNK_TYPE = %s, " "SRC_PORT = %u, DST_PORT = %u",
1746              sctp_conn->sub_conn[idx].connection.s_index,
1747              sctp_conn->sub_conn[idx].connection.c_index,
1748              sctp_conn->state, sctp_state_to_string (sctp_conn->state),
1749              sctp_chunk_to_string (chunk_type), full_hdr->hdr.src_port,
1750              full_hdr->hdr.dst_port);
1751
1752           /* Let's make sure the state-machine does not send anything crazy */
1753 #if SCTP_DEBUG_STATE_MACHINE
1754           if (sctp_validate_output_state_machine (sctp_conn, chunk_type) != 0)
1755             {
1756               SCTP_DBG_STATE_MACHINE
1757                 ("Sending the wrong chunk (%s) based on state-machine status (%s)",
1758                  sctp_chunk_to_string (chunk_type),
1759                  sctp_state_to_string (sctp_conn->state));
1760
1761               error0 = SCTP_ERROR_UNKNOWN_CHUNK;
1762               next0 = SCTP_OUTPUT_NEXT_DROP;
1763               goto done;
1764
1765             }
1766 #endif
1767
1768           /* Karn's algorithm: RTT measurements MUST NOT be made using
1769            * packets that were retransmitted
1770            */
1771           if (!sctp_is_retransmitting (sctp_conn, idx))
1772             {
1773               /* Measure RTT with this */
1774               if (chunk_type == DATA
1775                   && sctp_conn->sub_conn[idx].RTO_pending == 0)
1776                 {
1777                   sctp_conn->sub_conn[idx].RTO_pending = 1;
1778                   sctp_conn->sub_conn[idx].rtt_ts = sctp_time_now ();
1779                 }
1780               else
1781                 sctp_conn->sub_conn[idx].rtt_ts = sctp_time_now ();
1782             }
1783
1784           /* Let's take care of TIMERS */
1785           switch (chunk_type)
1786             {
1787             case COOKIE_ECHO:
1788               {
1789                 sctp_conn->state = SCTP_STATE_COOKIE_ECHOED;
1790                 break;
1791               }
1792             case DATA:
1793               {
1794                 SCTP_ADV_DBG_OUTPUT ("PACKET_LENGTH = %u", packet_length);
1795
1796                 sctp_timer_update (sctp_conn, idx, SCTP_TIMER_T3_RXTX,
1797                                    sctp_conn->sub_conn[idx].RTO);
1798                 break;
1799               }
1800             case SHUTDOWN:
1801               {
1802                 /* Start the SCTP_TIMER_T2_SHUTDOWN timer */
1803                 sctp_timer_set (sctp_conn, idx, SCTP_TIMER_T2_SHUTDOWN,
1804                                 sctp_conn->sub_conn[idx].RTO);
1805                 sctp_conn->state = SCTP_STATE_SHUTDOWN_SENT;
1806                 break;
1807               }
1808             case SHUTDOWN_ACK:
1809               {
1810                 /* Start the SCTP_TIMER_T2_SHUTDOWN timer */
1811                 sctp_timer_set (sctp_conn, idx, SCTP_TIMER_T2_SHUTDOWN,
1812                                 sctp_conn->sub_conn[idx].RTO);
1813                 sctp_conn->state = SCTP_STATE_SHUTDOWN_ACK_SENT;
1814                 break;
1815               }
1816             case SHUTDOWN_COMPLETE:
1817               {
1818                 sctp_conn->state = SCTP_STATE_CLOSED;
1819                 break;
1820               }
1821             }
1822
1823           vnet_buffer (b0)->sw_if_index[VLIB_RX] = 0;
1824           vnet_buffer (b0)->sw_if_index[VLIB_TX] =
1825             sctp_conn->sub_conn[idx].c_fib_index;
1826
1827           b0->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
1828
1829           SCTP_DBG_STATE_MACHINE
1830             ("SESSION_INDEX = %u, CONNECTION_INDEX = %u, " "NEW_STATE = %s, "
1831              "CHUNK_SENT = %s", sctp_conn->sub_conn[idx].connection.s_index,
1832              sctp_conn->sub_conn[idx].connection.c_index,
1833              sctp_state_to_string (sctp_conn->state),
1834              sctp_chunk_to_string (chunk_type));
1835
1836           vnet_sctp_common_hdr_params_host_to_net (&full_hdr->common_hdr);
1837
1838         done:
1839           b0->error = node->errors[error0];
1840           if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
1841             {
1842               t0 = vlib_add_trace (vm, node, b0, sizeof (*t0));
1843               if (th0)
1844                 {
1845                   clib_memcpy (&t0->sctp_header, th0,
1846                                sizeof (t0->sctp_header));
1847                 }
1848               else
1849                 {
1850                   memset (&t0->sctp_header, 0, sizeof (t0->sctp_header));
1851                 }
1852               clib_memcpy (&t0->sctp_connection, sctp_conn,
1853                            sizeof (t0->sctp_connection));
1854             }
1855
1856           vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1857                                            n_left_to_next, bi0, next0);
1858         }
1859
1860       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1861     }
1862
1863   return from_frame->n_vectors;
1864 }
1865
1866 static uword
1867 sctp4_output (vlib_main_t * vm, vlib_node_runtime_t * node,
1868               vlib_frame_t * from_frame)
1869 {
1870   return sctp46_output_inline (vm, node, from_frame, 1 /* is_ip4 */ );
1871 }
1872
1873 static uword
1874 sctp6_output (vlib_main_t * vm, vlib_node_runtime_t * node,
1875               vlib_frame_t * from_frame)
1876 {
1877   return sctp46_output_inline (vm, node, from_frame, 0 /* is_ip4 */ );
1878 }
1879
1880 /* *INDENT-OFF* */
1881 VLIB_REGISTER_NODE (sctp4_output_node) =
1882 {
1883   .function = sctp4_output,.name = "sctp4-output",
1884     /* Takes a vector of packets. */
1885     .vector_size = sizeof (u32),
1886     .n_errors = SCTP_N_ERROR,
1887     .error_strings = sctp_error_strings,
1888     .n_next_nodes = SCTP_OUTPUT_N_NEXT,
1889     .next_nodes = {
1890 #define _(s,n) [SCTP_OUTPUT_NEXT_##s] = n,
1891     foreach_sctp4_output_next
1892 #undef _
1893     },
1894     .format_buffer = format_sctp_header,
1895     .format_trace = format_sctp_tx_trace,
1896 };
1897 /* *INDENT-ON* */
1898
1899 VLIB_NODE_FUNCTION_MULTIARCH (sctp4_output_node, sctp4_output);
1900
1901 /* *INDENT-OFF* */
1902 VLIB_REGISTER_NODE (sctp6_output_node) =
1903 {
1904   .function = sctp6_output,
1905   .name = "sctp6-output",
1906     /* Takes a vector of packets. */
1907   .vector_size = sizeof (u32),
1908   .n_errors = SCTP_N_ERROR,
1909   .error_strings = sctp_error_strings,
1910   .n_next_nodes = SCTP_OUTPUT_N_NEXT,
1911   .next_nodes = {
1912 #define _(s,n) [SCTP_OUTPUT_NEXT_##s] = n,
1913     foreach_sctp6_output_next
1914 #undef _
1915   },
1916   .format_buffer = format_sctp_header,
1917   .format_trace = format_sctp_tx_trace,
1918 };
1919 /* *INDENT-ON* */
1920
1921 VLIB_NODE_FUNCTION_MULTIARCH (sctp6_output_node, sctp6_output);
1922
1923 /*
1924  * fd.io coding-style-patch-verification: ON
1925  *
1926  * Local Variables:
1927  * eval: (c-set-style "gnu")
1928  * End:
1929  */