/*
 * 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.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.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
 */

/*****************************************************************************
 Source   socket.c

 Version    0.1

 Date   2012/02/28

 Product    NAS stack

 Subsystem  Utilities

 Author   Frederic Maurel

 Description  Implements socket handlers

 *****************************************************************************/

#include "socket.h"
#include "commonDef.h"

#include <stdlib.h> // malloc, free, atoi
#include <string.h> // memset
#include <unistd.h> // close
#include <errno.h>  // EINTR
#include <sys/types.h>
#include <sys/socket.h> // socket, setsockopt, connect, bind, recv, send
#include <netdb.h>  // getaddrinfo
/****************************************************************************/
/****************  E X T E R N A L    D E F I N I T I O N S  ****************/
/****************************************************************************/

/****************************************************************************/
/*******************  L O C A L    D E F I N I T I O N S  *******************/
/****************************************************************************/

/* -------------------------------------
 * Identifier of network socket endpoint
 * -------------------------------------
 *  A network socket endpoint is defined with a type (client or server),
 *  a port number, and the name and address of the remote host it should
 *  be connected to. A socket file descriptor is created to handle the
 *  setup of the communication channel with the remote peer.
 */
struct socket_id_s {
  int type; /* connection type (client/server)  */
  int port; /* port number      */
#define SOCKET_HOSTNAME_SIZE  32
  char rhost[SOCKET_HOSTNAME_SIZE]; /* remote hostname    */
  struct sockaddr_storage addr; /* remote address   */
  int fd; /* socket file descriptor */
};

/* Set socket option at the sockets API level (SOL_SOCKET) */
static int _socket_set_option(int sfd);

/****************************************************************************/
/******************  E X P O R T E D    F U N C T I O N S  ******************/
/****************************************************************************/

/****************************************************************************
 **                                                                        **
 ** Name:  socket_udp_open()                                         **
 **                                                                        **
 ** Description: Initializes a communication endpoint for any IPv4 and     **
 **    IPv6 protocol used by a local host to send/receive UDP    **
 **    datagrams to/from a remote host in "connected" mode of    **
 **    operation.                                                **
 **                                                                        **
 ** Inputs:  type:    Type of the connection (client/server)     **
 **      host:    For client application, the remote host-   **
 **       name, or numerical IPv4 or IPv6 network    **
 **       address to connect to. NULL for server     **
 **       application.                               **
 **      port:    The port number                            **
 **      Others:  None                                       **
 **                                                                        **
 ** Outputs:   None                                                      **
 **      Return:  A pointer to the local endpoint identifier **
 **       that has been allocated for communication  **
 **       with the remote peer. NULL if the setup of **
 **       the communication endpoint failed.         **
 **      Others:  None                                       **
 **                                                                        **
 ***************************************************************************/
