path: root/epan/manuf.c

/* manuf.c
 *
 * Wireshark - Network traffic analyzer
 * By Gerald Combs <gerald@wireshark.org>
 * Copyright 1998 Gerald Combs
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */

#include "manuf.h"
#include <stdlib.h>

// MA-L / OUI - MAC Address Block Large (24-bit prefix)
#define MA_L 0
// MA-M - MAC Address Block Medium (28-bit prefix)
#define MA_M 1
// MA-S / OUI-36 - MAC Address Block Small (36-bit prefix)
#define MA_S 2

typedef struct {
    uint8_t oui24[3];
    /* Identifies the 3-byte prefix as part of MA-M or MA-S (or MA-L if none of those). */
    uint8_t kind;
} manuf_registry_t;

typedef struct {
    uint8_t oui24[3];
    const char *short_name;
    const char *long_name;
} manuf_oui24_t;

typedef struct {
    uint8_t oui28[4];
    const char *short_name;
    const char *long_name;
} manuf_oui28_t;

typedef struct {
    uint8_t oui36[5];
    const char *short_name;
    const char *long_name;
} manuf_oui36_t;

#include "manuf-data.c"

static int
compare_oui24_registry(const void *key, const void *element)
{
    const uint8_t *addr = (const uint8_t *)key;
    const manuf_registry_t *entry = (const manuf_registry_t *)element;

    return memcmp(addr, entry->oui24, 3);
}

static int
compare_oui24_entry(const void *key, const void *element)
{
    const uint8_t *addr = (const uint8_t *)key;
    const manuf_oui24_t *oui = (const manuf_oui24_t *)element;

    return memcmp(addr, oui->oui24, 3);
}

static int
compare_oui28_entry(const void *key, const void *element)
{
    const uint8_t *addr = (const uint8_t *)key;
    const manuf_oui28_t *oui = (const manuf_oui28_t *)element;

    // The caller is expected to have masked out (addr[3] & 0xF0).
    return memcmp(addr, oui->oui28, 4);
}

static int
compare_oui36_entry(const void *key, const void *element)
{
    const uint8_t *addr = (const uint8_t *)key;
    const manuf_oui36_t *oui = (const manuf_oui36_t *)element;

    // The caller is expected to have masked out (addr[4] & 0xF0).
    return memcmp(addr, oui->oui36, 5);
}

static int
select_registry(const uint8_t addr[6])
{
    const manuf_registry_t *entry;

    entry = bsearch(addr, ieee_registry_table, G_N_ELEMENTS(ieee_registry_table), sizeof(manuf_registry_t), compare_oui24_registry);
    if (entry)
        return entry->kind;
    return MA_L;
}

static const manuf_oui24_t *
manuf_oui24_lookup(const uint8_t addr[6])
{
    return bsearch(addr, global_manuf_oui24_table,
                    G_N_ELEMENTS(global_manuf_oui24_table),
                    sizeof(manuf_oui24_t),
                    compare_oui24_entry);
}

static const manuf_oui28_t *
manuf_oui28_lookup(const uint8_t addr[6])
{
    const uint8_t addr28[6] = { addr[0], addr[1], addr[2], addr[3] & 0xF0, };
    return bsearch(addr28, global_manuf_oui28_table,
                    G_N_ELEMENTS(global_manuf_oui28_table),
                    sizeof(manuf_oui28_t),
                    compare_oui28_entry);
}

static const manuf_oui36_t *
manuf_oui36_lookup(const uint8_t addr[6])
{
    const uint8_t addr36[6] = { addr[0], addr[1], addr[2], addr[3], addr[4] & 0xF0, };
    return bsearch(addr36, global_manuf_oui36_table,
                    G_N_ELEMENTS(global_manuf_oui36_table),
                    sizeof(manuf_oui36_t),
                    compare_oui36_entry);
}

