---

sockets.c

Go to the documentation of this file.

/*! \file sockets.c
    This file implements low level network functionalities.
 */

#include "sockets.h"

static char *get_doted_ip (unsigned long int ip);

/*! \brief Maximum number of characters for the error message.
 */

#define SOCKET_ERROR_SIZE  4096

/*! \brief Maximum number of network interfaces fot the host.
 */

#define MAX_INTERFACE      16

/*! \brief Buffer that will contain the last error message.
 */

static char last_error[SOCKET_ERROR_SIZE];

/*! \brief Returns a pointer to the last error message.
    \author Denis BEURIVE
    \return The function returns a pointer to a zero terminated string of characters that represents
            the last error message.
 */

char *get_last_socket_error() { return last_error; }

/*! \brief Fake logging service.
    \author Denis BEURIVE
 */

static int my_fake_syslog (const char *file, const char * fmt,...) { return 0; }


/*! \brief Create a UDP socket and bind it to a given port and a given network interface.
           Note that this socket is allowed to send broadcast messages.
    \author Denis BEURIVE
    \param port Port number: the socket is binded to this port.
    \param add Pointer to a sockaddr_in data structure that will be used to store the internet address
           of the created socket.
    \param host Pointer to a zero terminated string of characters that represents the host name
           (or IP address) of the network interface to bind with the socket.
    \param interface Pointer to a buffer used to store the name of the network interface.
           This buffer MUST be at least IFNAMSIZ bytes long.
    \param len Size, in bytes, of the buffer 'buff'.
    \param broadcast Pointer to a 4 bytes long integer used to store the binary representation of the IP
           address associated with broadcasts (in network byte order) - for the interface.
    \param netmask Pointer to a 4 bytes long integer used to store the binary representation of the netmask
           (in network byte order) - for the interface.
    \param myip  Pointer to a 4 bytes long integer used to store the binary representation of the IP address
           associated with the interace.
    \param syslog Pointer to a function used to log messages. The function signature must be :<P>
           int syslog (const char *file, const char * fmt,...)<P>
           Upon successful completion, the function returns the value 0.<P>
           To desactivate logging, just set this pointer to NULL.<P>
           If NULL, logging service is not activated (no matter the value of 'log').
    \param log Pointer to the log file.
           If NULL, logging service is not activated (no matter the value of 'syslog').
    \return Upon successful completion, the function returns the newly created socket descriptor.
            Otherwise, the function returns the value -1.
 */

