/* ******************************************************************** *
 * ni_util.c    version 0.01 1-12-09                                    *
 *                                                                      *
 *     COPYRIGHT 2008-2009 Michael Robinton <michael@bizsystems.com>      *
 *                                                                      *
 * This program is free software; you can redistribute it and/or modify *
 * it under the terms of either:                                        *
 *                                                                      *
 *  a) the GNU General Public License as published by the Free          *
 *  Software Foundation; either version 2, or (at your option) any      *
 *  later version, or                                                   *
 *                                                                      *
 *  b) the "Artistic License" which comes with this distribution.       *
 *                                                                      *
 * This program 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 either     *
 * the GNU General Public License or the Artistic License for more      *
 * details.                                                             *
 *                                                                      *
 * You should have received a copy of the Artistic License with this    *
 * distribution, in the file named "Artistic".  If not, I'll be glad    *
 * to provide one.                                                      *
 *                                                                      *
 * You should also have received a copy of the GNU General Public       *
 * License along with this program in the file named "Copying". If not, *
 * write to the                                                         *
 *                                                                      *
 *      Free Software Foundation, Inc.                                  *
 *      59 Temple Place, Suite 330                                      *
 *      Boston, MA  02111-1307, USA                                     *
 *                                                                      *
 * or visit their web page on the internet at:                          *
 *                                                                      *
 *      http://www.gnu.org/copyleft/gpl.html.                           *
 * ******************************************************************** */
#include "localconf.h"
  
/* duplicate allocate memory and return pointer **** memory must be freed */
void *
ni_memdup(void * memp, int size)
{
    void * newmp;
    if ((newmp = malloc(size)) == NULL) {
        errno = ENOMEM;
        return NULL;
    }
    return memcpy(newmp,memp,size);
}
/* two functions to conditionally close and reopen an ifconf socket
 *
 * if fd is < 0 it is ignored
 * af is modified if required
 */
  
int
ni_clos_reopn_dgrm(int fd, u_int af)
{
    if (fd >= 0)
        close(fd);
    af == AF_UNSPEC ? AF_INET : af;
    return socket(af,SOCK_DGRAM,0);
}
/* **************************************************** *
 *      provide _SIZEOF_ADDR_IFREQ(ifr) equivalent      *
 *      that will cover our use of in6_ifreq, lifreq    *
 * **************************************************** */
#ifdef _SIZEOF_ADDR_IFREQ
int
ni_SIZEOF_ADDR_IFREQ(struct ifreq * ifrp,struct sockaddr * sa,int size)
{
    struct ifreq ifr;
     
    memcpy(&ifr,ifrp,sizeof(struct ifreq));
    return _SIZEOF_ADDR_IFREQ(ifr);
}
#endif
/* **************************************************** *
 *      on systems with embedded scope, get it          *
 *      and correct the bits in the addrsess            *
 * **************************************************** */
  
#ifdef LOCAL_SIZEOF_SOCKADDR_IN6
u_int
ni_get_scopeid(struct sockaddr_in6 * sin6)
{
    unsigned int scopeid = 0;
# ifdef __KAME__
    if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) {
        scopeid = ntohs(*(u_int16_t *)&sin6->sin6_addr.s6_addr[2]);
        sin6->sin6_addr.s6_addr[2] = sin6->sin6_addr.s6_addr[3] = 0;
    }
# elif defined HAVE_SIN6_SCOPEID
    scopeid =  sin6->sin6_scopeid;
# endif
    return scopeid;
}
#endif
/* **************************************************** *
 *      generate a netmask from a prefix length         *
 * **************************************************** */
  
void
ni_plen2mask(void * in_addr, int plen, int sizeofaddr)
{
    char * mask = in_addr;
    int ffs, rm, i;
     
    ffs = plen / 8;
    rm  = plen % 8;
    if (rm != 0) {
        rm = 8 - rm;
        rm = 0xFFu << rm;
    }
    for (i = 0; i < ffs; i++)
        mask[i] = 0xFFu;
    if (rm != 0) {
        mask[i] = rm;
        i++;
    }
    for (; i < sizeofaddr; i++)
        mask[i] = 0;
}
/* **************************************************** *
 *      calculate the length of netmask prefix          *
 * **************************************************** */
  
int
ni_prefix(void * ap, int sz)
{
    unsigned char byte, * addr = (unsigned char *)ap;
    int bit, bp, plen = 0;
    for (bp = 0; bp < sz; bp++) {
      if (addr[bp] != 0xFFu)
          break;
      plen += 8;
    }
    if (bp == sz)
        return plen;
    byte = addr[bp];
    for (bit = 0x80u; bit != 0; bit >>= 1) {      /*  for (bit = 7; bit != 0; bit--, plen++)      */
        if (byte & bit)     {                       /*      if (!(name[byte] & (1 << bit)))               */
            byte ^= bit;                        /*          break;                              */
            plen++;
        }
        else if (byte != 0)                     /*  for (; bit != 0; bit--)                     */
            return 0;                           /*      if (name[byte] & (1 << bit))          */
        else                                    /*          return 0;                           */
            break;
    }
    bp++;
    for (; bp < sz; bp++) {
        if (addr[bp] != 0)
            return 0;
    }
     return plen;
}
/* **************************************************** *
 *              constructor registration                *
 * **************************************************** */
