mmutils.h

/*
 * Copyright 2024 Morse Micro
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#pragma once
 
#include <stdarg.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define MM_MIN(_x, _y) (((_x) < (_y)) ? (_x) : (_y))
 
#define MM_MAX(_x, _y) (((_x) > (_y)) ? (_x) : (_y))
 
#ifndef MM_FAST_ROUND_UP
#define MM_FAST_ROUND_UP(x, m) ((((x) - 1) | ((m) - 1)) + 1)
#endif
 
#define MM_UNUSED(_x) (void)(_x)
 
#ifndef MM_PACKED
#define MM_PACKED __attribute__((packed))
#endif
 
#ifndef MM_WEAK
#define MM_WEAK __attribute__((weak))
#endif
 
#ifndef MM_FALLTHROUGH
#define MM_FALLTHROUGH __attribute__((fallthrough))
#endif
 
#ifndef MM_STATIC_ASSERT
#define MM_STATIC_ASSERT(_expression, _message) _Static_assert((_expression), _message)
#endif
 
#define MM_ARRAY_COUNT(_a) (sizeof(_a) / sizeof((_a)[0]))
 
#define MM_MEMBER_SIZE(_type, _member) (sizeof(((_type *)0)->_member))
 
static inline char mm_nibble_to_hex_char(uint8_t nibble)
{
    nibble &= 0x0f;
    if (nibble < 0x0a)
    {
        return '0' + nibble;
    }
    else
    {
        return 'A' + nibble - 0x0a;
    }
}
 
enum mm_akm_suite_oui
{
    MM_AKM_SUITE_NONE  = 0,
    MM_AKM_SUITE_PSK   = 0x506f9a02,
    MM_AKM_SUITE_SAE   = 0x000fac08,
    MM_AKM_SUITE_OWE   = 0x000fac12,
    MM_AKM_SUITE_OTHER = 1,
};
 
enum mm_cipher_suite_oui
{
    MM_CIPHER_SUITE_AES_CCM = 0x000fac04,
    MM_CIPHER_SUITE_OTHER   = 1,
};
 
#ifndef MM_RSN_INFORMATION_MAX_PAIRWISE_CIPHER_SUITES
#define MM_RSN_INFORMATION_MAX_PAIRWISE_CIPHER_SUITES   (2)
#endif
 
#ifndef MM_RSN_INFORMATION_MAX_AKM_SUITES
#define MM_RSN_INFORMATION_MAX_AKM_SUITES               (2)
#endif
 
#define MM_RSN_INFORMATION_IE_TYPE                      (48)
#define MM_VENDOR_SPECIFIC_IE_TYPE                      (221)
#define MM_S1G_OPERATION_IE_TYPE                        (232)
 
enum mm_errno
{
    MM_ENOMEM    = 12,
    MM_EFAULT    = 14,
    MM_ENODEV    = 19,
    MM_EINVAL    = 22,
    MM_ETIMEDOUT = 110,
};
 
struct mm_rsn_information
{
    uint32_t group_cipher_suite;
    uint32_t pairwise_cipher_suites[MM_RSN_INFORMATION_MAX_PAIRWISE_CIPHER_SUITES];
    uint32_t akm_suites[MM_RSN_INFORMATION_MAX_AKM_SUITES];
    uint16_t num_pairwise_cipher_suites;
    uint16_t num_akm_suites;
    uint16_t version;
    uint16_t rsn_capabilities;
};
 
const char *mm_akm_suite_to_string(uint32_t akm_suite_oui);
 
int mm_find_ie_from_offset(const uint8_t *ies, uint32_t ies_len,
                           uint32_t search_offset, uint8_t ie_type);
 
static inline int mm_find_ie(const uint8_t *ies, uint32_t ies_len, uint8_t ie_type)
{
    return mm_find_ie_from_offset(ies, ies_len, 0, ie_type);
}
 
int mm_find_vendor_specific_ie_from_offset(const uint8_t *ies, uint32_t ies_len,
                                           uint32_t search_offset,
                                           const uint8_t *id, size_t id_len);
 
static inline int mm_find_vendor_specific_ie(const uint8_t *ies, uint32_t ies_len,
                                             const uint8_t *id, size_t id_len)
{
    return mm_find_vendor_specific_ie_from_offset(ies, ies_len, 0, id, id_len);
}
 
int mm_parse_rsn_information(const uint8_t *ies, uint32_t ies_len,
                             struct mm_rsn_information *output);
 
struct mm_s1g_operation
{
    uint8_t operating_class;
    uint8_t operating_channel_width_mhz;
    uint8_t primary_channel_width_mhz;
    uint8_t operating_channel_number;
    uint8_t primary_channel_number;
};
 
int mm_parse_s1g_operation(const uint8_t *ies, uint32_t ies_len,
                           struct mm_s1g_operation *output);
 
static inline bool mm_mac_addr_is_zero(const uint8_t *mac_addr)
{
    return (mac_addr[0] | mac_addr[1] | mac_addr[2] |
            mac_addr[3] | mac_addr[4] | mac_addr[5]) == 0x00;
}
 
#ifdef __cplusplus
}
#endif