sctp_common.c

/*
 * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The OpenAirInterface Software Alliance licenses this file to You under
 * the OAI Public License, Version 1.1  (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.openairinterface.org/?page_id=698
 *
 * 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.
 *-------------------------------------------------------------------------------
 * For more information about the OpenAirInterface (OAI) Software Alliance:
 *      contact@openairinterface.org
 */

/*! \file sctp_common.c
 *  \brief eNB/MME SCTP related common procedures
 *  \author Sebastien ROUX
 *  \date 2013
 *  \version 1.0
 *  @ingroup _sctp
 */

#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>

#include <sys/socket.h>
#include <arpa/inet.h>

#include <netinet/in.h>
#include <netinet/sctp.h>

#include "sctp_common.h"

/* Pre-bind socket options configuration.
 * See http://linux.die.net/man/7/sctp for more information on these options.
 */
int sctp_set_init_opt(int sd, uint16_t instreams, uint16_t outstreams,
                      uint16_t max_attempts, uint16_t init_timeout)
{
  int on = 1;
  struct sctp_initmsg init;

  memset((void *)&init, 0, sizeof(struct sctp_initmsg));

  /* Request a number of streams */
  init.sinit_num_ostreams   = outstreams;
  init.sinit_max_instreams  = instreams;
  init.sinit_max_attempts   = max_attempts;
  init.sinit_max_init_timeo = init_timeout;

  if (setsockopt(sd, IPPROTO_SCTP, SCTP_INITMSG, &init, sizeof(struct sctp_initmsg)) < 0) {
    SCTP_ERROR("setsockopt: %d:%s\n", errno, strerror(errno));
    close(sd);
    return -1;
  }

  /* Allow socket reuse */
  if (setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) {
    SCTP_ERROR("setsockopt SO_REUSEADDR failed (%d:%s)\n", errno, strerror(errno));
    close(sd);
    return -1;
  }

  return 0;
}

int sctp_get_sockinfo(int sock, uint16_t *instream, uint16_t *outstream,
                      int32_t *assoc_id)
{
  socklen_t i;
  struct sctp_status status;

  if (socket <= 0) {
    return -1;
  }

  memset(&status, 0, sizeof(struct sctp_status));
  i = sizeof(struct sctp_status);

  /* if sock refers to a multi SCTP endpoint, *assoc_id gives us
   * the association ID that we want
   */
  if (assoc_id != NULL)
    status.sstat_assoc_id = *assoc_id;

  if (getsockopt(sock, IPPROTO_SCTP, SCTP_STATUS, &status, &i) < 0) {
    SCTP_ERROR("Getsockopt SCTP_STATUS failed: %s\n", strerror(errno));
    return -1;
  }

  SCTP_DEBUG("----------------------\n");
  SCTP_DEBUG("SCTP Status:\n");
  SCTP_DEBUG("assoc id .....: %u\n", status.sstat_assoc_id);
  SCTP_DEBUG("state ........: %d\n", status.sstat_state);
  SCTP_DEBUG("instrms ......: %u\n", status.sstat_instrms);
  SCTP_DEBUG("outstrms .....: %u\n", status.sstat_outstrms);
  SCTP_DEBUG("fragmentation : %u\n", status.sstat_fragmentation_point);
  SCTP_DEBUG("pending data .: %u\n", status.sstat_penddata);
  SCTP_DEBUG("unack data ...: %u\n", status.sstat_unackdata);
  SCTP_DEBUG("rwnd .........: %u\n", status.sstat_rwnd);
  SCTP_DEBUG("peer info     :\n");
  SCTP_DEBUG("    state ....: %u\n", status.sstat_primary.spinfo_state);
  SCTP_DEBUG("    cwnd .....: %u\n", status.sstat_primary.spinfo_cwnd);
  SCTP_DEBUG("    srtt .....: %u\n" , status.sstat_primary.spinfo_srtt);
  SCTP_DEBUG("    rto ......: %u\n" , status.sstat_primary.spinfo_rto);
  SCTP_DEBUG("    mtu ......: %u\n" , status.sstat_primary.spinfo_mtu);
  SCTP_DEBUG("----------------------\n");

  if (instream != NULL) {
    *instream = status.sstat_instrms;
  }

  if (outstream != NULL) {
    *outstream = status.sstat_outstrms;
  }

  if (assoc_id != NULL) {
    *assoc_id = status.sstat_assoc_id;
  }

  return 0;
}