/*      for ifreq or equivalent flavor support          */
struct ni_ifconf_flavor * nifcf = NULL;
void
ni_ifcf_register(struct ni_ifconf_flavor * nifp)
{
    nifp->ni_ifcf_next = nifcf;
    nifcf = nifp;
}
struct ni_ifconf_flavor *
ni_ifcf_get(enum ni_FLAVOR type)
{
    struct ni_ifconf_flavor * nifp;
    for (nifp = nifcf; nifp != NULL; nifp = nifp->ni_ifcf_next)
        if (nifp->ni_type == type)
            return nifp;
    errno = ENOSYS;
    return NULL;
}
struct ni_ifconf_flavor *
ni_safe_ifcf_get(enum ni_FLAVOR type)
{
    struct ni_ifconf_flavor * nifp;
    if ((nifp = ni_ifcf_get(type)) != NULL)
        return nifp;
    return ni_ifcf_get(NI_IFREQ);
}
/* **************************************************** *
 *      developer support, not for production           *
 * **************************************************** */
int
ni_developer(enum ni_FLAVOR type)
{
    void * notused = NULL;
    struct ni_ifconf_flavor * nifp = ni_ifcf_get(type);
    if (nifp == NULL)
        return ENOSYS;
    return nifp->developer(notused);
}
/* **************************************************** *
 *      IPV6 support for linux like type info           *
 * **************************************************** */
/* does not have to be ifdef'd #ifdef LOCAL_SIZEOF_SOCKADDR_IN6 */
/*      scope flags     rfc-2373
 *
        0         reserved
        1       node-local
        2       link-local
        3         unassigned
        4         unassigned
        5       site-local
        6         unassigned
        7         unassigned
        8       organization-local
        9         unassigned
        A         unassigned
        B         unassigned
        C         unassigned
        D         unassigned
        E       global scope
        F         reserved
 */
# ifdef ___NEVER_DEFINED___for_info
/*                            0x0000      0xe
#define IPV6_ADDR_LOOPBACK      0x0010u /*      0x1     aka NODELOCAL, INTERFACELOCAL */
#define IPV6_ADDR_LINKLOCAL     0x0020u /*      0x2     */
#define IPV6_ADDR_SITELOCAL     0x0040u /*      0x5     */
#define IPV6_ADDR_COMPATv4      0x0080u /*      0x10    mapped back out of range */
# endif
int
ni_lx_type2scope(int lscope)
{
    lscope &= 0xF0u;
    switch (lscope) {
    case 0 :
        return 0xEu;
    case 0x10 :
        return 0x1;
    case 0x20 :
        return 0x2;
    case 0x40 :
        return 0x5;
    case 0x80:
        return 0x10;    /* linux compat-v4      */
    }
    return 0;
}
const ni_iff_t ni_lx_type2txt[] = {
        { IPV6_ADDR_ANY,                "addr-any" },
        { IPV6_ADDR_UNICAST,            "unicast" },
        { IPV6_ADDR_MULTICAST,          "multicast" },
        { IPV6_ADDR_ANYCAST,            "anycast" },
        { IPV6_ADDR_LOOPBACK,           "loopback" },
        { IPV6_ADDR_LINKLOCAL,          "link-local" },
        { IPV6_ADDR_SITELOCAL,          "site-local" },
        { IPV6_ADDR_COMPATv4,           "compat-v4" },
        { IPV6_ADDR_SCOPE_MASK,         "scope-mask" },
        { IPV6_ADDR_MAPPED,             "mapped" },
        { IPV6_ADDR_RESERVED,           "reserved" },
        { IPV6_ADDR_ULUA,               "uniq-lcl-unicast" },
        { IPV6_ADDR_6TO4,               "6to4" },
        { IPV6_ADDR_6BONE,              "6bone" },
        { IPV6_ADDR_AGU,                "global-unicast" },
        { IPV6_ADDR_UNSPECIFIED,        "unspecified" },
        { IPV6_ADDR_SOLICITED_NODE,     "solicited-node" },
        { IPV6_ADDR_ISATAP,             "ISATAP" },
        { IPV6_ADDR_PRODUCTIVE,         "productive" },
        { IPV6_ADDR_6TO4_MICROSOFT,     "6to4-ms" },
        { IPV6_ADDR_TEREDO,             "teredo" },
        { IPV6_ADDR_ORCHID,             "orchid" },
        { IPV6_ADDR_NON_ROUTE_DOC,      "non-routeable-doc" }
};
int
ni_sizeof_type2txt()
{
    return sizeof(ni_lx_type2txt);
}
void
ni_linux_scope2txt(uint32_t flags)
{
    int i, n = sizeof(ni_lx_type2txt) / sizeof(ni_iff_t);
     
    for (i=0; i < n; i++)
        if (flags & ni_lx_type2txt[i].iff_val)
            printf("%s ",ni_lx_type2txt[i].iff_nam);
}
/* does not have to be ifdef'd #endif   LOCAL_SIZEOF_SOCKADDR_IN6 */