/src/kamailio/src/core/socket_info.c

Source (jump to first uncovered line)

/*
 * find & manage listen addresses
 *
 * Copyright (C) 2001-2003 FhG Fokus
 *
 * This file is part of Kamailio, a free SIP server.
 *
 * Kamailio 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 2 of the License, or
 * (at your option) any later version
 *
 * Kamailio 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 this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

/*!
 * \file
 * \brief Kamailio core :: find & manage listen addresses
 *
 * This file contains code that initializes and handles Kamailio listen addresses
 * lists (struct socket_info). It is used mainly on startup.
 * \ingroup core
 * Module: \ref core
 */

#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/utsname.h>
#include <stdio.h>

#include <sys/ioctl.h>
#include <net/if.h>
#include <ifaddrs.h>
#include <netdb.h>
#ifdef HAVE_SYS_SOCKIO_H
#include <sys/sockio.h>
#endif

#include "globals.h"
#include "socket_info.h"
#include "dprint.h"
#include "mem/mem.h"
#include "ut.h"
#include "resolve.h"
#include "name_alias.h"


/* list manip. functions (internal use only) */


/* append */
#define sock_listadd(head, el)                          \
  do {                                                \
    if(*(head) == 0)                                \
      *(head) = (el);                             \
    else {                                          \
      for((el)->next = *(head); (el)->next->next; \
          (el)->next = (el)->next->next)      \
        ;                                       \
      (el)->next->next = (el);                    \
      (el)->prev = (el)->next;                    \
      (el)->next = 0;                             \
    }                                               \
  } while(0)


/* insert after "after" */
#define sock_listins(el, after)             \
  do {                                    \
    if((after)) {                       \
      (el)->next = (after)->next;     \
      if((after)->next)               \
        (after)->next->prev = (el); \
      (after)->next = (el);           \
      (el)->prev = (after);           \
    } else { /* after==0 = list head */ \
      (after) = (el);                 \
      (el)->next = (el)->prev = 0;    \
    }                                   \
  } while(0)


#define sock_listrm(head, el)              \
  do {                                   \
    if(*(head) == (el))                \
      *(head) = (el)->next;          \
    if((el)->next)                     \
      (el)->next->prev = (el)->prev; \
    if((el)->prev)                     \
      (el)->prev->next = (el)->next; \
  } while(0)


#define addr_info_listadd sock_listadd
#define addr_info_listins sock_listins
#define addr_info_listrm sock_listrm

/**
 * return the scope for IPv6 interface matching the ipval parameter
 * - needed for binding to link local IPv6 addresses
 */
unsigned int ipv6_get_netif_scope(char *ipval)
{
  struct ifaddrs *netiflist = NULL;
  struct ifaddrs *netif = NULL;
  char ipaddr[NI_MAXHOST];
  unsigned int iscope = 0;
  int i = 0;
  int r = 0;
  ip_addr_t *ipa = NULL;
  ip_addr_t vaddr;
  str ips;

  ips.s = ipval;
  ips.len = strlen(ipval);

  ipa = str2ip6(&ips);
  if(ipa == NULL) {
    LM_ERR("could not parse ipv6 address: %s\n", ipval);
    return 0;
  }
  memcpy(&vaddr, ipa, sizeof(ip_addr_t));
  ipa = NULL;

  /* walk over the list of all network interface addresses */
  if(getifaddrs(&netiflist) != 0) {
    LM_ERR("failed to get network interfaces - errno: %d\n", errno);
    return 0;
  }
  for(netif = netiflist; netif; netif = netif->ifa_next) {
    /* only active and ipv6 */
    if(netif->ifa_addr && (netif->ifa_flags & IFF_UP)
        && netif->ifa_addr->sa_family == AF_INET6) {
      r = getnameinfo(netif->ifa_addr, sizeof(struct sockaddr_in6),
          ipaddr, sizeof(ipaddr), NULL, 0, NI_NUMERICHOST);
      if(r != 0) {
        LM_ERR("failed to get the name info - ret: %d\n", r);
        goto done;
      }
      /* strip the interface name after */
      for(i = 0; ipaddr[i]; i++) {
        if(ipaddr[i] == '%') {
          ipaddr[i] = '\0';
          break;
        }
      }
      ips.s = ipaddr;
      ips.len = strlen(ipaddr);
      ipa = str2ip6(&ips);
      if(ipa != NULL) {
        /* if the ips match, get scope index from interface name */
        if(ip_addr_cmp(&vaddr, ipa)) {
          iscope = if_nametoindex(netif->ifa_name);
          goto done;
        }
      }
    }
  }

done:
  freeifaddrs(netiflist);
  return iscope;
}

inline static void addr_info_list_ins_lst(
    struct addr_info *lst, struct addr_info *after)
{
  struct addr_info *l;
  struct addr_info *n;

  if(lst) {
    n = after->next;
    after->next = lst;
    lst->prev = after;
    if(n) {
      for(l = lst; l->next; l = l->next)
        ;
      l->next = n;
      n->prev = l;
    }
  }
}


/* protocol order, filled by init_proto_order() */
enum sip_protos nxt_proto[PROTO_LAST + 1] = {
    PROTO_UDP, PROTO_TCP, PROTO_TLS, PROTO_SCTP, 0};
/* Deliberately left PROTO_WS and PROTO_WSS out of this as they are just
   upgraded TCP and TLS connections */


/* another helper function, it just fills a struct addr_info
 * returns: 0 on success, -1 on error*/
static int init_addr_info(struct addr_info *a, char *name, enum si_flags flags)
{

  memset(a, 0, sizeof(*a));
  a->name.len = strlen(name);
  a->name.s = pkg_malloc(a->name.len + 1); /* include \0 */
  if(a->name.s == 0)
    goto error;
  memcpy(a->name.s, name, a->name.len + 1);
  a->flags = flags;
  return 0;
error:
  PKG_MEM_ERROR;
  return -1;
}


/* returns 0 on error, new addr_info_lst element on success */
static inline struct addr_info *new_addr_info(char *name, enum si_flags gf)
{
  struct addr_info *al;

  al = pkg_malloc(sizeof(*al));
  if(al == 0)
    goto error;
  al->next = 0;
  al->prev = 0;
  if(init_addr_info(al, name, gf) != 0)
    goto error;
  return al;
error:
  PKG_MEM_ERROR;
  if(al) {
    if(al->name.s)
      pkg_free(al->name.s);
    pkg_free(al);
  }
  return 0;
}


static inline void free_addr_info(struct addr_info *a)
{
  if(a) {
    if(a->name.s) {
      pkg_free(a->name.s);
      a->name.s = 0;
    }
    pkg_free(a);
  }
}


static inline void free_addr_info_lst(struct addr_info **lst)
{
  struct addr_info *a;
  struct addr_info *tmp;

  a = *lst;
  while(a) {
    tmp = a;
    a = a->next;
    free_addr_info(tmp);
  }
}


/* adds a new add_info_lst element to the corresponding list
 * returns 0 on success, -1 on error */
static int new_addr_info2list(char *name, enum si_flags f, struct addr_info **l)
{
  struct addr_info *al;

  al = new_addr_info(name, f);
  if(al == 0)
    goto error;
  addr_info_listadd(l, al);
  return 0;
error:
  return -1;
}


/* another helper function, it just creates a socket_info struct
 * allocates a si and a si->name in new pkg memory */
static inline struct socket_info *new_sock_info(char *name,
    struct name_lst *addr_l, unsigned short port, unsigned short proto,
    unsigned short useproto, char *usename, unsigned short useport,
    char *sockname, enum si_flags flags)
{
  struct socket_info *si;
  struct name_lst *n;
  struct hostent *he;
  char *p;

  si = (struct socket_info *)pkg_malloc(sizeof(struct socket_info));
  if(si == 0)
    goto error;
  memset(si, 0, sizeof(struct socket_info));
  si->socket = -1;
  si->name.len = strlen(name);
  si->name.s = (char *)pkg_malloc(si->name.len + 1); /* include \0 */
  if(si->name.s == 0)
    goto error;
  memcpy(si->name.s, name, si->name.len + 1);
  /* set port & proto */
  si->port_no = port;
  si->proto = proto;
  si->flags = flags;
  si->addr_info_lst = 0;
  for(n = addr_l; n; n = n->next) {
    if(new_addr_info2list(n->name, n->flags, &si->addr_info_lst) != 0) {
      LM_ERR("new_addr_info2list failed\n");
      goto error;
    }
  }
  if(sockname != NULL) {
    si->sockname.len = strlen(sockname);
    si->sockname.s =
        (char *)pkg_malloc(si->sockname.len + 1); /* include \0 */
    if(si->sockname.s == 0) {
      goto error;
    }
    memcpy(si->sockname.s, sockname, si->sockname.len + 1);
  }
  if(usename != NULL) {
    si->useinfo.name.len = strlen(usename);
    si->useinfo.name.s = (char *)pkg_malloc(si->useinfo.name.len + 1);
    if(si->useinfo.name.s == 0)
      goto error;
    strncpy(si->useinfo.name.s, usename, si->useinfo.name.len + 1);
    if(usename[0] == '[' && usename[si->useinfo.name.len - 1] == ']') {
      si->useinfo.address_str.len = si->useinfo.name.len - 2;
      p = si->useinfo.name.s + 1;
    } else {
      si->useinfo.address_str.len = si->useinfo.name.len;
      p = si->useinfo.name.s;
    }
    si->useinfo.proto = (useproto != PROTO_NONE) ? useproto : proto;
    si->useinfo.address_str.s =
        (char *)pkg_malloc(si->useinfo.address_str.len + 1);
    if(si->useinfo.address_str.s == NULL)
      goto error;
    strncpy(si->useinfo.address_str.s, p, si->useinfo.address_str.len);
    si->useinfo.address_str.s[si->useinfo.address_str.len] = '\0';

    p = int2str(useport, &si->useinfo.port_no_str.len);
    if(p == NULL)
      goto error;
    si->useinfo.port_no_str.s =
        (char *)pkg_malloc(si->useinfo.port_no_str.len + 1);
    if(si->useinfo.port_no_str.s == NULL)
      goto error;
    strncpy(si->useinfo.port_no_str.s, p, si->useinfo.port_no_str.len);
    si->useinfo.port_no = useport;

    he = resolvehost(si->useinfo.name.s);
    if(he == 0) {
      LM_ERR("unable to resolve advertised name %s\n",
          si->useinfo.name.s);
      goto error;
    }
    hostent2ip_addr(&si->useinfo.address, he, 0);
  }
  return si;
error:
  PKG_MEM_ERROR;
  if(si) {
    if(si->name.s) {
      pkg_free(si->name.s);
    }
    if(si->sockname.s) {
      pkg_free(si->sockname.s);
    }
    pkg_free(si);
  }
  return 0;
}


