maki/openairinterface5g
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
dda5083174c8691f5e2bd120ea45af3ce2fea67a
openairinterface5g/openair-cn/SCTP/sctp_primitives_server.c
T
Lionel Gauthier bb55cd631c Trace 
git-svn-id: http://svn.eurecom.fr/openair4G/trunk@5668 818b1a75-f10b-46b9-bf7c-635c3b92a50f
2014-08-06 09:50:09 +00:00

659 lines
22 KiB
C
Raw Blame History

/*******************************************************************************
OpenAirInterface
Copyright(c) 1999 - 2014 Eurecom
OpenAirInterface is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenAirInterface is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenAirInterface.The full GNU General Public License is
included in this distribution in the file called "COPYING". If not,
see <http://www.gnu.org/licenses/>.
Contact Information
OpenAirInterface Admin: openair_admin@eurecom.fr
OpenAirInterface Tech : openair_tech@eurecom.fr
OpenAirInterface Dev : openair4g-devel@eurecom.fr
Address : Eurecom, Compus SophiaTech 450, route des chappes, 06451 Biot, France.
*******************************************************************************/
/*! \file sctp_primitives_server.c
* \brief Main server primitives
* \author Sebastien ROUX
* \date 2013
* \version 1.0
* @ingroup _sctp
*/
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/sctp.h>
#include <arpa/inet.h>
#include "assertions.h"
#include "intertask_interface.h"
#include "sctp_primitives_server.h"
#include "mme_config.h"
#include "conversions.h"
#include "sctp_common.h"
#include "sctp_itti_messaging.h"
#define SCTP_DUMP_LIST
#define SCTP_RC_ERROR -1
#define SCTP_RC_NORMAL_READ 0
#define SCTP_RC_DISCONNECT 1
struct sctp_association_s {
struct sctp_association_s *next_assoc; ///< Next association in the list
struct sctp_association_s *previous_assoc; ///< Previous association in the list
int sd; ///< Socket descriptor
uint32_t ppid; ///< Payload protocol Identifier
uint16_t instreams; ///< Number of input streams negociated for this connection
uint16_t outstreams; ///< Number of output strams negotiated for this connection
int32_t assoc_id; ///< SCTP association id for the connection
uint32_t messages_recv; ///< Number of messages received on this connection
uint32_t messages_sent; ///< Number of messages sent on this connection
struct sockaddr *peer_addresses; ///< A list of peer addresses
int nb_peer_addresses;
};
struct sctp_descriptor_s {
// List of connected peers
struct sctp_association_s *available_connections_head;
struct sctp_association_s *available_connections_tail;
uint32_t number_of_connections;
uint16_t nb_instreams;
uint16_t nb_outstreams;
};
struct sctp_arg_s {
int sd;
uint32_t ppid;
};
static struct sctp_descriptor_s sctp_desc;
// Thread used to handle sctp messages
static pthread_t assoc_thread;
// LOCAL FUNCTIONS prototypes
void *sctp_receiver_thread(void *args_p);
static int sctp_send_msg(int32_t sctp_assoc_id, uint16_t stream,
const uint8_t *buffer, const uint32_t length);
// Association list related local functions prototypes
static struct sctp_association_s *sctp_is_assoc_in_list(int32_t assoc_id);
static struct sctp_association_s *sctp_add_new_peer(void);
static int sctp_handle_com_down(uint32_t assoc_id);
static void sctp_dump_list(void);
static struct sctp_association_s *sctp_add_new_peer(void)
{
struct sctp_association_s *new_sctp_descriptor = NULL;
new_sctp_descriptor = calloc(1, sizeof(struct sctp_association_s));
if (new_sctp_descriptor == NULL) {
SCTP_ERROR("Failed to allocate memory for new peer (%s:%d)\n",
__FILE__, __LINE__);
return NULL;
}
new_sctp_descriptor->next_assoc = NULL;
new_sctp_descriptor->previous_assoc = NULL;
if (sctp_desc.available_connections_tail == NULL) {
sctp_desc.available_connections_head = new_sctp_descriptor;
sctp_desc.available_connections_tail = sctp_desc.available_connections_head;
} else {
new_sctp_descriptor->previous_assoc = sctp_desc.available_connections_tail;
sctp_desc.available_connections_tail->next_assoc = new_sctp_descriptor;
sctp_desc.available_connections_tail = new_sctp_descriptor;
}
sctp_desc.number_of_connections++;
sctp_dump_list();
return new_sctp_descriptor;
}
static struct sctp_association_s *sctp_is_assoc_in_list(int32_t assoc_id)
{
struct sctp_association_s *assoc_desc;
if (assoc_id < 0) {
return NULL;
}
for (assoc_desc = sctp_desc.available_connections_head;
assoc_desc;
assoc_desc = assoc_desc->next_assoc) {
if (assoc_desc->assoc_id == assoc_id) {
break;
}
}
return assoc_desc;
}
static int sctp_remove_assoc_from_list(int32_t assoc_id)
{
struct sctp_association_s *assoc_desc;
/* Association not in the list */
if ((assoc_desc = sctp_is_assoc_in_list(assoc_id)) == NULL) {
return -1;
}
if (assoc_desc->next_assoc == NULL) {
if (assoc_desc->previous_assoc == NULL) {
/* Head and tail */
sctp_desc.available_connections_head = sctp_desc.available_connections_tail = NULL;
} else {
/* Not head but tail */
sctp_desc.available_connections_tail = assoc_desc->previous_assoc;
assoc_desc->previous_assoc->next_assoc = NULL;
}
} else {
if (assoc_desc->previous_assoc == NULL) {
/* Head but not tail */
sctp_desc.available_connections_head = assoc_desc->next_assoc;
assoc_desc->next_assoc->previous_assoc = NULL;
} else {
/* Not head and not tail */
assoc_desc->previous_assoc->next_assoc = assoc_desc->next_assoc;
assoc_desc->next_assoc->previous_assoc = assoc_desc->previous_assoc;
}
}
free(assoc_desc);
assoc_desc = NULL;
sctp_desc.number_of_connections --;
return 0;
}
static void sctp_dump_assoc(struct sctp_association_s *sctp_assoc_p)
{
#if defined(SCTP_DUMP_LIST)
int i;
if (sctp_assoc_p == NULL) {
return;
}
SCTP_DEBUG("sd : %d\n", sctp_assoc_p->sd);
SCTP_DEBUG("input streams: %d\n", sctp_assoc_p->instreams);
SCTP_DEBUG("out streams : %d\n", sctp_assoc_p->outstreams);
SCTP_DEBUG("assoc_id : %d\n", sctp_assoc_p->assoc_id);
SCTP_DEBUG("peer address :\n");
for (i = 0; i < sctp_assoc_p->nb_peer_addresses; i++) {
char address[40];
memset(address, 0, sizeof(address));
if (inet_ntop(sctp_assoc_p->peer_addresses[i].sa_family,
sctp_assoc_p->peer_addresses[i].sa_data, address, sizeof(address)) != NULL)
{
SCTP_DEBUG(" - [%s]\n", address);
}
}
#else
sctp_assoc_p = sctp_assoc_p;
#endif
}
static void sctp_dump_list(void)
{
#if defined(SCTP_DUMP_LIST)
struct sctp_association_s *sctp_assoc_p;
sctp_assoc_p = sctp_desc.available_connections_head;
SCTP_DEBUG("SCTP list contains %d associations\n", sctp_desc.number_of_connections);
while (sctp_assoc_p != NULL) {
sctp_dump_assoc(sctp_assoc_p);
sctp_assoc_p = sctp_assoc_p->next_assoc;
}
#else
sctp_dump_assoc(NULL);
#endif
}
static int sctp_send_msg(int32_t sctp_assoc_id, uint16_t stream,
const uint8_t *buffer, const uint32_t length)
{
struct sctp_association_s *assoc_desc = NULL;
DevAssert(buffer != NULL);
if ((assoc_desc = sctp_is_assoc_in_list(sctp_assoc_id)) == NULL) {
SCTP_DEBUG("This assoc id has not been fount in list (%d)\n",
sctp_assoc_id);
return -1;
}
if (assoc_desc->sd == -1) {
/* The socket is invalid may be closed.
*/
return -1;
}
SCTP_DEBUG("[%d][%d] Sending buffer %p of %d bytes on stream %d with ppid %d\n",
assoc_desc->sd, sctp_assoc_id, buffer,
length, stream, assoc_desc->ppid);
/* Send message_p on specified stream of the sd association */
if (sctp_sendmsg(assoc_desc->sd,
(const void *)buffer,
length,
NULL,
0,
assoc_desc->ppid, 0, stream, 0, 0) < 0) {
SCTP_ERROR("send: %s:%d", strerror(errno), errno);
return -1;
}
assoc_desc->messages_sent++;
SCTP_DEBUG("Successfully sent %d bytes on stream %d\n", length, stream);
return 0;
}
static int sctp_create_new_listener(SctpInit *init_p)
{
struct sctp_event_subscribe event;
struct sockaddr *addr;
struct sctp_arg_s *sctp_arg_p;
uint16_t i = 0, j;
int sd;
int used_addresses = 0;
DevAssert(init_p != NULL);
if (init_p->ipv4 == 0 && init_p->ipv6 == 0) {
SCTP_ERROR("Illegal IP configuration upper layer should request at"
"least ipv4 and/or ipv6 config\n");
return -1;
}
if ((used_addresses = init_p->nb_ipv4_addr + init_p->nb_ipv6_addr) == 0) {
SCTP_WARN("No address provided...\n");
return -1;
}
addr = calloc(used_addresses, sizeof(struct sockaddr));
SCTP_DEBUG("Creating new listen socket on port %u with\n", init_p->port);
if (init_p->ipv4 == 1) {
struct sockaddr_in *ip4_addr;
SCTP_DEBUG("ipv4 addresses:\n");
for (i = 0; i < init_p->nb_ipv4_addr; i++) {
SCTP_DEBUG("\t- "IPV4_ADDR"\n",
IPV4_ADDR_FORMAT(init_p->ipv4_address[i]));
ip4_addr = (struct sockaddr_in *)&addr[i];
ip4_addr->sin_family = AF_INET;
ip4_addr->sin_port = htons(init_p->port);
ip4_addr->sin_addr.s_addr = init_p->ipv4_address[i];
}
}
if (init_p->ipv6 == 1) {
struct sockaddr_in6 *ip6_addr;
SCTP_DEBUG("ipv6 addresses:\n");
for (j = 0; j < init_p->nb_ipv6_addr; j++) {
SCTP_DEBUG("\t- %s\n", init_p->ipv6_address[j]);
ip6_addr = (struct sockaddr_in6 *)&addr[i + j];
ip6_addr->sin6_family = AF_INET6;
ip6_addr->sin6_port = htons(init_p->port);
if (inet_pton(AF_INET6, init_p->ipv6_address[j],
ip6_addr->sin6_addr.s6_addr) <= 0) {
SCTP_WARN("Provided ipv6 address %s is not valid\n",
init_p->ipv6_address[j]);
}
}
}
if ((sd = socket(AF_INET6, SOCK_STREAM, IPPROTO_SCTP)) < 0) {
SCTP_ERROR("socket: %s:%d\n", strerror(errno), errno);
return -1;
}
memset((void *)&event, 1, sizeof(struct sctp_event_subscribe));
if (setsockopt(sd, IPPROTO_SCTP, SCTP_EVENTS, &event,
sizeof(struct sctp_event_subscribe)) < 0) {
SCTP_ERROR("setsockopt: %s:%d\n", strerror(errno), errno);
return -1;
}
/* Some pre-bind socket configuration */
if (sctp_set_init_opt(sd, sctp_desc.nb_instreams, sctp_desc.nb_outstreams,
0, 0) < 0)
{
goto err;
}
if (sctp_bindx(sd, addr, used_addresses, SCTP_BINDX_ADD_ADDR) != 0) {
SCTP_ERROR("sctp_bindx: %s:%d\n", strerror(errno), errno);
return -1;
}
if (listen(sd, 5) < 0) {
SCTP_ERROR("listen: %s:%d\n", strerror(errno), errno);
return -1;
}
if ((sctp_arg_p = malloc(sizeof(struct sctp_arg_s))) == NULL) {
return -1;
}
sctp_arg_p->sd = sd;
sctp_arg_p->ppid = init_p->ppid;
if (pthread_create(&assoc_thread, NULL, &sctp_receiver_thread,
(void *)sctp_arg_p) < 0) {
SCTP_ERROR("pthread_create: %s:%d\n", strerror(errno), errno);
return -1;
}
return sd;
err:
if (sd != -1) {
close(sd);
sd = -1;
}
return -1;
}
static
inline int sctp_read_from_socket(int sd, int ppid)
{
int flags = 0, n;
socklen_t from_len;
struct sctp_sndrcvinfo sinfo;
struct sockaddr_in addr;
uint8_t buffer[SCTP_RECV_BUFFER_SIZE];
if (sd < 0) {
return -1;
}
memset((void *)&addr, 0, sizeof(struct sockaddr_in));
from_len = (socklen_t)sizeof(struct sockaddr_in);
memset((void *)&sinfo, 0, sizeof(struct sctp_sndrcvinfo));
n = sctp_recvmsg(sd, (void *)buffer, SCTP_RECV_BUFFER_SIZE,
(struct sockaddr *)&addr, &from_len,
&sinfo, &flags);
if (n < 0) {
SCTP_DEBUG("An error occured during read\n");
SCTP_ERROR("sctp_recvmsg: %s:%d\n", strerror(errno), errno);
return SCTP_RC_ERROR;
}
if (flags & MSG_NOTIFICATION) {
union sctp_notification *snp;
snp = (union sctp_notification *)buffer;
/* Client deconnection */
if (SCTP_SHUTDOWN_EVENT == snp->sn_header.sn_type) {
SCTP_DEBUG("SCTP_SHUTDOWN_EVENT received\n");
return sctp_handle_com_down(snp->sn_shutdown_event.sse_assoc_id);
}
/* Association has changed. */
else if (SCTP_ASSOC_CHANGE == snp->sn_header.sn_type) {
struct sctp_assoc_change *sctp_assoc_changed;
sctp_assoc_changed = &snp->sn_assoc_change;
SCTP_DEBUG("Client association changed: %d\n", sctp_assoc_changed->sac_state);
/* New physical association requested by a peer */
switch (sctp_assoc_changed->sac_state) {
case SCTP_COMM_UP: {
struct sctp_association_s *new_association;
sctp_get_sockinfo(sd, NULL, NULL, NULL);
SCTP_DEBUG("New connection\n");
if ((new_association = sctp_add_new_peer()) == NULL) {
// TODO: handle this case
DevMessage("Unexpected error...\n");
return SCTP_RC_ERROR;
} else {
new_association->sd = sd;
new_association->ppid = ppid;
new_association->instreams = sctp_assoc_changed->sac_inbound_streams;
new_association->outstreams = sctp_assoc_changed->sac_outbound_streams;
new_association->assoc_id = sctp_assoc_changed->sac_assoc_id;
sctp_get_localaddresses(sd, NULL, NULL);
sctp_get_peeraddresses(sd, &new_association->peer_addresses,
&new_association->nb_peer_addresses);
if (sctp_itti_send_new_association(
new_association->assoc_id, new_association->instreams,
new_association->outstreams) < 0)
{
SCTP_ERROR("Failed to send message to S1AP\n");
return SCTP_RC_ERROR;
}
}
} break;
default:
break;
}
}
} else {
/* Data payload received */
struct sctp_association_s *association;
if ((association = sctp_is_assoc_in_list(sinfo.sinfo_assoc_id)) == NULL) {
// TODO: handle this case
return SCTP_RC_ERROR;
}
association->messages_recv++;
if (ntohl(sinfo.sinfo_ppid) != association->ppid) {
/* Mismatch in Payload Protocol Identifier,
* may be we received unsollicited traffic from stack other than S1AP.
*/
SCTP_ERROR("Received data from peer with unsollicited PPID %d, expecting %d\n",
ntohl(sinfo.sinfo_ppid), association->ppid);
return SCTP_RC_ERROR;
}
SCTP_DEBUG("[%d][%d] Msg of length %d received from port %u, on stream %d, PPID %d\n",
sinfo.sinfo_assoc_id, sd, n, ntohs(addr.sin_port),
sinfo.sinfo_stream, ntohl(sinfo.sinfo_ppid));
sctp_itti_send_new_message_ind(n, buffer, sinfo.sinfo_assoc_id, sinfo.sinfo_stream,
association->instreams, association->outstreams);
}
return SCTP_RC_NORMAL_READ;
}
static int sctp_handle_com_down(uint32_t assoc_id)
{
SCTP_DEBUG("Sending close connection for assoc_id %u\n", assoc_id);
if (sctp_itti_send_com_down_ind(assoc_id) < 0) {
SCTP_ERROR("Failed to send message to TASK_S1AP\n");
}
if (sctp_remove_assoc_from_list(assoc_id) < 0) {
SCTP_ERROR("Failed to find client in list\n");
}
return SCTP_RC_DISCONNECT;
}
void *sctp_receiver_thread(void *args_p)
{
struct sctp_arg_s *sctp_arg_p;
/* maximum file descriptor number */
int fdmax, clientsock, i;
/* master file descriptor list */
fd_set master;
/* temp file descriptor list for select() */
fd_set read_fds;
if ((sctp_arg_p = (struct sctp_arg_s *)args_p) == NULL) {
pthread_exit(NULL);
}
/* clear the master and temp sets */
FD_ZERO(&master);
FD_ZERO(&read_fds);
FD_SET(sctp_arg_p->sd, &master);
fdmax = sctp_arg_p->sd; /* so far, it's this one*/
while(1) {
memcpy(&read_fds, &master, sizeof(master));
if (select(fdmax+1, &read_fds, NULL, NULL, NULL) == -1) {
SCTP_ERROR("[%d] Select() error: %s",
sctp_arg_p->sd, strerror(errno));
free(args_p);
args_p = NULL;
pthread_exit(NULL);
}
for (i = 0; i <= fdmax; i++) {
if (FD_ISSET(i, &read_fds)) {
if (i == sctp_arg_p->sd) {
/* There is data to read on listener socket. This means we have to accept
* the connection.
*/
if ((clientsock = accept(sctp_arg_p->sd, NULL, NULL)) < 0) {
SCTP_ERROR("[%d] accept: %s:%d\n", sctp_arg_p->sd, strerror(errno), errno);
free(args_p);
args_p = NULL;
pthread_exit(NULL);
} else {
FD_SET(clientsock, &master); /* add to master set */
if(clientsock > fdmax)
{
/* keep track of the maximum */
fdmax = clientsock;
}
}
} else {
int ret;
/* Read from socket */
ret = sctp_read_from_socket(i, sctp_arg_p->ppid);
/* When the socket is disconnected we have to update
* the fd_set.
*/
if (ret == SCTP_RC_DISCONNECT) {
/* Remove the socket from the FD set and update the max sd */
FD_CLR(i, &master);
if (i == fdmax) {
while (FD_ISSET(fdmax, &master) == FALSE)
fdmax -= 1;
}
}
}
}
}
}
free(args_p);
args_p = NULL;
return NULL;
}
static void *sctp_intertask_interface(void *args_p)
{
itti_mark_task_ready(TASK_SCTP);
while(1) {
MessageDef *received_message_p;
itti_receive_msg(TASK_SCTP, &received_message_p);
switch (ITTI_MSG_ID(received_message_p))
{
case SCTP_INIT_MSG: {
SCTP_DEBUG("Received SCTP_INIT_MSG\n");
/* We received a new connection request */
if (sctp_create_new_listener(&received_message_p->ittiMsg.sctpInit) < 0) {
/* SCTP socket creation or bind failed... */
SCTP_ERROR("Failed to create new SCTP listener\n");
}
} break;
case SCTP_CLOSE_ASSOCIATION: {
} break;
case SCTP_DATA_REQ: {
if (sctp_send_msg(SCTP_DATA_REQ(received_message_p).assocId,
SCTP_DATA_REQ(received_message_p).stream,
SCTP_DATA_REQ(received_message_p).buffer,
SCTP_DATA_REQ(received_message_p).bufLen) < 0) {
SCTP_ERROR("Failed to send message over SCTP\n");
}
} break;
case MESSAGE_TEST: {
// int i = 10000;
// while(i--);
} break;
case TERMINATE_MESSAGE: {
itti_exit_task();
} break;
default: {
SCTP_DEBUG("Unkwnon message ID %d:%s\n",
ITTI_MSG_ID(received_message_p),
ITTI_MSG_NAME(received_message_p));
} break;
}
itti_free(ITTI_MSG_ORIGIN_ID(received_message_p), received_message_p);
received_message_p = NULL;
}
return NULL;
}
int sctp_init(const mme_config_t *mme_config_p)
{
SCTP_DEBUG("Initializing SCTP task interface\n");
memset(&sctp_desc, 0, sizeof(struct sctp_descriptor_s));
/* Number of streams from configuration */
sctp_desc.nb_instreams = mme_config_p->sctp_config.in_streams;
sctp_desc.nb_outstreams = mme_config_p->sctp_config.out_streams;
if (itti_create_task(TASK_SCTP, &sctp_intertask_interface,
NULL) < 0) {
SCTP_ERROR("create task failed");
SCTP_DEBUG("Initializing SCTP task interface: FAILED\n");
return -1;
}
SCTP_DEBUG("Initializing SCTP task interface: DONE\n");
return 0;
}
Reference in New Issue View Git Blame Copy Permalink