sctp_output_node.c

Go to the documentation of this file.

/*
 * Copyright (c) 2018 SUSE LLC.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#include <vnet/sctp/sctp.h>
#include <vnet/sctp/sctp_debug.h>
#include <vppinfra/random.h>
#include <openssl/hmac.h>

u32
ip6_sctp_compute_checksum (vlib_main_t * vm, vlib_buffer_t * p0,
                           ip6_header_t * ip0, int *bogus_lengthp);

u32
ip4_sctp_compute_checksum (vlib_main_t * vm, vlib_buffer_t * p0,
                           ip4_header_t * ip0);

#define foreach_sctp4_output_next               \
  _ (DROP, "error-drop")                        \
  _ (IP_LOOKUP, "ip4-lookup")

#define foreach_sctp6_output_next               \
  _ (DROP, "error-drop")                        \
  _ (IP_LOOKUP, "ip6-lookup")

static char *sctp_error_strings[] = {
#define sctp_error(n,s) s,
#include <vnet/sctp/sctp_error.def>
#undef sctp_error
};

typedef enum _sctp_output_next
{
  SCTP_OUTPUT_NEXT_DROP,
  SCTP_OUTPUT_NEXT_IP_LOOKUP,
  SCTP_OUTPUT_N_NEXT
} sctp_output_next_t;

typedef struct
{
  sctp_header_t sctp_header;
  sctp_connection_t sctp_connection;
} sctp_tx_trace_t;

always_inline u8
sctp_is_retransmitting (sctp_connection_t * sctp_conn, u8 idx)
{
  return sctp_conn->sub_conn[idx].is_retransmitting;
}

always_inline uword
sctp46_output_inline (vlib_main_t * vm,
                      vlib_node_runtime_t * node,
                      vlib_frame_t * from_frame, int is_ip4)
{
  u32 n_left_from, next_index, *from, *to_next;
  u32 my_thread_index = vm->thread_index;

  from = vlib_frame_vector_args (from_frame);
  n_left_from = from_frame->n_vectors;
  next_index = node->cached_next_index;
  sctp_set_time_now (my_thread_index);

  while (n_left_from > 0)
    {
      u32 n_left_to_next;

      vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);

      while (n_left_from > 0 && n_left_to_next > 0)
        {
          u32 bi0;
          vlib_buffer_t *b0;
          sctp_header_t *sctp_hdr = 0;
          sctp_connection_t *sctp_conn;
          sctp_tx_trace_t *t0;
          sctp_header_t *th0 = 0;
          u32 error0 = SCTP_ERROR_PKTS_SENT, next0 =
            SCTP_OUTPUT_NEXT_IP_LOOKUP;

#if SCTP_DEBUG_STATE_MACHINE
          u16 packet_length = 0;
#endif

          bi0 = from[0];
          to_next[0] = bi0;
          from += 1;
          to_next += 1;
          n_left_from -= 1;
          n_left_to_next -= 1;

          b0 = vlib_get_buffer (vm, bi0);

          sctp_conn =
            sctp_connection_get (vnet_buffer (b0)->sctp.connection_index,
                                 my_thread_index);

          if (PREDICT_FALSE (sctp_conn == 0))
            {
              error0 = SCTP_ERROR_INVALID_CONNECTION;
              next0 = SCTP_OUTPUT_NEXT_DROP;
              goto done;
            }

          u8 idx = vnet_buffer (b0)->sctp.subconn_idx;

          th0 = vlib_buffer_get_current (b0);

          if (is_ip4)
            {
              ip4_header_t *iph4 = vlib_buffer_push_ip4 (vm,
                                                         b0,
                                                         &sctp_conn->sub_conn
                                                         [idx].connection.
                                                         lcl_ip.ip4,
                                                         &sctp_conn->
                                                         sub_conn
                                                         [idx].connection.
                                                         rmt_ip.ip4,
                                                         IP_PROTOCOL_SCTP, 1);

              u32 checksum = ip4_sctp_compute_checksum (vm, b0, iph4);

              sctp_hdr = ip4_next_header (iph4);
              sctp_hdr->checksum = checksum;

              vnet_buffer (b0)->l4_hdr_offset = (u8 *) th0 - b0->data;

#if SCTP_DEBUG_STATE_MACHINE
              packet_length = clib_net_to_host_u16 (iph4->length);
#endif
            }
          else
            {
              ip6_header_t *iph6 = vlib_buffer_push_ip6 (vm,
                                                         b0,
                                                         &sctp_conn->sub_conn
                                                         [idx].
                                                         connection.lcl_ip.
                                                         ip6,
                                                         &sctp_conn->sub_conn
                                                         [idx].
                                                         connection.rmt_ip.
                                                         ip6,
                                                         IP_PROTOCOL_SCTP);

              int bogus = ~0;
              u32 checksum = ip6_sctp_compute_checksum (vm, b0, iph6, &bogus);
              ASSERT (!bogus);

              sctp_hdr = ip6_next_header (iph6);
              sctp_hdr->checksum = checksum;

              vnet_buffer (b0)->l3_hdr_offset = (u8 *) iph6 - b0->data;
              vnet_buffer (b0)->l4_hdr_offset = (u8 *) th0 - b0->data;

#if SCTP_DEBUG_STATE_MACHINE
              packet_length = clib_net_to_host_u16 (iph6->payload_length);
#endif
            }

          sctp_full_hdr_t *full_hdr = (sctp_full_hdr_t *) sctp_hdr;
          u8 chunk_type = vnet_sctp_get_chunk_type (&full_hdr->common_hdr);
          if (chunk_type >= UNKNOWN)
            {
              clib_warning
                ("Trying to send an unrecognized chunk... something is really bad.");
              error0 = SCTP_ERROR_UNKNOWN_CHUNK;
              next0 = SCTP_OUTPUT_NEXT_DROP;
              goto done;
            }

#if SCTP_DEBUG_STATE_MACHINE
          u8 is_valid =
            (sctp_conn->sub_conn[idx].connection.lcl_port ==
             sctp_hdr->src_port
             || sctp_conn->sub_conn[idx].connection.lcl_port ==
             sctp_hdr->dst_port)
            && (sctp_conn->sub_conn[idx].connection.rmt_port ==
                sctp_hdr->dst_port
                || sctp_conn->sub_conn[idx].connection.rmt_port ==
                sctp_hdr->src_port);

          if (!is_valid)
            {
              SCTP_DBG_STATE_MACHINE ("BUFFER IS INCORRECT: conn_index = %u, "
                                      "packet_length = %u, "
                                      "chunk_type = %u [%s], "
                                      "connection.lcl_port = %u, sctp_hdr->src_port = %u, "
                                      "connection.rmt_port = %u, sctp_hdr->dst_port = %u",
                                      sctp_conn->sub_conn[idx].
                                      connection.c_index, packet_length,
                                      chunk_type,
                                      sctp_chunk_to_string (chunk_type),
                                      sctp_conn->sub_conn[idx].
                                      connection.lcl_port, sctp_hdr->src_port,
                                      sctp_conn->sub_conn[idx].
                                      connection.rmt_port,
                                      sctp_hdr->dst_port);

              error0 = SCTP_ERROR_UNKNOWN_CHUNK;
              next0 = SCTP_OUTPUT_NEXT_DROP;
              goto done;
            }
#endif
          SCTP_DBG_STATE_MACHINE
            ("SESSION_INDEX = %u, CONN_INDEX = %u, CURR_CONN_STATE = %u (%s), "
             "CHUNK_TYPE = %s, " "SRC_PORT = %u, DST_PORT = %u",
             sctp_conn->sub_conn[idx].connection.s_index,
             sctp_conn->sub_conn[idx].connection.c_index,
             sctp_conn->state, sctp_state_to_string (sctp_conn->state),
             sctp_chunk_to_string (chunk_type), full_hdr->hdr.src_port,
             full_hdr->hdr.dst_port);

          /* Let's make sure the state-machine does not send anything crazy */