/*  delete a socket_info struct */
static void free_sock_info(struct socket_info *si)
{
  if(si) {
    if(si->name.s)
      pkg_free(si->name.s);
    if(si->address_str.s)
      pkg_free(si->address_str.s);
    if(si->port_no_str.s)
      pkg_free(si->port_no_str.s);
    if(si->addr_info_lst)
      free_addr_info_lst(&si->addr_info_lst);
    if(si->sock_str.s)
      pkg_free(si->sock_str.s);
    if(si->sockname.s)
      pkg_free(si->sockname.s);
    if(si->useinfo.name.s)
      pkg_free(si->useinfo.name.s);
    if(si->useinfo.port_no_str.s)
      pkg_free(si->useinfo.port_no_str.s);
    if(si->useinfo.sock_str.s)
      pkg_free(si->useinfo.sock_str.s);
  }
}


char *get_valid_proto_name(unsigned short proto)
{
  switch(proto) {
    case PROTO_NONE:
      return "*";
    case PROTO_UDP:
      return "udp";
#ifdef USE_TCP
    case PROTO_TCP:
      return "tcp";
#endif
#ifdef USE_TLS
    case PROTO_TLS:
      return "tls";
#endif
#ifdef USE_SCTP
    case PROTO_SCTP:
      return "sctp";
#endif
    default:
      return "unknown";
  }
}

/** Convert socket to its textual representation.
 *
 * This function converts the transport protocol, the IP address and the port
 * number in a comma delimited string of form proto:ip:port. The resulting
 * string is NOT zero terminated
 *
 * @param s is a pointer to the destination memory buffer
 * @param len is a pointer to an integer variable. Initially the variable
 *        should contain the size of the buffer in s. The value of the variable
 *        will be changed to the length of the resulting string on success and
 *        to the desired size of the destination buffer if it is too small
 * @param si is a pointer to the socket_info structure to be printed
 * @return -1 on error and 0 on success
 */
int socket2str(char *s, int *len, struct socket_info *si)
{
  return socketinfo2str(s, len, si, 0);
}

int socketinfo2str(char *s, int *len, struct socket_info *si, int mode)
{
  str proto;
  int l;

  if(si->useinfo.proto != PROTO_NONE) {
    proto.s = get_valid_proto_name(si->useinfo.proto);
  } else {
    proto.s = get_valid_proto_name(si->proto);
  }
  proto.len = strlen(proto.s);

  if(mode == 1)
    l = proto.len + si->useinfo.name.len + si->useinfo.port_no_str.len + 2;
  else
    l = proto.len + si->address_str.len + si->port_no_str.len + 2;

  if(si->address.af == AF_INET6)
    l += 2;

  if(*len < l) {
    LM_ERR("Destionation buffer too short\n");
    *len = l;
    return -1;
  }

  memcpy(s, proto.s, proto.len);
  s += proto.len;
  *s = ':';
  s++;
  if(mode == 1) {
    memcpy(s, si->useinfo.name.s, si->useinfo.name.len);
    s += si->useinfo.name.len;
    *s = ':';
    s++;
    memcpy(s, si->useinfo.port_no_str.s, si->useinfo.port_no_str.len);
    s += si->useinfo.port_no_str.len;
  } else {
    if(si->address.af == AF_INET6) {
      *s = '[';
      s++;
    }
    memcpy(s, si->address_str.s, si->address_str.len);
    s += si->address_str.len;
    if(si->address.af == AF_INET6) {
      *s = ']';
      s++;
    }
    *s = ':';
    s++;
    memcpy(s, si->port_no_str.s, si->port_no_str.len);
    s += si->port_no_str.len;
  }

  *len = l;
  return 0;
}


/* Fill si->sock_str with string representing the socket_info structure,
 * format of the string is 'proto:address:port'. Returns 0 on success and
 * negative number on failure.
 */
static int fix_sock_str(struct socket_info *si)
{
  int len = MAX_SOCKET_STR;

  if(si->sock_str.s)
    pkg_free(si->sock_str.s);

  si->sock_str.s = pkg_malloc(len + 1);
  if(si->sock_str.s == NULL) {
    PKG_MEM_ERROR;
    return -1;
  }
  if(socketinfo2str(si->sock_str.s, &len, si, 0) < 0) {
    BUG("fix_sock_str: Error in socket to str\n");
    return -1;
  }
  si->sock_str.s[len] = '\0';
  si->sock_str.len = len;
  if(si->useinfo.name.s != NULL) {
    len = MAX_SOCKET_ADVERTISE_STR;

    if(si->useinfo.sock_str.s)
      pkg_free(si->useinfo.sock_str.s);

    si->useinfo.sock_str.s = pkg_malloc(len + 1);
    if(si->useinfo.sock_str.s == NULL) {
      PKG_MEM_ERROR;
      return -1;
    }
    if(socketinfo2str(si->useinfo.sock_str.s, &len, si, 1) < 0) {
      BUG("fix_sock_str: Error in socket to str\n");
      return -1;
    }
    si->useinfo.sock_str.s[len] = '\0';
    si->useinfo.sock_str.len = len;
  }
  return 0;
}


/* returns 0 if support for the protocol is not compiled or if proto is
   invalid */
struct socket_info **get_sock_info_list(unsigned short proto)
{

  switch(proto) {
    case PROTO_UDP:
      return &udp_listen;
      break;
    case PROTO_TCP:
    case PROTO_WS:
#ifdef USE_TCP
      return &tcp_listen;
#endif
      break;
    case PROTO_TLS:
    case PROTO_WSS:
#ifdef USE_TLS
      return &tls_listen;
#endif
      break;
    case PROTO_SCTP:
#ifdef USE_SCTP
      return &sctp_listen;
#endif
      break;
    default:
      LM_CRIT("invalid proto %d\n", proto);
  }
  return 0;
}

/* Check list of active local IPs for grep_sock_info
 * This function is only used for sockets with the SI_IS_VIRTUAL flag set. This
 * is so floating (virtual) IPs that are not currently local, are not returned
 * as matches by grep_sock_info.
 *
 * Params:
 * - si - Socket info of socket that has been flagged with SI_IS_VIRTUAL,
 *   that we want to check if it's actually local right now.
 *
 * Returns 1 if socket is local, or 0 if not.
 */
static int check_local_addresses(struct socket_info *si)
{
  int match = 0;
  struct ifaddrs *ifap, *ifa;

  if(si == NULL) {
    LM_ERR("Socket info is NULL. Returning no match.\n");
    return 0;
  }

  if(!(si->flags & SI_IS_VIRTUAL)) {
    LM_ERR("Have been passed a socket without the virtual flag set. This "
         "should "
         "not happen. Returning a match to maintain standard "
         "behaviour.\n");
    return 1;
  }

  if(getifaddrs(&ifap) != 0) {
    LM_ERR("getifaddrs failed. Assuming no match.\n");
    return 0;
  }

  for(ifa = ifap; ifa; ifa = ifa->ifa_next) {
    /* skip if no IP addr associated with the interface */
    if(ifa->ifa_addr == 0)
      continue;
#ifdef AF_PACKET
    /* skip AF_PACKET addr family since it is of no use later on */
    if(ifa->ifa_addr->sa_family == AF_PACKET)
      continue;
#endif
    struct ip_addr local_addr;
    sockaddr2ip_addr(&local_addr, (struct sockaddr *)ifa->ifa_addr);

    LM_DBG("Checking local address: %s\n", ip_addr2a(&local_addr));
    if(ip_addr_cmp(&si->address, &local_addr)) {
      match = 1;
      LM_DBG("Found matching local IP %s for virtual socket %s\n",
          ip_addr2a(&local_addr), si->name.s);
      break;
    }
  }
  freeifaddrs(ifap);
  //Default to not local if no match is found
  if(!match) {
    LM_DBG("No matching local IP found for socket %s.\n", si->name.s);
    return 0;
  } else {
    return 1;
  }
}

/* helper function for grep_sock_info
 * params:
 *  host - hostname to compare with
 *  name - official name
 *  addr_str - name's resolved ip address converted to string
 *  ip_addr - name's ip address
 *  flags - set to SI_IS_IP if name contains an IP
 *
 * returns 0 if host matches, -1 if not */
inline static int si_hname_cmp(
    str *host, str *name, str *addr_str, struct ip_addr *ip_addr, int flags)
{
  struct ip_addr *ip6;

  if((host->len == name->len)
      && (strncasecmp(host->s, name->s, name->len) == 0) /*slower*/)
    /* comp. must be case insensitive, host names
     * can be written in mixed case, it will also match
     * ipv6 addresses if we are lucky*/
    goto found;
  /* check if host == ip address */
  /* ipv6 case is uglier, host can be [3ffe::1] */
  ip6 = str2ip6(host);
  if(ip6) {
    if(ip_addr_cmp(ip6, ip_addr))
      goto found; /* match */
    else
      return -1; /* no match, but this is an ipv6 address
             so no point in trying ipv4 */
  }
  /* ipv4 */
  if((!(flags & SI_IS_IP)) && (host->len == addr_str->len)
      && (memcmp(host->s, addr_str->s, addr_str->len) == 0))
    goto found;
  return -1;
found:
  return 0;
}


/* checks if the proto: host:port is one of the address we listen on
 * and returns the corresponding socket_info structure.
 * if port==0, the  port number is ignored
 * if proto==0 (PROTO_NONE) the protocol is ignored
 * returns  0 if not found
 * WARNING: uses str2ip6 so it will overwrite any previous
 *  unsaved result of this function (static buffer)
 */