int sctp_get_peeraddresses(int sock, struct sockaddr **remote_addr, int *nb_remote_addresses)
{
  int nb, j;
  struct sockaddr *temp_addr_p;

  if ((nb = sctp_getpaddrs(sock, -1, &temp_addr_p)) <= 0) {
    SCTP_ERROR("Failed to retrieve peer addresses\n");
    return -1;
  }

  SCTP_DEBUG("----------------------\n");
  SCTP_DEBUG("Peer addresses:\n");

  for (j = 0; j < nb; j++) {
    if (temp_addr_p[j].sa_family == AF_INET) {
      char address[16];
      struct sockaddr_in *addr;

      memset(&address, 0, sizeof(address));

      addr = (struct sockaddr_in*)&temp_addr_p[j];

      if (inet_ntop(AF_INET, &addr->sin_addr, address, sizeof(address)) != NULL) {
        SCTP_DEBUG("    - [%s]\n", address);
      }
    } else {
      struct sockaddr_in6 *addr;
      char address[40];

      addr = (struct sockaddr_in6*)&temp_addr_p[j];

      memset(&address, 0, sizeof(address));

      if (inet_ntop(AF_INET6, &addr->sin6_addr.s6_addr, address, sizeof(address)) != NULL) {
        SCTP_DEBUG("    - [%s]\n", address);
      }
    }
  }

  SCTP_DEBUG("----------------------\n");

  if (remote_addr != NULL && nb_remote_addresses != NULL) {
    *nb_remote_addresses = nb;
    *remote_addr = temp_addr_p;
  } else {
    /* We can destroy buffer */
    sctp_freepaddrs((struct sockaddr*)temp_addr_p);
  }

  return 0;
}

int sctp_get_localaddresses(int sock, struct sockaddr **local_addr, int *nb_local_addresses)
{
  int nb, j;
  struct sockaddr *temp_addr_p;

  if ((nb = sctp_getladdrs(sock, -1, &temp_addr_p)) <= 0) {
    SCTP_ERROR("Failed to retrieve local addresses\n");
    return -1;
  }

  SCTP_DEBUG("----------------------\n");
  SCTP_DEBUG("Local addresses:\n");

  for (j = 0; j < nb; j++) {
    if (temp_addr_p[j].sa_family == AF_INET) {
      char address[16];
      struct sockaddr_in *addr;

      memset(address, 0, sizeof(address));

      addr = (struct sockaddr_in*)&temp_addr_p[j];

      if (inet_ntop(AF_INET, &addr->sin_addr, address, sizeof(address)) != NULL) {
        SCTP_DEBUG("    - [%s]\n", address);
      }
    } else {
      struct sockaddr_in6 *addr;
      char address[40];

      addr = (struct sockaddr_in6*)&temp_addr_p[j];

      memset(address, 0, sizeof(address));

      if (inet_ntop(AF_INET6, &addr->sin6_addr.s6_addr, address, sizeof(address)) != NULL) {
        SCTP_DEBUG("    - [%s]\n", address);
      }
    }
  }

  SCTP_DEBUG("----------------------\n");

  if (local_addr != NULL && nb_local_addresses != NULL) {
    *nb_local_addresses = nb;
    *local_addr = temp_addr_p;
  } else {
    /* We can destroy buffer */
    sctp_freeladdrs((struct sockaddr*)temp_addr_p);
  }

  return 0;
}