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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
15 #include <vnet/sctp/sctp.h>
16 #include <vnet/sctp/sctp_debug.h>
17 #include <vppinfra/random.h>
18 #include <openssl/hmac.h>
20 vlib_node_registration_t sctp4_output_node;
21 vlib_node_registration_t sctp6_output_node;
23 typedef enum _sctp_output_next
25 SCTP_OUTPUT_NEXT_DROP,
26 SCTP_OUTPUT_NEXT_IP_LOOKUP,
30 #define foreach_sctp4_output_next \
31 _ (DROP, "error-drop") \
32 _ (IP_LOOKUP, "ip4-lookup")
34 #define foreach_sctp6_output_next \
35 _ (DROP, "error-drop") \
36 _ (IP_LOOKUP, "ip6-lookup")
38 static char *sctp_error_strings[] = {
39 #define sctp_error(n,s) s,
40 #include <vnet/sctp/sctp_error.def>
46 sctp_header_t sctp_header;
47 sctp_connection_t sctp_connection;
51 * Flush tx frame populated by retransmits and timer pops
54 sctp_flush_frame_to_output (vlib_main_t * vm, u8 thread_index, u8 is_ip4)
56 if (sctp_main.tx_frames[!is_ip4][thread_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;
67 * Flush ip lookup tx frames populated by timer pops
70 sctp_flush_frame_to_ip_lookup (vlib_main_t * vm, u8 thread_index, u8 is_ip4)
72 if (sctp_main.ip_lookup_tx_frames[!is_ip4][thread_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]
79 sctp_main.ip_lookup_tx_frames[!is_ip4][thread_index] = 0;
84 * Flush v4 and v6 sctp and ip-lookup tx frames for thread index
87 sctp_flush_frames_to_output (u8 thread_index)
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);
97 ip4_sctp_compute_checksum (vlib_main_t * vm, vlib_buffer_t * p0,
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;
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;
110 clib_host_to_net_u32 (payload_length_host_byte_order +
111 (ip0->protocol << 16));
113 if (BITS (uword) == 32)
116 ip_csum_with_carry (checksum,
117 clib_mem_unaligned (&ip0->src_address, u32));
119 ip_csum_with_carry (checksum,
120 clib_mem_unaligned (&ip0->dst_address, u32));
124 ip_csum_with_carry (checksum,
125 clib_mem_unaligned (&ip0->src_address, u64));
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)
133 n_this_buffer = n_ip_bytes_this_buffer > ip_header_length ?
134 n_ip_bytes_this_buffer - ip_header_length : 0;
139 ip_incremental_checksum (checksum, data_this_buffer, n_this_buffer);
140 n_bytes_left -= n_this_buffer;
141 if (n_bytes_left == 0)
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;
154 ip6_sctp_compute_checksum (vlib_main_t * vm, vlib_buffer_t * p0,
155 ip6_header_t * ip0, int *bogus_lengthp)
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;
163 ASSERT (bogus_lengthp);
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);
171 for (i = 0; i < ARRAY_LEN (ip0->src_address.as_uword); i++)
173 checksum = ip_csum_with_carry (checksum,
174 clib_mem_unaligned (&ip0->
178 ip_csum_with_carry (checksum,
179 clib_mem_unaligned (&ip0->dst_address.as_uword[i],
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))
188 ip6_hop_by_hop_ext_t *ext_hdr =
189 (ip6_hop_by_hop_ext_t *) data_this_buffer;
191 /* validate really icmp6 next */
192 ASSERT ((ext_hdr->next_hdr == IP_PROTOCOL_SCTP));
194 skip_bytes = 8 * (1 + ext_hdr->n_data_u64s);
195 data_this_buffer = (void *) ((u8 *) data_this_buffer + skip_bytes);
197 payload_length_host_byte_order -= skip_bytes;
198 headers_size += skip_bytes;
201 n_bytes_left = n_this_buffer = payload_length_host_byte_order;
202 if (p0 && n_this_buffer + headers_size > p0->current_length)
205 headers_size ? p0->current_length - headers_size : 0;
209 ip_incremental_checksum (checksum, data_this_buffer, n_this_buffer);
210 n_bytes_left -= n_this_buffer;
211 if (n_bytes_left == 0)
214 if (!(p0->flags & VLIB_BUFFER_NEXT_PRESENT))
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;
228 sctp_push_ip_hdr (sctp_main_t * tm, sctp_sub_connection_t * sctp_sub_conn,
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)
236 ih = vlib_buffer_push_ip4 (vm, b, &sctp_sub_conn->c_lcl_ip4,
237 &sctp_sub_conn->c_rmt_ip4, IP_PROTOCOL_SCTP,
239 th->checksum = ip4_sctp_compute_checksum (vm, b, ih);
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);
254 sctp_reuse_buffer (vlib_main_t * vm, vlib_buffer_t * b)
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;
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;
266 /* Leave enough space for headers */
267 return vlib_buffer_make_headroom (b, TRANSPORT_MAX_HDRS_LEN);
271 sctp_init_buffer (vlib_main_t * vm, vlib_buffer_t * b)
273 ASSERT ((b->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
274 b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
275 b->total_length_not_including_first_buffer = 0;
276 vnet_buffer (b)->sctp.flags = 0;
277 vnet_buffer (b)->sctp.subconn_idx = MAX_SCTP_CONNECTIONS;
278 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b);
279 /* Leave enough space for headers */
280 return vlib_buffer_make_headroom (b, TRANSPORT_MAX_HDRS_LEN);
284 sctp_alloc_tx_buffers (sctp_main_t * tm, u8 thread_index, u32 n_free_buffers)
286 vlib_main_t *vm = vlib_get_main ();
287 u32 current_length = vec_len (tm->tx_buffers[thread_index]);
290 vec_validate (tm->tx_buffers[thread_index],
291 current_length + n_free_buffers - 1);
293 vlib_buffer_alloc (vm, &tm->tx_buffers[thread_index][current_length],
295 _vec_len (tm->tx_buffers[thread_index]) = current_length + n_allocated;
296 /* buffer shortage, report failure */
297 if (vec_len (tm->tx_buffers[thread_index]) == 0)
299 clib_warning ("out of buffers");
306 sctp_get_free_buffer_index (sctp_main_t * tm, u32 * bidx)
309 u32 thread_index = vlib_get_thread_index ();
310 if (PREDICT_FALSE (vec_len (tm->tx_buffers[thread_index]) == 0))
312 if (sctp_alloc_tx_buffers (tm, thread_index, VLIB_FRAME_SIZE))
315 my_tx_buffers = tm->tx_buffers[thread_index];
316 *bidx = my_tx_buffers[vec_len (my_tx_buffers) - 1];
317 _vec_len (my_tx_buffers) -= 1;
322 sctp_enqueue_to_output_i (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
325 sctp_main_t *tm = vnet_get_sctp_main ();
326 u32 thread_index = vlib_get_thread_index ();
327 u32 *to_next, next_index;
330 b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
333 /* Decide where to send the packet */
334 next_index = is_ip4 ? sctp4_output_node.index : sctp6_output_node.index;
335 sctp_trajectory_add_start (b, 2);
337 /* Get frame to v4/6 output node */
338 f = tm->tx_frames[!is_ip4][thread_index];
341 f = vlib_get_frame_to_node (vm, next_index);
343 tm->tx_frames[!is_ip4][thread_index] = f;
345 to_next = vlib_frame_vector_args (f);
346 to_next[f->n_vectors] = bi;
348 if (flush || f->n_vectors == VLIB_FRAME_SIZE)
350 vlib_put_frame_to_node (vm, next_index, f);
351 tm->tx_frames[!is_ip4][thread_index] = 0;
356 sctp_enqueue_to_output_now (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
359 sctp_enqueue_to_output_i (vm, b, bi, is_ip4, 1);
363 sctp_enqueue_to_ip_lookup_i (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
364 u8 is_ip4, u32 fib_index, u8 flush)
366 sctp_main_t *tm = vnet_get_sctp_main ();
367 u32 thread_index = vlib_get_thread_index ();
368 u32 *to_next, next_index;
371 b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
374 vnet_buffer (b)->sw_if_index[VLIB_TX] = fib_index;
375 vnet_buffer (b)->sw_if_index[VLIB_RX] = 0;
377 /* Send to IP lookup */
378 next_index = is_ip4 ? ip4_lookup_node.index : ip6_lookup_node.index;
379 if (VLIB_BUFFER_TRACE_TRAJECTORY > 0)
382 b->pre_data[1] = next_index;
385 f = tm->ip_lookup_tx_frames[!is_ip4][thread_index];
388 f = vlib_get_frame_to_node (vm, next_index);
390 tm->ip_lookup_tx_frames[!is_ip4][thread_index] = f;
393 to_next = vlib_frame_vector_args (f);
394 to_next[f->n_vectors] = bi;
396 if (flush || f->n_vectors == VLIB_FRAME_SIZE)
398 vlib_put_frame_to_node (vm, next_index, f);
399 tm->ip_lookup_tx_frames[!is_ip4][thread_index] = 0;
404 sctp_enqueue_to_ip_lookup (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
405 u8 is_ip4, u32 fib_index)
407 sctp_enqueue_to_ip_lookup_i (vm, b, bi, is_ip4, fib_index, 0);
408 if (vm->thread_index == 0 && vlib_num_workers ())
409 session_flush_frames_main_thread (vm);
413 * Convert buffer to INIT
416 sctp_prepare_init_chunk (sctp_connection_t * sctp_conn, u8 idx,
419 u32 random_seed = random_default_seed ();
420 u16 alloc_bytes = sizeof (sctp_init_chunk_t);
421 sctp_sub_connection_t *sub_conn = &sctp_conn->sub_conn[idx];
423 sctp_ipv4_addr_param_t *ip4_param = 0;
424 sctp_ipv6_addr_param_t *ip6_param = 0;
426 if (sub_conn->c_is_ip4)
427 alloc_bytes += sizeof (sctp_ipv4_addr_param_t);
429 alloc_bytes += sizeof (sctp_ipv6_addr_param_t);
431 /* As per RFC 4960 the chunk_length value does NOT contemplate
432 * the size of the first header (see sctp_header_t) and any padding
434 u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
436 alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
438 sctp_init_chunk_t *init_chunk = vlib_buffer_push_uninit (b, alloc_bytes);
440 u16 pointer_offset = sizeof (init_chunk);
441 if (sub_conn->c_is_ip4)
443 ip4_param = (sctp_ipv4_addr_param_t *) init_chunk + pointer_offset;
444 ip4_param->address.as_u32 = sub_conn->c_lcl_ip.ip4.as_u32;
446 pointer_offset += sizeof (sctp_ipv4_addr_param_t);
450 ip6_param = (sctp_ipv6_addr_param_t *) init_chunk + pointer_offset;
451 ip6_param->address.as_u64[0] = sub_conn->c_lcl_ip.ip6.as_u64[0];
452 ip6_param->address.as_u64[1] = sub_conn->c_lcl_ip.ip6.as_u64[1];
454 pointer_offset += sizeof (sctp_ipv6_addr_param_t);
457 init_chunk->sctp_hdr.src_port = sub_conn->c_lcl_port; /* No need of host_to_net conversion, already in net-byte order */
458 init_chunk->sctp_hdr.dst_port = sub_conn->c_rmt_port; /* No need of host_to_net conversion, already in net-byte order */
459 init_chunk->sctp_hdr.checksum = 0;
460 /* The sender of an INIT must set the VERIFICATION_TAG to 0 as per RFC 4960 Section 8.5.1 */
461 init_chunk->sctp_hdr.verification_tag = 0x0;
463 vnet_sctp_set_chunk_type (&init_chunk->chunk_hdr, INIT);
464 vnet_sctp_set_chunk_length (&init_chunk->chunk_hdr, chunk_len);
465 vnet_sctp_common_hdr_params_host_to_net (&init_chunk->chunk_hdr);
467 sctp_init_cwnd (sctp_conn);
469 init_chunk->a_rwnd = clib_host_to_net_u32 (sctp_conn->sub_conn[idx].cwnd);
470 init_chunk->initiate_tag = clib_host_to_net_u32 (random_u32 (&random_seed));
471 init_chunk->inboud_streams_count =
472 clib_host_to_net_u16 (INBOUND_STREAMS_COUNT);
473 init_chunk->outbound_streams_count =
474 clib_host_to_net_u16 (OUTBOUND_STREAMS_COUNT);
476 init_chunk->initial_tsn =
477 clib_host_to_net_u32 (sctp_conn->local_initial_tsn);
478 SCTP_CONN_TRACKING_DBG ("sctp_conn->local_initial_tsn = %u",
479 sctp_conn->local_initial_tsn);
481 sctp_conn->local_tag = init_chunk->initiate_tag;
483 vnet_buffer (b)->sctp.connection_index = sub_conn->c_c_index;
484 vnet_buffer (b)->sctp.subconn_idx = idx;
486 SCTP_DBG_STATE_MACHINE ("CONN_INDEX = %u, CURR_CONN_STATE = %u (%s), "
488 "SRC_PORT = %u, DST_PORT = %u",
489 sub_conn->connection.c_index,
491 sctp_state_to_string (sctp_conn->state),
492 sctp_chunk_to_string (INIT),
493 init_chunk->sctp_hdr.src_port,
494 init_chunk->sctp_hdr.dst_port);
498 sctp_compute_mac (sctp_connection_t * sctp_conn,
499 sctp_state_cookie_param_t * state_cookie)
501 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
506 unsigned int len = 0;
507 const EVP_MD *md = EVP_sha1 ();
508 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
509 ctx = HMAC_CTX_new ();
510 HMAC_Init_ex (ctx, &state_cookie->creation_time,
511 sizeof (state_cookie->creation_time), md, NULL);
512 HMAC_Update (ctx, (const unsigned char *) &sctp_conn, sizeof (sctp_conn));
513 HMAC_Final (ctx, state_cookie->mac, &len);
515 HMAC_CTX_init (&ctx);
516 HMAC_Init_ex (&ctx, &state_cookie->creation_time,
517 sizeof (state_cookie->creation_time), md, NULL);
518 HMAC_Update (&ctx, (const unsigned char *) &sctp_conn, sizeof (sctp_conn));
519 HMAC_Final (&ctx, state_cookie->mac, &len);
520 HMAC_CTX_cleanup (&ctx);
523 ENDIANESS_SWAP (state_cookie->mac);
527 sctp_prepare_cookie_ack_chunk (sctp_connection_t * sctp_conn, u8 idx,
530 vlib_main_t *vm = vlib_get_main ();
532 sctp_reuse_buffer (vm, b);
534 u16 alloc_bytes = sizeof (sctp_cookie_ack_chunk_t);
536 /* As per RFC 4960 the chunk_length value does NOT contemplate
537 * the size of the first header (see sctp_header_t) and any padding
539 u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
541 alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
543 sctp_cookie_ack_chunk_t *cookie_ack_chunk =
544 vlib_buffer_push_uninit (b, alloc_bytes);
546 cookie_ack_chunk->sctp_hdr.checksum = 0;
547 cookie_ack_chunk->sctp_hdr.src_port =
548 sctp_conn->sub_conn[idx].connection.lcl_port;
549 cookie_ack_chunk->sctp_hdr.dst_port =
550 sctp_conn->sub_conn[idx].connection.rmt_port;
551 cookie_ack_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
552 vnet_sctp_set_chunk_type (&cookie_ack_chunk->chunk_hdr, COOKIE_ACK);
553 vnet_sctp_set_chunk_length (&cookie_ack_chunk->chunk_hdr, chunk_len);
555 vnet_buffer (b)->sctp.connection_index =
556 sctp_conn->sub_conn[idx].connection.c_index;
557 vnet_buffer (b)->sctp.subconn_idx = idx;
561 sctp_prepare_cookie_echo_chunk (sctp_connection_t * sctp_conn, u8 idx,
562 vlib_buffer_t * b, u8 reuse_buffer)
564 vlib_main_t *vm = vlib_get_main ();
567 sctp_reuse_buffer (vm, b);
569 /* The minimum size of the message is given by the sctp_init_ack_chunk_t */
570 u16 alloc_bytes = sizeof (sctp_cookie_echo_chunk_t);
571 /* As per RFC 4960 the chunk_length value does NOT contemplate
572 * the size of the first header (see sctp_header_t) and any padding
574 u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
575 alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
576 sctp_cookie_echo_chunk_t *cookie_echo_chunk =
577 vlib_buffer_push_uninit (b, alloc_bytes);
578 cookie_echo_chunk->sctp_hdr.checksum = 0;
579 cookie_echo_chunk->sctp_hdr.src_port =
580 sctp_conn->sub_conn[idx].connection.lcl_port;
581 cookie_echo_chunk->sctp_hdr.dst_port =
582 sctp_conn->sub_conn[idx].connection.rmt_port;
583 cookie_echo_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
584 vnet_sctp_set_chunk_type (&cookie_echo_chunk->chunk_hdr, COOKIE_ECHO);
585 vnet_sctp_set_chunk_length (&cookie_echo_chunk->chunk_hdr, chunk_len);
586 clib_memcpy_fast (&(cookie_echo_chunk->cookie), &sctp_conn->cookie_param,
587 sizeof (sctp_state_cookie_param_t));
589 vnet_buffer (b)->sctp.connection_index =
590 sctp_conn->sub_conn[idx].connection.c_index;
591 vnet_buffer (b)->sctp.subconn_idx = idx;
599 sctp_send_cookie_echo (sctp_connection_t * sctp_conn)
603 sctp_main_t *tm = vnet_get_sctp_main ();
604 vlib_main_t *vm = vlib_get_main ();
606 if (PREDICT_FALSE (sctp_conn->init_retransmit_err > SCTP_MAX_INIT_RETRANS))
608 clib_warning ("Reached MAX_INIT_RETRANS times. Aborting connection.");
610 session_stream_connect_notify (&sctp_conn->sub_conn
611 [SCTP_PRIMARY_PATH_IDX].connection, 1);
613 sctp_connection_timers_reset (sctp_conn);
615 sctp_connection_cleanup (sctp_conn);
618 if (PREDICT_FALSE (sctp_get_free_buffer_index (tm, &bi)))
621 b = vlib_get_buffer (vm, bi);
622 u8 idx = SCTP_PRIMARY_PATH_IDX;
624 sctp_init_buffer (vm, b);
625 sctp_prepare_cookie_echo_chunk (sctp_conn, idx, b, 0);
626 sctp_enqueue_to_output_now (vm, b, bi, sctp_conn->sub_conn[idx].c_is_ip4);
628 /* Start the T1_INIT timer */
629 sctp_timer_set (sctp_conn, idx, SCTP_TIMER_T1_INIT,
630 sctp_conn->sub_conn[idx].RTO);
632 /* Change state to COOKIE_WAIT */
633 sctp_conn->state = SCTP_STATE_COOKIE_WAIT;
635 /* Measure RTT with this */
636 sctp_conn->sub_conn[idx].rtt_ts = sctp_time_now ();
641 * Convert buffer to ERROR
644 sctp_prepare_operation_error (sctp_connection_t * sctp_conn, u8 idx,
645 vlib_buffer_t * b, u8 err_cause)
647 vlib_main_t *vm = vlib_get_main ();
649 sctp_reuse_buffer (vm, b);
651 /* The minimum size of the message is given by the sctp_operation_error_t */
653 sizeof (sctp_operation_error_t) + sizeof (sctp_err_cause_param_t);
655 /* As per RFC 4960 the chunk_length value does NOT contemplate
656 * the size of the first header (see sctp_header_t) and any padding
658 u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
660 alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
662 sctp_operation_error_t *err_chunk =
663 vlib_buffer_push_uninit (b, alloc_bytes);
665 /* src_port & dst_port are already in network byte-order */
666 err_chunk->sctp_hdr.checksum = 0;
667 err_chunk->sctp_hdr.src_port = sctp_conn->sub_conn[idx].connection.lcl_port;
668 err_chunk->sctp_hdr.dst_port = sctp_conn->sub_conn[idx].connection.rmt_port;
669 /* As per RFC4960 Section 5.2.2: copy the INITIATE_TAG into the VERIFICATION_TAG of the ABORT chunk */
670 err_chunk->sctp_hdr.verification_tag = sctp_conn->local_tag;
672 err_chunk->err_causes[0].param_hdr.length =
673 clib_host_to_net_u16 (sizeof (err_chunk->err_causes[0].param_hdr.type) +
674 sizeof (err_chunk->err_causes[0].param_hdr.length));
675 err_chunk->err_causes[0].param_hdr.type = clib_host_to_net_u16 (err_cause);
677 vnet_sctp_set_chunk_type (&err_chunk->chunk_hdr, OPERATION_ERROR);
678 vnet_sctp_set_chunk_length (&err_chunk->chunk_hdr, chunk_len);
680 vnet_buffer (b)->sctp.connection_index =
681 sctp_conn->sub_conn[idx].connection.c_index;
682 vnet_buffer (b)->sctp.subconn_idx = idx;
686 * Convert buffer to ABORT
689 sctp_prepare_abort_for_collision (sctp_connection_t * sctp_conn, u8 idx,
690 vlib_buffer_t * b, ip4_address_t * ip4_addr,
691 ip6_address_t * ip6_addr)
693 vlib_main_t *vm = vlib_get_main ();
695 sctp_reuse_buffer (vm, b);
697 /* The minimum size of the message is given by the sctp_abort_chunk_t */
698 u16 alloc_bytes = sizeof (sctp_abort_chunk_t);
700 /* As per RFC 4960 the chunk_length value does NOT contemplate
701 * the size of the first header (see sctp_header_t) and any padding
703 u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
705 alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
707 sctp_abort_chunk_t *abort_chunk = vlib_buffer_push_uninit (b, alloc_bytes);
709 /* src_port & dst_port are already in network byte-order */
710 abort_chunk->sctp_hdr.checksum = 0;
711 abort_chunk->sctp_hdr.src_port =
712 sctp_conn->sub_conn[idx].connection.lcl_port;
713 abort_chunk->sctp_hdr.dst_port =
714 sctp_conn->sub_conn[idx].connection.rmt_port;
715 /* As per RFC4960 Section 5.2.2: copy the INITIATE_TAG into the VERIFICATION_TAG of the ABORT chunk */
716 abort_chunk->sctp_hdr.verification_tag = sctp_conn->local_tag;
718 vnet_sctp_set_chunk_type (&abort_chunk->chunk_hdr, ABORT);
719 vnet_sctp_set_chunk_length (&abort_chunk->chunk_hdr, chunk_len);
721 vnet_buffer (b)->sctp.connection_index =
722 sctp_conn->sub_conn[idx].connection.c_index;
723 vnet_buffer (b)->sctp.subconn_idx = idx;
727 * Convert buffer to INIT-ACK
730 sctp_prepare_initack_chunk_for_collision (sctp_connection_t * sctp_conn,
731 u8 idx, vlib_buffer_t * b,
732 ip4_address_t * ip4_addr,
733 ip6_address_t * ip6_addr)
735 vlib_main_t *vm = vlib_get_main ();
736 sctp_ipv4_addr_param_t *ip4_param = 0;
737 sctp_ipv6_addr_param_t *ip6_param = 0;
739 sctp_reuse_buffer (vm, b);
741 /* The minimum size of the message is given by the sctp_init_ack_chunk_t */
743 sizeof (sctp_init_ack_chunk_t) + sizeof (sctp_state_cookie_param_t);
745 if (PREDICT_TRUE (ip4_addr != NULL))
747 /* Create room for variable-length fields in the INIT_ACK chunk */
748 alloc_bytes += SCTP_IPV4_ADDRESS_TYPE_LENGTH;
750 if (PREDICT_TRUE (ip6_addr != NULL))
752 /* Create room for variable-length fields in the INIT_ACK chunk */
753 alloc_bytes += SCTP_IPV6_ADDRESS_TYPE_LENGTH;
756 if (sctp_conn->sub_conn[idx].connection.is_ip4)
757 alloc_bytes += sizeof (sctp_ipv4_addr_param_t);
759 alloc_bytes += sizeof (sctp_ipv6_addr_param_t);
761 /* As per RFC 4960 the chunk_length value does NOT contemplate
762 * the size of the first header (see sctp_header_t) and any padding
764 u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
766 alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
768 sctp_init_ack_chunk_t *init_ack_chunk =
769 vlib_buffer_push_uninit (b, alloc_bytes);
771 u16 pointer_offset = sizeof (sctp_init_ack_chunk_t);
773 /* Create State Cookie parameter */
774 sctp_state_cookie_param_t *state_cookie_param =
775 (sctp_state_cookie_param_t *) ((char *) init_ack_chunk + pointer_offset);
777 state_cookie_param->param_hdr.type =
778 clib_host_to_net_u16 (SCTP_STATE_COOKIE_TYPE);
779 state_cookie_param->param_hdr.length =
780 clib_host_to_net_u16 (sizeof (sctp_state_cookie_param_t));
781 state_cookie_param->creation_time = clib_host_to_net_u64 (sctp_time_now ());
782 state_cookie_param->cookie_lifespan =
783 clib_host_to_net_u32 (SCTP_VALID_COOKIE_LIFE);
785 sctp_compute_mac (sctp_conn, state_cookie_param);
787 pointer_offset += sizeof (sctp_state_cookie_param_t);
789 if (PREDICT_TRUE (ip4_addr != NULL))
791 sctp_ipv4_addr_param_t *ipv4_addr =
792 (sctp_ipv4_addr_param_t *) init_ack_chunk + pointer_offset;
794 ipv4_addr->param_hdr.type =
795 clib_host_to_net_u16 (SCTP_IPV4_ADDRESS_TYPE);
796 ipv4_addr->param_hdr.length =
797 clib_host_to_net_u16 (SCTP_IPV4_ADDRESS_TYPE_LENGTH);
798 ipv4_addr->address.as_u32 = ip4_addr->as_u32;
800 pointer_offset += SCTP_IPV4_ADDRESS_TYPE_LENGTH;
802 if (PREDICT_TRUE (ip6_addr != NULL))
804 sctp_ipv6_addr_param_t *ipv6_addr =
805 (sctp_ipv6_addr_param_t *) init_ack_chunk + pointer_offset;
807 ipv6_addr->param_hdr.type =
808 clib_host_to_net_u16 (SCTP_IPV6_ADDRESS_TYPE);
809 ipv6_addr->param_hdr.length =
810 clib_host_to_net_u16 (SCTP_IPV6_ADDRESS_TYPE_LENGTH);
811 ipv6_addr->address.as_u64[0] = ip6_addr->as_u64[0];
812 ipv6_addr->address.as_u64[1] = ip6_addr->as_u64[1];
814 pointer_offset += SCTP_IPV6_ADDRESS_TYPE_LENGTH;
817 if (sctp_conn->sub_conn[idx].connection.is_ip4)
819 ip4_param = (sctp_ipv4_addr_param_t *) init_ack_chunk + pointer_offset;
820 ip4_param->address.as_u32 =
821 sctp_conn->sub_conn[idx].connection.lcl_ip.ip4.as_u32;
823 pointer_offset += sizeof (sctp_ipv4_addr_param_t);
827 ip6_param = (sctp_ipv6_addr_param_t *) init_ack_chunk + pointer_offset;
828 ip6_param->address.as_u64[0] =
829 sctp_conn->sub_conn[idx].connection.lcl_ip.ip6.as_u64[0];
830 ip6_param->address.as_u64[1] =
831 sctp_conn->sub_conn[idx].connection.lcl_ip.ip6.as_u64[1];
833 pointer_offset += sizeof (sctp_ipv6_addr_param_t);
836 /* src_port & dst_port are already in network byte-order */
837 init_ack_chunk->sctp_hdr.checksum = 0;
838 init_ack_chunk->sctp_hdr.src_port =
839 sctp_conn->sub_conn[idx].connection.lcl_port;
840 init_ack_chunk->sctp_hdr.dst_port =
841 sctp_conn->sub_conn[idx].connection.rmt_port;
842 /* the sctp_conn->verification_tag is already in network byte-order (being a copy of the init_tag coming with the INIT chunk) */
843 init_ack_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
844 init_ack_chunk->initial_tsn =
845 clib_host_to_net_u32 (sctp_conn->local_initial_tsn);
846 SCTP_CONN_TRACKING_DBG ("init_ack_chunk->initial_tsn = %u",
847 init_ack_chunk->initial_tsn);
849 vnet_sctp_set_chunk_type (&init_ack_chunk->chunk_hdr, INIT_ACK);
850 vnet_sctp_set_chunk_length (&init_ack_chunk->chunk_hdr, chunk_len);
852 init_ack_chunk->initiate_tag = sctp_conn->local_tag;
854 init_ack_chunk->a_rwnd =
855 clib_host_to_net_u32 (sctp_conn->sub_conn[idx].cwnd);
856 init_ack_chunk->inboud_streams_count =
857 clib_host_to_net_u16 (INBOUND_STREAMS_COUNT);
858 init_ack_chunk->outbound_streams_count =
859 clib_host_to_net_u16 (OUTBOUND_STREAMS_COUNT);
861 vnet_buffer (b)->sctp.connection_index =
862 sctp_conn->sub_conn[idx].connection.c_index;
863 vnet_buffer (b)->sctp.subconn_idx = idx;
867 * Convert buffer to INIT-ACK
870 sctp_prepare_initack_chunk (sctp_connection_t * sctp_conn, u8 idx,
871 vlib_buffer_t * b, ip4_address_t * ip4_addr,
872 u8 add_ip4, ip6_address_t * ip6_addr, u8 add_ip6)
874 vlib_main_t *vm = vlib_get_main ();
875 sctp_ipv4_addr_param_t *ip4_param = 0;
876 sctp_ipv6_addr_param_t *ip6_param = 0;
877 u32 random_seed = random_default_seed ();
879 sctp_reuse_buffer (vm, b);
881 /* The minimum size of the message is given by the sctp_init_ack_chunk_t */
883 sizeof (sctp_init_ack_chunk_t) + sizeof (sctp_state_cookie_param_t);
885 if (PREDICT_FALSE (add_ip4 == 1))
887 /* Create room for variable-length fields in the INIT_ACK chunk */
888 alloc_bytes += SCTP_IPV4_ADDRESS_TYPE_LENGTH;
890 if (PREDICT_FALSE (add_ip6 == 1))
892 /* Create room for variable-length fields in the INIT_ACK chunk */
893 alloc_bytes += SCTP_IPV6_ADDRESS_TYPE_LENGTH;
896 if (sctp_conn->sub_conn[idx].connection.is_ip4)
897 alloc_bytes += sizeof (sctp_ipv4_addr_param_t);
899 alloc_bytes += sizeof (sctp_ipv6_addr_param_t);
901 /* As per RFC 4960 the chunk_length value does NOT contemplate
902 * the size of the first header (see sctp_header_t) and any padding
904 u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
906 alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
908 sctp_init_ack_chunk_t *init_ack_chunk =
909 vlib_buffer_push_uninit (b, alloc_bytes);
911 u16 pointer_offset = sizeof (sctp_init_ack_chunk_t);
913 /* Create State Cookie parameter */
914 sctp_state_cookie_param_t *state_cookie_param =
915 (sctp_state_cookie_param_t *) ((char *) init_ack_chunk + pointer_offset);
917 state_cookie_param->param_hdr.type =
918 clib_host_to_net_u16 (SCTP_STATE_COOKIE_TYPE);
919 state_cookie_param->param_hdr.length =
920 clib_host_to_net_u16 (sizeof (sctp_state_cookie_param_t));
921 state_cookie_param->creation_time = clib_host_to_net_u64 (sctp_time_now ());
922 state_cookie_param->cookie_lifespan =
923 clib_host_to_net_u32 (SCTP_VALID_COOKIE_LIFE);
925 sctp_compute_mac (sctp_conn, state_cookie_param);
927 pointer_offset += sizeof (sctp_state_cookie_param_t);
929 if (PREDICT_TRUE (ip4_addr != NULL))
931 sctp_ipv4_addr_param_t *ipv4_addr =
932 (sctp_ipv4_addr_param_t *) init_ack_chunk + pointer_offset;
934 ipv4_addr->param_hdr.type =
935 clib_host_to_net_u16 (SCTP_IPV4_ADDRESS_TYPE);
936 ipv4_addr->param_hdr.length =
937 clib_host_to_net_u16 (SCTP_IPV4_ADDRESS_TYPE_LENGTH);
938 ipv4_addr->address.as_u32 = ip4_addr->as_u32;
940 pointer_offset += SCTP_IPV4_ADDRESS_TYPE_LENGTH;
942 if (PREDICT_TRUE (ip6_addr != NULL))
944 sctp_ipv6_addr_param_t *ipv6_addr =
945 (sctp_ipv6_addr_param_t *) init_ack_chunk + pointer_offset;
947 ipv6_addr->param_hdr.type =
948 clib_host_to_net_u16 (SCTP_IPV6_ADDRESS_TYPE);
949 ipv6_addr->param_hdr.length =
950 clib_host_to_net_u16 (SCTP_IPV6_ADDRESS_TYPE_LENGTH);
951 ipv6_addr->address.as_u64[0] = ip6_addr->as_u64[0];
952 ipv6_addr->address.as_u64[1] = ip6_addr->as_u64[1];
954 pointer_offset += SCTP_IPV6_ADDRESS_TYPE_LENGTH;
957 if (sctp_conn->sub_conn[idx].connection.is_ip4)
959 ip4_param = (sctp_ipv4_addr_param_t *) init_ack_chunk + pointer_offset;
960 ip4_param->address.as_u32 =
961 sctp_conn->sub_conn[idx].connection.lcl_ip.ip4.as_u32;
963 pointer_offset += sizeof (sctp_ipv4_addr_param_t);
967 ip6_param = (sctp_ipv6_addr_param_t *) init_ack_chunk + pointer_offset;
968 ip6_param->address.as_u64[0] =
969 sctp_conn->sub_conn[idx].connection.lcl_ip.ip6.as_u64[0];
970 ip6_param->address.as_u64[1] =
971 sctp_conn->sub_conn[idx].connection.lcl_ip.ip6.as_u64[1];
973 pointer_offset += sizeof (sctp_ipv6_addr_param_t);
976 /* src_port & dst_port are already in network byte-order */
977 init_ack_chunk->sctp_hdr.checksum = 0;
978 init_ack_chunk->sctp_hdr.src_port =
979 sctp_conn->sub_conn[idx].connection.lcl_port;
980 init_ack_chunk->sctp_hdr.dst_port =
981 sctp_conn->sub_conn[idx].connection.rmt_port;
982 /* the sctp_conn->verification_tag is already in network byte-order (being a copy of the init_tag coming with the INIT chunk) */
983 init_ack_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
984 init_ack_chunk->initial_tsn =
985 clib_host_to_net_u32 (sctp_conn->local_initial_tsn);
986 SCTP_CONN_TRACKING_DBG ("init_ack_chunk->initial_tsn = %u",
987 init_ack_chunk->initial_tsn);
989 vnet_sctp_set_chunk_type (&init_ack_chunk->chunk_hdr, INIT_ACK);
990 vnet_sctp_set_chunk_length (&init_ack_chunk->chunk_hdr, chunk_len);
992 init_ack_chunk->initiate_tag =
993 clib_host_to_net_u32 (random_u32 (&random_seed));
995 init_ack_chunk->a_rwnd =
996 clib_host_to_net_u32 (sctp_conn->sub_conn[idx].cwnd);
997 init_ack_chunk->inboud_streams_count =
998 clib_host_to_net_u16 (INBOUND_STREAMS_COUNT);
999 init_ack_chunk->outbound_streams_count =
1000 clib_host_to_net_u16 (OUTBOUND_STREAMS_COUNT);
1002 sctp_conn->local_tag = init_ack_chunk->initiate_tag;
1004 vnet_buffer (b)->sctp.connection_index =
1005 sctp_conn->sub_conn[idx].connection.c_index;
1006 vnet_buffer (b)->sctp.subconn_idx = idx;
1010 * Convert buffer to SHUTDOWN
1013 sctp_prepare_shutdown_chunk (sctp_connection_t * sctp_conn, u8 idx,
1016 u16 alloc_bytes = sizeof (sctp_shutdown_association_chunk_t);
1018 /* As per RFC 4960 the chunk_length value does NOT contemplate
1019 * the size of the first header (see sctp_header_t) and any padding
1021 u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
1023 alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
1025 sctp_shutdown_association_chunk_t *shutdown_chunk =
1026 vlib_buffer_push_uninit (b, alloc_bytes);
1028 shutdown_chunk->sctp_hdr.checksum = 0;
1029 /* No need of host_to_net conversion, already in net-byte order */
1030 shutdown_chunk->sctp_hdr.src_port =
1031 sctp_conn->sub_conn[idx].connection.lcl_port;
1032 shutdown_chunk->sctp_hdr.dst_port =
1033 sctp_conn->sub_conn[idx].connection.rmt_port;
1034 shutdown_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
1035 vnet_sctp_set_chunk_type (&shutdown_chunk->chunk_hdr, SHUTDOWN);
1036 vnet_sctp_set_chunk_length (&shutdown_chunk->chunk_hdr, chunk_len);
1038 shutdown_chunk->cumulative_tsn_ack = sctp_conn->last_rcvd_tsn;
1040 vnet_buffer (b)->sctp.connection_index =
1041 sctp_conn->sub_conn[idx].connection.c_index;
1042 vnet_buffer (b)->sctp.subconn_idx = idx;
1049 sctp_send_shutdown (sctp_connection_t * sctp_conn)
1053 sctp_main_t *tm = vnet_get_sctp_main ();
1054 vlib_main_t *vm = vlib_get_main ();
1056 if (sctp_check_outstanding_data_chunks (sctp_conn) > 0)
1059 if (PREDICT_FALSE (sctp_get_free_buffer_index (tm, &bi)))
1062 u8 idx = SCTP_PRIMARY_PATH_IDX;
1064 b = vlib_get_buffer (vm, bi);
1065 sctp_init_buffer (vm, b);
1066 sctp_prepare_shutdown_chunk (sctp_conn, idx, b);
1068 sctp_enqueue_to_output_now (vm, b, bi,
1069 sctp_conn->sub_conn[idx].connection.is_ip4);
1073 * Convert buffer to SHUTDOWN_ACK
1076 sctp_prepare_shutdown_ack_chunk (sctp_connection_t * sctp_conn, u8 idx,
1079 u16 alloc_bytes = sizeof (sctp_shutdown_association_chunk_t);
1080 alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
1082 u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
1084 sctp_shutdown_ack_chunk_t *shutdown_ack_chunk =
1085 vlib_buffer_push_uninit (b, alloc_bytes);
1087 shutdown_ack_chunk->sctp_hdr.checksum = 0;
1088 /* No need of host_to_net conversion, already in net-byte order */
1089 shutdown_ack_chunk->sctp_hdr.src_port =
1090 sctp_conn->sub_conn[idx].connection.lcl_port;
1091 shutdown_ack_chunk->sctp_hdr.dst_port =
1092 sctp_conn->sub_conn[idx].connection.rmt_port;
1093 shutdown_ack_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
1095 vnet_sctp_set_chunk_type (&shutdown_ack_chunk->chunk_hdr, SHUTDOWN_ACK);
1096 vnet_sctp_set_chunk_length (&shutdown_ack_chunk->chunk_hdr, chunk_len);
1098 vnet_buffer (b)->sctp.connection_index =
1099 sctp_conn->sub_conn[idx].connection.c_index;
1100 vnet_buffer (b)->sctp.subconn_idx = idx;
1107 sctp_send_shutdown_ack (sctp_connection_t * sctp_conn, u8 idx,
1110 vlib_main_t *vm = vlib_get_main ();
1112 if (sctp_check_outstanding_data_chunks (sctp_conn) > 0)
1115 sctp_reuse_buffer (vm, b);
1117 sctp_prepare_shutdown_ack_chunk (sctp_conn, idx, b);
1121 * Convert buffer to SACK
1124 sctp_prepare_sack_chunk (sctp_connection_t * sctp_conn, u8 idx,
1127 vlib_main_t *vm = vlib_get_main ();
1129 sctp_reuse_buffer (vm, b);
1131 u16 alloc_bytes = sizeof (sctp_selective_ack_chunk_t);
1133 /* As per RFC 4960 the chunk_length value does NOT contemplate
1134 * the size of the first header (see sctp_header_t) and any padding
1136 u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
1138 alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
1140 sctp_selective_ack_chunk_t *sack = vlib_buffer_push_uninit (b, alloc_bytes);
1142 sack->sctp_hdr.checksum = 0;
1143 sack->sctp_hdr.src_port = sctp_conn->sub_conn[idx].connection.lcl_port;
1144 sack->sctp_hdr.dst_port = sctp_conn->sub_conn[idx].connection.rmt_port;
1145 sack->sctp_hdr.verification_tag = sctp_conn->remote_tag;
1146 vnet_sctp_set_chunk_type (&sack->chunk_hdr, SACK);
1147 vnet_sctp_set_chunk_length (&sack->chunk_hdr, chunk_len);
1149 sack->cumulative_tsn_ack = sctp_conn->next_tsn_expected;
1151 sctp_conn->ack_state = 0;
1153 vnet_buffer (b)->sctp.connection_index =
1154 sctp_conn->sub_conn[idx].connection.c_index;
1155 vnet_buffer (b)->sctp.subconn_idx = idx;
1159 * Convert buffer to HEARTBEAT_ACK
1162 sctp_prepare_heartbeat_ack_chunk (sctp_connection_t * sctp_conn, u8 idx,
1165 vlib_main_t *vm = vlib_get_main ();
1167 u16 alloc_bytes = sizeof (sctp_hb_ack_chunk_t);
1169 sctp_reuse_buffer (vm, b);
1171 /* As per RFC 4960 the chunk_length value does NOT contemplate
1172 * the size of the first header (see sctp_header_t) and any padding
1174 u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
1176 alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
1178 sctp_hb_ack_chunk_t *hb_ack = vlib_buffer_push_uninit (b, alloc_bytes);
1180 hb_ack->sctp_hdr.checksum = 0;
1181 /* No need of host_to_net conversion, already in net-byte order */
1182 hb_ack->sctp_hdr.src_port = sctp_conn->sub_conn[idx].connection.lcl_port;
1183 hb_ack->sctp_hdr.dst_port = sctp_conn->sub_conn[idx].connection.rmt_port;
1184 hb_ack->sctp_hdr.verification_tag = sctp_conn->remote_tag;
1185 hb_ack->hb_info.param_hdr.type = clib_host_to_net_u16 (1);
1186 hb_ack->hb_info.param_hdr.length =
1187 clib_host_to_net_u16 (sizeof (hb_ack->hb_info.hb_info));
1189 vnet_sctp_set_chunk_type (&hb_ack->chunk_hdr, HEARTBEAT_ACK);
1190 vnet_sctp_set_chunk_length (&hb_ack->chunk_hdr, chunk_len);
1192 vnet_buffer (b)->sctp.connection_index =
1193 sctp_conn->sub_conn[idx].connection.c_index;
1194 vnet_buffer (b)->sctp.subconn_idx = idx;
1198 * Convert buffer to HEARTBEAT
1201 sctp_prepare_heartbeat_chunk (sctp_connection_t * sctp_conn, u8 idx,
1204 u16 alloc_bytes = sizeof (sctp_hb_req_chunk_t);
1206 /* As per RFC 4960 the chunk_length value does NOT contemplate
1207 * the size of the first header (see sctp_header_t) and any padding
1209 u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
1211 alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
1213 sctp_hb_req_chunk_t *hb_req = vlib_buffer_push_uninit (b, alloc_bytes);
1215 hb_req->sctp_hdr.checksum = 0;
1216 /* No need of host_to_net conversion, already in net-byte order */
1217 hb_req->sctp_hdr.src_port = sctp_conn->sub_conn[idx].connection.lcl_port;
1218 hb_req->sctp_hdr.dst_port = sctp_conn->sub_conn[idx].connection.rmt_port;
1219 hb_req->sctp_hdr.verification_tag = sctp_conn->remote_tag;
1220 hb_req->hb_info.param_hdr.type = clib_host_to_net_u16 (1);
1221 hb_req->hb_info.param_hdr.length =
1222 clib_host_to_net_u16 (sizeof (hb_req->hb_info.hb_info));
1224 vnet_sctp_set_chunk_type (&hb_req->chunk_hdr, HEARTBEAT);
1225 vnet_sctp_set_chunk_length (&hb_req->chunk_hdr, chunk_len);
1227 vnet_buffer (b)->sctp.connection_index =
1228 sctp_conn->sub_conn[idx].connection.c_index;
1229 vnet_buffer (b)->sctp.subconn_idx = idx;
1233 sctp_send_heartbeat (sctp_connection_t * sctp_conn)
1237 sctp_main_t *tm = vnet_get_sctp_main ();
1238 vlib_main_t *vm = vlib_get_main ();
1241 u64 now = sctp_time_now ();
1243 for (i = 0; i < MAX_SCTP_CONNECTIONS; i++)
1245 if (sctp_conn->sub_conn[i].state == SCTP_SUBCONN_STATE_DOWN)
1248 if (now > (sctp_conn->sub_conn[i].last_seen + SCTP_HB_INTERVAL))
1250 if (PREDICT_FALSE (sctp_get_free_buffer_index (tm, &bi)))
1253 b = vlib_get_buffer (vm, bi);
1254 sctp_init_buffer (vm, b);
1255 sctp_prepare_heartbeat_chunk (sctp_conn, i, b);
1257 sctp_enqueue_to_output_now (vm, b, bi,
1258 sctp_conn->sub_conn[i].
1261 sctp_conn->sub_conn[i].unacknowledged_hb += 1;
1267 * Convert buffer to SHUTDOWN_COMPLETE
1270 sctp_prepare_shutdown_complete_chunk (sctp_connection_t * sctp_conn, u8 idx,
1273 u16 alloc_bytes = sizeof (sctp_shutdown_association_chunk_t);
1274 alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
1276 u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
1278 sctp_shutdown_complete_chunk_t *shutdown_complete =
1279 vlib_buffer_push_uninit (b, alloc_bytes);
1281 shutdown_complete->sctp_hdr.checksum = 0;
1282 /* No need of host_to_net conversion, already in net-byte order */
1283 shutdown_complete->sctp_hdr.src_port =
1284 sctp_conn->sub_conn[idx].connection.lcl_port;
1285 shutdown_complete->sctp_hdr.dst_port =
1286 sctp_conn->sub_conn[idx].connection.rmt_port;
1287 shutdown_complete->sctp_hdr.verification_tag = sctp_conn->remote_tag;
1289 vnet_sctp_set_chunk_type (&shutdown_complete->chunk_hdr, SHUTDOWN_COMPLETE);
1290 vnet_sctp_set_chunk_length (&shutdown_complete->chunk_hdr, chunk_len);
1292 vnet_buffer (b)->sctp.connection_index =
1293 sctp_conn->sub_conn[idx].connection.c_index;
1294 vnet_buffer (b)->sctp.subconn_idx = idx;
1298 sctp_send_shutdown_complete (sctp_connection_t * sctp_conn, u8 idx,
1301 vlib_main_t *vm = vlib_get_main ();
1303 if (sctp_check_outstanding_data_chunks (sctp_conn) > 0)
1306 sctp_reuse_buffer (vm, b0);
1308 sctp_prepare_shutdown_complete_chunk (sctp_conn, idx, b0);
1315 sctp_send_init (sctp_connection_t * sctp_conn)
1319 sctp_main_t *tm = vnet_get_sctp_main ();
1320 vlib_main_t *vm = vlib_get_main ();
1322 if (PREDICT_FALSE (sctp_conn->init_retransmit_err > SCTP_MAX_INIT_RETRANS))
1324 clib_warning ("Reached MAX_INIT_RETRANS times. Aborting connection.");
1326 session_stream_connect_notify (&sctp_conn->sub_conn
1327 [SCTP_PRIMARY_PATH_IDX].connection, 1);
1329 sctp_connection_timers_reset (sctp_conn);
1331 sctp_connection_cleanup (sctp_conn);
1336 if (PREDICT_FALSE (sctp_get_free_buffer_index (tm, &bi)))
1339 b = vlib_get_buffer (vm, bi);
1340 u8 idx = SCTP_PRIMARY_PATH_IDX;
1342 sctp_init_buffer (vm, b);
1343 sctp_prepare_init_chunk (sctp_conn, idx, b);
1345 sctp_push_ip_hdr (tm, &sctp_conn->sub_conn[idx], b);
1346 sctp_enqueue_to_ip_lookup (vm, b, bi, sctp_conn->sub_conn[idx].c_is_ip4,
1347 sctp_conn->sub_conn[idx].c_fib_index);
1349 /* Start the T1_INIT timer */
1350 sctp_timer_set (sctp_conn, idx, SCTP_TIMER_T1_INIT,
1351 sctp_conn->sub_conn[idx].RTO);
1353 /* Change state to COOKIE_WAIT */
1354 sctp_conn->state = SCTP_STATE_COOKIE_WAIT;
1356 /* Measure RTT with this */
1357 sctp_conn->sub_conn[idx].rtt_ts = sctp_time_now ();
1361 * Push SCTP header and update connection variables
1364 sctp_push_hdr_i (sctp_connection_t * sctp_conn, vlib_buffer_t * b,
1365 sctp_state_t next_state)
1368 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));
1373 SCTP_ADV_DBG_OUTPUT ("b->current_length = %u, "
1374 "b->current_data = %p "
1376 b->current_length, b->current_data, data_len);
1378 u16 data_padding = vnet_sctp_calculate_padding (b->current_length);
1379 if (data_padding > 0)
1381 u8 *p_tail = vlib_buffer_put_uninit (b, data_padding);
1382 clib_memset_u8 (p_tail, 0, data_padding);
1385 u16 bytes_to_add = sizeof (sctp_payload_data_chunk_t);
1386 u16 chunk_length = data_len + bytes_to_add - sizeof (sctp_header_t);
1388 sctp_payload_data_chunk_t *data_chunk =
1389 vlib_buffer_push_uninit (b, bytes_to_add);
1391 u8 idx = sctp_data_subconn_select (sctp_conn);
1393 ("SCTP_CONN = %p, IDX = %u, S_INDEX = %u, C_INDEX = %u, sctp_conn->[...].LCL_PORT = %u, sctp_conn->[...].RMT_PORT = %u",
1394 sctp_conn, idx, sctp_conn->sub_conn[idx].connection.s_index,
1395 sctp_conn->sub_conn[idx].connection.c_index,
1396 sctp_conn->sub_conn[idx].connection.lcl_port,
1397 sctp_conn->sub_conn[idx].connection.rmt_port);
1398 data_chunk->sctp_hdr.checksum = 0;
1399 data_chunk->sctp_hdr.src_port =
1400 sctp_conn->sub_conn[idx].connection.lcl_port;
1401 data_chunk->sctp_hdr.dst_port =
1402 sctp_conn->sub_conn[idx].connection.rmt_port;
1403 data_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
1405 data_chunk->tsn = clib_host_to_net_u32 (sctp_conn->next_tsn);
1406 data_chunk->stream_id = clib_host_to_net_u16 (0);
1407 data_chunk->stream_seq = clib_host_to_net_u16 (0);
1409 vnet_sctp_set_chunk_type (&data_chunk->chunk_hdr, DATA);
1410 vnet_sctp_set_chunk_length (&data_chunk->chunk_hdr, chunk_length);
1412 vnet_sctp_set_bbit (&data_chunk->chunk_hdr);
1413 vnet_sctp_set_ebit (&data_chunk->chunk_hdr);
1415 SCTP_ADV_DBG_OUTPUT ("POINTER_WITH_DATA = %p, DATA_OFFSET = %u",
1416 b->data, b->current_data);
1418 if (sctp_conn->sub_conn[idx].state != SCTP_SUBCONN_AWAITING_SACK)
1420 sctp_conn->sub_conn[idx].state = SCTP_SUBCONN_AWAITING_SACK;
1421 sctp_conn->last_unacked_tsn = sctp_conn->next_tsn;
1424 sctp_conn->next_tsn += data_len;
1426 u32 inflight = sctp_conn->next_tsn - sctp_conn->last_unacked_tsn;
1427 /* Section 7.2.2; point (3) */
1428 if (sctp_conn->sub_conn[idx].partially_acked_bytes >=
1429 sctp_conn->sub_conn[idx].cwnd
1430 && inflight >= sctp_conn->sub_conn[idx].cwnd)
1432 sctp_conn->sub_conn[idx].cwnd += sctp_conn->sub_conn[idx].PMTU;
1433 sctp_conn->sub_conn[idx].partially_acked_bytes -=
1434 sctp_conn->sub_conn[idx].cwnd;
1437 sctp_conn->sub_conn[idx].last_data_ts = sctp_time_now ();
1439 vnet_buffer (b)->sctp.connection_index =
1440 sctp_conn->sub_conn[idx].connection.c_index;
1442 vnet_buffer (b)->sctp.subconn_idx = idx;
1446 sctp_push_header (transport_connection_t * trans_conn, vlib_buffer_t * b)
1448 sctp_connection_t *sctp_conn =
1449 sctp_get_connection_from_transport (trans_conn);
1451 SCTP_DBG_OUTPUT ("TRANS_CONN = %p, SCTP_CONN = %p, "
1452 "S_INDEX = %u, C_INDEX = %u,"
1453 "trans_conn->LCL_PORT = %u, trans_conn->RMT_PORT = %u",
1456 trans_conn->s_index,
1457 trans_conn->c_index,
1458 trans_conn->lcl_port, trans_conn->rmt_port);
1460 sctp_push_hdr_i (sctp_conn, b, SCTP_STATE_ESTABLISHED);
1462 sctp_trajectory_add_start (b, 3);
1468 sctp_prepare_data_retransmit (sctp_connection_t * sctp_conn,
1471 u32 max_deq_bytes, vlib_buffer_t ** b)
1473 sctp_main_t *tm = vnet_get_sctp_main ();
1474 vlib_main_t *vm = vlib_get_main ();
1476 u32 bi, available_bytes, seg_size;
1479 ASSERT (sctp_conn->state >= SCTP_STATE_ESTABLISHED);
1480 ASSERT (max_deq_bytes != 0);
1483 * Make sure we can retransmit something
1486 session_tx_fifo_max_dequeue (&sctp_conn->sub_conn[idx].connection);
1487 ASSERT (available_bytes >= offset);
1488 available_bytes -= offset;
1489 if (!available_bytes)
1491 max_deq_bytes = clib_min (sctp_conn->sub_conn[idx].cwnd, max_deq_bytes);
1492 max_deq_bytes = clib_min (available_bytes, max_deq_bytes);
1494 seg_size = max_deq_bytes;
1497 * Allocate and fill in buffer(s)
1500 if (PREDICT_FALSE (sctp_get_free_buffer_index (tm, &bi)))
1502 *b = vlib_get_buffer (vm, bi);
1503 data = sctp_init_buffer (vm, *b);
1505 /* Easy case, buffer size greater than mss */
1506 if (PREDICT_TRUE (seg_size <= tm->bytes_per_buffer))
1509 stream_session_peek_bytes (&sctp_conn->sub_conn[idx].connection, data,
1510 offset, max_deq_bytes);
1511 ASSERT (n_bytes == max_deq_bytes);
1512 b[0]->current_length = n_bytes;
1513 sctp_push_hdr_i (sctp_conn, *b, sctp_conn->state);
1520 sctp_data_retransmit (sctp_connection_t * sctp_conn)
1522 vlib_main_t *vm = vlib_get_main ();
1523 vlib_buffer_t *b = 0;
1524 u32 bi, n_bytes = 0;
1526 u8 idx = sctp_data_subconn_select (sctp_conn);
1529 ("SCTP_CONN = %p, IDX = %u, S_INDEX = %u, C_INDEX = %u, sctp_conn->[...].LCL_PORT = %u, sctp_conn->[...].RMT_PORT = %u",
1530 sctp_conn, idx, sctp_conn->sub_conn[idx].connection.s_index,
1531 sctp_conn->sub_conn[idx].connection.c_index,
1532 sctp_conn->sub_conn[idx].connection.lcl_port,
1533 sctp_conn->sub_conn[idx].connection.rmt_port);
1535 if (sctp_conn->state >= SCTP_STATE_ESTABLISHED)
1541 sctp_prepare_data_retransmit (sctp_conn, idx, 0,
1542 sctp_conn->sub_conn[idx].cwnd, &b);
1544 SCTP_DBG_OUTPUT ("We have data (%u bytes) to retransmit", n_bytes);
1546 bi = vlib_get_buffer_index (vm, b);
1548 sctp_enqueue_to_output_now (vm, b, bi,
1549 sctp_conn->sub_conn[idx].connection.is_ip4);
1554 #if SCTP_DEBUG_STATE_MACHINE
1556 sctp_validate_output_state_machine (sctp_connection_t * sctp_conn,
1560 switch (sctp_conn->state)
1562 case SCTP_STATE_CLOSED:
1563 if (chunk_type != INIT && chunk_type != INIT_ACK)
1566 case SCTP_STATE_ESTABLISHED:
1567 if (chunk_type != DATA && chunk_type != HEARTBEAT &&
1568 chunk_type != HEARTBEAT_ACK && chunk_type != SACK &&
1569 chunk_type != COOKIE_ACK && chunk_type != SHUTDOWN)
1572 case SCTP_STATE_COOKIE_WAIT:
1573 if (chunk_type != COOKIE_ECHO)
1576 case SCTP_STATE_SHUTDOWN_SENT:
1577 if (chunk_type != SHUTDOWN_COMPLETE)
1580 case SCTP_STATE_SHUTDOWN_RECEIVED:
1581 if (chunk_type != SHUTDOWN_ACK)
1590 sctp_is_retransmitting (sctp_connection_t * sctp_conn, u8 idx)
1592 return sctp_conn->sub_conn[idx].is_retransmitting;
1596 sctp46_output_inline (vlib_main_t * vm,
1597 vlib_node_runtime_t * node,
1598 vlib_frame_t * from_frame, int is_ip4)
1600 u32 n_left_from, next_index, *from, *to_next;
1601 u32 my_thread_index = vm->thread_index;
1603 from = vlib_frame_vector_args (from_frame);
1604 n_left_from = from_frame->n_vectors;
1605 next_index = node->cached_next_index;
1606 sctp_set_time_now (my_thread_index);
1608 while (n_left_from > 0)
1612 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1614 while (n_left_from > 0 && n_left_to_next > 0)
1618 sctp_header_t *sctp_hdr = 0;
1619 sctp_connection_t *sctp_conn;
1620 sctp_tx_trace_t *t0;
1621 sctp_header_t *th0 = 0;
1622 u32 error0 = SCTP_ERROR_PKTS_SENT, next0 =
1623 SCTP_OUTPUT_NEXT_IP_LOOKUP;
1625 #if SCTP_DEBUG_STATE_MACHINE
1626 u16 packet_length = 0;
1634 n_left_to_next -= 1;
1636 b0 = vlib_get_buffer (vm, bi0);
1639 sctp_connection_get (vnet_buffer (b0)->sctp.connection_index,
1642 if (PREDICT_FALSE (sctp_conn == 0))
1644 error0 = SCTP_ERROR_INVALID_CONNECTION;
1645 next0 = SCTP_OUTPUT_NEXT_DROP;
1649 u8 idx = vnet_buffer (b0)->sctp.subconn_idx;
1651 th0 = vlib_buffer_get_current (b0);
1655 ip4_header_t *iph4 = vlib_buffer_push_ip4 (vm,
1657 &sctp_conn->sub_conn
1664 IP_PROTOCOL_SCTP, 1);
1666 u32 checksum = ip4_sctp_compute_checksum (vm, b0, iph4);
1668 sctp_hdr = ip4_next_header (iph4);
1669 sctp_hdr->checksum = checksum;
1671 vnet_buffer (b0)->l4_hdr_offset = (u8 *) th0 - b0->data;
1673 #if SCTP_DEBUG_STATE_MACHINE
1674 packet_length = clib_net_to_host_u16 (iph4->length);
1679 ip6_header_t *iph6 = vlib_buffer_push_ip6 (vm,
1681 &sctp_conn->sub_conn
1685 &sctp_conn->sub_conn
1692 u32 checksum = ip6_sctp_compute_checksum (vm, b0, iph6, &bogus);
1695 sctp_hdr = ip6_next_header (iph6);
1696 sctp_hdr->checksum = checksum;
1698 vnet_buffer (b0)->l3_hdr_offset = (u8 *) iph6 - b0->data;
1699 vnet_buffer (b0)->l4_hdr_offset = (u8 *) th0 - b0->data;
1701 #if SCTP_DEBUG_STATE_MACHINE
1702 packet_length = clib_net_to_host_u16 (iph6->payload_length);
1706 sctp_full_hdr_t *full_hdr = (sctp_full_hdr_t *) sctp_hdr;
1707 u8 chunk_type = vnet_sctp_get_chunk_type (&full_hdr->common_hdr);
1708 if (chunk_type >= UNKNOWN)
1711 ("Trying to send an unrecognized chunk... something is really bad.");
1712 error0 = SCTP_ERROR_UNKNOWN_CHUNK;
1713 next0 = SCTP_OUTPUT_NEXT_DROP;
1717 #if SCTP_DEBUG_STATE_MACHINE
1719 (sctp_conn->sub_conn[idx].connection.lcl_port ==
1721 || sctp_conn->sub_conn[idx].connection.lcl_port ==
1723 && (sctp_conn->sub_conn[idx].connection.rmt_port ==
1725 || sctp_conn->sub_conn[idx].connection.rmt_port ==
1726 sctp_hdr->src_port);
1730 SCTP_DBG_STATE_MACHINE ("BUFFER IS INCORRECT: conn_index = %u, "
1731 "packet_length = %u, "
1732 "chunk_type = %u [%s], "
1733 "connection.lcl_port = %u, sctp_hdr->src_port = %u, "
1734 "connection.rmt_port = %u, sctp_hdr->dst_port = %u",
1735 sctp_conn->sub_conn[idx].
1736 connection.c_index, packet_length,
1738 sctp_chunk_to_string (chunk_type),
1739 sctp_conn->sub_conn[idx].
1740 connection.lcl_port, sctp_hdr->src_port,
1741 sctp_conn->sub_conn[idx].
1742 connection.rmt_port,
1743 sctp_hdr->dst_port);
1745 error0 = SCTP_ERROR_UNKNOWN_CHUNK;
1746 next0 = SCTP_OUTPUT_NEXT_DROP;
1750 SCTP_DBG_STATE_MACHINE
1751 ("SESSION_INDEX = %u, CONN_INDEX = %u, CURR_CONN_STATE = %u (%s), "
1752 "CHUNK_TYPE = %s, " "SRC_PORT = %u, DST_PORT = %u",
1753 sctp_conn->sub_conn[idx].connection.s_index,
1754 sctp_conn->sub_conn[idx].connection.c_index,
1755 sctp_conn->state, sctp_state_to_string (sctp_conn->state),
1756 sctp_chunk_to_string (chunk_type), full_hdr->hdr.src_port,
1757 full_hdr->hdr.dst_port);
1759 /* Let's make sure the state-machine does not send anything crazy */
1760 #if SCTP_DEBUG_STATE_MACHINE
1761 if (sctp_validate_output_state_machine (sctp_conn, chunk_type) != 0)
1763 SCTP_DBG_STATE_MACHINE
1764 ("Sending the wrong chunk (%s) based on state-machine status (%s)",
1765 sctp_chunk_to_string (chunk_type),
1766 sctp_state_to_string (sctp_conn->state));
1768 error0 = SCTP_ERROR_UNKNOWN_CHUNK;
1769 next0 = SCTP_OUTPUT_NEXT_DROP;
1775 /* Karn's algorithm: RTT measurements MUST NOT be made using
1776 * packets that were retransmitted
1778 if (!sctp_is_retransmitting (sctp_conn, idx))
1780 /* Measure RTT with this */
1781 if (chunk_type == DATA
1782 && sctp_conn->sub_conn[idx].RTO_pending == 0)
1784 sctp_conn->sub_conn[idx].RTO_pending = 1;
1785 sctp_conn->sub_conn[idx].rtt_ts = sctp_time_now ();
1788 sctp_conn->sub_conn[idx].rtt_ts = sctp_time_now ();
1791 /* Let's take care of TIMERS */
1796 sctp_conn->state = SCTP_STATE_COOKIE_ECHOED;
1801 SCTP_ADV_DBG_OUTPUT ("PACKET_LENGTH = %u", packet_length);
1803 sctp_timer_update (sctp_conn, idx, SCTP_TIMER_T3_RXTX,
1804 sctp_conn->sub_conn[idx].RTO);
1809 /* Start the SCTP_TIMER_T2_SHUTDOWN timer */
1810 sctp_timer_set (sctp_conn, idx, SCTP_TIMER_T2_SHUTDOWN,
1811 sctp_conn->sub_conn[idx].RTO);
1812 sctp_conn->state = SCTP_STATE_SHUTDOWN_SENT;
1817 /* Start the SCTP_TIMER_T2_SHUTDOWN timer */
1818 sctp_timer_set (sctp_conn, idx, SCTP_TIMER_T2_SHUTDOWN,
1819 sctp_conn->sub_conn[idx].RTO);
1820 sctp_conn->state = SCTP_STATE_SHUTDOWN_ACK_SENT;
1823 case SHUTDOWN_COMPLETE:
1825 sctp_conn->state = SCTP_STATE_CLOSED;
1830 vnet_buffer (b0)->sw_if_index[VLIB_RX] = 0;
1831 vnet_buffer (b0)->sw_if_index[VLIB_TX] =
1832 sctp_conn->sub_conn[idx].c_fib_index;
1834 b0->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
1836 SCTP_DBG_STATE_MACHINE
1837 ("SESSION_INDEX = %u, CONNECTION_INDEX = %u, " "NEW_STATE = %s, "
1838 "CHUNK_SENT = %s", sctp_conn->sub_conn[idx].connection.s_index,
1839 sctp_conn->sub_conn[idx].connection.c_index,
1840 sctp_state_to_string (sctp_conn->state),
1841 sctp_chunk_to_string (chunk_type));
1843 vnet_sctp_common_hdr_params_host_to_net (&full_hdr->common_hdr);
1846 b0->error = node->errors[error0];
1847 if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
1849 t0 = vlib_add_trace (vm, node, b0, sizeof (*t0));
1852 clib_memcpy_fast (&t0->sctp_header, th0,
1853 sizeof (t0->sctp_header));
1857 clib_memset (&t0->sctp_header, 0, sizeof (t0->sctp_header));
1859 clib_memcpy_fast (&t0->sctp_connection, sctp_conn,
1860 sizeof (t0->sctp_connection));
1863 vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1864 n_left_to_next, bi0, next0);
1867 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1870 return from_frame->n_vectors;
1874 sctp4_output (vlib_main_t * vm, vlib_node_runtime_t * node,
1875 vlib_frame_t * from_frame)
1877 return sctp46_output_inline (vm, node, from_frame, 1 /* is_ip4 */ );
1881 sctp6_output (vlib_main_t * vm, vlib_node_runtime_t * node,
1882 vlib_frame_t * from_frame)
1884 return sctp46_output_inline (vm, node, from_frame, 0 /* is_ip4 */ );
1888 VLIB_REGISTER_NODE (sctp4_output_node) =
1890 .function = sctp4_output,.name = "sctp4-output",
1891 /* Takes a vector of packets. */
1892 .vector_size = sizeof (u32),
1893 .n_errors = SCTP_N_ERROR,
1894 .error_strings = sctp_error_strings,
1895 .n_next_nodes = SCTP_OUTPUT_N_NEXT,
1897 #define _(s,n) [SCTP_OUTPUT_NEXT_##s] = n,
1898 foreach_sctp4_output_next
1901 .format_buffer = format_sctp_header,
1902 .format_trace = format_sctp_tx_trace,
1906 VLIB_NODE_FUNCTION_MULTIARCH (sctp4_output_node, sctp4_output);
1909 VLIB_REGISTER_NODE (sctp6_output_node) =
1911 .function = sctp6_output,
1912 .name = "sctp6-output",
1913 /* Takes a vector of packets. */
1914 .vector_size = sizeof (u32),
1915 .n_errors = SCTP_N_ERROR,
1916 .error_strings = sctp_error_strings,
1917 .n_next_nodes = SCTP_OUTPUT_N_NEXT,
1919 #define _(s,n) [SCTP_OUTPUT_NEXT_##s] = n,
1920 foreach_sctp6_output_next
1923 .format_buffer = format_sctp_header,
1924 .format_trace = format_sctp_tx_trace,
1928 VLIB_NODE_FUNCTION_MULTIARCH (sctp6_output_node, sctp6_output);
1931 * fd.io coding-style-patch-verification: ON
1934 * eval: (c-set-style "gnu")