struct socket_info *grep_sock_info(
    str *host, unsigned short port, unsigned short proto)
{
  str hname;
  struct socket_info *si;
  struct socket_info **list;
  struct addr_info *ai;
  unsigned short c_proto;

  hname = *host;
  if((hname.len > 2) && ((*hname.s) == '[')
      && (hname.s[hname.len - 1] == ']')) {
    /* ipv6 - skip [] */
    hname.s++;
    hname.len -= 2;
  }

  c_proto = (proto != PROTO_NONE) ? proto : PROTO_UDP;
retry:
  do {
    /* get the proper sock_list */
    list = get_sock_info_list(c_proto);

    if(list == 0) {
      /* disabled or unknown protocol */
      continue;
    }
    for(si = *list; si; si = si->next) {
      LM_DBG("checking if host==us: %d==%d && [%.*s] == [%.*s]\n",
          hname.len, si->name.len, hname.len, hname.s, si->name.len,
          si->name.s);
      if(port) {
        LM_DBG("checking if port %d (advertise %d) matches port %d\n",
            si->port_no, si->useinfo.port_no, port);
        if(si->port_no != port && si->useinfo.port_no != port) {
          continue;
        }
      }
      if(si_hname_cmp(&hname, &si->name, &si->address_str, &si->address,
             si->flags)
          == 0) {
        if(si->flags & SI_IS_VIRTUAL) {
          LM_DBG("Checking virtual socket: [%.*s]\n", si->name.len,
              si->name.s);
          if(check_local_addresses(si)) {
            goto found;
          } else {
            LM_DBG("Skipping virtual socket that is not local.\n");
          }
        } else {
          goto found;
        }
      }
      if(si->useinfo.name.s != NULL) {
        LM_DBG("checking advertise if host==us:"
             " %d==%d && [%.*s] == [%.*s]\n",
            hname.len, si->useinfo.name.len, hname.len, hname.s,
            si->useinfo.name.len, si->useinfo.name.s);
        if(si_hname_cmp(&hname, &si->useinfo.name,
               &si->useinfo.address_str, &si->useinfo.address,
               si->flags)
            == 0) {
          goto found;
        }
      }
      /* try among the extra addresses */
      for(ai = si->addr_info_lst; ai; ai = ai->next) {
        if(si_hname_cmp(&hname, &ai->name, &ai->address_str,
               &ai->address, ai->flags)
            == 0) {
          goto found;
        }
      }
    }

  } while((proto == 0) && (c_proto = next_proto(c_proto)));

#ifdef USE_TLS
  if(unlikely(c_proto == PROTO_WS)) {
    c_proto = PROTO_WSS;
    goto retry;
  }
#endif
  /* not_found: */
  return 0;
found:
  return si;
}

/**
 *
 */
static int _ksr_sockets_no = 0;

/**
 *
 */
int ksr_sockets_no_get(void)
{
  return _ksr_sockets_no;
}

/**
 *
 */
void ksr_sockets_index(void)
{
  socket_info_t *si = NULL;
  struct socket_info **list;
  unsigned short c_proto;

  if(_ksr_sockets_no > 0) {
    return;
  }

  c_proto = PROTO_UDP;
  do {
    /* get the proper sock_list */
    list = get_sock_info_list(c_proto);

    if(list == 0) {
      /* disabled or unknown protocol */
      continue;
    }

    for(si = *list; si; si = si->next) {
      if(si->sockname.s == NULL) {
        continue;
      }
      si->gindex = _ksr_sockets_no;
      _ksr_sockets_no++;
    }
  } while((c_proto = next_proto(c_proto)) != 0);

  LM_DBG("number of listen sockets: %d\n", _ksr_sockets_no);
}

socket_info_t *ksr_get_socket_by_name(str *sockname)
{
  socket_info_t *si = NULL;
  struct socket_info **list;
  unsigned short c_proto;

  c_proto = PROTO_UDP;
  do {
    /* get the proper sock_list */
    list = get_sock_info_list(c_proto);

    if(list == 0) {
      /* disabled or unknown protocol */
      continue;
    }

    for(si = *list; si; si = si->next) {
      if(si->sockname.s == NULL) {
        continue;
      }
      LM_DBG("checking if sockname %.*s matches %.*s\n", sockname->len,
          sockname->s, si->sockname.len, si->sockname.s);
      if(sockname->len == si->sockname.len
          && strncasecmp(sockname->s, si->sockname.s, sockname->len)
                 == 0) {
        return si;
      }
    }
  } while((c_proto = next_proto(c_proto)) != 0);

  return NULL;
}

socket_info_t *ksr_get_socket_by_listen(str *sockstr)
{
  socket_info_t *si = NULL;
  struct socket_info **list;
  unsigned short c_proto;

  c_proto = PROTO_UDP;
  do {
    /* get the proper sock_list */
    list = get_sock_info_list(c_proto);

    if(list == 0) {
      /* disabled or unknown protocol */
      continue;
    }

    for(si = *list; si; si = si->next) {
      if(si->sock_str.s == NULL) {
        continue;
      }
      LM_DBG("checking if listen %.*s matches %.*s\n", sockstr->len,
          sockstr->s, si->sock_str.len, si->sock_str.s);
      if(sockstr->len == si->sock_str.len
          && strncasecmp(sockstr->s, si->sock_str.s, sockstr->len)
                 == 0) {
        return si;
      }
    }
  } while((c_proto = next_proto(c_proto)) != 0);

  return NULL;
}

socket_info_t *ksr_get_socket_by_advertise(str *sockstr)
{
  socket_info_t *si = NULL;
  struct socket_info **list;
  unsigned short c_proto;

  c_proto = PROTO_UDP;
  do {
    /* get the proper sock_list */
    list = get_sock_info_list(c_proto);

    if(list == 0) {
      /* disabled or unknown protocol */
      continue;
    }

    for(si = *list; si; si = si->next) {
      if(si->useinfo.sock_str.s == NULL) {
        continue;
      }
      LM_DBG("checking if listen %.*s matches %.*s\n", sockstr->len,
          sockstr->s, si->useinfo.sock_str.len,
          si->useinfo.sock_str.s);
      if(sockstr->len == si->useinfo.sock_str.len
          && strncasecmp(
                 sockstr->s, si->useinfo.sock_str.s, sockstr->len)
                 == 0) {
        return si;
      }
    }
  } while((c_proto = next_proto(c_proto)) != 0);

  return NULL;
}

socket_info_t *ksr_get_socket_by_index(int idx)
{
  socket_info_t *si = NULL;
  struct socket_info **list;
  unsigned short c_proto;

  if(idx < 0) {
    idx += _ksr_sockets_no;
    if(idx < 0) {
      LM_DBG("negative overall index\n");
      return NULL;
    }
  }
  c_proto = PROTO_UDP;
  do {
    /* get the proper sock_list */
    list = get_sock_info_list(c_proto);

    if(list == 0) {
      /* disabled or unknown protocol */
      continue;
    }

    for(si = *list; si; si = si->next) {
      if(idx == 0) {
        return si;
      }
      idx--;
    }
  } while((c_proto = next_proto(c_proto)) != 0);

  return NULL;
}

socket_info_t *ksr_get_socket_by_address(str *sockstr)
{
  socket_info_t *si = NULL;

  si = ksr_get_socket_by_listen(sockstr);

  if(si != NULL) {
    return si;
  }

  return ksr_get_socket_by_advertise(sockstr);
}

/* checks if the proto:port is one of the ports we listen on
 * and returns the corresponding socket_info structure.
 * if proto==0 (PROTO_NONE) the protocol is ignored
 * returns  0 if not found
 */
struct socket_info *grep_sock_info_by_port(
    unsigned short port, unsigned short proto)
{
  struct socket_info *si;
  struct socket_info **list;
  unsigned short c_proto;

  if(!port) {
    goto not_found;
  }
  c_proto = (proto != PROTO_NONE) ? proto : PROTO_UDP;
  do {
    /* get the proper sock_list */
    list = get_sock_info_list(c_proto);

    if(list == 0) /* disabled or unknown protocol */
      continue;

    for(si = *list; si; si = si->next) {
      LM_DBG("checking if port %d matches port %d\n", si->port_no, port);
      if(si->port_no == port) {
        goto found;
      }
    }
  } while((proto == 0) && (c_proto = next_proto(c_proto)));

not_found:
  return 0;

found:
  return si;
}


/* checks if the proto: ip:port is one of the address we listen on
 * and returns the corresponding socket_info structure.
 * (same as grep_socket_info, but use ip addr instead)
 * if port==0, the  port number is ignored
 * if proto==0 (PROTO_NONE) the protocol is ignored
 * returns  0 if not found
 * WARNING: uses str2ip6 so it will overwrite any previous
 *  unsaved result of this function (static buffer)
 */
struct socket_info *find_si(
    struct ip_addr *ip, unsigned short port, unsigned short proto)
{
  struct socket_info *si;
  struct socket_info **list;
  struct addr_info *ai;
  unsigned short c_proto;

  c_proto = (proto != PROTO_NONE) ? proto : PROTO_UDP;
  do {
    /* get the proper sock_list */
    list = get_sock_info_list(c_proto);

    if(list == 0) /* disabled or unknown protocol */
      continue;

    for(si = *list; si; si = si->next) {
      if(port) {
        if(si->port_no != port) {
          continue;
        }
      }
      if(ip_addr_cmp(ip, &si->address)
          || ip_addr_cmp(ip, &si->useinfo.address))
        goto found;
      for(ai = si->addr_info_lst; ai; ai = ai->next)
        if(ip_addr_cmp(ip, &ai->address))
          goto found;
    }
  } while((proto == 0) && (c_proto = next_proto(c_proto)));
  /* not_found: */
  return 0;
found:
  return si;
}


/* append a new sock_info structure to the corresponding list
 * return  new sock info on success, 0 on error */