#if SCTP_DEBUG_STATE_MACHINE
          if (sctp_validate_output_state_machine (sctp_conn, chunk_type) != 0)
            {
              SCTP_DBG_STATE_MACHINE
                ("Sending the wrong chunk (%s) based on state-machine status (%s)",
                 sctp_chunk_to_string (chunk_type),
                 sctp_state_to_string (sctp_conn->state));

              error0 = SCTP_ERROR_UNKNOWN_CHUNK;
              next0 = SCTP_OUTPUT_NEXT_DROP;
              goto done;

            }
#endif

          /* Karn's algorithm: RTT measurements MUST NOT be made using
           * packets that were retransmitted
           */
          if (!sctp_is_retransmitting (sctp_conn, idx))
            {
              /* Measure RTT with this */
              if (chunk_type == DATA
                  && sctp_conn->sub_conn[idx].RTO_pending == 0)
                {
                  sctp_conn->sub_conn[idx].RTO_pending = 1;
                  sctp_conn->sub_conn[idx].rtt_ts = sctp_time_now ();
                }
              else
                sctp_conn->sub_conn[idx].rtt_ts = sctp_time_now ();
            }

          /* Let's take care of TIMERS */
          switch (chunk_type)
            {
            case COOKIE_ECHO:
              {
                sctp_conn->state = SCTP_STATE_COOKIE_ECHOED;
                break;
              }
            case DATA:
              {
                SCTP_ADV_DBG_OUTPUT ("PACKET_LENGTH = %u", packet_length);

                sctp_timer_update (sctp_conn, idx, SCTP_TIMER_T3_RXTX,
                                   sctp_conn->sub_conn[idx].RTO);
                break;
              }
            case SHUTDOWN:
              {
                /* Start the SCTP_TIMER_T2_SHUTDOWN timer */
                sctp_timer_set (sctp_conn, idx, SCTP_TIMER_T2_SHUTDOWN,
                                sctp_conn->sub_conn[idx].RTO);
                sctp_conn->state = SCTP_STATE_SHUTDOWN_SENT;
                break;
              }
            case SHUTDOWN_ACK:
              {
                /* Start the SCTP_TIMER_T2_SHUTDOWN timer */
                sctp_timer_set (sctp_conn, idx, SCTP_TIMER_T2_SHUTDOWN,
                                sctp_conn->sub_conn[idx].RTO);
                sctp_conn->state = SCTP_STATE_SHUTDOWN_ACK_SENT;
                break;
              }
            case SHUTDOWN_COMPLETE:
              {
                sctp_conn->state = SCTP_STATE_CLOSED;
                break;
              }
            }

          vnet_buffer (b0)->sw_if_index[VLIB_RX] = 0;
          vnet_buffer (b0)->sw_if_index[VLIB_TX] =
            sctp_conn->sub_conn[idx].c_fib_index;

          b0->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;

          SCTP_DBG_STATE_MACHINE
            ("SESSION_INDEX = %u, CONNECTION_INDEX = %u, " "NEW_STATE = %s, "
             "CHUNK_SENT = %s", sctp_conn->sub_conn[idx].connection.s_index,
             sctp_conn->sub_conn[idx].connection.c_index,
             sctp_state_to_string (sctp_conn->state),
             sctp_chunk_to_string (chunk_type));

          vnet_sctp_common_hdr_params_host_to_net (&full_hdr->common_hdr);

        done:
          b0->error = node->errors[error0];
          if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
            {
              t0 = vlib_add_trace (vm, node, b0, sizeof (*t0));
              if (th0)
                {
                  clib_memcpy_fast (&t0->sctp_header, th0,
                                    sizeof (t0->sctp_header));
                }
              else
                {
                  clib_memset (&t0->sctp_header, 0, sizeof (t0->sctp_header));
                }
              clib_memcpy_fast (&t0->sctp_connection, sctp_conn,
                                sizeof (t0->sctp_connection));
            }

          vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
                                           n_left_to_next, bi0, next0);
        }

      vlib_put_next_frame (vm, node, next_index, n_left_to_next);
    }

  return from_frame->n_vectors;
}