int create_socket (
                     int port,
                     struct sockaddr_in *add,
                     char *host,
                     char *interface,
                     int len,
                     unsigned long int *broadcast,
                     unsigned long int *netmask,
                     unsigned long int *myip,
                     int (*syslog)(const char *file, const char * fmt,...),
                     char *log
                  )
{
  int                desc, longueur, on, i, number_of_interfaces, length;
  struct ifreq       *ifr, if_req;
  struct hostent     *h;
  struct ifconf      if_conf;
  unsigned long int  ip, fip;
  char               *buffer, interfaces_names[MAX_INTERFACE][IFNAMSIZ];
  char               *log_file;
  int                (*my_syslog) (const char *file, const char * fmt,...);



  if ((syslog != NULL) && (log != NULL))
  {
     my_syslog = syslog; 
     log_file  = log;
  }
  else { my_syslog = my_fake_syslog; }

  memset ((void*)last_error, 0, SOCKET_ERROR_SIZE);
  for (i=0; i<MAX_INTERFACE; i++) { memset ((void*)&(interfaces_names[i][0]), 0, IFNAMSIZ); }
  *myip = 0;

  /* ------------------------------------------------------- */
  /* Sanity check                                            */
  /* ------------------------------------------------------- */

  if (len < IFNAMSIZ)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1, 
              "Invalid lenght for interface's buffer (segmentation fault avoided!)");
    return -1;
  }

  memset ((void*)interface, 0, len);

  /* ------------------------------------------------------- */
  /* Get the IP address of the host 'host'                   */
  /* ------------------------------------------------------- */

  h = gethostbyname(host);

  if (h == NULL)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1, "System call gethostbyname(%s) failed - %s)",
              host,
              strerror(errno));
    return -1;
  }

  if (h->h_length != 4)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1, 
              "The size of the Internet address returned by gethostbyname(%s) - %d - is not valid",
              host,
              h->h_length);
    return -1;
  }

  memcpy ((void*)&ip, h->h_addr_list[0], h->h_length);

  my_syslog (log_file, "[INFO] [%s:%d] IP address of host %s is %s",
             __FILE__, __LINE__,
             host,
             get_doted_ip(ip));

  *myip = ip;

  /* ------------------------------------------------------- */
  /* Create the UDP socket                                   */
  /* ------------------------------------------------------- */

  if ((desc = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1, 
              "System call socket(INET, SOCK_DGRAM, IPPROTO_UDP) failed - %s", strerror(errno));
    return -1;
  }

  /* ------------------------------------------------------- */
  /* Get the list of all interfaces available                */
  /* ------------------------------------------------------- */

  memset ((void*)&if_conf, 0, sizeof(struct ifconf));

  buffer = (char*)malloc(MAX_INTERFACE * sizeof(struct ifreq));
  if (buffer == NULL)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1, "Could not allocate memory (this should never happen)");
    return -1;
  }

  if_conf.ifc_len = MAX_INTERFACE * sizeof(struct ifreq);
  if_conf.ifc_buf = buffer;

  if (ioctl(desc, SIOCGIFCONF, &if_conf) == -1)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1, "System call ioctl(SIOCGIFCONF) failed - %s", strerror(errno));
    free (buffer);
    return -1;
  }

  /* ------------------------------------------------------- */
  /* Get the list of all interfaces names                    */
  /* ------------------------------------------------------- */

  number_of_interfaces = 0;
  for (i=0; i<(if_conf.ifc_len)/sizeof(struct ifreq); i++)
  {  
    ifr = ((struct ifreq*)buffer) + i;  

    /* ----------------------------------------------------- */
    /* Skip interfaces that are not connected to the network */
    /* ----------------------------------------------------- */

    if (ifr->ifr_addr.sa_family != AF_INET) { continue; }

    /* ----------------------------------------------------- */
    /* Get the name                                          */
    /* ----------------------------------------------------- */

    memcpy (interfaces_names[number_of_interfaces++], ifr->ifr_name, IFNAMSIZ);
  }

  free (buffer);

  /* ------------------------------------------------------- */
  /* Find the interface with the wanted IP address           */
  /* ------------------------------------------------------- */

  for (i=0; i<number_of_interfaces; i++)
  {
     /* ---------------------------------------------------- */
     /* Get the IP address of the specified interface        */
     /* Note: See file /usr/include/if.h for details about   */
     /*       the 'ifreq' structure.                         */
     /*       See 'man ioctl_list' for the list of all       */
     /*       posible interface's actions.                   */
     /* ----------------------------------------------------- */
   
     memset ((void*)&if_req, 0, sizeof(struct ifreq));
     strcpy (if_req.ifr_name, interfaces_names[i]);
   
     if (ioctl(desc, SIOCGIFADDR, &if_req) == -1)
     {
       snprintf (last_error, SOCKET_ERROR_SIZE - 1,
                 "System call ioctl(SIOCGIFADDR) failed - %s", strerror(errno));
       return -1;
     }
   
     fip = ((struct sockaddr_in*)(&(if_req.ifr_addr)))->sin_addr.s_addr;

     if (fip == ip) { strcpy (interface, interfaces_names[i]); }
   
     my_syslog (log_file, "[INFO] [%s:%d] Found interface %s (%s)",
                __FILE__, __LINE__,
                interfaces_names[i],
                get_doted_ip(fip));
  } 

  /* ------------------------------------------------------- */
  /* Make sure that we found the interface                   */
  /* ------------------------------------------------------- */
 
  if (interface[0] == 0)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1, "No interface found for alias %s (%s)", host, get_doted_ip(ip));
    return -1;
  } 
 
  /* ------------------------------------------------------- */
  /* Get the network mask (for information)                  */
  /* ------------------------------------------------------- */

  memset ((void*)&if_req, 0, sizeof(struct ifreq));
  strcpy (if_req.ifr_name, interface);

  if (ioctl(desc, SIOCGIFNETMASK, &if_req) == -1)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1,
              "System call ioctl(SIOCGIFNETMASK) failed - %s", strerror(errno));
    return -1;
  }

  *netmask = ((struct sockaddr_in*)(&(if_req.ifr_netmask)))->sin_addr.s_addr;

  my_syslog (log_file, "[INFO] [%s:%d] Netmask assigned to %s is: %s",
             __FILE__, __LINE__,
             interface,
             get_doted_ip(*netmask));

  /* ------------------------------------------------------- */
  /* Get broadcast address (for information)                 */
  /* ------------------------------------------------------- */

  memset ((void*)&if_req, 0, sizeof(struct ifreq));
  strcpy (if_req.ifr_name, interface);

  if (ioctl(desc, SIOCGIFBRDADDR, &if_req) == -1)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1,
              "System call ioctl(SIOCGIFNETMASK) failed - %s", strerror(errno));
    return -1;
  }

  *broadcast = ((struct sockaddr_in*)(&(if_req.ifr_broadaddr)))->sin_addr.s_addr;

  my_syslog (log_file, "[INFO] [%s:%d] Broadcast address assigned to %s is: %s",
             __FILE__, __LINE__,
             interface,
             get_doted_ip(*broadcast));

  /* ------------------------------------------------------- */
  /* make the socket quickly reusable                        */
  /* ------------------------------------------------------- */

  on = 1;
  if (setsockopt(desc, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1,
              "System call setsockopt(SO_REUSEADDR) failed - %s", strerror(errno));
    return -1;
  }

  /* ------------------------------------------------------- */
  /* Bind the socket to the given port                       */
  /*                                                         */
  /* Important note: Don't try to bind the socket to any     */
  /* specific IP address. You must bind it to 'INADDR_ANY'.  */
  /* The value 'INADDR_ANY' means "any IP address associated */
  /* with the host". This includes:                          */
  /* (1) All IP addresses of all network interfaces.         */
  /* (2) The broadcast address.                              */
  /* (3) Any assigned multicast address.                     */
  /*                                                         */
  /* If you bind the socket to a specific IP address (for    */
  /* example 10.33.33.2), then the socket can receive pac-   */
  /* -kets which destination IP address is 10.33.33.2. All   */
  /* other destination IP address are ignored (the broadcast */
  /* IP address included!). This means that you can not re-  */
  /* -ceive broadcasts.                                      */
  /*                                                         */
  /* In order to associate a specific network interface to   */
  /* the socket, we use the socket's option SO_BINDTODEVICE. */
  /* The combination (INADDR_ANY, SO_BINDTODEVICE/eth0)      */
  /* means "any UP address associated to the interface eth0, */
  /* and only eth0. This includes the broadcast address and  */
  /* any multicast addresses.                                */
  /* ------------------------------------------------------- */

  longueur = (int)sizeof (struct sockaddr_in);

  memset ((void*)add, 0, longueur);
  add->sin_family      = AF_INET; 
  add->sin_port        = htons((unsigned short)port); 
  add->sin_addr.s_addr = INADDR_ANY;

  if (bind(desc, (struct sockaddr*)add, longueur) == -1)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1, "System call bind() failed - %s", strerror(errno));
    return -1;
  }

  /* ------------------------------------------------------- */
  /* "Link" the socket to a given interface                  */
  /* ------------------------------------------------------- */

  if (setsockopt(desc, SOL_SOCKET, SO_BINDTODEVICE, interface, strlen(interface)+1) < 0)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1, "System call setsockopt(SO_BINDTODEVICE, %s) failed - %s",
              interface,
              strerror(errno));
    return -1;
  }

  my_syslog (log_file,
             "[INFO] [%s:%d] Binding server to IP address %s - (%s) on port %d - %s (%s)",
             __FILE__, __LINE__,
             get_doted_ip(add->sin_addr.s_addr),
             interface,
             port,
             host,
             get_doted_ip(ip));

  /* ------------------------------------------------------- */
  /* Allow socket to receive / send broadcast messages       */
  /* ------------------------------------------------------- */

  on = 1;
  if (setsockopt(desc, SOL_SOCKET, SO_BROADCAST, &on, sizeof(int)) < 0)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1,
              "System call setsockopt(SO_BROADCAST) failed - %s", strerror(errno));
    return -1;
  }

  /* ------------------------------------------------------- */
  /* Make sure that we can handle broadcasts                 */
  /* ------------------------------------------------------- */
 
  on = 0;
  length = sizeof(int);
  if (getsockopt(desc, SOL_SOCKET, SO_BROADCAST, &on, &length) < 0)
  {
    snprintf (last_error, SOCKET_ERROR_SIZE - 1,
              "System call getsockopt(SO_BROADCAST) failed - %s", strerror(errno));
    return -1;
  }

  if (on == 1)
  {
    my_syslog (log_file, "[INFO] [%s:%d] Broadcast is activated", __FILE__, __LINE__);
  }
  else
  {
    my_syslog (log_file, "[INFO] [%s:%d] Broadcast is __NOT__ activated",
               __FILE__, __LINE__);
  }

  return (desc);
};