static struct socket_info *new_sock2list(char *name, struct name_lst *addr_l,
    unsigned short port, unsigned short proto, unsigned short useproto,
    char *usename, unsigned short useport, char *sockname,
    enum si_flags flags, struct socket_info **list)
{
  struct socket_info *si;
  /* allocates si and si->name in new pkg memory */
  si = new_sock_info(name, addr_l, port, proto, useproto, usename, useport,
      sockname, flags);
  if(si == 0) {
    LM_ERR("new_sock_info failed\n");
    goto error;
  }
  if(socket_workers > 0) {
    si->workers = socket_workers;
    socket_workers = 0;
  }
#ifdef USE_MCAST
  if(mcast != 0) {
    si->mcast.len = strlen(mcast);
    si->mcast.s = (char *)pkg_mallocxz(si->mcast.len + 1);
    if(si->mcast.s == 0) {
      PKG_MEM_ERROR;
      si->mcast.len = 0;
      pkg_free(si->name.s);
      pkg_free(si);
      return 0;
    }
    memcpy(si->mcast.s, mcast, si->mcast.len);
    mcast = 0;
  }
#endif /* USE_MCAST */
  sock_listadd(list, si);
  return si;
error:
  return 0;
}


/* adds a new sock_info structure immediately after "after"
 * return  new sock info on success, 0 on error */
static struct socket_info *new_sock2list_after(char *name,
    struct name_lst *addr_l, unsigned short port, unsigned short proto,
    unsigned short useproto, char *usename, unsigned short useport,
    char *sockname, enum si_flags flags, struct socket_info *after)
{
  struct socket_info *si;

  si = new_sock_info(name, addr_l, port, proto, useproto, usename, useport,
      sockname, flags);
  if(si == 0) {
    LM_ERR("new_sock_info failed\n");
    goto error;
  }
  sock_listins(si, after);
  return si;
error:
  return 0;
}


/* adds a sock_info structure to the corresponding proto list
 * return last new socket info structur on success, NULL on error */
socket_info_t *add_listen_socket_info(char *name, struct name_lst *addr_l,
    unsigned short port, unsigned short proto, unsigned short useproto,
    char *usename, unsigned short useport, char *sockname,
    enum si_flags flags)
{
  socket_info_t *newsi = NULL;
  socket_info_t **list = NULL;
  unsigned short c_proto;
  struct name_lst *a_l;
  unsigned short c_port;

  c_proto = (proto != PROTO_NONE) ? proto : PROTO_UDP;
  do {
    list = get_sock_info_list(c_proto);
    if(list == 0) /* disabled or unknown protocol */
      continue;

    if(port == 0) { /* use default port */
      c_port =
#ifdef USE_TLS
          ((c_proto) == PROTO_TLS) ? tls_port_no :
#endif
                       port_no;
    }
#ifdef USE_TLS
    else if((c_proto == PROTO_TLS) && (proto == 0)) {
      /* -l  ip:port => on udp:ip:port; tcp:ip:port and tls:ip:port+1?*/
      c_port = port + 1;
    }
#endif
    else {
      c_port = port;
    }
    if(c_proto != PROTO_SCTP) {
      newsi = new_sock2list(name, 0, c_port, c_proto, useproto, usename,
          useport, sockname, flags & ~SI_IS_MHOMED, list);
      if(newsi == 0) {
        LM_ERR("new_sock2list failed\n");
        goto error;
      }
      /* add the other addresses in the list as separate sockets
       * since only SCTP can bind to multiple addresses */
      for(a_l = addr_l; a_l; a_l = a_l->next) {
        if(new_sock2list(a_l->name, 0, c_port, c_proto, useproto,
               usename, useport, sockname, flags & ~SI_IS_MHOMED,
               list)
            == 0) {
          LM_ERR("new_sock2list failed\n");
          goto error;
        }
      }
    } else {
      newsi = new_sock2list(name, addr_l, c_port, c_proto, useproto,
          usename, useport, sockname, flags, list);
      if(newsi == 0) {
        LM_ERR("new_sock2list failed\n");
        goto error;
      }
    }
  } while((proto == 0) && (c_proto = next_proto(c_proto)));

  return newsi;
error:
  return NULL;
}

/* adds a sock_info structure to the corresponding proto list
 * return  0 on success, -1 on error */
int add_listen_advertise_iface_name(char *name, struct name_lst *addr_l,
    unsigned short port, unsigned short proto, unsigned short useproto,
    char *usename, unsigned short useport, char *sockname,
    enum si_flags flags)
{
  if(add_listen_socket_info(name, addr_l, port, proto, useproto, usename,
         useport, sockname, flags)
      == NULL) {
    return -1;
  }
  return 0;
}

/* adds a sock_info structure to the corresponding proto list
 * return  0 on success, -1 on error */
int add_listen_advertise_iface(char *name, struct name_lst *addr_l,
    unsigned short port, unsigned short proto, unsigned short useproto,
    char *usename, unsigned short useport, enum si_flags flags)
{
  return add_listen_advertise_iface_name(
      name, addr_l, port, proto, useproto, usename, useport, NULL, flags);
}

/* adds a sock_info structure to the corresponding proto list
 * return  0 on success, -1 on error */
int add_listen_iface(char *name, struct name_lst *addr_l, unsigned short port,
    unsigned short proto, enum si_flags flags)
{
  return add_listen_advertise_iface_name(
      name, addr_l, port, proto, 0, 0, 0, 0, flags);
}

/* adds a sock_info structure to the corresponding proto list
 * return  0 on success, -1 on error */
int add_listen_iface_name(char *name, struct name_lst *addr_l,
    unsigned short port, unsigned short proto, char *sockname,
    enum si_flags flags)
{
  return add_listen_advertise_iface_name(
      name, addr_l, port, proto, 0, 0, 0, sockname, flags);
}

int add_listen_socket(socket_attrs_t *sa)
{
  socket_info_t *newsi;
  name_lst_t addr_l;

  if(sa->bindaddr.s == NULL) {
    LM_ERR("no bind address provided\n");
    return -1;
  }
  memset(&addr_l, 0, sizeof(name_lst_t));
  addr_l.name = sa->bindaddr.s;

  newsi = add_listen_socket_info(sa->bindaddr.s, &addr_l, sa->bindport,
      sa->bindproto, sa->useproto, sa->useaddr.s, sa->useport,
      sa->sockname.s, sa->sflags);

  return (newsi != NULL) ? 0 : -1;
}

#ifdef __OS_linux

#include "linux/types.h"
#include "linux/netlink.h"
#include "linux/rtnetlink.h"
#include "arpa/inet.h"


#define MAX_IF_LEN 64
struct idx
{
  struct idx *next;
  int family;
  unsigned ifa_flags;
  char addr[MAX_IF_LEN];
};

struct idxlist
{
  struct idx *addresses;
  int index;
  char name[MAX_IF_LEN];
  unsigned flags;
};

#define MAX_IFACE_NO 32

static struct idxlist *ifaces = NULL;
static int seq = 0;

#define SADDR(s) ((struct sockaddr_in *)s)->sin_addr.s_addr

#define NLMSG_TAIL(nmsg) \
  ((struct rtattr *)(((void *)(nmsg)) + NLMSG_ALIGN((nmsg)->nlmsg_len)))

int addattr_l(
    struct nlmsghdr *n, int maxlen, int type, const void *data, int alen)
{
  int len = RTA_LENGTH(alen);
  struct rtattr *rta;

  if(NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(len) > maxlen) {
    fprintf(stderr, "addattr_l ERROR: message exceeded bound of %d\n",
        maxlen);
    return -1;
  }
  rta = NLMSG_TAIL(n);
  rta->rta_type = type;
  rta->rta_len = len;
  memcpy(RTA_DATA(rta), data, alen);
  n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(len);
  return 0;
}


static int nl_bound_sock(void)
{
  int sock = -1;
  struct sockaddr_nl la;

  sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
  if(sock < 0) {
    LM_ERR("could not create NETLINK sock to get interface list\n");
    goto error;
  }

  /* bind NETLINK socket to pid */
  bzero(&la, sizeof(la));
  la.nl_family = AF_NETLINK;
  la.nl_pad = 0;
  la.nl_pid = getpid();
  la.nl_groups = 0;
  if(bind(sock, (struct sockaddr *)&la, sizeof(la)) < 0) {
    LM_ERR("could not bind NETLINK sock to sockaddr_nl\n");
    goto error;
  }

  return sock;
error:
  if(sock >= 0)
    close(sock);
  return -1;
}

#define fill_nl_req(req, type, family)                                 \
  do {                                                               \
    memset(&req, 0, sizeof(req));                                  \
    req.nlh.nlmsg_len = sizeof(req);                               \
    req.nlh.nlmsg_type = type;                                     \
    req.nlh.nlmsg_flags =                                          \
        NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST | NLM_F_DUMP; \
    req.nlh.nlmsg_pid = getpid();                                  \
    req.nlh.nlmsg_seq = seq++;                                     \
    req.g.rtgen_family = family;                                   \
  } while(0);

#define NETLINK_BUFFER_SIZE 32768

static int get_flags(int family)
{
  struct
  {
    struct nlmsghdr nlh;
    struct rtgenmsg g;
  } req;
  int rtn = 0;
  struct nlmsghdr *nlp;
  struct ifinfomsg *ifi;
  char buf[NETLINK_BUFFER_SIZE];
  char *p = buf;
  int nll = 0;
  int nl_sock = -1;

  fill_nl_req(req, RTM_GETLINK, family);

  if((nl_sock = nl_bound_sock()) < 0)
    return -1;

  if(send(nl_sock, (void *)&req, sizeof(req), 0) < 0) {
    LM_ERR("error sending NETLINK request\n");
    goto error;
  }

  while(1) {
    if((sizeof(buf) - nll) == 0) {
      LM_ERR("netlink buffer overflow in get_flags");
      goto error;
    }
    rtn = recv(nl_sock, p, sizeof(buf) - nll, 0);
    nlp = (struct nlmsghdr *)p;
    if(nlp->nlmsg_type == NLMSG_DONE) {
      LM_DBG("done\n");
      break;
    }
    if(nlp->nlmsg_type == NLMSG_ERROR) {
      LM_DBG("Error on message to netlink");
      break;
    }
    p += rtn;

    nll += rtn;
  }

  nlp = (struct nlmsghdr *)buf;
  for(; NLMSG_OK(nlp, nll); nlp = NLMSG_NEXT(nlp, nll)) {
    ifi = NLMSG_DATA(nlp);

    if(nlp->nlmsg_len < NLMSG_LENGTH(sizeof(ifi)))
      goto error;

    LM_ERR("Interface with index %d has flags %d\n", ifi->ifi_index,
        ifi->ifi_flags);
    if(ifaces == NULL) {
      LM_ERR("get_flags must not be called on empty interface list");
      goto error;
    }
    if(ifi->ifi_index >= MAX_IFACE_NO) {
      LM_ERR("invalid network interface index returned %d",
          ifi->ifi_index);
      goto error;
    }
    ifaces[ifi->ifi_index].flags = ifi->ifi_flags;
  }

  if(nl_sock >= 0)
    close(nl_sock);
  return 0;

error:
  if(nl_sock >= 0)
    close(nl_sock);
  return -1;
}