VLIB_NODE_FN (sctp4_output_node) (vlib_main_t * vm,
                                  vlib_node_runtime_t * node,
                                  vlib_frame_t * from_frame)
{
  return sctp46_output_inline (vm, node, from_frame, 1 /* is_ip4 */ );
}

VLIB_NODE_FN (sctp6_output_node) (vlib_main_t * vm,
                                  vlib_node_runtime_t * node,
                                  vlib_frame_t * from_frame)
{
  return sctp46_output_inline (vm, node, from_frame, 0 /* is_ip4 */ );
}

/* *INDENT-OFF* */
VLIB_REGISTER_NODE (sctp4_output_node) =
{
    .name = "sctp4-output",
    /* Takes a vector of packets. */
    .vector_size = sizeof (u32),
    .n_errors = SCTP_N_ERROR,
    .error_strings = sctp_error_strings,
    .n_next_nodes = SCTP_OUTPUT_N_NEXT,
    .next_nodes = {
#define _(s,n) [SCTP_OUTPUT_NEXT_##s] = n,
    foreach_sctp4_output_next
#undef _
    },
    .format_buffer = format_sctp_header,
    .format_trace = format_sctp_tx_trace,
};
/* *INDENT-ON* */

/* *INDENT-OFF* */
VLIB_REGISTER_NODE (sctp6_output_node) =
{
  .name = "sctp6-output",
    /* Takes a vector of packets. */
  .vector_size = sizeof (u32),
  .n_errors = SCTP_N_ERROR,
  .error_strings = sctp_error_strings,
  .n_next_nodes = SCTP_OUTPUT_N_NEXT,
  .next_nodes = {
#define _(s,n) [SCTP_OUTPUT_NEXT_##s] = n,
    foreach_sctp6_output_next
#undef _
  },
  .format_buffer = format_sctp_header,
  .format_trace = format_sctp_tx_trace,
};
/* *INDENT-ON* */

/*
 * fd.io coding-style-patch-verification: ON
 *
 * Local Variables:
 * eval: (c-set-style "gnu")
 * End:
 */