#include <assert.h>
#include <errno.h>
#if !defined(WIN32) && !defined(SN_TARGET_ORBIS) && !defined(SN_TARGET_PSP2) && !defined(NN_COMPILER_RVCT)
#include <dlfcn.h>
#endif
#include <limits.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#if !defined(NN_COMPILER_RVCT) && !defined(SN_TARGET_PSP2)
#include <sys/types.h>
#endif
#if !defined(WIN32) && !defined(NN_COMPILER_RVCT)
#include <sys/socket.h>

#include <unistd.h>
#endif

#if LINUX
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <linux/if_arp.h>
#endif /* def LINUX */
#if !defined(WIN32) && !defined(NN_COMPILER_RVCT) && !defined(SN_TARGET_PSP2)
#include <netinet/in.h>
#endif

#if ANDROID
#include <android/log.h>
#endif

#include "logger.h"
#include "xamarin_getifaddrs.h"

/* These aren't defined in android's rtnetlink.h (as of ndk 9d). We define fake values for them if
 * they aren't found so that the debug code works properly. We could skip them but future versions
 * of the NDK might include definitions for them.
 */
#ifndef IFLA_LINKINFO
#define IFLA_LINKINFO 1000
#endif

#ifndef IFLA_NET_NS_PID
#define IFLA_NET_NS_PID 1001
#endif

#ifndef IFLA_IFALIAS
#define IFLA_IFALIAS 1002
#endif

#ifndef IFLA_NUM_VF
#define IFLA_NUM_VF 1003
#endif

#ifndef IFLA_VFINFO_LIST
#define IFLA_VFINFO_LIST 1004
#endif

#ifndef IFLA_STATS64
#define IFLA_STATS64 1005
#endif

#ifndef IFLA_VF_PORTS
#define IFLA_VF_PORTS 1006
#endif

#ifndef IFLA_PORT_SELF
#define IFLA_PORT_SELF 1007
#endif

#ifndef IFLA_AF_SPEC
#define IFLA_AF_SPEC 1008
#endif

#ifndef IFLA_GROUP
#define IFLA_GROUP 1009
#endif

#ifndef IFLA_NET_NS_FD
#define IFLA_NET_NS_FD 1010
#endif

#ifndef IFLA_EXT_MASK
#define IFLA_EXT_MASK 1011
#endif

#ifndef IFLA_PROMISCUITY
#define IFLA_PROMISCUITY 1012
#endif

#ifndef IFLA_NUM_TX_QUEUES
#define IFLA_NUM_TX_QUEUES 1013
#endif

#ifndef IFLA_NUM_RX_QUEUES
#define IFLA_NUM_RX_QUEUES 1014
#endif

#ifndef IFLA_CARRIER
#define IFLA_CARRIER 1015
#endif

#ifndef IFLA_PHYS_PORT_ID
#define IFLA_PHYS_PORT_ID 1016
#endif

/* The amount of data we read from the kernel in one call */
#define RESPONSE_BUFFER_SIZE 1024

/* Maximum interface address label size, should be more than enough */
#define MAX_IFA_LABEL_SIZE 1024

#if LINUX

/* This is the message we send to the kernel */
typedef struct
{
    struct nlmsghdr header;
    struct rtgenmsg message;
} netlink_request;

typedef struct
{
    int sock_fd;
    int seq;
    struct sockaddr_nl them; /* kernel end */
    struct sockaddr_nl us; /* our end */
    struct msghdr message_header; /* for use with sendmsg */
    struct iovec payload_vector; /* Used to send netlink_request */
} netlink_session;

/* Turns out that quite a few link types have address length bigger than the 8 bytes allocated in
 * this structure as defined by the OS. Examples are Infiniband or ipv6 tunnel devices
 */
struct sockaddr_ll_extended
{
    unsigned short int sll_family;
    unsigned short int sll_protocol;
    int sll_ifindex;
    unsigned short int sll_hatype;
    unsigned char sll_pkttype;
    unsigned char sll_halen;
    unsigned char sll_addr[24];
};