static int build_iface_list(void)
{
  struct
  {
    struct nlmsghdr nlh;
    struct rtgenmsg g;
  } req;

  int rtn = 0;
  struct nlmsghdr *nlp;
  struct ifaddrmsg *ifi;
  int rtl;
  char buf[NETLINK_BUFFER_SIZE];
  char *p = buf;
  int nll = 0;
  struct rtattr *rtap;
  int index, i;
  struct idx *entry;
  struct idx *tmp;
  int nl_sock = -1;
  int families[] = {AF_INET, AF_INET6};
  char name[MAX_IF_LEN];
  int is_link_local = 0;

  if(ifaces == NULL) {
    if((ifaces = (struct idxlist *)pkg_malloc(
          MAX_IFACE_NO * sizeof(struct idxlist)))
        == NULL) {
      PKG_MEM_ERROR;
      return -1;
    }
    memset(ifaces, 0, sizeof(struct idxlist) * MAX_IFACE_NO);
  }

  /* bind netlink socket */
  if((nl_sock = nl_bound_sock()) < 0)
    return -1;

  for(i = 0; i < sizeof(families) / sizeof(int); i++) {
    fill_nl_req(req, RTM_GETADDR, families[i]);

    if(send(nl_sock, (void *)&req, sizeof(req), 0) < 0) {
      LM_ERR("error sending NETLINK request\n");
      goto error;
    };

    memset(buf, 0, sizeof(buf));
    nll = 0;
    p = buf;
    while(1) {
      if((sizeof(buf) - nll) == 0) {
        LM_ERR("netlink buffer overflow in build_iface_list");
        goto error;
      }
      rtn = recv(nl_sock, p, sizeof(buf) - nll, 0);
      LM_DBG("received %d byles \n", rtn);
      nlp = (struct nlmsghdr *)p;
      if(nlp->nlmsg_type == NLMSG_DONE) {
        LM_DBG("done receiving netlink info \n");
        break;
      }
      if(nlp->nlmsg_type == NLMSG_ERROR) {
        LM_ERR("Error on message to netlink");
        break;
      }
      p += rtn;

      nll += rtn;
    }

    nlp = (struct nlmsghdr *)buf;
    for(; NLMSG_OK(nlp, nll); nlp = NLMSG_NEXT(nlp, nll)) {
      ifi = NLMSG_DATA(nlp);

      if(nlp->nlmsg_len < NLMSG_LENGTH(sizeof(ifi)))
        continue;
      // init all the strings
      // inner loop: loop thru all the attributes of
      // one route entry
      rtap = (struct rtattr *)IFA_RTA(ifi);

      rtl = IFA_PAYLOAD(nlp);

      index = ifi->ifa_index;
      if(index >= MAX_IFACE_NO) {
        LM_ERR("Invalid interface index returned: %d\n", index);
        goto error;
      }

      entry = (struct idx *)pkg_malloc(sizeof(struct idx));
      if(entry == 0) {
        PKG_MEM_ERROR;
        goto error;
      }

      entry->next = 0;
      entry->family = families[i];
      entry->ifa_flags = ifi->ifa_flags;
      is_link_local = 0;

      name[0] = '\0';
      for(; RTA_OK(rtap, rtl); rtap = RTA_NEXT(rtap, rtl)) {
        switch(rtap->rta_type) {
          case IFA_ADDRESS:
            if((*(int *)RTA_DATA(rtap)) == htons(0xfe80)) {
              LM_DBG("Link Local Address, ignoring ...\n");
              is_link_local = 1;
              break;
            }
            inet_ntop(families[i], RTA_DATA(rtap), entry->addr,
                MAX_IF_LEN);
            LM_DBG("iface <IFA_ADDRESS> addr is  %s\n",
                entry->addr);
            break;
          case IFA_LOCAL:
            if((*(int *)RTA_DATA(rtap)) == htons(0xfe80)) {
              LM_DBG("Link Local Address, ignoring ...\n");
              is_link_local = 1;
            }
            inet_ntop(families[i], RTA_DATA(rtap), entry->addr,
                MAX_IF_LEN);
            LM_DBG("iface <IFA_LOCAL> addr is %s\n", entry->addr);
            break;
          case IFA_LABEL:
            LM_DBG("iface name is %s\n", (char *)RTA_DATA(rtap));
            strncpy(name, (char *)RTA_DATA(rtap), MAX_IF_LEN - 1);
            name[MAX_IF_LEN - 1] = '\0';
            break;
          case IFA_BROADCAST:
          case IFA_ANYCAST:
          case IFA_UNSPEC:
          case IFA_CACHEINFO:
          default:
            break;
        }
      }
      if(is_link_local) {
        if(sr_bind_ipv6_link_local == 0) {
          /* skip - link local addresses are not bindable without scope */
          pkg_free(entry);
          continue;
        }
      }

      if(strlen(ifaces[index].name) == 0 && strlen(name) > 0) {
        memcpy(ifaces[index].name, name, MAX_IF_LEN - 1);
        ifaces[index].name[MAX_IF_LEN - 1] = '\0';
      }

      ifaces[index].index = index;

      if(ifaces[index].addresses == 0)
        ifaces[index].addresses = entry;
      else {
        for(tmp = ifaces[index].addresses; tmp->next;
            tmp = tmp->next) /*empty*/
          ;
        tmp->next = entry;
      }
    }
  }
  if(nl_sock > 0)
    close(nl_sock);
  /* the socket should be closed so we can bind again */
  for(i = 0; i < sizeof(families) / sizeof(int); i++) {
    /* get device flags */
    get_flags(families[i]); /* AF_INET or AF_INET6 */
  }

  return 0;
error:
  if(nl_sock >= 0)
    close(nl_sock);
  return -1;
}
/* add all family type addresses of interface if_name to the socket_info array
 * if family ==0, uses all families
 * if if_name==0, adds all addresses on all interfaces
 * uses RTNETLINK sockets to get addresses on the present interface on LINUX
 * return: -1 on error, 0 on success
 */
int add_interfaces_via_netlink(char *if_name, int family, unsigned short port,
    unsigned short proto, struct addr_info **ai_l)
{
  int i;
  struct idx *tmp;
  enum si_flags flags;

  if(ifaces == NULL && (build_iface_list() != 0)) {
    LM_ERR("Could not get network interface list\n");
    return -1;
  }

  flags = SI_NONE;
  for(i = 0; i < MAX_IFACE_NO; ++i) {
    if(ifaces[i].addresses == NULL)
      continue; /* not present/configured */
    if((if_name == 0)
        || (strncmp(if_name, ifaces[i].name, strlen(ifaces[i].name))
            == 0)) {

      /* check if iface is up */
      //if(! (ifaces[i].flags & IFF_UP) ) continue;

      for(tmp = ifaces[i].addresses; tmp; tmp = tmp->next) {
        LM_DBG("in add_iface_via_netlink Name %s Address %s\n",
            ifaces[i].name, tmp->addr);
        /* match family */
        if(family && family == tmp->family) {
          /* check if loopback */
          if(ifaces[i].flags & IFF_LOOPBACK) {
            LM_DBG("INTERFACE %s is loopback", ifaces[i].name);
            flags |= SI_IS_LO;
          }
          /* save the info */
          if(new_addr_info2list(tmp->addr, flags, ai_l) != 0) {
            LM_ERR("new_addr_info2list failed\n");
            goto error;
          }
        }
      }
    }
  }
  return 0;
error:
  return -1;
}
#endif /* __OS_linux */

/* add all family type addresses of interface if_name to the socket_info array
 * if family ==0, uses all families
 * if if_name==0, adds all addresses on all interfaces
 * return: -1 on error, 0 on success
 */
int add_interfaces(char *if_name, int family, unsigned short port,
    unsigned short proto, struct addr_info **ai_l)
{
  char *tmp;
  struct ip_addr addr;
  int ret = -1;
  enum si_flags flags;
  struct ifaddrs *ifap, *ifa;

  if(getifaddrs(&ifap) != 0) {
    LM_ERR("getifaddrs failed\n");
    return -1;
  }

  for(ifa = ifap; ifa; ifa = ifa->ifa_next) {
    /* skip if no IP addr associated with the interface */
    if(ifa->ifa_addr == 0)
      continue;
#ifdef AF_PACKET
    /* skip AF_PACKET addr family since it is of no use later on */
    if(ifa->ifa_addr->sa_family == AF_PACKET)
      continue;
#endif
    if(if_name && strcmp(if_name, ifa->ifa_name))
      continue;
    if(family && family != ifa->ifa_addr->sa_family)
      continue;
    sockaddr2ip_addr(&addr, (struct sockaddr *)ifa->ifa_addr);
    tmp = ip_addr2a(&addr);
    if(ifa->ifa_flags & IFF_LOOPBACK)
      flags = SI_IS_LO;
    else
      flags = SI_NONE;
    if(new_addr_info2list(tmp, flags, ai_l) != 0) {
      LM_ERR("new_addr_info2list failed\n");
      ret = -1;
      break;
    }
    LM_DBG("If: %8s Fam: %8x Flg: %16lx Adr: %s\n", ifa->ifa_name,
        ifa->ifa_addr->sa_family, (unsigned long)ifa->ifa_flags, tmp);

    ret = 0;
  }
  freeifaddrs(ifap);
  return ret;
}


