source: azure_iot_hub/trunk/musl-1.1.18/src/network/if_nameindex.c@ 389

#define _GNU_SOURCE
#include <net/if.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include "netlink.h"

#define IFADDRS_HASH_SIZE 64

struct ifnamemap {
        unsigned int hash_next;
        unsigned int index;
        unsigned char namelen;
        char name[IFNAMSIZ];
};

struct ifnameindexctx {
        unsigned int num, allocated, str_bytes;
        struct ifnamemap *list;
        unsigned int hash[IFADDRS_HASH_SIZE];
};

static int netlink_msg_to_nameindex(void *pctx, struct nlmsghdr *h)
{
        struct ifnameindexctx *ctx = pctx;
        struct ifnamemap *map;
        struct rtattr *rta;
        unsigned int i;
        int index, type, namelen, bucket;

        if (h->nlmsg_type == RTM_NEWLINK) {
                struct ifinfomsg *ifi = NLMSG_DATA(h);
                index = ifi->ifi_index;
                type = IFLA_IFNAME;
                rta = NLMSG_RTA(h, sizeof(*ifi));
        } else {
                struct ifaddrmsg *ifa = NLMSG_DATA(h);
                index = ifa->ifa_index;
                type = IFA_LABEL;
                rta = NLMSG_RTA(h, sizeof(*ifa));
        }
        for (; NLMSG_RTAOK(rta, h); rta = RTA_NEXT(rta)) {
                if (rta->rta_type != type) continue;

                namelen = RTA_DATALEN(rta) - 1;
                if (namelen > IFNAMSIZ) return 0;

                /* suppress duplicates */
                bucket = index % IFADDRS_HASH_SIZE;
                i = ctx->hash[bucket];
                while (i) {
                        map = &ctx->list[i-1];
                        if (map->index == index &&
                            map->namelen == namelen &&
                            memcmp(map->name, RTA_DATA(rta), namelen) == 0)
                                return 0;
                        i = map->hash_next;
                }

                if (ctx->num >= ctx->allocated) {
                        size_t a = ctx->allocated ? ctx->allocated * 2 + 1 : 8;
                        if (a > SIZE_MAX/sizeof *map) return -1;
                        map = realloc(ctx->list, a * sizeof *map);
                        if (!map) return -1;
                        ctx->list = map;
                        ctx->allocated = a;
                }
                map = &ctx->list[ctx->num];
                map->index = index;
                map->namelen = namelen;
                memcpy(map->name, RTA_DATA(rta), namelen);
                ctx->str_bytes += namelen + 1;
                ctx->num++;
                map->hash_next = ctx->hash[bucket];
                ctx->hash[bucket] = ctx->num;
                return 0;
        }
        return 0;
}

struct if_nameindex *if_nameindex()
{
        struct ifnameindexctx _ctx, *ctx = &_ctx;
        struct if_nameindex *ifs = 0, *d;
        struct ifnamemap *s;
        char *p;
        int i;
        int cs;

        pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
        memset(ctx, 0, sizeof(*ctx));
        if (__rtnetlink_enumerate(AF_UNSPEC, AF_INET, netlink_msg_to_nameindex, ctx) < 0) goto err;

        ifs = malloc(sizeof(struct if_nameindex[ctx->num+1]) + ctx->str_bytes);
        if (!ifs) goto err;

        p = (char*)(ifs + ctx->num + 1);
        for (i = ctx->num, d = ifs, s = ctx->list; i; i--, s++, d++) {
                d->if_index = s->index;
                d->if_name = p;
                memcpy(p, s->name, s->namelen);
                p += s->namelen;
                *p++ = 0;
        }
        d->if_index = 0;
        d->if_name = 0;
err:
        pthread_setcancelstate(cs, 0);
        free(ctx->list);
        errno = ENOBUFS;
        return ifs;
}