static int parse_netlink_reply(netlink_session *session, struct _monodroid_ifaddrs **ifaddrs_head, struct _monodroid_ifaddrs **last_ifaddr);
static struct _monodroid_ifaddrs *get_link_info(const struct nlmsghdr *message);
static struct _monodroid_ifaddrs *get_link_address(const struct nlmsghdr *message, struct _monodroid_ifaddrs **ifaddrs_head);
static int open_netlink_session(netlink_session *session);
static int send_netlink_dump_request(netlink_session *session, int type);
static int append_ifaddr(struct _monodroid_ifaddrs *addr, struct _monodroid_ifaddrs **ifaddrs_head, struct _monodroid_ifaddrs **last_ifaddr);
static int fill_ll_address(struct sockaddr_ll_extended **sa, struct ifinfomsg *net_interface, void *rta_data, int rta_payload_length);
static int fill_sa_address(struct sockaddr **sa, struct ifaddrmsg *net_address, void *rta_data, int rta_payload_length);
static void free_single_xamarin_ifaddrs(struct _monodroid_ifaddrs **ifap);
static void get_ifaddrs_impl(int(**getifaddrs_impl) (struct _monodroid_ifaddrs **ifap), void(**freeifaddrs_impl) (struct _monodroid_ifaddrs *ifa));
static struct _monodroid_ifaddrs *find_interface_by_index(int index, struct _monodroid_ifaddrs **ifaddrs_head);
static char *get_interface_name_by_index(int index, struct _monodroid_ifaddrs **ifaddrs_head);
static int get_interface_flags_by_index(int index, struct _monodroid_ifaddrs **ifaddrs_head);
static int calculate_address_netmask(struct _monodroid_ifaddrs *ifa, struct ifaddrmsg *net_address);
#if DEBUG
static void print_ifla_name(int id);
static void print_address_list(char *title, struct _monodroid_ifaddrs *list);
#endif

/* We don't use 'struct ifaddrs' since that doesn't exist in Android's bionic, but since our
 * version of the structure is 100% compatible we can just use it instead
 */
typedef int (*getifaddrs_impl_fptr)(struct _monodroid_ifaddrs **);
typedef void (*freeifaddrs_impl_fptr)(struct _monodroid_ifaddrs *ifa);

static getifaddrs_impl_fptr getifaddrs_impl = NULL;
static freeifaddrs_impl_fptr freeifaddrs_impl = NULL;

void
_monodroid_getifaddrs_init()
{
    get_ifaddrs_impl(&getifaddrs_impl, &freeifaddrs_impl);
}

int
_monodroid_getifaddrs(struct _monodroid_ifaddrs **ifap)
{
    netlink_session session;
    struct _monodroid_ifaddrs *ifaddrs_head;
    struct _monodroid_ifaddrs *last_ifaddr;
    int ret = -1;

    if (getifaddrs_impl)
        return (*getifaddrs_impl)(ifap);

    if (!ifap)
    {
        goto cleanup;
    }

    *ifap = NULL;
    ifaddrs_head = 0;
    last_ifaddr = 0;

    if (open_netlink_session(&session) < 0)
    {
        goto cleanup;
    }

    /* Request information about the specified link. In our case it will be all of them since we
       request the root of the link tree below
    */
    if ((send_netlink_dump_request(&session, RTM_GETLINK) < 0) ||
        (parse_netlink_reply(&session, &ifaddrs_head, &last_ifaddr) < 0) ||
        (send_netlink_dump_request(&session, RTM_GETADDR) < 0) ||
        (parse_netlink_reply(&session, &ifaddrs_head, &last_ifaddr) < 0))
    {
        _monodroid_freeifaddrs(ifaddrs_head);
        goto cleanup;
    }

    ret = 0;
    *ifap = ifaddrs_head;
#if DEBUG
    print_address_list("Initial interfaces list", *ifap);
#endif

cleanup:
    if (session.sock_fd >= 0)
    {
        close(session.sock_fd);
        session.sock_fd = -1;
    }

    return ret;
}

void
_monodroid_freeifaddrs(struct _monodroid_ifaddrs *ifa)
{
    struct _monodroid_ifaddrs *cur, *next;

    if (!ifa)
        return;

    if (freeifaddrs_impl)
    {
        (*freeifaddrs_impl)(ifa);
        return;
    }

#if DEBUG
    print_address_list("List passed to freeifaddrs", ifa);
#endif
    cur = ifa;
    while (cur)
    {
        next = cur->ifa_next;
        free_single_xamarin_ifaddrs(&cur);
        cur = next;
    }
}

