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_ALWAYS_INLINE
#define MM_ALWAYS_INLINE __attribute__((always_inline))
#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);
 
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;
}
 
static inline bool mm_mac_addr_is_multicast(const uint8_t *mac_addr)
{
    return mac_addr[0] & 0x01;
}
 
inline bool mm_mac_addr_is_broadcast(const uint8_t *mac_addr)
{
    return (mac_addr[0] & mac_addr[1] & mac_addr[2] & mac_addr[3] & mac_addr[4] & mac_addr[5]) ==
           0xff;
}
 
static inline bool mm_mac_addr_is_equal(const uint8_t *mac_addr1, const uint8_t *mac_addr2)
{
    return memcmp(mac_addr1, mac_addr2, 6) == 0;
}
 
#ifdef __cplusplus
}
#endif