//==========================================================================
//
//      src/ifaddrs.c
//
//==========================================================================
// ####BSDCOPYRIGHTBEGIN####                                    
// -------------------------------------------                  
// This file is part of eCos, the Embedded Configurable Operating System.
//
// Portions of this software may have been derived from FreeBSD, OpenBSD,
// or other sources, and if so are covered by the appropriate copyright
// and license included herein.                                 
//
// Portions created by the Free Software Foundation are         
// Copyright (C) 2002 Free Software Foundation, Inc.            
// -------------------------------------------                  
// ####BSDCOPYRIGHTEND####                                      
//==========================================================================

//
// Adapted from KAME getifaddrs.c, if_nametoindex.c, if_indextoname.c
//

/*	$KAME: getifaddrs.c,v 1.9 2001/08/20 02:31:20 itojun Exp $	*/
/*	$KAME: if_nametoindex.c,v 1.6 2000/11/24 08:18:54 itojun Exp $	*/
/*	$KAME: if_indextoname.c,v 1.7 2000/11/08 03:09:30 itojun Exp $	*/

/*
 * Copyright (c) 1995, 1999
 *	Berkeley Software Design, Inc.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * THIS SOFTWARE IS PROVIDED BY Berkeley Software Design, Inc. ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL Berkeley Software Design, Inc. BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *	BSDI getifaddrs.c,v 2.12 2000/02/23 14:51:59 dab Exp
 */

#include <cyg/infra/diag.h>

#include <unistd.h>
#include <stdlib.h>
#include <string.h>

#undef _KERNEL
#undef __INSIDE_NET
#include <sys/param.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <net/if.h>
#include <net/if_dl.h>
#ifndef CYGPKG_NET_OPENBSD_STACK
#include <net/if_var.h>
#endif
#include <errno.h>
#include <netinet/in.h>
#include <net/netdb.h>
#include <ifaddrs.h>
#include <netinet/in_var.h>


#if !defined(AF_LINK)
#define	SA_LEN(sa)	sizeof(struct sockaddr)
#endif

#if !defined(SA_LEN)
#define	SA_LEN(sa)	(sa)->sa_len
#endif

#define	SALIGN	(sizeof(long) - 1)
#define	SA_RLEN(sa)	((sa)->sa_len ? (((sa)->sa_len + SALIGN) & ~SALIGN) : (SALIGN + 1))

#ifndef	ALIGNBYTES
/*
 * On systems with a routing socket, ALIGNBYTES should match the value
 * that the kernel uses when building the messages.
 */
#define	ALIGNBYTES	XXX
#endif
#ifndef	ALIGN
#define	ALIGN(p)	(((u_long)(p) + ALIGNBYTES) &~ ALIGNBYTES)
#endif

int
getifaddrs(struct ifaddrs **pif)
{
    int icnt = 1;  // Interface count
    int dcnt = 0;  // Data [length] count
    int ncnt = 0;  // Length of interface names
    char *buf;
#define	IF_WORK_SPACE_SZ	1024
    int i, sock;
#ifdef CYGPKG_NET_INET6
    int sock6;
    struct in6_ifreq ifrq6;
#endif
    struct ifconf ifc;
    struct ifreq *ifr, *lifr;
    struct ifreq ifrq;
    char *data, *names;
    struct ifaddrs *ifa, *ift;

    buf = malloc(IF_WORK_SPACE_SZ);
    if (buf == NULL)
        return (-1);
    ifc.ifc_buf = buf;
    ifc.ifc_len = IF_WORK_SPACE_SZ;

    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        free(buf);
        return (-1);
    }
    i =  ioctl(sock, SIOCGIFCONF, (char *)&ifc);

    if (i < 0) {
        close(sock); 
        free(buf);
        return (-1);
    }

    ifr = ifc.ifc_req;
    lifr = (struct ifreq *)&ifc.ifc_buf[ifc.ifc_len];

    while (ifr < lifr) {
        struct sockaddr *sa;

        sa = &ifr->ifr_addr;
        ++icnt;
        dcnt += SA_RLEN(sa) * 3;  /* addr, mask, brdcst */
        ncnt += sizeof(ifr->ifr_name) + 1;
		
        if (SA_LEN(sa) < sizeof(*sa))
            ifr = (struct ifreq *)(((char *)sa) + sizeof(*sa));
        else
            ifr = (struct ifreq *)(((char *)sa) + SA_LEN(sa));
    }

    if (icnt + dcnt + ncnt == 1) {
        // Nothing found
        *pif = NULL;
        free(buf);
        close(sock);
        return (0);
    }
    data = malloc(sizeof(struct ifaddrs) * icnt + dcnt + ncnt);
    if (data == NULL) {
        free(buf);
        close(sock);
        return(-1);
    }

    ifa = (struct ifaddrs *)(void *)data;
    data += sizeof(struct ifaddrs) * icnt;
    names = data + dcnt;

    memset(ifa, 0, sizeof(struct ifaddrs) * icnt);
    ift = ifa;

    ifr = ifc.ifc_req;