static void
get_ifaddrs_impl(int(**getifaddrs_impl) (struct _monodroid_ifaddrs **ifap), void(**freeifaddrs_impl) (struct _monodroid_ifaddrs *ifa))
{
    void *libc;

    assert(getifaddrs_impl);
    assert(freeifaddrs_impl);

    libc = dlopen("libc.so", RTLD_NOW);
    if (libc)
    {
        *getifaddrs_impl = dlsym(libc, "getifaddrs");
        if (*getifaddrs_impl)
            *freeifaddrs_impl = dlsym(libc, "freeifaddrs");
    }

    if (!*getifaddrs_impl)
        log_info(LOG_NET, "This libc does not have getifaddrs/freeifaddrs, using Xamarin's\n");
    else
        log_info(LOG_NET, "This libc has getifaddrs/freeifaddrs\n");
}

static void
free_single_xamarin_ifaddrs(struct _monodroid_ifaddrs **ifap)
{
    struct _monodroid_ifaddrs *ifa = ifap ? *ifap : NULL;
    if (!ifa)
        return;

    if (ifa->ifa_name)
        free(ifa->ifa_name);

    if (ifa->ifa_addr)
        free(ifa->ifa_addr);

    if (ifa->ifa_netmask)
        free(ifa->ifa_netmask);

    if (ifa->_monodroid_ifa_broadaddr)
        free(ifa->_monodroid_ifa_broadaddr);

    if (ifa->ifa_data)
        free(ifa->ifa_data);

    free(ifa);
    *ifap = NULL;
}

static int
open_netlink_session(netlink_session *session)
{
    assert(session != 0);

    memset(session, 0, sizeof(*session));
    session->sock_fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
    if (session->sock_fd == -1)
    {
        log_warn(LOG_NETLINK, "Failed to create a netlink socket. %s\n", strerror(errno));
        return -1;
    }

    /* Fill out addresses */
    session->us.nl_family = AF_NETLINK;
    session->us.nl_pid = getpid();
    session->us.nl_groups = 0;

    session->them.nl_family = AF_NETLINK;

    if (bind(session->sock_fd, (struct sockaddr *)&session->us, sizeof(session->us)) < 0)
    {
        log_warn(LOG_NETLINK, "Failed to bind to the netlink socket. %s\n", strerror(errno));
        return -1;
    }

    return 0;
}

static int
send_netlink_dump_request(netlink_session *session, int type)
{
    netlink_request request;

    memset(&request, 0, sizeof(request));
    request.header.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtgenmsg));
    /* Flags (from netlink.h):
       NLM_F_REQUEST - it's a request message
       NLM_F_DUMP - gives us the root of the link tree and returns all links matching our requested
       AF, which in our case means all of them (AF_PACKET)
    */
    request.header.nlmsg_flags = NLM_F_REQUEST | NLM_F_ROOT | NLM_F_MATCH;
    request.header.nlmsg_seq = ++session->seq;
    request.header.nlmsg_pid = session->us.nl_pid;
    request.header.nlmsg_type = type;

    /* AF_PACKET means we want to see everything */
    request.message.rtgen_family = AF_PACKET;

    memset(&session->payload_vector, 0, sizeof(session->payload_vector));
    session->payload_vector.iov_len = request.header.nlmsg_len;
    session->payload_vector.iov_base = &request;

    memset(&session->message_header, 0, sizeof(session->message_header));
    session->message_header.msg_namelen = sizeof(session->them);
    session->message_header.msg_name = &session->them;
    session->message_header.msg_iovlen = 1;
    session->message_header.msg_iov = &session->payload_vector;

    if (sendmsg(session->sock_fd, (const struct msghdr*)&session->message_header, 0) < 0)
    {
        log_warn(LOG_NETLINK, "Failed to send netlink message. %s\n", strerror(errno));
        return -1;
    }

    return 0;
}

static int
append_ifaddr(struct _monodroid_ifaddrs *addr, struct _monodroid_ifaddrs **ifaddrs_head, struct _monodroid_ifaddrs **last_ifaddr)
{
    assert(addr);
    assert(ifaddrs_head);
    assert(last_ifaddr);

    if (!*ifaddrs_head)
    {
        *ifaddrs_head = *last_ifaddr = addr;
        if (!*ifaddrs_head)
            return -1;
    }
    else if (!*last_ifaddr)
    {
        struct _monodroid_ifaddrs *last = *ifaddrs_head;

        while (last->ifa_next)
            last = last->ifa_next;
        *last_ifaddr = last;
    }

    addr->ifa_next = NULL;
    if (addr == *last_ifaddr)
        return 0;

    assert(addr != *last_ifaddr);
    (*last_ifaddr)->ifa_next = addr;
    *last_ifaddr = addr;
    assert((*last_ifaddr)->ifa_next == NULL);

    return 0;
}