/*! \brief Return the IP address and the port number of a remote end point.
    \author Denis BEURIVE
    \param sender Pointer to the address of the destant end point.
    \param ip Pointer to a string of character used to store the IP address.
           This string should be, at least MAX_IP_ADDRESS_STR_SIZE characters long.
    \param port Pointer to an integer used to store the port number.
 */

void get_remote_address (struct sockaddr_in *sender, char *ip, int *port)
{
   int  i;
   char *a;

   a = inet_ntoa(sender->sin_addr);
   for (i=0; i<MAX_IP_ADDRESS_STR_SIZE-1; i++) { ip[i] = *(a+i); };
   ip[MAX_IP_ADDRESS_STR_SIZE-1] = 0;
   *port = ntohs (sender->sin_port);
}

/*! \brief Convert IP address in binary representation (4 bytes in network byte order)
           into standard numbers-and-dots notation.
    \author Denis BEURIVE
    \param ip Binary representation of the IP address to convert (4 bytes in network byte order).
    \return The function returns a zero terminated string that represents the IP address in standard
            numbers-and-dots notation.
    \warning The string is returned in a statically allocated buffer, which subsequent calls will overwrite.
             Do not try to free it!
 */

static char *get_doted_ip (unsigned long int ip)
{
  struct in_addr     add;

  add.s_addr = ip;

  return inet_ntoa(add);
}

---