third_party/ulib/musl/src/network/if_nameindex.c

#define _GNU_SOURCE
#include "netlink.h"
#include <errno.h>
#include <net/if.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.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;

    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:
    free(ctx->list);
    errno = ENOBUFS;
    return ifs;
}