const char *
ws_manuf_lookup(const uint8_t addr[6], const char **long_name_ptr, unsigned *mask_ptr)
{
    uint8_t addr_copy[6];
    memcpy(addr_copy, addr, 6);
    /* Mask out the broadcast/multicast flag */
    addr_copy[0] &= 0xFE;

    const char *short_name = NULL, *long_name = NULL;
    unsigned mask = 0;

    switch (select_registry(addr_copy)) {
        case MA_L:
        {
            const manuf_oui24_t *ptr = manuf_oui24_lookup(addr_copy);
            if (ptr) {
                short_name = ptr->short_name;
                long_name = ptr->long_name;
                mask = 24;
            }
            break;
        }
        case MA_M:
        {
            const manuf_oui28_t *ptr = manuf_oui28_lookup(addr_copy);
            if (ptr) {
                short_name = ptr->short_name;
                long_name = ptr->long_name;
                mask = 28;
            }
            break;
        }
        case MA_S:
        {
            const manuf_oui36_t *ptr = manuf_oui36_lookup(addr_copy);
            if (ptr) {
                short_name = ptr->short_name;
                long_name = ptr->long_name;
                mask = 36;
            }
            break;
        }
        default:
            ws_assert_not_reached();
    }

    if (mask_ptr) {
        *mask_ptr = mask;
    }
    if (long_name_ptr) {
        *long_name_ptr = long_name;
    }
    return short_name;
}

const char *
ws_manuf_lookup_str(const uint8_t addr[6], const char **long_name_ptr)
{
    return ws_manuf_lookup(addr, long_name_ptr, NULL);
}

const char *
ws_manuf_lookup_oui24(const uint8_t oui[3], const char **long_name_ptr)
{
    uint8_t addr_copy[6] = {0};
    memcpy(addr_copy, oui, 3);
    /* Mask out the broadcast/multicast flag */
    addr_copy[0] &= 0xFE;

    const char *short_name = NULL, *long_name = NULL;

    switch (select_registry(addr_copy)) {
        case MA_L:
        {
            const manuf_oui24_t *ptr = manuf_oui24_lookup(addr_copy);
            if (ptr) {
                short_name = ptr->short_name;
                long_name = ptr->long_name;
            }
            break;
        }
        case MA_M:
        case MA_S:
        {
            /* XXX: These are officially registered to
             * "IEEE Registration Authority" and we could return that, but
             * we'd have to change expectatins elsewhere in the code.
             */
            break;
        }
        default:
            ws_assert_not_reached();
    }

    if (long_name_ptr) {
        *long_name_ptr = long_name;
    }
    return short_name;
}

static inline struct ws_manuf *
copy_oui24(struct ws_manuf *dst, const manuf_oui24_t *src)
{
    memcpy(dst->block, src->oui24, sizeof(src->oui24));
    dst->block[3] = 0;
    dst->block[4] = 0;
    dst->mask = 24;
    dst->short_name = src->short_name;
    dst->long_name = src->long_name;
    return dst;
}

static inline struct ws_manuf *
copy_oui28(struct ws_manuf *dst, const manuf_oui28_t *src)
{
    memcpy(dst->block, src->oui28, sizeof(src->oui28));
    dst->block[4] = 0;
    dst->mask = 28;
    dst->short_name = src->short_name;
    dst->long_name = src->long_name;
    return dst;
}

static inline struct ws_manuf *
copy_oui36(struct ws_manuf *dst, const manuf_oui36_t *src)
{
    memcpy(dst->block, src->oui36, sizeof(src->oui36));
    dst->mask = 36;
    dst->short_name = src->short_name;
    dst->long_name = src->long_name;
    return dst;
}

void
ws_manuf_iter_init(ws_manuf_iter_t *iter)
{
    iter->idx24 = 0;
    copy_oui24(&iter->buf24, &global_manuf_oui24_table[iter->idx24]);
    iter->idx28 = 0;
    copy_oui28(&iter->buf28, &global_manuf_oui28_table[iter->idx28]);
    iter->idx36 = 0;
    copy_oui36(&iter->buf36, &global_manuf_oui36_table[iter->idx36]);
}

/**
 * Iterate between 3 registries in ascending order. This is not the same as
 * fully iterating through one registry followed by another. For example, after
 * visiting "00:55:B1", it could go to  "00:55:DA:00/28", and eventually end up
 * at "00:56:2B" again.
 *
 * The "iter" structure must be zero initialized before the first iteration.
 */