#ifdef CYGPKG_NET_INET6
    if ((sock6 = socket(AF_INET6, SOCK_STREAM, 0)) < 0) {
      free(buf);
      free(ifa);
      close(sock);
      return (-1);
    }
#endif

    while (ifr < lifr) {
       struct sockaddr * sa;

        ift->ifa_name = names;
        names[sizeof(ifr->ifr_name)] = 0;
        strncpy(names, ifr->ifr_name, sizeof(ifr->ifr_name));
        while (*names++) ;

        ift->ifa_addr = (struct sockaddr *)data;
        sa = &ifr->ifr_addr;
        memcpy(data, sa, SA_LEN(sa));
        data += SA_RLEN(sa);

        if ((sa->sa_family == AF_INET) || (sa->sa_family == AF_INET6)) {
          struct sockaddr *sa_netmask = NULL;
          struct sockaddr *sa_broadcast = NULL;
          struct sockaddr *sa_dst = NULL;
          
          memset(&ifrq,0,sizeof(ifrq));
          strcpy(ifrq.ifr_name,ifr->ifr_name);
          ioctl( sock, SIOCGIFFLAGS, &ifrq );

          ift->ifa_flags = ifrq.ifr_flags;

          memcpy(&ifrq.ifr_addr, ift->ifa_addr,sizeof(struct sockaddr));
          if (sa->sa_family == AF_INET) {
            ioctl(sock, SIOCGIFNETMASK, &ifrq); 
            sa_netmask = &ifrq.ifr_addr;
          }
#ifdef CYGPKG_NET_INET6
          if (sa->sa_family == AF_INET6) {
            memset(&ifrq6,0,sizeof(ifrq));
            strcpy(ifrq6.ifr_name,ifr->ifr_name);
            memcpy(&ifrq6.ifr_addr, ift->ifa_addr,sizeof(struct sockaddr));
          
            ioctl(sock6, SIOCGIFNETMASK_IN6, &ifrq6);
            sa_netmask = (struct sockaddr *)&ifrq6.ifr_addr;
          }
#endif
          ift->ifa_netmask = (struct sockaddr *)data;
          memcpy(data, sa_netmask, SA_LEN(sa_netmask));
          data += SA_RLEN(sa_netmask);

          memcpy(&ifrq.ifr_addr, ift->ifa_addr,sizeof(struct sockaddr));
          if ((sa->sa_family == AF_INET) && (ift->ifa_flags & IFF_BROADCAST)) {
            if (ioctl(sock, SIOCGIFBRDADDR, &ifrq) == 0) {
              sa_broadcast = &ifrq.ifr_addr;
              ift->ifa_broadaddr = (struct sockaddr *)data;
              memcpy(data, sa_broadcast, SA_LEN(sa_broadcast));
              data += SA_RLEN(sa_broadcast);
            }
          }

          memcpy(&ifrq.ifr_addr, ift->ifa_addr,sizeof(struct sockaddr));
          if ((sa->sa_family == AF_INET) && 
              (ift->ifa_flags & IFF_POINTOPOINT)) {
            if (ioctl(sock, SIOCGIFDSTADDR, &ifrq) == 0) {
              sa_dst = &ifrq.ifr_addr;
              ift->ifa_dstaddr = (struct sockaddr *)data;
              memcpy(data, sa_dst, SA_LEN(sa_dst));
              data += SA_RLEN(sa_dst);
            }
          }
        }
        
        if (SA_LEN(sa) < sizeof(*sa))
            ifr = (struct ifreq *)(((char *)sa) + sizeof(*sa));
        else
            ifr = (struct ifreq *)(((char *)sa) + SA_LEN(sa));
        ift = (ift->ifa_next = ift + 1);
    }
    free(buf);

    if (--ift >= ifa) {
        ift->ifa_next = NULL;
        *pif = ifa;
    } else {
        *pif = NULL;
        free(ifa);
    }