static int
parse_netlink_reply(netlink_session *session, struct _monodroid_ifaddrs **ifaddrs_head, struct _monodroid_ifaddrs **last_ifaddr)
{
    ssize_t length;
    struct msghdr netlink_reply;
    struct iovec reply_vector;
    struct nlmsghdr *current_message;
    struct _monodroid_ifaddrs *addr;
    unsigned char response[RESPONSE_BUFFER_SIZE];

    assert(session);
    assert(ifaddrs_head);
    assert(last_ifaddr);

    while (1)
    {
        memset(response, 0, RESPONSE_BUFFER_SIZE);
        memset(&reply_vector, 0, sizeof(reply_vector));
        reply_vector.iov_len = RESPONSE_BUFFER_SIZE;
        reply_vector.iov_base = response;

        memset(&netlink_reply, 0, sizeof(netlink_reply));
        netlink_reply.msg_namelen = sizeof(&session->them);
        netlink_reply.msg_name = &session->them;
        netlink_reply.msg_iovlen = 1;
        netlink_reply.msg_iov = &reply_vector;

        log_debug(LOG_NETLINK, "receiving message...\n");
        length = recvmsg(session->sock_fd, &netlink_reply, 0);
        log_debug(LOG_NETLINK, "  length == %d\n", (int)length);

        if (length < 0)
        {
            log_debug(LOG_NETLINK, "Failed to receive reply from netlink. %s\n", strerror(errno));
            return -1;
        }

        if (length == 0)
            return 0; /* done, apparently */

        for (current_message = (struct nlmsghdr*)response; current_message && NLMSG_OK(current_message, length); current_message = NLMSG_NEXT(current_message, length))
        {
            log_debug(LOG_NETLINK, "next message... (type: %u)\n", current_message->nlmsg_type);
            switch (current_message->nlmsg_type)
            {
                /* See rtnetlink.h */
                case RTM_NEWLINK:
                    log_debug(LOG_NETLINK, "  dumping link...\n");
                    addr = get_link_info(current_message);
                    if (!addr || append_ifaddr(addr, ifaddrs_head, last_ifaddr) < 0)
                        return -1;
                    log_debug(LOG_NETLINK, "  done\n");
                    break;

                case RTM_NEWADDR:
                    log_debug(LOG_NETLINK, "  got an address\n");
                    addr = get_link_address(current_message, ifaddrs_head);
                    if (!addr || append_ifaddr(addr, ifaddrs_head, last_ifaddr) < 0)
                        return -1;
                    break;

                case NLMSG_DONE:
                    log_debug(LOG_NETLINK, "  message done\n");
                    return 0;
            }
        }
    }
}

static int
fill_sa_address(struct sockaddr **sa, struct ifaddrmsg *net_address, void *rta_data, int rta_payload_length)
{
    assert(sa);
    assert(net_address);
    assert(rta_data);

    switch (net_address->ifa_family)
    {
        case AF_INET:
        {
            struct sockaddr_in *sa4;
            assert(rta_payload_length == 4);  /* IPv4 address length */
            sa4 = (struct sockaddr_in*)calloc(1, sizeof(*sa4));
            if (!sa4)
                return -1;

            sa4->sin_family = AF_INET;
            memcpy(&sa4->sin_addr, rta_data, rta_payload_length);
            *sa = (struct sockaddr*)sa4;
            break;
        }

        case AF_INET6:
        {
            struct sockaddr_in6 *sa6;
            assert(rta_payload_length == 16);  /* IPv6 address length */
            sa6 = (struct sockaddr_in6*)calloc(1, sizeof(*sa6));
            if (!sa6)
                return -1;

            sa6->sin6_family = AF_INET6;
            memcpy(&sa6->sin6_addr, rta_data, rta_payload_length);
            if (IN6_IS_ADDR_LINKLOCAL(&sa6->sin6_addr) || IN6_IS_ADDR_MC_LINKLOCAL(&sa6->sin6_addr))
                sa6->sin6_scope_id = net_address->ifa_index;
            *sa = (struct sockaddr*)sa6;
            break;
        }

        default:
        {
            struct sockaddr *sagen;
            assert(rta_payload_length <= sizeof(sagen->sa_data));
            *sa = sagen = (struct sockaddr*)calloc(1, sizeof(*sagen));
            if (sagen)
                return -1;

            sagen->sa_family = net_address->ifa_family;
            memcpy(&sagen->sa_data, rta_data, rta_payload_length);
            break;
        }
    }

    return 0;
}