void* socket_udp_open(int type, const char* host, const char* port)
{
  struct addrinfo socket_info; /* endpoint information    */
  struct addrinfo *socket_addr, *sp; /* endpoint address    */
  int sfd; /* socket file descriptor  */

  /*
   * Parameters sanity check
   * -----------------------
   * The local connection endpoint shall be of type CLIENT or SERVER
   */
  if (host == NULL) {
    type = SOCKET_SERVER;
  } else if (type != SOCKET_CLIENT && type != SOCKET_SERVER) {
    return NULL;
  }

  /*
   * Initialize the endpoint address information
   * -------------------------------------------
   *  The AI_PASSIVE flag allows "wildcard address" when hostname is not
   *  provided (NULL). The wildcard address is used by applications (ty-
   *  pically servers) that intend to accept connections on any of the
   *  hosts's network addresses. If the hostname is not NULL, then the
   *  AI_PASSIVE flag is ignored.
   *  When the AI_V4MAPPED flag is set, and AF_INET6 is specified, and no
   *  matching IPv6 addresses could be found, then IPv4-mapped IPv6 addresses
   *  are returned by getaddrinfo in the list pointed to by result.
   */
  memset (&socket_info, 0, sizeof(struct addrinfo));
  socket_info.ai_socktype = SOCK_DGRAM; /* Datagram socket   */
  socket_info.ai_flags = AI_NUMERICSERV; /* numeric port number  */

  if (type != SOCKET_CLIENT) {
    /* Setup socket address options at the server side */
    socket_info.ai_family = AF_INET6; /* Accept either IPv4 or IPv6
         * connections     */
    socket_info.ai_flags |= AI_PASSIVE; /* Use "wildcard address"  */
    socket_info.ai_flags |= AI_V4MAPPED; /* IPv4-mapped IPv6 address */
  } else {
    /* Setup socket address options at the client side */
    socket_info.ai_family = AF_INET; /* Any address family   */
    //         socket_info.ai_flags |= AI_V4MAPPED; /* IPv4-mapped IPv6 address */
  }

  /*
   * getaddrinfo() returns a linked list of address structures:
   *  - The network host may be multi-homed, accessible over multiple
   *    protocols (e.g. both AF_INET and AF_INET6);
   *  - The same service (port number) may be available from multiple
   *    socket types (one SOCK_STREAM address and another SOCK_DGRAM address);
   */
  int rc = getaddrinfo (host, port, &socket_info, &socket_addr);

  if (rc != 0) {
    if (rc != EAI_SYSTEM) {
      errno = rc;
    }

    return NULL;
  }

  /*
   * Try each address until we successfully connect
   */
  for (sp = socket_addr; sp != NULL; sp = sp->ai_next) {
    /* Create the socket endpoint for communication */
    sfd = socket (sp->ai_family, sp->ai_socktype, sp->ai_protocol);

    if (sfd < 0) {
      continue;
    }

    /*
     * Initiate a communication channel at the CLIENT side
     */
    if (type == SOCKET_CLIENT) {
      /* Connect the socket to the remote server's address */
      if (connect (sfd, sp->ai_addr, sp->ai_addrlen) != -1) {
        break; /* Connection succeed */
      }
    }

    /*
     * Initiate a communication channel at the SERVER side
     */
    else {
      if (type == SOCKET_SERVER) {
        /* Set socket options */
        if (_socket_set_option (sfd) != RETURNok) {
          continue;
        }

        /* Bind the socket to the local server's address */
        if (bind (sfd, sp->ai_addr, sp->ai_addrlen) != -1) {
          break; /* Bind succeed */
        }
      }
    }

    close (sfd);
  }

  /* Free the memory that was dynamically allocated for the linked list */
  freeaddrinfo (socket_addr);

  if (sp == NULL) {
    /* Connect or bind failed */
    return NULL;
  }

  /* The connection endpoint has been successfully setup */
  socket_id_t * sid = (socket_id_t *) malloc (sizeof(struct socket_id_s));

  if (sid != NULL) {
    sid->type = type;
    sid->port = atoi (port);
    sid->fd = sfd;
  }

  return sid;
}

/****************************************************************************
 **                                                                        **
 ** Name:  socket_close()                                            **
 **                                                                        **
 ** Description: Cleanup the specified communication endpoint: Close the   **
 **    socket file descriptor and frees all the memory space     **
 **    allocated to handle the communication channel towards the **
 **    remote peer                                               **
 **                                                                        **
 ** Inputs:  None                                                      **
 **      Others:  None                                       **
 **                                                                        **
 ** Outputs:   id:    The identifier of the connection endpoint  **
 **      Return:  None                                       **
 **      Others:  None                                       **
 **                                                                        **
 ***************************************************************************/
void socket_close(void* id)
{
  if (id) {
    close (((socket_id_t*) id)->fd);
    free (id);
  }
}

/****************************************************************************
 **                                                                        **
 ** Name:  socket_recv()                                             **
 **                                                                        **
 ** Description: Receives data from a given communication endpoint to a    **
 **    receive buffer of specified length                        **
 **                                                                        **
 ** Inputs:  id:    The identifier of the connection endpoint  **
 **      length:  Length of the receive buffer               **
 **      Others:  None                                       **
 **                                                                        **
 ** Outputs:   id:    The identifier of the connection endpoint  **
 **      buffer:  The receive buffer                         **
 **      Return:  The number of bytes received when success; **
 **       RETURNerror otherwise.                     **
 **      Others:  None                                       **
 **                                                                        **
 ***************************************************************************/