#ifdef CYGPKG_NET_INET6
    close(sock6);
#endif
    close(sock);
    return (0);
}

void
freeifaddrs(struct ifaddrs *ifp)
{
    free(ifp);
}

void
_show_all_interfaces(void)
{
    struct ifaddrs *iflist, *ifp;
    char addr[64];
    int indx;

    if (getifaddrs(&iflist) < 0) {
        diag_printf("Can't get interface information!!\n");
        return;
    }
    ifp = iflist;
    while (ifp != (struct ifaddrs *)NULL) {
        if (ifp->ifa_addr->sa_family != AF_LINK) {
            getnameinfo (ifp->ifa_addr, ifp->ifa_addr->sa_len, addr, 
                         sizeof(addr), 0, 0, NI_NUMERICHOST);
            diag_printf("%p - %s - %s\n", ifp, ifp->ifa_name, addr);
        }
        ifp = ifp->ifa_next;
    }
    indx = if_nametoindex(iflist->ifa_name);
    diag_printf("indx(%s) = %d\n", iflist->ifa_name, indx);
    if (indx > 0) {
        if (if_indextoname(indx, addr)) {
            diag_printf("index(%s) = %d/%s\n", iflist->ifa_name, indx, addr);
        } else {
            diag_printf("index(%s) = %d: %s\n", iflist->ifa_name, indx, strerror(errno));
        }
    } else {
        diag_printf("index(%s): %s\n", iflist->ifa_name, strerror(errno));
    }
    freeifaddrs(iflist);
}

/*
 * From RFC 2553:
 *
 * 4.1 Name-to-Index
 *
 *
 *    The first function maps an interface name into its corresponding
 *    index.
 *
 *       #include <net/if.h>
 *
 *       unsigned int  if_nametoindex(const char *ifname);
 *
 *    If the specified interface name does not exist, the return value is
 *    0, and errno is set to ENXIO.  If there was a system error (such as
 *    running out of memory), the return value is 0 and errno is set to the
 *    proper value (e.g., ENOMEM).
 */

unsigned int
if_nametoindex(const char *ifname)
{
    struct ifaddrs *ifaddrs, *ifa;
    unsigned int ni;

    if (getifaddrs(&ifaddrs) < 0)
        return(0);

    ni = 0;

    for (ifa = ifaddrs; ifa != NULL; ifa = ifa->ifa_next) {
        if (ifa->ifa_addr &&
            ifa->ifa_addr->sa_family == AF_LINK &&
            strcmp(ifa->ifa_name, ifname) == 0) {
            ni = ((struct sockaddr_dl*)ifa->ifa_addr)->sdl_index;
            break;
        }
    }

    freeifaddrs(ifaddrs);
    if (!ni)
        errno = ENXIO;
    return(ni);
}

/*
 * From RFC 2533:
 *
 * The second function maps an interface index into its corresponding
 * name.
 *
 *    #include <net/if.h>
 *
 *    char  *if_indextoname(unsigned int ifindex, char *ifname);
 *
 * The ifname argument must point to a buffer of at least IF_NAMESIZE
 * bytes into which the interface name corresponding to the specified
 * index is returned.  (IF_NAMESIZE is also defined in <net/if.h> and
 * its value includes a terminating null byte at the end of the
 * interface name.) This pointer is also the return value of the
 * function.  If there is no interface corresponding to the specified
 * index, NULL is returned, and errno is set to ENXIO, if there was a
 * system error (such as running out of memory), if_indextoname returns
 * NULL and errno would be set to the proper value (e.g., ENOMEM).
 */

char *
if_indextoname(unsigned int ifindex, char *ifname)
{
    struct ifaddrs *ifaddrs, *ifa;
    int error = 0;

    if (getifaddrs(&ifaddrs) < 0)
        return(NULL);	/* getifaddrs properly set errno */

    for (ifa = ifaddrs; ifa != NULL; ifa = ifa->ifa_next) {
        if (ifa->ifa_addr &&
            ifa->ifa_addr->sa_family == AF_LINK &&
            ifindex == ((struct sockaddr_dl*)ifa->ifa_addr)->sdl_index)
            break;
    }

    if (ifa == NULL) {
        error = ENXIO;
        ifname = NULL;
    }
    else
        strncpy(ifname, ifa->ifa_name, IFNAMSIZ);

    freeifaddrs(ifaddrs);

    errno = error;
    return(ifname);
}