static int
fill_ll_address(struct sockaddr_ll_extended **sa, struct ifinfomsg *net_interface, void *rta_data, int rta_payload_length)
{
    assert(sa);
    assert(net_interface);

    /* Always allocate, do not free - caller may reuse the same variable */
    *sa = calloc(1, sizeof(**sa));
    if (!*sa)
        return -1;

    (*sa)->sll_family = AF_PACKET; /* Always for physical links */

    /* The assert can only fail for Iniband links, which are quite unlikely to be found
     * in any mobile devices
     */
    log_debug(LOG_NETLINK, "rta_payload_length == %d; sizeof sll_addr == %d; hw type == 0x%X\n", rta_payload_length, sizeof((*sa)->sll_addr), net_interface->ifi_type);
    if (rta_payload_length > sizeof((*sa)->sll_addr))
    {
        log_info(LOG_NETLINK, "Address is too long to place in sockaddr_ll (%d > %d)", rta_payload_length, sizeof((*sa)->sll_addr));
        free(*sa);
        *sa = NULL;
        return -1;
    }

    (*sa)->sll_ifindex = net_interface->ifi_index;
    (*sa)->sll_hatype = net_interface->ifi_type;
    (*sa)->sll_halen = rta_payload_length;
    memcpy((*sa)->sll_addr, rta_data, rta_payload_length);

    return 0;
}

static struct _monodroid_ifaddrs *
find_interface_by_index(int index, struct _monodroid_ifaddrs **ifaddrs_head)
{
    struct _monodroid_ifaddrs *cur;
    if (!ifaddrs_head || !*ifaddrs_head)
        return NULL;

    /* Normally expensive, but with the small amount of links in the chain we'll deal with it's not
     * worth the extra houskeeping and memory overhead
     */
    cur = *ifaddrs_head;
    while (cur)
    {
        if (cur->ifa_addr && cur->ifa_addr->sa_family == AF_PACKET && ((struct sockaddr_ll_extended*)cur->ifa_addr)->sll_ifindex == index)
            return cur;
        if (cur == cur->ifa_next)
            break;
        cur = cur->ifa_next;
    }

    return NULL;
}

static char *
get_interface_name_by_index(int index, struct _monodroid_ifaddrs **ifaddrs_head)
{
    struct _monodroid_ifaddrs *iface = find_interface_by_index(index, ifaddrs_head);
    if (!iface || !iface->ifa_name)
        return NULL;

    return iface->ifa_name;
}

static int
get_interface_flags_by_index(int index, struct _monodroid_ifaddrs **ifaddrs_head)
{
    struct _monodroid_ifaddrs *iface = find_interface_by_index(index, ifaddrs_head);
    if (!iface)
        return 0;

    return iface->ifa_flags;
}