/* internal helper function: resolve host names and add aliases
 * name is a value result parameter: it should contain the hostname that
 * will be used to fill all the other members, including name itself
 * in some situation (name->s should be a 0 terminated pkg_malloc'ed string)
 * return 0 on success and -1 on error */
static int fix_hostname(str *name, struct ip_addr *address, str *address_str,
    enum si_flags *flags, int *type_flags, struct socket_info *s)
{
  struct hostent *he;
  char *tmp;
  char **h;

  /* get "official hostnames", all the aliases etc. */
  he = resolvehost(name->s);
  if(he == 0) {
    LM_ERR("could not resolve %s\n", name->s);
    goto error;
  }
  /* check if we got the official name */
  if(strcasecmp(he->h_name, name->s) != 0) {
    if(sr_auto_aliases
        && add_alias(name->s, name->len, s->port_no, s->proto) < 0) {
      LM_ERR("add_alias failed\n");
    }
    /* change the official name */
    pkg_free(name->s);
    name->s = (char *)pkg_malloc(strlen(he->h_name) + 1);
    if(name->s == 0) {
      PKG_MEM_ERROR;
      goto error;
    }
    name->len = strlen(he->h_name);
    strncpy(name->s, he->h_name, name->len + 1);
  }
  /* add the aliases*/
  for(h = he->h_aliases; sr_auto_aliases && h && *h; h++)
    if(add_alias(*h, strlen(*h), s->port_no, s->proto) < 0) {
      LM_ERR("add_alias failed\n");
    }
  hostent2ip_addr(address, he, 0); /*convert to ip_addr format*/
  if(type_flags) {
    *type_flags |= (address->af == AF_INET) ? SOCKET_T_IPV4 : SOCKET_T_IPV6;
  }
  if((tmp = ip_addr2a(address)) == 0)
    goto error;
  address_str->s = pkg_malloc(strlen(tmp) + 1);
  if(address_str->s == 0) {
    PKG_MEM_ERROR;
    goto error;
  }
  address_str->len = strlen(tmp);
  strncpy(address_str->s, tmp, address_str->len + 1);
  /* set is_ip (1 if name is an ip address, 0 otherwise) */
  if(sr_auto_aliases && (address_str->len == name->len)
      && (strncasecmp(address_str->s, name->s, address_str->len) == 0)) {
    *flags |= SI_IS_IP;
    /* do rev. DNS on it (for aliases)*/
    he = rev_resolvehost(address);
    if(he == 0) {
      LM_WARN("could not rev. resolve %s\n", name->s);
    } else {
      /* add the aliases*/
      if(add_alias(he->h_name, strlen(he->h_name), s->port_no, s->proto)
          < 0) {
        LM_ERR("add_alias failed\n");
      }
      for(h = he->h_aliases; h && *h; h++)
        if(add_alias(*h, strlen(*h), s->port_no, s->proto) < 0) {
          LM_ERR("add_alias failed\n");
        }
    }
  }

#ifdef USE_MCAST
  /* Check if it is a multicast address and
   * set the flag if so
   */
  if(is_mcast(address)) {
    *flags |= SI_IS_MCAST;
  }
#endif /* USE_MCAST */

  /* check if INADDR_ANY */
  if(ip_addr_any(address))
    *flags |= SI_IS_ANY;
  else if(ip_addr_loopback(address)) /* check for loopback */
    *flags |= SI_IS_LO;

  return 0;
error:
  return -1;
}


/* append new elements to a socket_info list after "list"
 * each element is created  from addr_info_lst + port, protocol and flags
 * return 0 on success, -1 on error
 */
static int addr_info_to_si_lst(struct addr_info *ai_lst, unsigned short port,
    char proto, char useproto, char *usename, unsigned short useport,
    char *sockname, enum si_flags flags, struct socket_info **list)
{
  struct addr_info *ail;

  for(ail = ai_lst; ail; ail = ail->next) {
    if(new_sock2list(ail->name.s, 0, port, proto, useproto, usename,
           useport, sockname, ail->flags | flags, list)
        == 0)
      return -1;
  }
  return 0;
}


/* insert new elements to a socket_info list after "el",
 * each element is created from addr_info_lst + port, * protocol and flags
 * return 0 on success, -1 on error
 */
static int addr_info_to_si_lst_after(struct addr_info *ai_lst,
    unsigned short port, char proto, char useproto, char *usename,
    unsigned short useport, char *sockname, enum si_flags flags,
    struct socket_info *el)
{
  struct addr_info *ail;
  struct socket_info *new_si;

  for(ail = ai_lst; ail; ail = ail->next) {
    if((new_si = new_sock2list_after(ail->name.s, 0, port, proto, useproto,
          usename, useport, sockname, ail->flags | flags, el))
        == 0)
      return -1;
    el = new_si;
  }
  return 0;
}


/* fixes a socket list => resolve addresses,
 * interface names, fills missing members, remove duplicates
 * fills type_flags if not null with SOCKET_T_IPV4 and/or SOCKET_T_IPV6*/