bool
ws_manuf_iter_next(ws_manuf_iter_t *iter, struct ws_manuf *result)
{
    struct ws_manuf *vector[3] = { NULL, NULL, NULL };
    size_t idx = 0;
    struct ws_manuf *ptr;

    /* Read current positions. */
    if (iter->idx24 < G_N_ELEMENTS(global_manuf_oui24_table)) {
        vector[idx++] = &iter->buf24;
    }
    if (iter->idx28 < G_N_ELEMENTS(global_manuf_oui28_table)) {
        vector[idx++] = &iter->buf28;
    }
    if (iter->idx36 < G_N_ELEMENTS(global_manuf_oui36_table)) {
        vector[idx++] = &iter->buf36;
    }

    /* None remaining, we're done. */
    if (idx == 0)
        return false;

    /* Select smallest current prefix out of the 3 registries.
     * There is at least one entry and index 0 is non-empty. */
    ptr = vector[0];
    for (size_t i = 1; i < idx; i++) {
        if (vector[i] && memcmp(vector[i]->block, ptr->block, MANUF_BLOCK_SIZE) < 0) {
            ptr = vector[i];
        }
    }

    /* We have the next smallest element, return result. */
    memcpy(result, ptr, sizeof(struct ws_manuf));

    /* Advance iterator and copy new element. */
    if (ptr->mask == 24) {
        iter->idx24++;
        if (iter->idx24 < G_N_ELEMENTS(global_manuf_oui24_table)) {
            copy_oui24(&iter->buf24, &global_manuf_oui24_table[iter->idx24]);
        }
    }
    else if (ptr->mask == 28) {
        iter->idx28++;
        if (iter->idx28 < G_N_ELEMENTS(global_manuf_oui28_table)) {
            copy_oui28(&iter->buf28, &global_manuf_oui28_table[iter->idx28]);
        }
    }
    else if (ptr->mask == 36) {
        iter->idx36++;
        if (iter->idx36 < G_N_ELEMENTS(global_manuf_oui36_table)) {
            copy_oui36(&iter->buf36, &global_manuf_oui36_table[iter->idx36]);
        }
    }
    else
        ws_assert_not_reached();

    return true;
}

const char *
ws_manuf_block_str(char *buf, size_t buf_size, const struct ws_manuf *ptr)
{
    if (ptr->mask == 24) {
        /* The mask is implied as the full 24 bits when printing a traditional OUI.*/
        snprintf(buf, buf_size, "%02"PRIX8":%02"PRIX8":%02"PRIX8,
            ptr->block[0], ptr->block[1], ptr->block[2]);
    }
    else if (ptr->mask == 28) {
        snprintf(buf, buf_size, "%02"PRIX8":%02"PRIX8":%02"PRIX8":%02"PRIX8"/28",
            ptr->block[0], ptr->block[1], ptr->block[2], ptr->block[3]);
    }
    else if (ptr->mask == 36) {
        snprintf(buf, buf_size, "%02"PRIX8":%02"PRIX8":%02"PRIX8":%02"PRIX8":%02"PRIX8"/36",
            ptr->block[0], ptr->block[1], ptr->block[2], ptr->block[3], ptr->block[4]);
    }
    else {
        ws_assert_not_reached();
    }

    return buf;
}

void
ws_manuf_dump(FILE *fp)
{
    ws_manuf_iter_t iter;
    struct ws_manuf item;
    char strbuf[64];

    ws_manuf_iter_init(&iter);

    while (ws_manuf_iter_next(&iter, &item)) {
        fprintf(fp, "%-17s\t%-12s\t%s\n",
            ws_manuf_block_str(strbuf, sizeof(strbuf), &item),
            item.short_name,
            item.long_name);
    }
}

size_t
ws_manuf_count(void)
{
    return G_N_ELEMENTS(global_manuf_oui24_table) +
            G_N_ELEMENTS(global_manuf_oui28_table) +
            G_N_ELEMENTS(global_manuf_oui36_table);
}