static int
calculate_address_netmask(struct _monodroid_ifaddrs *ifa, struct ifaddrmsg *net_address)
{
    if (ifa->ifa_addr && ifa->ifa_addr->sa_family != AF_UNSPEC && ifa->ifa_addr->sa_family != AF_PACKET)
    {
        uint32_t prefix_length = 0;
        uint32_t data_length = 0;
        unsigned char *netmask_data = NULL;

        switch (ifa->ifa_addr->sa_family)
        {
            case AF_INET:
            {
                struct sockaddr_in *sa = (struct sockaddr_in*)calloc(1, sizeof(struct sockaddr_in));
                if (!sa)
                    return -1;

                ifa->ifa_netmask = (struct sockaddr*)sa;
                prefix_length = net_address->ifa_prefixlen;
                if (prefix_length > 32)
                    prefix_length = 32;
                data_length = sizeof(sa->sin_addr);
                netmask_data = (unsigned char*)&sa->sin_addr;
                break;
            }

            case AF_INET6:
            {
                struct sockaddr_in6 *sa = (struct sockaddr_in6*)calloc(1, sizeof(struct sockaddr_in6));
                if (!sa)
                    return -1;

                ifa->ifa_netmask = (struct sockaddr*)sa;
                prefix_length = net_address->ifa_prefixlen;
                if (prefix_length > 128)
                    prefix_length = 128;
                data_length = sizeof(sa->sin6_addr);
                netmask_data = (unsigned char*)&sa->sin6_addr;
                break;
            }
        }

        if (ifa->ifa_netmask && netmask_data)
        {
            /* Fill the first X bytes with 255 */
            uint32_t prefix_bytes = prefix_length / 8;
            uint32_t postfix_bytes;
            int i;

            if (prefix_bytes > data_length)
            {
                errno = EINVAL;
                return -1;
            }
            postfix_bytes = data_length - prefix_bytes;
            memset(netmask_data, 0xFF, prefix_bytes);
            if (postfix_bytes > 0)
                memset(netmask_data + prefix_bytes + 1, 0x00, postfix_bytes);
            log_debug(LOG_NETLINK, "   calculating netmask, prefix length is %u bits (%u bytes), data length is %u bytes\n", prefix_length, prefix_bytes, data_length);
            if (prefix_bytes + 2 < data_length)
                /* Set the rest of the mask bits in the byte following the last 0xFF value */
                netmask_data[prefix_bytes + 1] = 0xff << (8 - (prefix_length % 8));
            log_debug(LOG_NETLINK, "   netmask is: ");
            for (i = 0; i < data_length; i++)
            {
                log_debug(LOG_NETLINK, "%s%u", i == 0 ? "" : ".", (unsigned char)ifa->ifa_netmask->sa_data[i]);
            }
            log_debug(LOG_NETLINK, "\n");
        }
    }

    return 0;
}

static struct _monodroid_ifaddrs *
get_link_address(const struct nlmsghdr *message, struct _monodroid_ifaddrs **ifaddrs_head)
{
    size_t length;
    struct rtattr *attribute;
    struct ifaddrmsg *net_address;
    struct _monodroid_ifaddrs *ifa = NULL;
    struct sockaddr **sa;
    int payload_size;

    assert(message);
    net_address = NLMSG_DATA(message);
    length = IFA_PAYLOAD(message);
    if (length <= 0)
    {
        goto error;
    }

    ifa = calloc(1, sizeof(*ifa));
    if (!ifa)
    {
        goto error;
    }

    ifa->ifa_flags = get_interface_flags_by_index(net_address->ifa_index, ifaddrs_head);

    attribute = IFA_RTA(net_address);
    while (RTA_OK(attribute, length))
    {
        payload_size = RTA_PAYLOAD(attribute);
        sa = NULL;

        switch (attribute->rta_type)
        {
            case IFA_LABEL:
            {
                int room_for_trailing_null = 0;

                if (payload_size > MAX_IFA_LABEL_SIZE)
                {
                    payload_size = MAX_IFA_LABEL_SIZE;
                    room_for_trailing_null = 1;
                }

                if (payload_size > 0)
                {
                    ifa->ifa_name = (char*)malloc(payload_size + room_for_trailing_null);
                    if (!ifa->ifa_name)
                    {
                        goto error;
                    }

                    memcpy(ifa->ifa_name, RTA_DATA(attribute), payload_size);
                    if (room_for_trailing_null)
                        ifa->ifa_name[payload_size] = '\0';
                }
                break;
            }

            case IFA_LOCAL:
                if (ifa->ifa_addr)
                {
                    /* P2P protocol, set the dst/broadcast address union from the original address.
                     * Since ifa_addr is set it means IFA_ADDRESST occured earlier and that address
                     * is indeed the P2P destination one.
                     */
                    ifa->_monodroid_ifa_dstaddr = ifa->ifa_addr;
                    ifa->ifa_addr = 0;
                }
                sa = &ifa->ifa_addr;
                break;

            case IFA_BROADCAST:
                if (ifa->_monodroid_ifa_dstaddr)
                {
                    /* IFA_LOCAL happened earlier, undo its effect here */
                    free(ifa->_monodroid_ifa_dstaddr);
                    ifa->_monodroid_ifa_dstaddr = NULL;
                }
                sa = &ifa->_monodroid_ifa_broadaddr;
                break;

            case IFA_ADDRESS:
                if (ifa->ifa_addr)
                {
                    /* Apparently IFA_LOCAL occured earlier and we have a P2P connection
                     * here. IFA_LOCAL carries the destination address, move it there
                     */
                    ifa->_monodroid_ifa_dstaddr = ifa->ifa_addr;
                    ifa->ifa_addr = NULL;
                }
                sa = &ifa->ifa_addr;
                break;
        }

        if (sa)
        {
            if (fill_sa_address(sa, net_address, RTA_DATA(attribute), RTA_PAYLOAD(attribute)) < 0)
            {
                goto error;
            }
        }

        attribute = RTA_NEXT(attribute, length);
    }

    /* glibc stores the associated interface name in the address if IFA_LABEL never occured */
    if (!ifa->ifa_name)
    {
        char *name = get_interface_name_by_index(net_address->ifa_index, ifaddrs_head);
        log_debug(LOG_NETLINK, "   address has no name/label, getting one from interface\n");
        ifa->ifa_name = name ? strdup(name) : NULL;
    }
    log_debug(LOG_NETLINK, "   address label: %s\n", ifa->ifa_name);

    if (calculate_address_netmask(ifa, net_address) < 0)
    {
        goto error;
    }

    return ifa;

    error :
    {
        /* errno may be modified by free, or any other call inside the free_single_xamarin_ifaddrs
         * function. We don't care about errors in there since it is more important to know how we
         * failed to obtain the link address and not that we went OOM. Save and restore the value
         * after the resources are freed.
         */
        int errno_save = errno;
        free_single_xamarin_ifaddrs(&ifa);
        errno = errno_save;
        return NULL;
    }
}