static int fix_socket_list(struct socket_info **list, int *type_flags)
{
  struct socket_info *si;
  struct socket_info *new_si;
  struct socket_info *l;
  struct socket_info *next;
  struct socket_info *next_si;
  struct socket_info *del_si;
  struct socket_info *keep_si;
  char *tmp;
  int len;
  struct addr_info *ai_lst;
  struct addr_info *ail;
  struct addr_info *tmp_ail;
  struct addr_info *tmp_ail_next;
  struct addr_info *ail_next;

  if(type_flags)
    *type_flags = 0;
  /* try to change all the interface names into addresses
   *  --ugly hack */
  for(si = *list; si;) {
    next = si->next;
    ai_lst = 0;
    if(add_interfaces(si->name.s, auto_bind_ipv6 ? 0 : AF_INET, si->port_no,
           si->proto, &ai_lst)
        != -1) {
      if(si->flags & SI_IS_MHOMED) {
        if((new_si = new_sock2list_after(ai_lst->name.s, 0, si->port_no,
              si->proto, si->useinfo.proto, si->useinfo.name.s,
              si->useinfo.port_no, si->sockname.s,
              ai_lst->flags | si->flags, si))
            == 0)
          break;
        ail = ai_lst;
        ai_lst = ai_lst->next;
        free_addr_info(ail); /* free the first elem. */
        if(ai_lst) {
          ai_lst->prev = 0;
          /* find the end */
          for(ail = ai_lst; ail->next; ail = ail->next)
            ;
          /* add the mh list after the last position in ai_lst */
          addr_info_list_ins_lst(si->addr_info_lst, ail);
          new_si->addr_info_lst = ai_lst;
          si->addr_info_lst = 0; /* detached and moved to new_si */
          ail = ail->next;     /* ail== old si->addr_info_lst */
        } else {
          ail = si->addr_info_lst;
          new_si->addr_info_lst = ail;
          si->addr_info_lst = 0; /* detached and moved to new_si */
        }
      } else {
        /* add all addr. as separate  interfaces */
        if(addr_info_to_si_lst_after(ai_lst, si->port_no, si->proto,
               si->useinfo.proto, si->useinfo.name.s,
               si->useinfo.port_no, si->sockname.s, si->flags, si)
            != 0)
          goto error;
        /* ai_lst not needed anymore */
        free_addr_info_lst(&ai_lst);
        ail = 0;
        new_si = 0;
      }
      /* success => remove current entry (shift the entire array)*/
      sock_listrm(list, si);
      free_sock_info(si);
    } else {
      new_si = si;
      ail = si->addr_info_lst;
    }

    if(ail) {
      if(new_si && (new_si->flags & SI_IS_MHOMED)) {
        ai_lst = 0;
        for(; ail;) {
          ail_next = ail->next;
          if(add_interfaces(ail->name.s, AF_INET, new_si->port_no,
                 new_si->proto, &ai_lst)
              != -1) {
            /* add the resolved list after the current position */
            addr_info_list_ins_lst(ai_lst, ail);
            /* success, remove the current entity */
            addr_info_listrm(&new_si->addr_info_lst, ail);
            free_addr_info(ail);
            ai_lst = 0;
          }
          ail = ail_next;
        }
      }
    }
    si = next;
  }
  /* get ips & fill the port numbers*/
#ifdef EXTRA_DEBUG
  LM_DBG("Listening on\n");
#endif
  for(si = *list; si; si = si->next) {
    /* fix port number, port_no should be !=0 here */
    if(si->port_no == 0) {
#ifdef USE_TLS
      si->port_no = (si->proto == PROTO_TLS) ? tls_port_no : port_no;
#else
      si->port_no = port_no;
#endif
    }
    tmp = int2str(si->port_no, &len);
    if(len >= MAX_PORT_LEN) {
      LM_ERR("bad port number: %d\n", si->port_no);
      goto error;
    }
    si->port_no_str.s = (char *)pkg_malloc(len + 1);
    if(si->port_no_str.s == 0) {
      PKG_MEM_ERROR;
      goto error;
    }
    strncpy(si->port_no_str.s, tmp, len + 1);
    si->port_no_str.len = len;

    if(fix_hostname(&si->name, &si->address, &si->address_str, &si->flags,
           type_flags, si)
        != 0)
      goto error;
    /* fix hostnames in mh addresses */
    for(ail = si->addr_info_lst; ail; ail = ail->next) {
      if(fix_hostname(&ail->name, &ail->address, &ail->address_str,
             &ail->flags, type_flags, si)
          != 0)
        goto error;
    }

    if(fix_sock_str(si) < 0)
      goto error;

#ifdef EXTRA_DEBUG
    printf("              %.*s [%s]:%s%s\n", si->name.len, si->name.s,
        si->address_str.s, si->port_no_str.s,
        si->flags & SI_IS_MCAST ? " mcast" : "");
#endif
  }
  /* removing duplicate addresses*/
  for(si = *list; si;) {
    next_si = si->next;
    for(l = si->next; l;) {
      next = l->next;
      if((si->port_no == l->port_no) && (si->address.af == l->address.af)
          && (memcmp(si->address.u.addr, l->address.u.addr,
                si->address.len)
              == 0)) {
        /* remove the socket with no  extra addresses.,
         * if both of them have extra addresses, remove one of them
         * and merge the extra addresses into the other */
        if(l->addr_info_lst == 0) {
          del_si = l;
          keep_si = si;
        } else if(si->addr_info_lst == 0) {
          del_si = si;
          keep_si = l;
        } else {
          /* move l->addr_info_lst to si->addr_info_lst */
          /* find last elem */
          for(ail = si->addr_info_lst; ail->next; ail = ail->next)
            ;
          /* add the l list after the last position in si lst */
          addr_info_list_ins_lst(l->addr_info_lst, ail);
          l->addr_info_lst = 0; /* detached */
          del_si = l;       /* l will be removed */
          keep_si = l;
        }
#ifdef EXTRA_DEBUG
        printf("removing duplicate %s [%s] ==  %s [%s]\n",
            keep_si->name.s, keep_si->address_str.s, del_si->name.s,
            del_si->address_str.s);
#endif
        /* add the name to the alias list*/
        if((!(del_si->flags & SI_IS_IP))
            && ((del_si->name.len != keep_si->name.len)
                || (strncmp(del_si->name.s, keep_si->name.s,
                      del_si->name.len)
                    != 0)))
          add_alias(del_si->name.s, del_si->name.len, l->port_no,
              l->proto);
        /* make sure next_si doesn't point to del_si */
        if(del_si == next_si)
          next_si = next_si->next;
        /* remove del_si*/
        sock_listrm(list, del_si);
        free_sock_info(del_si);
      }
      l = next;
    }
    si = next_si;
  }
  /* check for duplicates in extra_addresses */
  for(si = *list; si; si = si->next) {
    /* check  for & remove internal duplicates: */
    for(ail = si->addr_info_lst; ail;) {
      ail_next = ail->next;
      /* 1. check if the extra addresses contain a duplicate for the
       * main  one */
      if((ail->address.af == si->address.af)
          && (memcmp(ail->address.u.addr, si->address.u.addr,
                ail->address.len)
              == 0)) {
        /* add the name to the alias list*/
        if((!(ail->flags & SI_IS_IP))
            && ((ail->name.len != si->name.len)
                || (strncmp(ail->name.s, si->name.s,
                      ail->name.len)
                    != 0)))
          add_alias(
              ail->name.s, ail->name.len, si->port_no, si->proto);
        /* remove ail*/
        addr_info_listrm(&si->addr_info_lst, ail);
        free_addr_info(ail);
        ail = ail_next;
        continue;
      }
      /* 2. check if the extra addresses contain a duplicate for
       *  other addresses in the same list */
      for(tmp_ail = ail->next; tmp_ail;) {
        tmp_ail_next = tmp_ail->next;
        if((ail->address.af == tmp_ail->address.af)
            && (memcmp(ail->address.u.addr, tmp_ail->address.u.addr,
                  ail->address.len)
                == 0)) {
          /* add the name to the alias list*/
          if((!(tmp_ail->flags & SI_IS_IP))
              && ((ail->name.len != tmp_ail->name.len)
                  || (strncmp(ail->name.s, tmp_ail->name.s,
                        tmp_ail->name.len)
                      != 0)))
            add_alias(tmp_ail->name.s, tmp_ail->name.len,
                si->port_no, si->proto);
          /* remove tmp_ail*/
          addr_info_listrm(&si->addr_info_lst, tmp_ail);
          if(ail_next == tmp_ail) {
            ail_next = tmp_ail_next;
          }
          free_addr_info(tmp_ail);
        }
        tmp_ail = tmp_ail_next;
      }
      ail = ail_next;
    }
    /* check for duplicates between extra addresses (e.g. sctp MH)
     * and other main addresses, on conflict remove the corresponding
     * extra addresses (another possible solution would be to join
     * the 2 si entries into one). */
    for(ail = si->addr_info_lst; ail;) {
      ail_next = ail->next;
      for(l = *list; l; l = l->next) {
        if(l == si)
          continue;
        if(si->port_no == l->port_no) {
          if((ail->address.af == l->address.af)
              && (memcmp(ail->address.u.addr, l->address.u.addr,
                    ail->address.len)
                  == 0)) {
            /* add the name to the alias list*/
            if((!(ail->flags & SI_IS_IP))
                && ((ail->name.len != l->name.len)
                    || (strncmp(ail->name.s, l->name.s,
                          l->name.len)
                        != 0)))
              add_alias(ail->name.s, ail->name.len, l->port_no,
                  l->proto);
            /* remove ail*/
            addr_info_listrm(&si->addr_info_lst, ail);
            free_addr_info(ail);
            break;
          }
          /* check for duplicates with other  extra addresses
           * lists */
          for(tmp_ail = l->addr_info_lst; tmp_ail;) {
            tmp_ail_next = tmp_ail->next;
            if((ail->address.af == tmp_ail->address.af)
                && (memcmp(ail->address.u.addr,
                      tmp_ail->address.u.addr,
                      ail->address.len)
                    == 0)) {
              /* add the name to the alias list*/
              if((!(tmp_ail->flags & SI_IS_IP))
                  && ((ail->name.len != tmp_ail->name.len)
                      || (strncmp(ail->name.s,
                            tmp_ail->name.s,
                            tmp_ail->name.len)
                          != 0)))
                add_alias(tmp_ail->name.s, tmp_ail->name.len,
                    l->port_no, l->proto);
              /* remove tmp_ail*/
              addr_info_listrm(&l->addr_info_lst, tmp_ail);
              free_addr_info(tmp_ail);
            }
            tmp_ail = tmp_ail_next;
          }
        }
      }
      ail = ail_next;
    }
  }

#ifdef USE_MCAST
  /* Remove invalid multicast entries */
  si = *list;
  while(si) {
    if((si->proto == PROTO_TCP)
#ifdef USE_TLS
        || (si->proto == PROTO_TLS)
#endif /* USE_TLS */
#ifdef USE_SCTP
        || (si->proto == PROTO_SCTP)
#endif
    ) {
      if(si->flags & SI_IS_MCAST) {
        LM_WARN("removing entry %s:%s [%s]:%s\n",
            get_valid_proto_name(si->proto), si->name.s,
            si->address_str.s, si->port_no_str.s);
        l = si;
        si = si->next;
        sock_listrm(list, l);
        free_sock_info(l);
      } else {
        ail = si->addr_info_lst;
        while(ail) {
          if(ail->flags & SI_IS_MCAST) {
            LM_WARN("removing mh entry %s:%s"
                " [%s]:%s\n",
                get_valid_proto_name(si->proto), ail->name.s,
                ail->address_str.s, si->port_no_str.s);
            tmp_ail = ail;
            ail = ail->next;
            addr_info_listrm(&si->addr_info_lst, tmp_ail);
            free_addr_info(tmp_ail);
          } else {
            ail = ail->next;
          }
        }
        si = si->next;
      }
    } else {
      si = si->next;
    }
  }
#endif /* USE_MCAST */

  return 0;
error:
  return -1;
}

int socket_types = 0;

/* fix all 3 socket lists, fills socket_types if non-null
 * return 0 on success, -1 on error */
int fix_all_socket_lists()
{
  struct utsname myname;
  int flags;
  struct addr_info *ai_lst;

  ai_lst = 0;

  if((udp_listen == 0)
#ifdef USE_TCP
      && (tcp_listen == 0)
#ifdef USE_TLS
      && (tls_listen == 0)
#endif
#endif
#ifdef USE_SCTP
      && (sctp_listen == 0)
#endif
  ) {
    /* get all listening ipv4/ipv6 interfaces */
    if(((add_interfaces(0, AF_INET, 0, PROTO_UDP, &ai_lst) == 0)
#ifdef __OS_linux
           && (!auto_bind_ipv6
               || add_interfaces_via_netlink(
                    0, AF_INET6, 0, PROTO_UDP, &ai_lst)
                    == 0)
#else
           && (!auto_bind_ipv6
               || add_interfaces(0, AF_INET6, 0, PROTO_UDP, &ai_lst)
                    == 0) /* add_interface does not work for IPv6 on Linux */
#endif /* __OS_linux */
               )
        && (addr_info_to_si_lst(
              ai_lst, 0, PROTO_UDP, 0, 0, 0, 0, 0, &udp_listen)
            == 0)) {
      free_addr_info_lst(&ai_lst);
      ai_lst = 0;
      /* if ok, try to add the others too */
#ifdef USE_TCP
      if(!tcp_disable) {
        if(((add_interfaces(0, AF_INET, 0, PROTO_TCP, &ai_lst) != 0)
#ifdef __OS_linux
               || (auto_bind_ipv6
                   && add_interfaces_via_netlink(0, AF_INET6, 0,
                        PROTO_TCP, &ai_lst)
                        != 0)
#else
               || (auto_bind_ipv6
                   && add_interfaces(0, AF_INET6, 0, PROTO_TCP,
                        &ai_lst)
                        != 0)
#endif /* __OS_linux */
                   )
            || (addr_info_to_si_lst(ai_lst, 0, PROTO_TCP, 0, 0, 0,
                  0, 0, &tcp_listen)
                != 0))
          goto error;
        free_addr_info_lst(&ai_lst);
        ai_lst = 0;
#ifdef USE_TLS
        if(!tls_disable) {
          if(((add_interfaces(0, AF_INET, 0, PROTO_TLS, &ai_lst) != 0)
#ifdef __OS_linux
                 || (auto_bind_ipv6
                     && add_interfaces_via_netlink(0,
                          AF_INET6, 0, PROTO_TLS,
                          &ai_lst)
                          != 0)
#else
                 || (auto_bind_ipv6
                     && add_interfaces(0, AF_INET6, 0,
                          PROTO_TLS, &ai_lst)
                          != 0)
#endif /* __OS_linux */
                     )
              || (addr_info_to_si_lst(ai_lst, 0, PROTO_TLS, 0, 0,
                    0, 0, 0, &tls_listen)
                  != 0))
            goto error;
        }
        free_addr_info_lst(&ai_lst);
        ai_lst = 0;
#endif
      }
#endif
#ifdef USE_SCTP
      if(!sctp_disable) {
        if(((add_interfaces(0, AF_INET, 0, PROTO_SCTP, &ai_lst) != 0)
#ifdef __OS_linux
               || (auto_bind_ipv6
                   && add_interfaces_via_netlink(0, AF_INET6, 0,
                        PROTO_SCTP, &ai_lst)
                        != 0)
#else
               || (auto_bind_ipv6
                   && add_interfaces(0, AF_INET6, 0, PROTO_SCTP,
                        &ai_lst)
                        != 0)
#endif /* __OS_linux */
                   )
            || (addr_info_to_si_lst(ai_lst, 0, PROTO_SCTP, 0, 0, 0,
                  0, 0, &sctp_listen)
                != 0))
          goto error;
        free_addr_info_lst(&ai_lst);
        ai_lst = 0;
      }
#endif /* USE_SCTP */
    } else {
      /* if error fall back to get hostname */
      /* get our address, only the first one */
      if(uname(&myname) < 0) {
        LM_ERR("cannot determine hostname, try -l address\n");
        goto error;
      }
      if(add_listen_iface(myname.nodename, 0, 0, 0, 0) != 0) {
        LM_ERR("add_listen_iface failed \n");
        goto error;
      }
    }
  }
  flags = 0;
  if(fix_socket_list(&udp_listen, &flags) != 0) {
    LM_ERR("fix_socket_list udp failed\n");
    goto error;
  }
  if(flags) {
    socket_types |= flags | SOCKET_T_UDP;
  }
#ifdef USE_TCP
  flags = 0;
  if(!tcp_disable && (fix_socket_list(&tcp_listen, &flags) != 0)) {
    LM_ERR("fix_socket_list tcp failed\n");
    goto error;
  }
  if(flags) {
    socket_types |= flags | SOCKET_T_TCP;
  }
#ifdef USE_TLS
  flags = 0;
  if(!tls_disable && (fix_socket_list(&tls_listen, &flags) != 0)) {
    LM_ERR("fix_socket_list tls failed\n");
    goto error;
  }
  if(flags) {
    socket_types |= flags | SOCKET_T_TLS;
  }
#endif
#endif
#ifdef USE_SCTP
  flags = 0;
  if(!sctp_disable && (fix_socket_list(&sctp_listen, &flags) != 0)) {
    LM_ERR("fix_socket_list sctp failed\n");
    goto error;
  }
  if(flags) {
    socket_types |= flags | SOCKET_T_SCTP;
  }
#endif /* USE_SCTP */
  if((udp_listen == 0)
#ifdef USE_TCP
      && (tcp_listen == 0)
#ifdef USE_TLS
      && (tls_listen == 0)
#endif
#endif
#ifdef USE_SCTP
      && (sctp_listen == 0)
#endif
  ) {
    LM_ERR("no listening sockets\n");
    goto error;
  }
  return 0;
error:
  if(ai_lst)
    free_addr_info_lst(&ai_lst);
  return -1;
}