ssize_t socket_recv(void* id, char* buffer, size_t length)
{
  socket_id_t* sid = (socket_id_t*) (id);
  ssize_t rbytes = -1;

  if (sid->type == SOCKET_CLIENT) {
    /* Receive data from the connected socket */
    rbytes = recv (sid->fd, buffer, length, 0);
  } else if (sid->type == SOCKET_SERVER) {
    struct sockaddr_storage addr;
    socklen_t addrlen = sizeof(addr);

    /* Receive data from the socket and retreive the remote host address */
    rbytes = recvfrom (sid->fd, buffer, length, 0, (struct sockaddr *) &addr, &addrlen);
    sid->addr = addr;
  }

  if (errno == EINTR) {
    /* A signal was caught */
    return 0;
  } else if (rbytes < 0) {
    /* Receive failed */
    return RETURNerror;
  }

  return rbytes;
}

/****************************************************************************
 **                                                                        **
 ** Name:  socket_send()                                             **
 **                                                                        **
 ** Description: Sends data to a given communication endpoint from a send  **
 **    buffer of specified length                                **
 **                                                                        **
 ** Inputs:  id:    The identifier of the connection endpoint  **
 **    buffer:  The send buffer                            **
 **      length:  Length of the send buffer                  **
 **      Others:  None                                       **
 **                                                                        **
 ** Outputs:   None                                                      **
 **      Return:  The number of bytes sent when success;     **
 **       RETURNerror otherwise.                     **
 **      Others:  None                                       **
 **                                                                        **
 ***************************************************************************/
ssize_t socket_send(const void* id, const char* buffer, size_t length)
{
  const socket_id_t* sid = (socket_id_t*) (id);
  ssize_t sbytes = -1;

  if (sid->type == SOCKET_CLIENT) {
    /* Send data to the connected socket */
    sbytes = send (sid->fd, buffer, length, 0);
  } else if (sid->type == SOCKET_SERVER) {
    /* Send data to the socket using the remote host address */
    sbytes = sendto (sid->fd, buffer, length, 0, (struct sockaddr *) &sid->addr, (socklen_t) sizeof(sid->addr));
  }

  if (errno == EINTR) {
    /* A signal was caught */
    return 0;
  } else if (sbytes != length) {
    /* Send failed */
    return RETURNerror;
  }

  return sbytes;
}

/****************************************************************************
 **                                                                        **
 ** Name:  socket_get_fd()                                           **
 **                                                                        **
 ** Description: Get the value of the socket file descriptor created for   **
 **    the given connection endpoint                             **
 **                                                                        **
 ** Inputs:  id:    The identifier of the connection endpoint  **
 **      Others:  None                                       **
 **                                                                        **
 ** Outputs:   None                                                      **
 **      Return:  The file descriptor of the socket created  **
 **       for this connection endpoint               **
 **      Others:  None                                       **
 **                                                                        **
 ***************************************************************************/
int socket_get_fd(const void* id)
{
  if (id) {
    return ((socket_id_t*) id)->fd;
  }

  return RETURNerror;
}

/****************************************************************************/
/*********************  L O C A L    F U N C T I O N S  *********************/
/****************************************************************************/

/****************************************************************************
 **                                                                        **
 ** Name:  _socket_set_option()                                      **
 **                                                                        **
 ** Description: Set socket option at the sockets API level (SOL_SOCKET)   **
 **                                                                        **
 ** Inputs:  sfd:   Socket file descriptor                     **
 **      Others:  None                                       **
 **                                                                        **
 ** Outputs:   None                                                      **
 **      Return:  RETURNok, RETURNerror                      **
 **      Others:  None                                       **
 **                                                                        **
 ***************************************************************************/
static int _socket_set_option(int sfd)
{
  int optval;

  /* SO_REUSEADDR socket option:
   * ---------------------------
   * Allows the server to bind a socket to this port, unless
   * there is an active listening socket already bound to the
   * port. This is useful when recovering from a crash and the
   * socket was not properly closed. The server can be restarted
   * and it will simply open another socket on the same port and
   * continue listening.
   */
  optval = TRUE;

  if (setsockopt (sfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) < 0) {
    return RETURNerror;
  }

  /* IPV6_V6ONLY socket option
   * -------------------------
   * When option is set to TRUE, the socket is restricted to sending and
   * receiving IPv6 packets only.
   * When option is set to FALSE, the socket can be used to send and receive
   * packets to and from an IPv6 address or an IPv4-mapped IPv6 address.
   */
  optval = FALSE;

  if (setsockopt (sfd, IPPROTO_IPV6, IPV6_V6ONLY, &optval, sizeof(optval)) < 0) {
    return RETURNerror;
  }

  return RETURNok;
}