static struct _monodroid_ifaddrs *
get_link_info(const struct nlmsghdr *message)
{
    ssize_t length;
    struct rtattr *attribute;
    struct ifinfomsg *net_interface;
    struct _monodroid_ifaddrs *ifa = NULL;
    struct sockaddr_ll_extended *sa = NULL;

    assert(message);
    net_interface = NLMSG_DATA(message);
    length = message->nlmsg_len - NLMSG_LENGTH(sizeof(*net_interface));
    if (length <= 0)
    {
        goto error;
    }

    ifa = calloc(1, sizeof(*ifa));
    if (!ifa)
    {
        goto error;
    }

    ifa->ifa_flags = net_interface->ifi_flags;
    attribute = IFLA_RTA(net_interface);
    while (RTA_OK(attribute, length))
    {
        switch (attribute->rta_type)
        {
            case IFLA_IFNAME:
                ifa->ifa_name = strdup(RTA_DATA(attribute));
                if (!ifa->ifa_name)
                {
                    goto error;
                }
                log_debug(LOG_NETLINK, "   interface name (payload length: %d; string length: %d)\n", RTA_PAYLOAD(attribute), strlen(ifa->ifa_name));
                log_debug(LOG_NETLINK, "     %s\n", ifa->ifa_name);
                break;

            case IFLA_BROADCAST:
                log_debug(LOG_NETLINK, "   interface broadcast (%d bytes)\n", RTA_PAYLOAD(attribute));
                if (fill_ll_address(&sa, net_interface, RTA_DATA(attribute), RTA_PAYLOAD(attribute)) < 0)
                {
                    goto error;
                }
                ifa->_monodroid_ifa_broadaddr = (struct sockaddr*)sa;
                break;

            case IFLA_ADDRESS:
                log_debug(LOG_NETLINK, "   interface address (%d bytes)\n", RTA_PAYLOAD(attribute));
                if (fill_ll_address(&sa, net_interface, RTA_DATA(attribute), RTA_PAYLOAD(attribute)) < 0)
                {
                    goto error;
                }
                ifa->ifa_addr = (struct sockaddr*)sa;
                break;

            default:
                log_debug(LOG_NETLINK, "     rta_type: ");
#if DEBUG
                print_ifla_name(attribute->rta_type);
#endif
                break;
        }

        attribute = RTA_NEXT(attribute, length);
    }
    log_debug(LOG_NETLINK, "link flags: 0x%X", ifa->ifa_flags);
    return ifa;

error:
    if (sa)
        free(sa);
    free_single_xamarin_ifaddrs(&ifa);

    return NULL;
}

#else
void
_monodroid_getifaddrs_init(void)
{
}

int
_monodroid_getifaddrs(struct _monodroid_ifaddrs **ifap)
{
    *ifap = NULL;
    return 0;
}