void print_all_socket_lists()
{
  struct socket_info *si;
  struct socket_info **list;
  struct addr_info *ai;
  unsigned short proto;

  proto = PROTO_UDP;
  do {
    list = get_sock_info_list(proto);
    for(si = list ? *list : 0; si; si = si->next) {
      if(si->addr_info_lst) {
        printf("             %s: (%s", get_valid_proto_name(proto),
            si->address_str.s);
        for(ai = si->addr_info_lst; ai; ai = ai->next) {
          printf(", %s", ai->address_str.s);
        }
        printf("):%s%s%s%s\n", si->port_no_str.s,
            si->flags & SI_IS_MCAST ? " mcast" : "",
            si->flags & SI_IS_MHOMED ? " mhomed" : "",
            si->flags & SI_IS_VIRTUAL ? " virtual" : "");
      } else {
        printf("             %s: %s", get_valid_proto_name(proto),
            si->name.s);
        if(!(si->flags & SI_IS_IP)) {
          printf(" [%s]", si->address_str.s);
        }
        printf(":%s%s%s%s", si->port_no_str.s,
            si->flags & SI_IS_MCAST ? " mcast" : "",
            si->flags & SI_IS_MHOMED ? " mhomed" : "",
            si->flags & SI_IS_VIRTUAL ? " virtual" : "");
        if(si->sockname.s) {
          printf(" name %s", si->sockname.s);
        }
        if(si->useinfo.name.s) {
          printf(" advertise %s:%s:%d",
              get_valid_proto_name(si->useinfo.proto),
              si->useinfo.name.s, si->useinfo.port_no);
        }
        printf("\n");
      }
    }
  } while((proto = next_proto(proto)));
}


void print_aliases()
{
  struct host_alias *a;

  for(a = aliases; a; a = a->next) {
    if(a->port) {
      printf("             %s: %.*s:%d\n", get_valid_proto_name(a->proto),
          a->alias.len, a->alias.s, a->port);
    } else {
      printf("             %s: %.*s:*\n", get_valid_proto_name(a->proto),
          a->alias.len, a->alias.s);
    }
  }
}


void init_proto_order()
{
  int r;

  /* fix proto list  (remove disabled protocols)*/
#ifdef USE_TCP
  if(tcp_disable)
#endif
    for(r = PROTO_NONE; r <= PROTO_LAST; r++) {
      if(nxt_proto[r] == PROTO_TCP)
        nxt_proto[r] = nxt_proto[PROTO_TCP];
    }
#ifdef USE_TCP
#ifdef USE_TLS
  if(tls_disable || tcp_disable)
#endif
#endif
    for(r = PROTO_NONE; r <= PROTO_LAST; r++) {
      if(nxt_proto[r] == PROTO_TLS)
        nxt_proto[r] = nxt_proto[PROTO_TLS];
    }
#ifdef USE_SCTP
  if(sctp_disable)
#endif
    for(r = PROTO_NONE; r <= PROTO_LAST; r++) {
      if(nxt_proto[r] == PROTO_SCTP)
        nxt_proto[r] = nxt_proto[PROTO_SCTP];
    }

  /* Deliberately skipping PROTO_WS and PROTO_WSS here as these
     are just upgraded TCP and TLS connections */
}


/**
 * parse '[proto:]host[:port]' string to a broken down structure
 */
int parse_protohostport(str *ins, sr_phostp_t *r)
{
  char *first;  /* first ':' occurrence */
  char *second; /* second ':' occurrence */
  char *p;
  int bracket;
  str tmp = STR_NULL;

  first = second = 0;
  bracket = 0;
  memset(r, 0, sizeof(sr_phostp_t));

  /* find the first 2 ':', ignoring possible ipv6 addresses
   * (substrings between [])
   */
  for(p = ins->s; p < ins->s + ins->len; p++) {
    switch(*p) {
      case '[':
        bracket++;
        if(bracket > 1)
          goto error_brackets;
        break;
      case ']':
        bracket--;
        if(bracket < 0)
          goto error_brackets;
        break;
      case ':':
        if(bracket == 0) {
          if(first == 0)
            first = p;
          else if(second == 0)
            second = p;
          else
            goto error_colons;
        }
        break;
    }
  }
  if(p == ins->s)
    return -1;
  if(*(p - 1) == ':')
    goto error_colons;

  if(first == 0) { /* no ':' => only host */
    r->host.s = ins->s;
    r->host.len = (int)(p - ins->s);
    goto end;
  }
  if(second) { /* 2 ':' found => check if valid */
    if(parse_proto((unsigned char *)ins->s, first - ins->s, &r->proto) < 0)
      goto error_proto;
    r->sproto.s = ins->s;
    r->sproto.len = first - ins->s;

    tmp.s = second + 1;
    tmp.len = (ins->s + ins->len) - tmp.s;

    if(str2int(&tmp, (unsigned int *)&(r->port)) < 0)
      goto error_port;
    r->sport = tmp;

    r->host.s = first + 1;
    r->host.len = (int)(second - r->host.s);
    goto end;
  }
  /* only 1 ':' found => it's either proto:host or host:port */
  tmp.s = first + 1;
  tmp.len = (ins->s + ins->len) - tmp.s;
  if(str2int(&tmp, (unsigned int *)&(r->port)) < 0) {
    /* invalid port => it's proto:host */
    if(parse_proto((unsigned char *)ins->s, first - ins->s, &r->proto) < 0)
      goto error_proto;
    r->sproto.s = ins->s;
    r->sproto.len = first - ins->s;
    r->host.s = first + 1;
    r->host.len = (int)(p - r->host.s);
  } else {
    /* valid port => it is host:port */
    r->sport = tmp;
    r->host.s = ins->s;
    r->host.len = (int)(first - r->host.s);
  }
end:
  return 0;
error_brackets:
  LM_ERR("too many brackets in %.*s\n", ins->len, ins->s);
  return -1;
error_colons:
  LM_ERR("too many colons in %.*s\n", ins->len, ins->s);
  return -1;
error_proto:
  LM_ERR("bad protocol in %.*s\n", ins->len, ins->s);
  return -1;
error_port:
  LM_ERR("bad port number in %.*s\n", ins->len, ins->s);
  return -1;
}

/**
 * lookup a local socket by '[proto:]host[:port]' string
 */
struct socket_info *lookup_local_socket(str *phostp)
{
  sr_phostp_t r;
  if(parse_protohostport(phostp, &r) < 0)
    return NULL;
  return grep_sock_info(
      &r.host, (unsigned short)r.port, (unsigned short)r.proto);
}

struct socket_info *find_sock_info_by_address_family(
    int proto, int address_family)
{
  struct addr_info *ai = NULL;
  int found = 0;
  struct socket_info *si = NULL;
  struct socket_info **si_list = get_sock_info_list(proto);

  for(si = si_list ? *si_list : NULL; si; si = si->next) {
    if(si->flags & (SI_IS_LO | SI_IS_MCAST)) {
      continue;
    }

    if(si->address.af == address_family) {
      break;
    }

    for(ai = si->addr_info_lst; ai; ai = ai->next) {
      if(ai->address.af == address_family) {
        found = 1;
        break;
      }
    }

    if(found) {
      break;
    }
  }

  return si;
}

Coverage Report

Created: 2023-11-19 07:01