blob: bb8332f5732d9c27f5893bbc122b95a3063b7a09 [file] [log] [blame]
Marco Varlese191a5942017-10-30 18:17:21 +01001/*
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>
Marco Varlese91389ac2018-01-31 11:00:01 +010018#include <openssl/hmac.h>
Marco Varlese191a5942017-10-30 18:17:21 +010019
20vlib_node_registration_t sctp4_output_node;
21vlib_node_registration_t sctp6_output_node;
22
23typedef 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
38static char *sctp_error_strings[] = {
39#define sctp_error(n,s) s,
40#include <vnet/sctp/sctp_error.def>
41#undef sctp_error
42};
43
44typedef 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 */
53void
54sctp_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 */
69always_inline void
70sctp_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 */
86void
87sctp_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
96u32
97ip4_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
153u32
154ip6_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
227void
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100228sctp_push_ip_hdr (sctp_main_t * tm, sctp_sub_connection_t * sctp_sub_conn,
Marco Varlese191a5942017-10-30 18:17:21 +0100229 vlib_buffer_t * b)
230{
231 sctp_header_t *th = vlib_buffer_get_current (b);
232 vlib_main_t *vm = vlib_get_main ();
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100233 if (sctp_sub_conn->c_is_ip4)
Marco Varlese191a5942017-10-30 18:17:21 +0100234 {
235 ip4_header_t *ih;
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100236 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);
Marco Varlese191a5942017-10-30 18:17:21 +0100239 th->checksum = ip4_sctp_compute_checksum (vm, b, ih);
240 }
241 else
242 {
243 ip6_header_t *ih;
244 int bogus = ~0;
245
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100246 ih = vlib_buffer_push_ip6 (vm, b, &sctp_sub_conn->c_lcl_ip6,
247 &sctp_sub_conn->c_rmt_ip6, IP_PROTOCOL_SCTP);
Marco Varlese191a5942017-10-30 18:17:21 +0100248 th->checksum = ip6_sctp_compute_checksum (vm, b, ih, &bogus);
249 ASSERT (!bogus);
250 }
251}
252
253always_inline void *
254sctp_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
265 /* Leave enough space for headers */
266 return vlib_buffer_make_headroom (b, MAX_HDRS_LEN);
267}
268
269always_inline void *
270sctp_init_buffer (vlib_main_t * vm, vlib_buffer_t * b)
271{
272 ASSERT ((b->flags & VLIB_BUFFER_NEXT_PRESENT) == 0);
Damjan Mariondac03522018-02-01 15:30:13 +0100273 b->flags &= VLIB_BUFFER_NON_DEFAULT_FREELIST;
Marco Varlese191a5942017-10-30 18:17:21 +0100274 b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
275 b->total_length_not_including_first_buffer = 0;
276 vnet_buffer (b)->sctp.flags = 0;
277 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b);
278 /* Leave enough space for headers */
279 return vlib_buffer_make_headroom (b, MAX_HDRS_LEN);
280}
281
282always_inline int
283sctp_alloc_tx_buffers (sctp_main_t * tm, u8 thread_index, u32 n_free_buffers)
284{
285 vlib_main_t *vm = vlib_get_main ();
286 u32 current_length = vec_len (tm->tx_buffers[thread_index]);
287 u32 n_allocated;
288
289 vec_validate (tm->tx_buffers[thread_index],
290 current_length + n_free_buffers - 1);
291 n_allocated =
292 vlib_buffer_alloc (vm, &tm->tx_buffers[thread_index][current_length],
293 n_free_buffers);
294 _vec_len (tm->tx_buffers[thread_index]) = current_length + n_allocated;
295 /* buffer shortage, report failure */
296 if (vec_len (tm->tx_buffers[thread_index]) == 0)
297 {
298 clib_warning ("out of buffers");
299 return -1;
300 }
301 return 0;
302}
303
304always_inline int
305sctp_get_free_buffer_index (sctp_main_t * tm, u32 * bidx)
306{
307 u32 *my_tx_buffers;
308 u32 thread_index = vlib_get_thread_index ();
309 if (PREDICT_FALSE (vec_len (tm->tx_buffers[thread_index]) == 0))
310 {
311 if (sctp_alloc_tx_buffers (tm, thread_index, VLIB_FRAME_SIZE))
312 return -1;
313 }
314 my_tx_buffers = tm->tx_buffers[thread_index];
315 *bidx = my_tx_buffers[vec_len (my_tx_buffers) - 1];
316 _vec_len (my_tx_buffers) -= 1;
317 return 0;
318}
319
320always_inline void
321sctp_enqueue_to_output_i (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
322 u8 is_ip4, u8 flush)
323{
324 sctp_main_t *tm = vnet_get_sctp_main ();
325 u32 thread_index = vlib_get_thread_index ();
326 u32 *to_next, next_index;
327 vlib_frame_t *f;
328
329 b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
330 b->error = 0;
331
332 /* Decide where to send the packet */
333 next_index = is_ip4 ? sctp4_output_node.index : sctp6_output_node.index;
334 sctp_trajectory_add_start (b, 2);
335
336 /* Get frame to v4/6 output node */
337 f = tm->tx_frames[!is_ip4][thread_index];
338 if (!f)
339 {
340 f = vlib_get_frame_to_node (vm, next_index);
341 ASSERT (f);
342 tm->tx_frames[!is_ip4][thread_index] = f;
343 }
344 to_next = vlib_frame_vector_args (f);
345 to_next[f->n_vectors] = bi;
346 f->n_vectors += 1;
347 if (flush || f->n_vectors == VLIB_FRAME_SIZE)
348 {
349 vlib_put_frame_to_node (vm, next_index, f);
350 tm->tx_frames[!is_ip4][thread_index] = 0;
351 }
352}
353
354always_inline void
Marco Varlesedf5a99c2018-02-06 13:48:30 +0100355sctp_enqueue_to_output (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
356 u8 is_ip4)
357{
358 sctp_enqueue_to_output_i (vm, b, bi, is_ip4, 0);
359}
360
361always_inline void
Marco Varlese191a5942017-10-30 18:17:21 +0100362sctp_enqueue_to_output_now (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
363 u8 is_ip4)
364{
365 sctp_enqueue_to_output_i (vm, b, bi, is_ip4, 1);
366}
367
368always_inline void
369sctp_enqueue_to_ip_lookup_i (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
370 u8 is_ip4, u8 flush)
371{
372 sctp_main_t *tm = vnet_get_sctp_main ();
373 u32 thread_index = vlib_get_thread_index ();
374 u32 *to_next, next_index;
375 vlib_frame_t *f;
376
377 b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
378 b->error = 0;
379
380 /* Default FIB for now */
381 vnet_buffer (b)->sw_if_index[VLIB_TX] = 0;
382
383 /* Send to IP lookup */
384 next_index = is_ip4 ? ip4_lookup_node.index : ip6_lookup_node.index;
385 if (VLIB_BUFFER_TRACE_TRAJECTORY > 0)
386 {
387 b->pre_data[0] = 2;
388 b->pre_data[1] = next_index;
389 }
390
391 f = tm->ip_lookup_tx_frames[!is_ip4][thread_index];
392 if (!f)
393 {
394 f = vlib_get_frame_to_node (vm, next_index);
395 ASSERT (f);
396 tm->ip_lookup_tx_frames[!is_ip4][thread_index] = f;
397 }
398
399 to_next = vlib_frame_vector_args (f);
400 to_next[f->n_vectors] = bi;
401 f->n_vectors += 1;
402 if (flush || f->n_vectors == VLIB_FRAME_SIZE)
403 {
404 vlib_put_frame_to_node (vm, next_index, f);
405 tm->ip_lookup_tx_frames[!is_ip4][thread_index] = 0;
406 }
407}
408
409always_inline void
410sctp_enqueue_to_ip_lookup (vlib_main_t * vm, vlib_buffer_t * b, u32 bi,
411 u8 is_ip4)
412{
413 sctp_enqueue_to_ip_lookup_i (vm, b, bi, is_ip4, 0);
414}
415
Marco Varlese191a5942017-10-30 18:17:21 +0100416/**
417 * Convert buffer to INIT
418 */
419void
420sctp_prepare_init_chunk (sctp_connection_t * sctp_conn, vlib_buffer_t * b)
421{
422 u32 random_seed = random_default_seed ();
423 u16 alloc_bytes = sizeof (sctp_init_chunk_t);
424 sctp_sub_connection_t *sub_conn =
425 &sctp_conn->sub_conn[sctp_pick_conn_idx_on_chunk (INIT)];
426
427 sctp_ipv4_addr_param_t *ip4_param = 0;
428 sctp_ipv6_addr_param_t *ip6_param = 0;
429
430 if (sub_conn->c_is_ip4)
431 alloc_bytes += sizeof (sctp_ipv4_addr_param_t);
432 else
433 alloc_bytes += sizeof (sctp_ipv6_addr_param_t);
434
435 /* As per RFC 4960 the chunk_length value does NOT contemplate
436 * the size of the first header (see sctp_header_t) and any padding
437 */
438 u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
439
440 alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
441
442 sctp_init_chunk_t *init_chunk = vlib_buffer_push_uninit (b, alloc_bytes);
443
444 u16 pointer_offset = sizeof (init_chunk);
445 if (sub_conn->c_is_ip4)
446 {
447 ip4_param = (sctp_ipv4_addr_param_t *) init_chunk + pointer_offset;
448 ip4_param->address.as_u32 = sub_conn->c_lcl_ip.ip4.as_u32;
449
450 pointer_offset += sizeof (sctp_ipv4_addr_param_t);
451 }
452 else
453 {
454 ip6_param = (sctp_ipv6_addr_param_t *) init_chunk + pointer_offset;
455 ip6_param->address.as_u64[0] = sub_conn->c_lcl_ip.ip6.as_u64[0];
456 ip6_param->address.as_u64[1] = sub_conn->c_lcl_ip.ip6.as_u64[1];
457
458 pointer_offset += sizeof (sctp_ipv6_addr_param_t);
459 }
460
461 init_chunk->sctp_hdr.src_port = sub_conn->c_lcl_port; /* No need of host_to_net conversion, already in net-byte order */
462 init_chunk->sctp_hdr.dst_port = sub_conn->c_rmt_port; /* No need of host_to_net conversion, already in net-byte order */
463 init_chunk->sctp_hdr.checksum = 0;
464 /* The sender of an INIT must set the VERIFICATION_TAG to 0 as per RFC 4960 Section 8.5.1 */
465 init_chunk->sctp_hdr.verification_tag = 0x0;
466
467 vnet_sctp_set_chunk_type (&init_chunk->chunk_hdr, INIT);
468 vnet_sctp_set_chunk_length (&init_chunk->chunk_hdr, chunk_len);
469 vnet_sctp_common_hdr_params_host_to_net (&init_chunk->chunk_hdr);
470
471 init_chunk->a_rwnd = clib_host_to_net_u32 (DEFAULT_A_RWND);
472 init_chunk->initiate_tag = clib_host_to_net_u32 (random_u32 (&random_seed));
473 init_chunk->inboud_streams_count =
474 clib_host_to_net_u16 (INBOUND_STREAMS_COUNT);
475 init_chunk->outbound_streams_count =
476 clib_host_to_net_u16 (OUTBOUND_STREAMS_COUNT);
477
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100478 init_chunk->initial_tsn =
479 clib_host_to_net_u32 (sctp_conn->local_initial_tsn);
480 SCTP_CONN_TRACKING_DBG ("sctp_conn->local_initial_tsn = %u",
481 sctp_conn->local_initial_tsn);
482
Marco Varlese191a5942017-10-30 18:17:21 +0100483 sctp_conn->local_tag = init_chunk->initiate_tag;
484
485 vnet_buffer (b)->sctp.connection_index = sub_conn->c_c_index;
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
Marco Varlese91389ac2018-01-31 11:00:01 +0100498void
499sctp_compute_mac (sctp_connection_t * sctp_conn,
500 sctp_state_cookie_param_t * state_cookie)
Marco Varlese191a5942017-10-30 18:17:21 +0100501{
Marco Varlese91389ac2018-01-31 11:00:01 +0100502#if OPENSSL_VERSION_NUMBER >= 0x10100000L
503 HMAC_CTX *ctx;
504#else
505 HMAC_CTX ctx;
Marco Varlese91389ac2018-01-31 11:00:01 +0100506#endif
507 unsigned int len = 0;
Marco Varlese18b63152018-02-12 09:08:21 +0100508 const EVP_MD *md = EVP_sha1 ();
Marco Varlese91389ac2018-01-31 11:00:01 +0100509#if OPENSSL_VERSION_NUMBER >= 0x10100000L
510 ctx = HMAC_CTX_new ();
Marco Varlese18b63152018-02-12 09:08:21 +0100511 HMAC_Init_ex (ctx, &state_cookie->creation_time,
Marco Varlese91389ac2018-01-31 11:00:01 +0100512 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);
Marco Varlese91389ac2018-01-31 11:00:01 +0100519 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);
Marco Varlese191a5942017-10-30 18:17:21 +0100525}
526
527void
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100528sctp_prepare_cookie_ack_chunk (sctp_connection_t * sctp_conn,
529 vlib_buffer_t * b)
Marco Varlese191a5942017-10-30 18:17:21 +0100530{
531 vlib_main_t *vm = vlib_get_main ();
532 u8 idx = sctp_pick_conn_idx_on_chunk (COOKIE_ACK);
533
534 sctp_reuse_buffer (vm, b);
535
536 u16 alloc_bytes = sizeof (sctp_cookie_ack_chunk_t);
537
538 /* As per RFC 4960 the chunk_length value does NOT contemplate
539 * the size of the first header (see sctp_header_t) and any padding
540 */
541 u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
542
543 alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
544
545 sctp_cookie_ack_chunk_t *cookie_ack_chunk =
546 vlib_buffer_push_uninit (b, alloc_bytes);
547
548 cookie_ack_chunk->sctp_hdr.checksum = 0;
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100549 cookie_ack_chunk->sctp_hdr.src_port =
550 sctp_conn->sub_conn[idx].connection.lcl_port;
551 cookie_ack_chunk->sctp_hdr.dst_port =
552 sctp_conn->sub_conn[idx].connection.rmt_port;
553 cookie_ack_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
Marco Varlese191a5942017-10-30 18:17:21 +0100554 vnet_sctp_set_chunk_type (&cookie_ack_chunk->chunk_hdr, COOKIE_ACK);
555 vnet_sctp_set_chunk_length (&cookie_ack_chunk->chunk_hdr, chunk_len);
556
557 vnet_buffer (b)->sctp.connection_index =
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100558 sctp_conn->sub_conn[idx].connection.c_index;
Marco Varlese191a5942017-10-30 18:17:21 +0100559}
560
561void
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100562sctp_prepare_cookie_echo_chunk (sctp_connection_t * sctp_conn,
563 vlib_buffer_t * b,
Marco Varlese191a5942017-10-30 18:17:21 +0100564 sctp_state_cookie_param_t * sc)
565{
566 vlib_main_t *vm = vlib_get_main ();
567 u8 idx = sctp_pick_conn_idx_on_chunk (COOKIE_ECHO);
568
569 sctp_reuse_buffer (vm, b);
570
571 /* The minimum size of the message is given by the sctp_init_ack_chunk_t */
572 u16 alloc_bytes = sizeof (sctp_cookie_echo_chunk_t);
573 /* As per RFC 4960 the chunk_length value does NOT contemplate
574 * the size of the first header (see sctp_header_t) and any padding
575 */
576 u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
577 alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
578 sctp_cookie_echo_chunk_t *cookie_echo_chunk =
579 vlib_buffer_push_uninit (b, alloc_bytes);
580 cookie_echo_chunk->sctp_hdr.checksum = 0;
581 cookie_echo_chunk->sctp_hdr.src_port =
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100582 sctp_conn->sub_conn[idx].connection.lcl_port;
Marco Varlese191a5942017-10-30 18:17:21 +0100583 cookie_echo_chunk->sctp_hdr.dst_port =
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100584 sctp_conn->sub_conn[idx].connection.rmt_port;
585 cookie_echo_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
Marco Varlese191a5942017-10-30 18:17:21 +0100586 vnet_sctp_set_chunk_type (&cookie_echo_chunk->chunk_hdr, COOKIE_ECHO);
587 vnet_sctp_set_chunk_length (&cookie_echo_chunk->chunk_hdr, chunk_len);
588 clib_memcpy (&(cookie_echo_chunk->cookie), sc,
589 sizeof (sctp_state_cookie_param_t));
Marco Varlese21c8baf2018-02-02 17:17:51 +0100590
Marco Varlese191a5942017-10-30 18:17:21 +0100591 vnet_buffer (b)->sctp.connection_index =
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100592 sctp_conn->sub_conn[idx].connection.c_index;
Marco Varlese191a5942017-10-30 18:17:21 +0100593}
594
595/**
596 * Convert buffer to INIT-ACK
597 */
598void
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100599sctp_prepare_initack_chunk (sctp_connection_t * sctp_conn, vlib_buffer_t * b,
Marco Varlese191a5942017-10-30 18:17:21 +0100600 ip4_address_t * ip4_addr,
601 ip6_address_t * ip6_addr)
602{
603 vlib_main_t *vm = vlib_get_main ();
604 sctp_ipv4_addr_param_t *ip4_param = 0;
605 sctp_ipv6_addr_param_t *ip6_param = 0;
606 u8 idx = sctp_pick_conn_idx_on_chunk (INIT_ACK);
607 u32 random_seed = random_default_seed ();
608
609 sctp_reuse_buffer (vm, b);
610
611 /* The minimum size of the message is given by the sctp_init_ack_chunk_t */
612 u16 alloc_bytes =
613 sizeof (sctp_init_ack_chunk_t) + sizeof (sctp_state_cookie_param_t);
614
615 if (PREDICT_TRUE (ip4_addr != NULL))
616 {
617 /* Create room for variable-length fields in the INIT_ACK chunk */
618 alloc_bytes += SCTP_IPV4_ADDRESS_TYPE_LENGTH;
619 }
620 if (PREDICT_TRUE (ip6_addr != NULL))
621 {
622 /* Create room for variable-length fields in the INIT_ACK chunk */
623 alloc_bytes += SCTP_IPV6_ADDRESS_TYPE_LENGTH;
624 }
625
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100626 if (sctp_conn->sub_conn[idx].connection.is_ip4)
Marco Varlese191a5942017-10-30 18:17:21 +0100627 alloc_bytes += sizeof (sctp_ipv4_addr_param_t);
628 else
629 alloc_bytes += sizeof (sctp_ipv6_addr_param_t);
630
631 /* As per RFC 4960 the chunk_length value does NOT contemplate
632 * the size of the first header (see sctp_header_t) and any padding
633 */
634 u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
635
636 alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
637
638 sctp_init_ack_chunk_t *init_ack_chunk =
639 vlib_buffer_push_uninit (b, alloc_bytes);
640
641 u16 pointer_offset = sizeof (sctp_init_ack_chunk_t);
642
643 /* Create State Cookie parameter */
644 sctp_state_cookie_param_t *state_cookie_param =
645 (sctp_state_cookie_param_t *) ((char *) init_ack_chunk + pointer_offset);
646
647 state_cookie_param->param_hdr.type =
648 clib_host_to_net_u16 (SCTP_STATE_COOKIE_TYPE);
649 state_cookie_param->param_hdr.length =
650 clib_host_to_net_u16 (sizeof (sctp_state_cookie_param_t));
651 state_cookie_param->creation_time = clib_host_to_net_u32 (sctp_time_now ());
652 state_cookie_param->cookie_lifespan =
653 clib_host_to_net_u32 (SCTP_VALID_COOKIE_LIFE);
Marco Varlese91389ac2018-01-31 11:00:01 +0100654
655 sctp_compute_mac (sctp_conn, state_cookie_param);
Marco Varlese191a5942017-10-30 18:17:21 +0100656
657 pointer_offset += sizeof (sctp_state_cookie_param_t);
658
659 if (PREDICT_TRUE (ip4_addr != NULL))
660 {
661 sctp_ipv4_addr_param_t *ipv4_addr =
662 (sctp_ipv4_addr_param_t *) init_ack_chunk + pointer_offset;
663
664 ipv4_addr->param_hdr.type =
665 clib_host_to_net_u16 (SCTP_IPV4_ADDRESS_TYPE);
666 ipv4_addr->param_hdr.length =
667 clib_host_to_net_u16 (SCTP_IPV4_ADDRESS_TYPE_LENGTH);
668 ipv4_addr->address.as_u32 = ip4_addr->as_u32;
669
670 pointer_offset += SCTP_IPV4_ADDRESS_TYPE_LENGTH;
671 }
672 if (PREDICT_TRUE (ip6_addr != NULL))
673 {
674 sctp_ipv6_addr_param_t *ipv6_addr =
Marco Varlesef429a932018-02-06 17:31:06 +0100675 (sctp_ipv6_addr_param_t *) init_ack_chunk + pointer_offset;
Marco Varlese191a5942017-10-30 18:17:21 +0100676
677 ipv6_addr->param_hdr.type =
678 clib_host_to_net_u16 (SCTP_IPV6_ADDRESS_TYPE);
679 ipv6_addr->param_hdr.length =
680 clib_host_to_net_u16 (SCTP_IPV6_ADDRESS_TYPE_LENGTH);
681 ipv6_addr->address.as_u64[0] = ip6_addr->as_u64[0];
682 ipv6_addr->address.as_u64[1] = ip6_addr->as_u64[1];
683
684 pointer_offset += SCTP_IPV6_ADDRESS_TYPE_LENGTH;
685 }
686
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100687 if (sctp_conn->sub_conn[idx].connection.is_ip4)
Marco Varlese191a5942017-10-30 18:17:21 +0100688 {
689 ip4_param = (sctp_ipv4_addr_param_t *) init_ack_chunk + pointer_offset;
690 ip4_param->address.as_u32 =
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100691 sctp_conn->sub_conn[idx].connection.lcl_ip.ip4.as_u32;
Marco Varlese191a5942017-10-30 18:17:21 +0100692
693 pointer_offset += sizeof (sctp_ipv4_addr_param_t);
694 }
695 else
696 {
697 ip6_param = (sctp_ipv6_addr_param_t *) init_ack_chunk + pointer_offset;
698 ip6_param->address.as_u64[0] =
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100699 sctp_conn->sub_conn[idx].connection.lcl_ip.ip6.as_u64[0];
Marco Varlese191a5942017-10-30 18:17:21 +0100700 ip6_param->address.as_u64[1] =
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100701 sctp_conn->sub_conn[idx].connection.lcl_ip.ip6.as_u64[1];
Marco Varlese191a5942017-10-30 18:17:21 +0100702
703 pointer_offset += sizeof (sctp_ipv6_addr_param_t);
704 }
705
706 /* src_port & dst_port are already in network byte-order */
707 init_ack_chunk->sctp_hdr.checksum = 0;
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100708 init_ack_chunk->sctp_hdr.src_port =
709 sctp_conn->sub_conn[idx].connection.lcl_port;
710 init_ack_chunk->sctp_hdr.dst_port =
711 sctp_conn->sub_conn[idx].connection.rmt_port;
712 /* the sctp_conn->verification_tag is already in network byte-order (being a copy of the init_tag coming with the INIT chunk) */
713 init_ack_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
714 init_ack_chunk->initial_tsn =
715 clib_host_to_net_u32 (sctp_conn->local_initial_tsn);
716 SCTP_CONN_TRACKING_DBG ("init_ack_chunk->initial_tsn = %u",
717 init_ack_chunk->initial_tsn);
Marco Varlese191a5942017-10-30 18:17:21 +0100718
719 vnet_sctp_set_chunk_type (&init_ack_chunk->chunk_hdr, INIT_ACK);
720 vnet_sctp_set_chunk_length (&init_ack_chunk->chunk_hdr, chunk_len);
721
722 init_ack_chunk->initiate_tag =
723 clib_host_to_net_u32 (random_u32 (&random_seed));
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100724
Marco Varlese191a5942017-10-30 18:17:21 +0100725 init_ack_chunk->a_rwnd = clib_host_to_net_u32 (DEFAULT_A_RWND);
726 init_ack_chunk->inboud_streams_count =
727 clib_host_to_net_u16 (INBOUND_STREAMS_COUNT);
728 init_ack_chunk->outbound_streams_count =
729 clib_host_to_net_u16 (OUTBOUND_STREAMS_COUNT);
730
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100731 sctp_conn->local_tag = init_ack_chunk->initiate_tag;
Marco Varlese191a5942017-10-30 18:17:21 +0100732
733 vnet_buffer (b)->sctp.connection_index =
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100734 sctp_conn->sub_conn[idx].connection.c_index;
Marco Varlese191a5942017-10-30 18:17:21 +0100735}
736
737/**
738 * Convert buffer to SHUTDOWN
739 */
740void
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100741sctp_prepare_shutdown_chunk (sctp_connection_t * sctp_conn, vlib_buffer_t * b)
Marco Varlese191a5942017-10-30 18:17:21 +0100742{
Marco Varlese191a5942017-10-30 18:17:21 +0100743 u8 idx = sctp_pick_conn_idx_on_chunk (SHUTDOWN);
744 u16 alloc_bytes = sizeof (sctp_shutdown_association_chunk_t);
745
Marco Varlese191a5942017-10-30 18:17:21 +0100746 /* As per RFC 4960 the chunk_length value does NOT contemplate
747 * the size of the first header (see sctp_header_t) and any padding
748 */
749 u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
750
751 alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
752
753 sctp_shutdown_association_chunk_t *shutdown_chunk =
754 vlib_buffer_push_uninit (b, alloc_bytes);
755
756 shutdown_chunk->sctp_hdr.checksum = 0;
757 /* No need of host_to_net conversion, already in net-byte order */
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100758 shutdown_chunk->sctp_hdr.src_port =
759 sctp_conn->sub_conn[idx].connection.lcl_port;
760 shutdown_chunk->sctp_hdr.dst_port =
761 sctp_conn->sub_conn[idx].connection.rmt_port;
762 shutdown_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
Marco Varlese191a5942017-10-30 18:17:21 +0100763 vnet_sctp_set_chunk_type (&shutdown_chunk->chunk_hdr, SHUTDOWN);
764 vnet_sctp_set_chunk_length (&shutdown_chunk->chunk_hdr, chunk_len);
765
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100766 shutdown_chunk->cumulative_tsn_ack = sctp_conn->last_rcvd_tsn;
Marco Varlese191a5942017-10-30 18:17:21 +0100767
768 vnet_buffer (b)->sctp.connection_index =
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100769 sctp_conn->sub_conn[idx].connection.c_index;
Marco Varlese191a5942017-10-30 18:17:21 +0100770}
771
772/*
773 * Send SHUTDOWN
774 */
775void
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100776sctp_send_shutdown (sctp_connection_t * sctp_conn)
Marco Varlese191a5942017-10-30 18:17:21 +0100777{
778 vlib_buffer_t *b;
779 u32 bi;
780 sctp_main_t *tm = vnet_get_sctp_main ();
781 vlib_main_t *vm = vlib_get_main ();
782
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100783 if (sctp_check_outstanding_data_chunks (sctp_conn) > 0)
Marco Varlese191a5942017-10-30 18:17:21 +0100784 return;
785
786 if (PREDICT_FALSE (sctp_get_free_buffer_index (tm, &bi)))
787 return;
788
789 b = vlib_get_buffer (vm, bi);
790 sctp_init_buffer (vm, b);
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100791 sctp_prepare_shutdown_chunk (sctp_conn, b);
Marco Varlese191a5942017-10-30 18:17:21 +0100792
793 u8 idx = sctp_pick_conn_idx_on_chunk (SHUTDOWN);
Marco Varlesebe2251b2018-02-07 12:22:41 +0100794 sctp_enqueue_to_output_now (vm, b, bi,
795 sctp_conn->sub_conn[idx].connection.is_ip4);
Marco Varlese191a5942017-10-30 18:17:21 +0100796}
797
798/**
799 * Convert buffer to SHUTDOWN_ACK
800 */
801void
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100802sctp_prepare_shutdown_ack_chunk (sctp_connection_t * sctp_conn,
803 vlib_buffer_t * b)
Marco Varlese191a5942017-10-30 18:17:21 +0100804{
805 u8 idx = sctp_pick_conn_idx_on_chunk (SHUTDOWN_ACK);
806 u16 alloc_bytes = sizeof (sctp_shutdown_association_chunk_t);
807 alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
808
809 u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
810
811 sctp_shutdown_ack_chunk_t *shutdown_ack_chunk =
812 vlib_buffer_push_uninit (b, alloc_bytes);
813
814 shutdown_ack_chunk->sctp_hdr.checksum = 0;
815 /* No need of host_to_net conversion, already in net-byte order */
816 shutdown_ack_chunk->sctp_hdr.src_port =
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100817 sctp_conn->sub_conn[idx].connection.lcl_port;
Marco Varlese191a5942017-10-30 18:17:21 +0100818 shutdown_ack_chunk->sctp_hdr.dst_port =
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100819 sctp_conn->sub_conn[idx].connection.rmt_port;
820 shutdown_ack_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
Marco Varlese191a5942017-10-30 18:17:21 +0100821
822 vnet_sctp_set_chunk_type (&shutdown_ack_chunk->chunk_hdr, SHUTDOWN_ACK);
823 vnet_sctp_set_chunk_length (&shutdown_ack_chunk->chunk_hdr, chunk_len);
824
825 vnet_buffer (b)->sctp.connection_index =
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100826 sctp_conn->sub_conn[idx].connection.c_index;
Marco Varlese191a5942017-10-30 18:17:21 +0100827}
828
829/*
830 * Send SHUTDOWN_ACK
831 */
832void
Marco Varlesebe2251b2018-02-07 12:22:41 +0100833sctp_send_shutdown_ack (sctp_connection_t * sctp_conn, vlib_buffer_t * b)
Marco Varlese191a5942017-10-30 18:17:21 +0100834{
Marco Varlese191a5942017-10-30 18:17:21 +0100835 vlib_main_t *vm = vlib_get_main ();
836
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100837 if (sctp_check_outstanding_data_chunks (sctp_conn) > 0)
Marco Varlese191a5942017-10-30 18:17:21 +0100838 return;
839
Marco Varlesebe2251b2018-02-07 12:22:41 +0100840 sctp_reuse_buffer (vm, b);
Marco Varlese191a5942017-10-30 18:17:21 +0100841
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100842 sctp_prepare_shutdown_ack_chunk (sctp_conn, b);
Marco Varlese191a5942017-10-30 18:17:21 +0100843}
844
845/**
846 * Convert buffer to SACK
847 */
848void
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100849sctp_prepare_sack_chunk (sctp_connection_t * sctp_conn, vlib_buffer_t * b)
Marco Varlese191a5942017-10-30 18:17:21 +0100850{
851 vlib_main_t *vm = vlib_get_main ();
852 u8 idx = sctp_pick_conn_idx_on_chunk (SACK);
853
854 sctp_reuse_buffer (vm, b);
855
856 u16 alloc_bytes = sizeof (sctp_selective_ack_chunk_t);
857
858 /* As per RFC 4960 the chunk_length value does NOT contemplate
859 * the size of the first header (see sctp_header_t) and any padding
860 */
861 u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
862
863 alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
864
865 sctp_selective_ack_chunk_t *sack = vlib_buffer_push_uninit (b, alloc_bytes);
866
867 sack->sctp_hdr.checksum = 0;
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100868 sack->sctp_hdr.src_port = sctp_conn->sub_conn[idx].connection.lcl_port;
869 sack->sctp_hdr.dst_port = sctp_conn->sub_conn[idx].connection.rmt_port;
870 sack->sctp_hdr.verification_tag = sctp_conn->remote_tag;
Marco Varlese191a5942017-10-30 18:17:21 +0100871 vnet_sctp_set_chunk_type (&sack->chunk_hdr, SACK);
872 vnet_sctp_set_chunk_length (&sack->chunk_hdr, chunk_len);
873
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100874 sack->cumulative_tsn_ack = sctp_conn->next_tsn_expected;
875
876 sctp_conn->ack_state = 0;
877
Marco Varlese191a5942017-10-30 18:17:21 +0100878 vnet_buffer (b)->sctp.connection_index =
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100879 sctp_conn->sub_conn[idx].connection.c_index;
880}
881
882/**
Marco Varlesedf5a99c2018-02-06 13:48:30 +0100883 * Convert buffer to HEARTBEAT_ACK
884 */
885void
886sctp_prepare_heartbeat_ack_chunk (sctp_connection_t * sctp_conn,
887 vlib_buffer_t * b)
888{
889 vlib_main_t *vm = vlib_get_main ();
890
891 u8 idx = sctp_pick_conn_idx_on_chunk (HEARTBEAT_ACK);
892 u16 alloc_bytes = sizeof (sctp_hb_ack_chunk_t);
893
894 sctp_reuse_buffer (vm, b);
895
896 /* As per RFC 4960 the chunk_length value does NOT contemplate
897 * the size of the first header (see sctp_header_t) and any padding
898 */
899 u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
900
901 alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
902
903 sctp_hb_ack_chunk_t *hb_ack = vlib_buffer_push_uninit (b, alloc_bytes);
904
905 hb_ack->sctp_hdr.checksum = 0;
906 /* No need of host_to_net conversion, already in net-byte order */
907 hb_ack->sctp_hdr.src_port = sctp_conn->sub_conn[idx].connection.lcl_port;
908 hb_ack->sctp_hdr.dst_port = sctp_conn->sub_conn[idx].connection.rmt_port;
909 hb_ack->sctp_hdr.verification_tag = sctp_conn->remote_tag;
910 hb_ack->hb_info.param_hdr.type = clib_host_to_net_u16 (1);
911 hb_ack->hb_info.param_hdr.length =
912 clib_host_to_net_u16 (sizeof (hb_ack->hb_info.hb_info));
913
914 vnet_sctp_set_chunk_type (&hb_ack->chunk_hdr, HEARTBEAT_ACK);
915 vnet_sctp_set_chunk_length (&hb_ack->chunk_hdr, chunk_len);
916
917 vnet_buffer (b)->sctp.connection_index =
918 sctp_conn->sub_conn[idx].connection.c_index;
919}
920
921/**
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100922 * Convert buffer to HEARTBEAT
923 */
924void
925sctp_prepare_heartbeat_chunk (sctp_connection_t * sctp_conn,
926 vlib_buffer_t * b)
927{
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100928 u8 idx = sctp_pick_conn_idx_on_chunk (HEARTBEAT);
929 u16 alloc_bytes = sizeof (sctp_hb_req_chunk_t);
930
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100931 /* As per RFC 4960 the chunk_length value does NOT contemplate
932 * the size of the first header (see sctp_header_t) and any padding
933 */
934 u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
935
936 alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
937
938 sctp_hb_req_chunk_t *hb_req = vlib_buffer_push_uninit (b, alloc_bytes);
939
940 hb_req->sctp_hdr.checksum = 0;
941 /* No need of host_to_net conversion, already in net-byte order */
942 hb_req->sctp_hdr.src_port = sctp_conn->sub_conn[idx].connection.lcl_port;
943 hb_req->sctp_hdr.dst_port = sctp_conn->sub_conn[idx].connection.rmt_port;
944 hb_req->sctp_hdr.verification_tag = sctp_conn->remote_tag;
945 hb_req->hb_info.param_hdr.type = clib_host_to_net_u16 (1);
946 hb_req->hb_info.param_hdr.length =
947 clib_host_to_net_u16 (sizeof (hb_req->hb_info.hb_info));
948
949 vnet_sctp_set_chunk_type (&hb_req->chunk_hdr, HEARTBEAT);
950 vnet_sctp_set_chunk_length (&hb_req->chunk_hdr, chunk_len);
951
952 vnet_buffer (b)->sctp.connection_index =
953 sctp_conn->sub_conn[idx].connection.c_index;
954}
955
956void
957sctp_send_heartbeat (sctp_connection_t * sctp_conn)
958{
959 vlib_buffer_t *b;
960 u32 bi;
961 sctp_main_t *tm = vnet_get_sctp_main ();
962 vlib_main_t *vm = vlib_get_main ();
963
964 if (PREDICT_FALSE (sctp_get_free_buffer_index (tm, &bi)))
965 return;
966
967 b = vlib_get_buffer (vm, bi);
968 sctp_init_buffer (vm, b);
969 sctp_prepare_heartbeat_chunk (sctp_conn, b);
970
971 u8 idx = sctp_pick_conn_idx_on_state (SCTP_STATE_ESTABLISHED);
Marco Varlesedf5a99c2018-02-06 13:48:30 +0100972 sctp_enqueue_to_output_now (vm, b, bi,
973 sctp_conn->sub_conn[idx].connection.is_ip4);
974
975 sctp_conn->sub_conn[idx].unacknowledged_hb += 1;
Marco Varlese191a5942017-10-30 18:17:21 +0100976}
977
978/**
979 * Convert buffer to SHUTDOWN_COMPLETE
980 */
981void
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100982sctp_prepare_shutdown_complete_chunk (sctp_connection_t * sctp_conn,
Marco Varlese191a5942017-10-30 18:17:21 +0100983 vlib_buffer_t * b)
984{
985 u8 idx = sctp_pick_conn_idx_on_chunk (SHUTDOWN_COMPLETE);
986 u16 alloc_bytes = sizeof (sctp_shutdown_association_chunk_t);
987 alloc_bytes += vnet_sctp_calculate_padding (alloc_bytes);
988
989 u16 chunk_len = alloc_bytes - sizeof (sctp_header_t);
990
991 sctp_shutdown_complete_chunk_t *shutdown_complete =
992 vlib_buffer_push_uninit (b, alloc_bytes);
993
994 shutdown_complete->sctp_hdr.checksum = 0;
995 /* No need of host_to_net conversion, already in net-byte order */
996 shutdown_complete->sctp_hdr.src_port =
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100997 sctp_conn->sub_conn[idx].connection.lcl_port;
Marco Varlese191a5942017-10-30 18:17:21 +0100998 shutdown_complete->sctp_hdr.dst_port =
Marco Varlese8ad6a2d2018-01-26 16:50:01 +0100999 sctp_conn->sub_conn[idx].connection.rmt_port;
1000 shutdown_complete->sctp_hdr.verification_tag = sctp_conn->remote_tag;
Marco Varlese191a5942017-10-30 18:17:21 +01001001
1002 vnet_sctp_set_chunk_type (&shutdown_complete->chunk_hdr, SHUTDOWN_COMPLETE);
1003 vnet_sctp_set_chunk_length (&shutdown_complete->chunk_hdr, chunk_len);
1004
1005 vnet_buffer (b)->sctp.connection_index =
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001006 sctp_conn->sub_conn[idx].connection.c_index;
Marco Varlese191a5942017-10-30 18:17:21 +01001007}
1008
1009void
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001010sctp_send_shutdown_complete (sctp_connection_t * sctp_conn)
Marco Varlese191a5942017-10-30 18:17:21 +01001011{
1012 vlib_buffer_t *b;
1013 u32 bi;
1014 sctp_main_t *tm = vnet_get_sctp_main ();
1015 vlib_main_t *vm = vlib_get_main ();
1016
1017 if (PREDICT_FALSE (sctp_get_free_buffer_index (tm, &bi)))
1018 return;
1019
1020 b = vlib_get_buffer (vm, bi);
1021 sctp_init_buffer (vm, b);
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001022 sctp_prepare_shutdown_complete_chunk (sctp_conn, b);
Marco Varlese191a5942017-10-30 18:17:21 +01001023
1024 u8 idx = sctp_pick_conn_idx_on_chunk (SHUTDOWN_COMPLETE);
Marco Varlesedf5a99c2018-02-06 13:48:30 +01001025 sctp_enqueue_to_output (vm, b, bi,
1026 sctp_conn->sub_conn[idx].connection.is_ip4);
Marco Varlese191a5942017-10-30 18:17:21 +01001027}
1028
1029
1030/*
1031 * Send INIT
1032 */
1033void
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001034sctp_send_init (sctp_connection_t * sctp_conn)
Marco Varlese191a5942017-10-30 18:17:21 +01001035{
1036 vlib_buffer_t *b;
1037 u32 bi;
1038 sctp_main_t *tm = vnet_get_sctp_main ();
1039 vlib_main_t *vm = vlib_get_main ();
1040
1041 if (PREDICT_FALSE (sctp_get_free_buffer_index (tm, &bi)))
1042 return;
1043
1044 b = vlib_get_buffer (vm, bi);
1045 u8 idx = sctp_pick_conn_idx_on_chunk (INIT);
1046
1047 sctp_init_buffer (vm, b);
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001048 sctp_prepare_init_chunk (sctp_conn, b);
Marco Varlese191a5942017-10-30 18:17:21 +01001049
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001050 sctp_push_ip_hdr (tm, &sctp_conn->sub_conn[idx], b);
Marco Varlesedf5a99c2018-02-06 13:48:30 +01001051 sctp_enqueue_to_ip_lookup (vm, b, bi, sctp_conn->sub_conn[idx].c_is_ip4);
Marco Varlese191a5942017-10-30 18:17:21 +01001052
1053 /* Start the T1_INIT timer */
Marco Varlese21c8baf2018-02-02 17:17:51 +01001054 sctp_timer_set (sctp_conn, idx, SCTP_TIMER_T1_INIT,
1055 sctp_conn->sub_conn[idx].RTO);
1056
Marco Varlese191a5942017-10-30 18:17:21 +01001057 /* Change state to COOKIE_WAIT */
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001058 sctp_conn->state = SCTP_STATE_COOKIE_WAIT;
Marco Varlesea38783e2018-02-13 12:38:52 +01001059
1060 /* Measure RTT with this */
1061 sctp_conn->sub_conn[idx].rtt_ts = sctp_time_now ();
Marco Varlese191a5942017-10-30 18:17:21 +01001062}
1063
Marco Varlese191a5942017-10-30 18:17:21 +01001064/**
1065 * Push SCTP header and update connection variables
1066 */
1067static void
Marco Varlese21c8baf2018-02-02 17:17:51 +01001068sctp_push_hdr_i (sctp_connection_t * sctp_conn, u8 idx, vlib_buffer_t * b,
Marco Varlese191a5942017-10-30 18:17:21 +01001069 sctp_state_t next_state)
1070{
Marco Varlese191a5942017-10-30 18:17:21 +01001071 u16 data_len =
1072 b->current_length + b->total_length_not_including_first_buffer;
1073 ASSERT (!b->total_length_not_including_first_buffer
1074 || (b->flags & VLIB_BUFFER_NEXT_PRESENT));
1075
1076 SCTP_ADV_DBG_OUTPUT ("b->current_length = %u, "
1077 "b->current_data = %p "
1078 "data_len = %u",
1079 b->current_length, b->current_data, data_len);
1080
1081 u16 bytes_to_add = sizeof (sctp_payload_data_chunk_t);
1082 u16 chunk_length = data_len + bytes_to_add - sizeof (sctp_header_t);
1083
1084 bytes_to_add += vnet_sctp_calculate_padding (bytes_to_add + data_len);
1085
1086 sctp_payload_data_chunk_t *data_chunk =
1087 vlib_buffer_push_uninit (b, bytes_to_add);
1088
1089 data_chunk->sctp_hdr.checksum = 0;
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001090 data_chunk->sctp_hdr.src_port =
1091 sctp_conn->sub_conn[idx].connection.lcl_port;
1092 data_chunk->sctp_hdr.dst_port =
1093 sctp_conn->sub_conn[idx].connection.rmt_port;
1094 data_chunk->sctp_hdr.verification_tag = sctp_conn->remote_tag;
Marco Varlese191a5942017-10-30 18:17:21 +01001095
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001096 data_chunk->tsn = clib_host_to_net_u32 (sctp_conn->next_tsn);
Marco Varlese191a5942017-10-30 18:17:21 +01001097 data_chunk->stream_id = clib_host_to_net_u16 (0);
1098 data_chunk->stream_seq = clib_host_to_net_u16 (0);
1099
1100 vnet_sctp_set_chunk_type (&data_chunk->chunk_hdr, DATA);
1101 vnet_sctp_set_chunk_length (&data_chunk->chunk_hdr, chunk_length);
1102
Marco Varlese91389ac2018-01-31 11:00:01 +01001103 vnet_sctp_set_bbit (&data_chunk->chunk_hdr);
1104 vnet_sctp_set_ebit (&data_chunk->chunk_hdr);
1105
Marco Varlese191a5942017-10-30 18:17:21 +01001106 SCTP_ADV_DBG_OUTPUT ("POINTER_WITH_DATA = %p, DATA_OFFSET = %u",
1107 b->data, b->current_data);
1108
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001109 sctp_conn->next_tsn += data_len;
1110
Marco Varlese191a5942017-10-30 18:17:21 +01001111 vnet_buffer (b)->sctp.connection_index =
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001112 sctp_conn->sub_conn[idx].connection.c_index;
Marco Varlese191a5942017-10-30 18:17:21 +01001113}
1114
1115u32
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001116sctp_push_header (transport_connection_t * trans_conn, vlib_buffer_t * b)
Marco Varlese191a5942017-10-30 18:17:21 +01001117{
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001118 sctp_connection_t *sctp_conn =
1119 sctp_get_connection_from_transport (trans_conn);
Marco Varlese191a5942017-10-30 18:17:21 +01001120
Marco Varlese21c8baf2018-02-02 17:17:51 +01001121 u8 idx = sctp_pick_conn_idx_on_chunk (DATA);
1122
Marco Varlesedf5a99c2018-02-06 13:48:30 +01001123 if (sctp_conn->sub_conn[idx].unacknowledged_hb >
1124 SCTP_ASSOCIATION_MAX_RETRANS)
1125 {
1126 // The remote-peer is considered to be unreachable hence shutting down
1127
1128 /* Start cleanup. App wasn't notified yet so use delete notify as
1129 * opposed to delete to cleanup session layer state. */
1130 stream_session_delete_notify (&sctp_conn->sub_conn
1131 [MAIN_SCTP_SUB_CONN_IDX].connection);
1132
1133 sctp_connection_timers_reset (sctp_conn);
1134
1135 sctp_connection_cleanup (sctp_conn);
1136 }
1137
Marco Varlese21c8baf2018-02-02 17:17:51 +01001138 sctp_push_hdr_i (sctp_conn, idx, b, SCTP_STATE_ESTABLISHED);
1139
Marco Varlese191a5942017-10-30 18:17:21 +01001140 sctp_trajectory_add_start (b0, 3);
1141
1142 return 0;
1143
1144}
1145
Marco Varlesea38783e2018-02-13 12:38:52 +01001146always_inline u8
1147sctp_validate_output_state_machine (sctp_connection_t * sctp_conn,
1148 u8 chunk_type)
1149{
1150 u8 result = 0;
1151 switch (sctp_conn->state)
1152 {
1153 case SCTP_STATE_CLOSED:
1154 if (chunk_type != INIT && chunk_type != INIT_ACK)
1155 result = 1;
1156 break;
1157 case SCTP_STATE_ESTABLISHED:
1158 if (chunk_type != DATA && chunk_type != HEARTBEAT &&
1159 chunk_type != HEARTBEAT_ACK && chunk_type != SACK &&
1160 chunk_type != COOKIE_ACK && chunk_type != SHUTDOWN)
1161 result = 1;
1162 break;
1163 case SCTP_STATE_COOKIE_WAIT:
1164 if (chunk_type != COOKIE_ECHO)
1165 result = 1;
1166 break;
1167 case SCTP_STATE_SHUTDOWN_SENT:
1168 if (chunk_type != SHUTDOWN_COMPLETE)
1169 result = 1;
1170 break;
1171 case SCTP_STATE_SHUTDOWN_RECEIVED:
1172 if (chunk_type != SHUTDOWN_ACK)
1173 result = 1;
1174 break;
1175 }
1176 return result;
1177}
1178
1179always_inline u8
1180sctp_is_retransmitting (sctp_connection_t * sctp_conn, u8 idx)
1181{
1182 return sctp_conn->sub_conn[idx].is_retransmitting;
1183}
1184
Marco Varlese191a5942017-10-30 18:17:21 +01001185always_inline uword
1186sctp46_output_inline (vlib_main_t * vm,
1187 vlib_node_runtime_t * node,
1188 vlib_frame_t * from_frame, int is_ip4)
1189{
1190 u32 n_left_from, next_index, *from, *to_next;
1191 u32 my_thread_index = vm->thread_index;
1192
1193 from = vlib_frame_vector_args (from_frame);
1194 n_left_from = from_frame->n_vectors;
1195 next_index = node->cached_next_index;
1196 sctp_set_time_now (my_thread_index);
1197
1198 while (n_left_from > 0)
1199 {
1200 u32 n_left_to_next;
1201
1202 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1203
1204 while (n_left_from > 0 && n_left_to_next > 0)
1205 {
1206 u32 bi0;
1207 vlib_buffer_t *b0;
1208 sctp_header_t *sctp_hdr = 0;
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001209 sctp_connection_t *sctp_conn;
Marco Varlese191a5942017-10-30 18:17:21 +01001210 sctp_tx_trace_t *t0;
1211 sctp_header_t *th0 = 0;
1212 u32 error0 = SCTP_ERROR_PKTS_SENT, next0 =
1213 SCTP_OUTPUT_NEXT_IP_LOOKUP;
1214
1215#if SCTP_DEBUG_STATE_MACHINE
1216 u16 packet_length = 0;
1217#endif
1218
1219 bi0 = from[0];
1220 to_next[0] = bi0;
1221 from += 1;
1222 to_next += 1;
1223 n_left_from -= 1;
1224 n_left_to_next -= 1;
1225
1226 b0 = vlib_get_buffer (vm, bi0);
Marco Varlesebe2251b2018-02-07 12:22:41 +01001227
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001228 sctp_conn =
1229 sctp_connection_get (vnet_buffer (b0)->sctp.connection_index,
1230 my_thread_index);
Marco Varlese191a5942017-10-30 18:17:21 +01001231
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001232 if (PREDICT_FALSE (sctp_conn == 0))
Marco Varlese191a5942017-10-30 18:17:21 +01001233 {
1234 error0 = SCTP_ERROR_INVALID_CONNECTION;
1235 next0 = SCTP_OUTPUT_NEXT_DROP;
1236 goto done;
1237 }
1238
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001239 u8 idx = sctp_pick_conn_idx_on_state (sctp_conn->state);
Marco Varlese191a5942017-10-30 18:17:21 +01001240
1241 th0 = vlib_buffer_get_current (b0);
1242
1243 if (is_ip4)
1244 {
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001245 ip4_header_t *iph4 = vlib_buffer_push_ip4 (vm,
1246 b0,
1247 &sctp_conn->sub_conn
1248 [idx].connection.
1249 lcl_ip.ip4,
1250 &sctp_conn->
1251 sub_conn
1252 [idx].connection.
1253 rmt_ip.ip4,
1254 IP_PROTOCOL_SCTP, 1);
Marco Varlese191a5942017-10-30 18:17:21 +01001255
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001256 u32 checksum = ip4_sctp_compute_checksum (vm, b0, iph4);
Marco Varlese191a5942017-10-30 18:17:21 +01001257
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001258 sctp_hdr = ip4_next_header (iph4);
Marco Varlese191a5942017-10-30 18:17:21 +01001259 sctp_hdr->checksum = checksum;
1260
1261 vnet_buffer (b0)->l4_hdr_offset = (u8 *) th0 - b0->data;
Marco Varlese191a5942017-10-30 18:17:21 +01001262
1263#if SCTP_DEBUG_STATE_MACHINE
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001264 packet_length = clib_net_to_host_u16 (iph4->length);
Marco Varlese191a5942017-10-30 18:17:21 +01001265#endif
1266 }
1267 else
1268 {
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001269 ip6_header_t *iph6 = vlib_buffer_push_ip6 (vm,
1270 b0,
1271 &sctp_conn->sub_conn
1272 [idx].
1273 connection.lcl_ip.
1274 ip6,
1275 &sctp_conn->sub_conn
1276 [idx].
1277 connection.rmt_ip.
1278 ip6,
1279 IP_PROTOCOL_SCTP);
Marco Varlese191a5942017-10-30 18:17:21 +01001280
1281 int bogus = ~0;
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001282 u32 checksum = ip6_sctp_compute_checksum (vm, b0, iph6, &bogus);
Marco Varlese191a5942017-10-30 18:17:21 +01001283 ASSERT (!bogus);
1284
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001285 sctp_hdr = ip6_next_header (iph6);
Marco Varlese191a5942017-10-30 18:17:21 +01001286 sctp_hdr->checksum = checksum;
1287
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001288 vnet_buffer (b0)->l3_hdr_offset = (u8 *) iph6 - b0->data;
Marco Varlese191a5942017-10-30 18:17:21 +01001289 vnet_buffer (b0)->l4_hdr_offset = (u8 *) th0 - b0->data;
Marco Varlese191a5942017-10-30 18:17:21 +01001290
1291#if SCTP_DEBUG_STATE_MACHINE
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001292 packet_length = clib_net_to_host_u16 (iph6->payload_length);
Marco Varlese191a5942017-10-30 18:17:21 +01001293#endif
1294 }
1295
1296 u8 is_valid =
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001297 (sctp_conn->sub_conn[idx].connection.lcl_port ==
Marco Varlese191a5942017-10-30 18:17:21 +01001298 sctp_hdr->src_port
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001299 || sctp_conn->sub_conn[idx].connection.lcl_port ==
Marco Varlese191a5942017-10-30 18:17:21 +01001300 sctp_hdr->dst_port)
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001301 && (sctp_conn->sub_conn[idx].connection.rmt_port ==
Marco Varlese191a5942017-10-30 18:17:21 +01001302 sctp_hdr->dst_port
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001303 || sctp_conn->sub_conn[idx].connection.rmt_port ==
Marco Varlese191a5942017-10-30 18:17:21 +01001304 sctp_hdr->src_port);
1305
1306 sctp_full_hdr_t *full_hdr = (sctp_full_hdr_t *) sctp_hdr;
1307 u8 chunk_type = vnet_sctp_get_chunk_type (&full_hdr->common_hdr);
1308
1309 if (!is_valid)
1310 {
1311 SCTP_DBG_STATE_MACHINE ("BUFFER IS INCORRECT: conn_index = %u, "
1312 "packet_length = %u, "
1313 "chunk_type = %u [%s], "
1314 "connection.lcl_port = %u, sctp_hdr->src_port = %u, "
1315 "connection.rmt_port = %u, sctp_hdr->dst_port = %u",
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001316 sctp_conn->sub_conn
Marco Varlese191a5942017-10-30 18:17:21 +01001317 [idx].connection.c_index, packet_length,
1318 chunk_type,
1319 sctp_chunk_to_string (chunk_type),
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001320 sctp_conn->sub_conn[idx].
1321 connection.lcl_port, sctp_hdr->src_port,
1322 sctp_conn->sub_conn[idx].
1323 connection.rmt_port,
Marco Varlese191a5942017-10-30 18:17:21 +01001324 sctp_hdr->dst_port);
1325
1326 error0 = SCTP_ERROR_UNKOWN_CHUNK;
1327 next0 = SCTP_OUTPUT_NEXT_DROP;
1328 goto done;
1329 }
1330
1331 SCTP_DBG_STATE_MACHINE
1332 ("CONN_INDEX = %u, CURR_CONN_STATE = %u (%s), "
1333 "CHUNK_TYPE = %s, " "SRC_PORT = %u, DST_PORT = %u",
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001334 sctp_conn->sub_conn[idx].connection.c_index,
1335 sctp_conn->state, sctp_state_to_string (sctp_conn->state),
Marco Varlese191a5942017-10-30 18:17:21 +01001336 sctp_chunk_to_string (chunk_type), full_hdr->hdr.src_port,
1337 full_hdr->hdr.dst_port);
1338
Marco Varlese191a5942017-10-30 18:17:21 +01001339 /* Let's make sure the state-machine does not send anything crazy */
Marco Varlesea38783e2018-02-13 12:38:52 +01001340#if SCTP_DEBUG_STATE_MACHINE
1341 if (sctp_validate_output_state_machine (sctp_conn, chunk_type) != 0)
Marco Varlese191a5942017-10-30 18:17:21 +01001342 {
Marco Varlese191a5942017-10-30 18:17:21 +01001343 SCTP_DBG_STATE_MACHINE
Marco Varlesea38783e2018-02-13 12:38:52 +01001344 ("Sending the wrong chunk (%s) based on state-machine status (%s)",
Marco Varlese191a5942017-10-30 18:17:21 +01001345 sctp_chunk_to_string (chunk_type),
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001346 sctp_state_to_string (sctp_conn->state));
Marco Varlesea38783e2018-02-13 12:38:52 +01001347
1348 error0 = SCTP_ERROR_UNKOWN_CHUNK;
1349 next0 = SCTP_OUTPUT_NEXT_DROP;
1350 goto done;
1351 }
1352#endif
1353
1354 /* Karn's algorithm: RTT measurements MUST NOT be made using
1355 * packets that were retransmitted
1356 */
1357 if (!sctp_is_retransmitting (sctp_conn, idx))
1358 {
1359 /* Measure RTT with this */
1360 if (chunk_type == DATA
1361 && sctp_conn->sub_conn[idx].RTO_pending == 0)
1362 {
1363 sctp_conn->sub_conn[idx].RTO_pending = 1;
1364 sctp_conn->sub_conn[idx].rtt_ts = sctp_time_now ();
1365 }
1366 else
1367 sctp_conn->sub_conn[idx].rtt_ts = sctp_time_now ();
Marco Varlese191a5942017-10-30 18:17:21 +01001368 }
1369
Marco Varlesea38783e2018-02-13 12:38:52 +01001370 /* Let's take care of TIMERS */
Marco Varlesebe2251b2018-02-07 12:22:41 +01001371 switch (chunk_type)
Marco Varlese191a5942017-10-30 18:17:21 +01001372 {
Marco Varlesea38783e2018-02-13 12:38:52 +01001373 case COOKIE_ECHO:
1374 {
1375 sctp_conn->state = SCTP_STATE_COOKIE_ECHOED;
1376 break;
1377 }
Marco Varlesebe2251b2018-02-07 12:22:41 +01001378 case DATA:
1379 {
Marco Varlesea38783e2018-02-13 12:38:52 +01001380 SCTP_ADV_DBG_OUTPUT ("PACKET_LENGTH = %u", packet_length);
1381
Marco Varlesebe2251b2018-02-07 12:22:41 +01001382 sctp_timer_update (sctp_conn, idx, SCTP_TIMER_T3_RXTX,
1383 sctp_conn->sub_conn[idx].RTO);
1384 break;
1385 }
1386 case SHUTDOWN:
1387 {
1388 /* Start the SCTP_TIMER_T2_SHUTDOWN timer */
1389 sctp_timer_set (sctp_conn, idx, SCTP_TIMER_T2_SHUTDOWN,
1390 sctp_conn->sub_conn[idx].RTO);
1391 sctp_conn->state = SCTP_STATE_SHUTDOWN_SENT;
1392 break;
1393 }
1394 case SHUTDOWN_ACK:
1395 {
1396 /* Start the SCTP_TIMER_T2_SHUTDOWN timer */
1397 sctp_timer_set (sctp_conn, idx, SCTP_TIMER_T2_SHUTDOWN,
1398 sctp_conn->sub_conn[idx].RTO);
1399 sctp_conn->state = SCTP_STATE_SHUTDOWN_ACK_SENT;
1400 break;
1401 }
Marco Varlesea38783e2018-02-13 12:38:52 +01001402 case SHUTDOWN_COMPLETE:
1403 {
1404 sctp_conn->state = SCTP_STATE_CLOSED;
1405 break;
1406 }
Marco Varlese191a5942017-10-30 18:17:21 +01001407 }
1408
1409 vnet_buffer (b0)->sw_if_index[VLIB_RX] = 0;
1410 vnet_buffer (b0)->sw_if_index[VLIB_TX] = ~0;
1411
1412 b0->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
1413
1414 SCTP_DBG_STATE_MACHINE ("CONNECTION_INDEX = %u, "
1415 "NEW_STATE = %s, "
1416 "CHUNK_SENT = %s",
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001417 sctp_conn->sub_conn[idx].connection.c_index,
1418 sctp_state_to_string (sctp_conn->state),
Marco Varlese191a5942017-10-30 18:17:21 +01001419 sctp_chunk_to_string (chunk_type));
1420
1421 vnet_sctp_common_hdr_params_host_to_net (&full_hdr->common_hdr);
1422
1423 done:
1424 b0->error = node->errors[error0];
1425 if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
1426 {
1427 t0 = vlib_add_trace (vm, node, b0, sizeof (*t0));
1428 if (th0)
1429 {
1430 clib_memcpy (&t0->sctp_header, th0,
1431 sizeof (t0->sctp_header));
1432 }
1433 else
1434 {
1435 memset (&t0->sctp_header, 0, sizeof (t0->sctp_header));
1436 }
Marco Varlese8ad6a2d2018-01-26 16:50:01 +01001437 clib_memcpy (&t0->sctp_connection, sctp_conn,
Marco Varlese191a5942017-10-30 18:17:21 +01001438 sizeof (t0->sctp_connection));
1439 }
1440
1441 vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1442 n_left_to_next, bi0, next0);
1443 }
1444
1445 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1446 }
1447
1448 return from_frame->n_vectors;
1449}
1450
1451static uword
1452sctp4_output (vlib_main_t * vm, vlib_node_runtime_t * node,
1453 vlib_frame_t * from_frame)
1454{
1455 return sctp46_output_inline (vm, node, from_frame, 1 /* is_ip4 */ );
1456}
1457
1458static uword
1459sctp6_output (vlib_main_t * vm, vlib_node_runtime_t * node,
1460 vlib_frame_t * from_frame)
1461{
1462 return sctp46_output_inline (vm, node, from_frame, 0 /* is_ip4 */ );
1463}
1464
1465/* *INDENT-OFF* */
1466VLIB_REGISTER_NODE (sctp4_output_node) =
1467{
1468 .function = sctp4_output,.name = "sctp4-output",
1469 /* Takes a vector of packets. */
1470 .vector_size = sizeof (u32),
1471 .n_errors = SCTP_N_ERROR,
1472 .error_strings = sctp_error_strings,
1473 .n_next_nodes = SCTP_OUTPUT_N_NEXT,
1474 .next_nodes = {
1475#define _(s,n) [SCTP_OUTPUT_NEXT_##s] = n,
1476 foreach_sctp4_output_next
1477#undef _
1478 },
1479 .format_buffer = format_sctp_header,
1480 .format_trace = format_sctp_tx_trace,
1481};
1482/* *INDENT-ON* */
1483
1484VLIB_NODE_FUNCTION_MULTIARCH (sctp4_output_node, sctp4_output);
1485
1486/* *INDENT-OFF* */
1487VLIB_REGISTER_NODE (sctp6_output_node) =
1488{
1489 .function = sctp6_output,
1490 .name = "sctp6-output",
1491 /* Takes a vector of packets. */
1492 .vector_size = sizeof (u32),
1493 .n_errors = SCTP_N_ERROR,
1494 .error_strings = sctp_error_strings,
1495 .n_next_nodes = SCTP_OUTPUT_N_NEXT,
1496 .next_nodes = {
1497#define _(s,n) [SCTP_OUTPUT_NEXT_##s] = n,
1498 foreach_sctp6_output_next
1499#undef _
1500 },
1501 .format_buffer = format_sctp_header,
1502 .format_trace = format_sctp_tx_trace,
1503};
1504/* *INDENT-ON* */
1505
1506VLIB_NODE_FUNCTION_MULTIARCH (sctp6_output_node, sctp6_output);
1507
1508/*
1509 * fd.io coding-style-patch-verification: ON
1510 *
1511 * Local Variables:
1512 * eval: (c-set-style "gnu")
1513 * End:
1514 */