void _monodroid_freeifaddrs(struct _monodroid_ifaddrs *ifa)
{
}

#endif

#if LINUX && DEBUG
#define ENUM_VALUE_ENTRY(enumvalue) { enumvalue, #enumvalue }
struct enumvalue
{
    int   value;
    char *name;
};

struct enumvalue iflas[] = {
    ENUM_VALUE_ENTRY(IFLA_UNSPEC),
    ENUM_VALUE_ENTRY(IFLA_ADDRESS),
    ENUM_VALUE_ENTRY(IFLA_BROADCAST),
    ENUM_VALUE_ENTRY(IFLA_IFNAME),
    ENUM_VALUE_ENTRY(IFLA_MTU),
    ENUM_VALUE_ENTRY(IFLA_LINK),
    ENUM_VALUE_ENTRY(IFLA_QDISC),
    ENUM_VALUE_ENTRY(IFLA_STATS),
    ENUM_VALUE_ENTRY(IFLA_COST),
    ENUM_VALUE_ENTRY(IFLA_PRIORITY),
    ENUM_VALUE_ENTRY(IFLA_MASTER),
    ENUM_VALUE_ENTRY(IFLA_WIRELESS),
    ENUM_VALUE_ENTRY(IFLA_PROTINFO),
    ENUM_VALUE_ENTRY(IFLA_TXQLEN),
    ENUM_VALUE_ENTRY(IFLA_MAP),
    ENUM_VALUE_ENTRY(IFLA_WEIGHT),
    ENUM_VALUE_ENTRY(IFLA_OPERSTATE),
    ENUM_VALUE_ENTRY(IFLA_LINKMODE),
    ENUM_VALUE_ENTRY(IFLA_LINKINFO),
    ENUM_VALUE_ENTRY(IFLA_NET_NS_PID),
    ENUM_VALUE_ENTRY(IFLA_IFALIAS),
    ENUM_VALUE_ENTRY(IFLA_NUM_VF),
    ENUM_VALUE_ENTRY(IFLA_VFINFO_LIST),
    ENUM_VALUE_ENTRY(IFLA_STATS64),
    ENUM_VALUE_ENTRY(IFLA_VF_PORTS),
    ENUM_VALUE_ENTRY(IFLA_PORT_SELF),
    ENUM_VALUE_ENTRY(IFLA_AF_SPEC),
    ENUM_VALUE_ENTRY(IFLA_GROUP),
    ENUM_VALUE_ENTRY(IFLA_NET_NS_FD),
    ENUM_VALUE_ENTRY(IFLA_EXT_MASK),
    ENUM_VALUE_ENTRY(IFLA_PROMISCUITY),
    ENUM_VALUE_ENTRY(IFLA_NUM_TX_QUEUES),
    ENUM_VALUE_ENTRY(IFLA_NUM_RX_QUEUES),
    ENUM_VALUE_ENTRY(IFLA_CARRIER),
    ENUM_VALUE_ENTRY(IFLA_PHYS_PORT_ID),
    { -1, 0 }
};

static void
print_ifla_name(int id)
{
    int i = 0;
    while (1)
    {
        if (iflas[i].value == -1 && iflas[i].name == 0)
        {
            log_info(LOG_NETLINK, "Unknown ifla->name: unknown id %d\n", id);
            break;
        }

        if (iflas[i].value != id)
        {
            i++;
            continue;
        }
        log_info(LOG_NETLINK, "ifla->name: %s (%d)\n", iflas[i].name, iflas[i].value);
        break;
    }
}

static void
print_address_list(char *title, struct _monodroid_ifaddrs *list)
{
    struct _monodroid_ifaddrs *cur;
    char *msg, *tmp;

    if (!list)
    {
        log_info(LOG_NETLINK, "monodroid-net", "No list to print in %s", __FUNCTION__);
        return;
    }

    cur = list;
    msg = NULL;
    while (cur)
    {
        tmp = NULL;
        asprintf(&tmp, "%s%s%p (%s; %p)", msg ? msg : "", msg ? " -> " : "", cur, cur->ifa_name, cur->ifa_name);
        if (msg)
            free(msg);
        msg = tmp;
        cur = cur->ifa_next;
    }

    log_info(LOG_NETLINK, "%s: %s", title, msg ? msg : "[no addresses]");
    free(msg);
}

#endif