ap_mode.c

Go to the documentation of this file.

/*
 * Copyright 2025 Morse Micro
 *
 * This file is licensed under terms that can be found in the LICENSE.md file in the root
 * directory of the Morse Micro IoT SDK software package.
 */
 
#include <string.h>
#include "mmconfig.h"
#include "mmosal.h"
#include "mmutils.h"
#include "mm_app_common.h"
#include "mm_app_loadconfig.h"
 
/*
 * --
 * Default Network configuration
 * --
 */
 
#ifndef STATIC_LOCAL_IP
#define STATIC_LOCAL_IP "192.168.1.1"
#endif
#ifndef STATIC_GATEWAY
#define STATIC_GATEWAY "192.168.1.1"
#endif
#ifndef STATIC_NETMASK
#define STATIC_NETMASK "255.255.255.0"
#endif
 
/*
 * --
 * Default SSID/Security configuration
 * --
 */
 
#ifndef AP_SSID
#define AP_SSID MorseMicroIoT
#endif
 
#ifndef SAE_PASSPHRASE
#define SAE_PASSPHRASE 12345678
#endif
 
/* Default security type  */
#ifndef SECURITY_TYPE
#define SECURITY_TYPE MMWLAN_SAE
#endif
 
/* Default PMF mode */
#ifndef PMF_MODE
#define PMF_MODE MMWLAN_PMF_REQUIRED
#endif
 
/*
 * --
 * Default channel configuration
 * --
 */
 
#ifndef OP_CLASS
#define OP_CLASS (71) /* US, 8 MHz */
#endif
 
#ifndef S1G_CHANNEL
#define S1G_CHANNEL (44) /* US, 8 MHz */
#endif
 
#ifndef PRIMARY_BW_MHZ
#define PRIMARY_BW_MHZ (0)
#endif
 
#ifndef PRIMARY_1MHZ_CHANNEL_INDEX
#define PRIMARY_1MHZ_CHANNEL_INDEX (0)
#endif
 
#ifndef MAX_STAS
#define MAX_STAS MMWLAN_DEFAULT_AP_MAX_STAS
#endif
 
#define _STRINGIFY(x) #x
#define STRINGIFY(x) _STRINGIFY(x)
 
uint32_t opaque_argument_value;
 
static void handle_ap_sta_status(const struct mmwlan_ap_sta_status *sta_status, void *arg)
{
    MM_UNUSED(sta_status);
 
    /* Validate that the opaque argument received matches the value passed in. This is just for
     * testing purposes. */
    MMOSAL_ASSERT(arg == &opaque_argument_value);
 
    printf("STA status updated\n");
}
 
static void load_ap_mmipal_init_args(struct mmipal_init_args *args)
{
    /* Load default static IP in case we don't find the key */
    (void)mmosal_safer_strcpy(args->ip_addr, STATIC_LOCAL_IP, sizeof(args->ip_addr));
    (void)mmconfig_read_string("ip.ip_addr", args->ip_addr, sizeof(args->ip_addr));
 
    /* Load default netmask in case we don't find the key */
    (void)mmosal_safer_strcpy(args->netmask, STATIC_NETMASK, sizeof(args->netmask));
    (void)mmconfig_read_string("ip.netmask", args->netmask, sizeof(args->netmask));
 
    /* Load default gateway in case we don't find the key */
    (void)mmosal_safer_strcpy(args->gateway_addr, STATIC_GATEWAY, sizeof(args->gateway_addr));
    (void)mmconfig_read_string("ip.gateway", args->gateway_addr, sizeof(args->gateway_addr));
}
 
void load_mmwlan_ap_args(struct mmwlan_ap_args *ap_args)
{
    char strval[32];
    uint32_t uint32val;
 
    /* Load SSID */
    (void)mmosal_safer_strcpy((char *)ap_args->ssid, STRINGIFY(AP_SSID), sizeof(ap_args->ssid));
    (void)mmconfig_read_string("wlan.ssid", (char *)ap_args->ssid, sizeof(ap_args->ssid));
    ap_args->ssid_len = strlen((char *)ap_args->ssid);
 
    /* Load password */
    (void)mmosal_safer_strcpy(ap_args->passphrase,
                              STRINGIFY(SAE_PASSPHRASE),
                              sizeof(ap_args->passphrase));
    (void)mmconfig_read_string("wlan.password", ap_args->passphrase, sizeof(ap_args->passphrase));
    ap_args->passphrase_len = strlen(ap_args->passphrase);
 
    /* Load security type */
    ap_args->security_type = SECURITY_TYPE;
    if (mmconfig_read_string("wlan.security", strval, sizeof(strval)) > 0)
    {
        if (strncmp("sae", strval, sizeof(strval)) == 0)
        {
            ap_args->security_type = MMWLAN_SAE;
        }
        else if (strncmp("owe", strval, sizeof(strval)) == 0)
        {
            ap_args->security_type = MMWLAN_OWE;
        }
        else if (strncmp("open", strval, sizeof(strval)) == 0)
        {
            ap_args->security_type = MMWLAN_OPEN;
        }
        else
        {
            printf("Invalid value of %s read from config store: %s\n", "wlan.security", strval);
        }
    }
 
    /* Load PMF mode */
    ap_args->pmf_mode = PMF_MODE;
    if (mmconfig_read_string("wlan.pmf_mode", strval, sizeof(strval)) > 0)
    {
        if (strncmp("disabled", strval, sizeof(strval)) == 0)
        {
            printf("PMF disabled\n");
            ap_args->pmf_mode = MMWLAN_PMF_DISABLED;
        }
        else if (strncmp("required", strval, sizeof(strval)) == 0)
        {
            ap_args->pmf_mode = MMWLAN_PMF_REQUIRED;
        }
        else
        {
            printf("Invalid value of %s read from config store: %s\n", "wlan.pmf_mode", strval);
        }
    }
 
    /* Load BSSID */
    if (mmconfig_read_string("wlan.bssid", strval, sizeof(strval)) > 0)
    {
        int temp[6];
        int i;
 
        int ret = sscanf(strval,
                         "%x:%x:%x:%x:%x:%x",
                         &temp[0],
                         &temp[1],
                         &temp[2],
                         &temp[3],
                         &temp[4],
                         &temp[5]);
        if (ret == 6)
        {
            for (i = 0; i < 6; i++)
            {
                if (temp[i] > UINT8_MAX || temp[i] < 0)
                {
                    /* Invalid value, ignore and reset to default */
                    memset(ap_args->bssid, 0, sizeof(ap_args->bssid));
                    break;
                }
 
                ap_args->bssid[i] = (uint8_t)temp[i];
            }
        }
    }
 
    ap_args->op_class = OP_CLASS;
    if (mmconfig_read_uint32("wlan.op_class", &uint32val) == MMCONFIG_OK)
    {
        if (uint32val <= UINT8_MAX)
        {
            ap_args->op_class = uint32val;
        }
        else
        {
            printf("%s out of range\n", "wlan.op_class");
        }
    }
 
    ap_args->s1g_chan_num = S1G_CHANNEL;
    if (mmconfig_read_uint32("wlan.s1g_chan_num", &uint32val) == MMCONFIG_OK)
    {
        if (uint32val <= UINT8_MAX)
        {
            ap_args->s1g_chan_num = uint32val;
        }
        else
        {
            printf("%s out of range\n", "wlan.s1g_chan_num");
        }
    }
 
    ap_args->pri_bw_mhz = PRIMARY_BW_MHZ;
    if (mmconfig_read_uint32("wlan.pri_bw_mhz", &uint32val) == MMCONFIG_OK)
    {
        if (uint32val <= UINT8_MAX)
        {
            ap_args->pri_bw_mhz = uint32val;
        }
        else
        {
            printf("%s out of range\n", "wlan.pri_bw_mhz");
        }
    }
 
    ap_args->pri_1mhz_chan_idx = PRIMARY_1MHZ_CHANNEL_INDEX;
    if (mmconfig_read_uint32("wlan.pri_1mhz_chan_idx", &uint32val) == MMCONFIG_OK)
    {
        if (uint32val <= UINT8_MAX)
        {
            ap_args->pri_1mhz_chan_idx = uint32val;
        }
        else
        {
            printf("%s out of range\n", "wlan.pri_1mhz_chan_idx");
        }
    }
}
 
static void load_mmwlan_settings_ap(void)
{
    int intval;
    uint32_t uintval;
    bool boolval;
 
    /* Apply subbands enabled if specified */
    if (mmconfig_read_bool("wlan.subbands_enabled", &boolval) == MMCONFIG_OK)
    {
        mmwlan_set_subbands_enabled(boolval);
    }
 
    /* Apply sgi enabled if specified */
    if (mmconfig_read_bool("wlan.sgi_enabled", &boolval) == MMCONFIG_OK)
    {
        mmwlan_set_sgi_enabled(boolval);
    }
 
    /* Apply ampdu enabled if specified */
    if (mmconfig_read_bool("wlan.ampdu_enabled", &boolval) == MMCONFIG_OK)
    {
        mmwlan_set_ampdu_enabled(boolval);
    }
 
    /* Apply fragment threshold if specified */
    if (mmconfig_read_int("wlan.fragment_threshold", &intval) == MMCONFIG_OK)
    {
        mmwlan_set_fragment_threshold(intval);
    }
 
    /* Apply rts threshold if specified */
    if (mmconfig_read_int("wlan.rts_threshold", &intval) == MMCONFIG_OK)
    {
        mmwlan_set_rts_threshold(intval);
    }
 
    /* Apply Health check intervals if specified */
    if (mmconfig_read_uint32("wlan.max_health_check_intvl_ms", &uintval) == MMCONFIG_OK)
    {
        /* If not specified, the minimum is 0 */
        uint32_t health_check_min = 0;
        mmconfig_read_uint32("wlan.min_health_check_intvl_ms", &health_check_min);
        mmwlan_set_health_check_interval(health_check_min, uintval);
    }
    else if (mmconfig_read_uint32("wlan.min_health_check_intvl_ms", &uintval) == MMCONFIG_OK)
    {
        /* If only minimum is specified, then treat the maximum as unbounded */
        mmwlan_set_health_check_interval(uintval, UINT32_MAX);
    }
}
 
static void link_status_callback(const struct mmipal_link_status *link_status)
{
    uint32_t time_ms = mmosal_get_time_ms();
    if (link_status->link_state == MMIPAL_LINK_UP)
    {
        printf("Link is up. Time: %lu ms", time_ms);
        printf(", IP: %s", link_status->ip_addr);
        printf(", Netmask: %s", link_status->netmask);
        printf(", Gateway: %s\n", link_status->gateway);
    }
    else
    {
        printf("Link is down. Time: %lu ms\n", time_ms);
    }
}
 
void app_init(void)
{
    printf("\n\nAP Mode Example (Built " __DATE__ " " __TIME__ ")\n\n");
    mmwlan_init();
    mmwlan_set_channel_list(load_channel_list());
    mmwlan_boot(NULL);
 
    app_print_version_info();
 
    /* Load IP stack settings from config store, or use defaults if no entry found in
     * config store. */
    struct mmipal_init_args mmipal_init_args = MMIPAL_INIT_ARGS_DEFAULT;
    mmipal_init_args.mode = MMIPAL_STATIC;
    mmipal_init_args.ip6_mode = MMIPAL_IP6_DISABLED;
    load_ap_mmipal_init_args(&mmipal_init_args);
 
    /* Initialize IP stack. */
    if (mmipal_init(&mmipal_init_args) != MMIPAL_SUCCESS)
    {
        printf("Error initializing network interface.\n");
        MMOSAL_ASSERT(false);
    }
 
    mmipal_set_link_status_callback(link_status_callback);
 
    mmwlan_set_power_save_mode(MMWLAN_PS_DISABLED);
    load_mmwlan_settings_ap();
 
    struct mmwlan_ap_args ap_args = MMWLAN_AP_ARGS_INIT;
    load_mmwlan_ap_args(&ap_args);
 
    ap_args.sta_status_cb = handle_ap_sta_status;
    ap_args.sta_status_cb_arg = &opaque_argument_value;
 
    ap_args.max_stas = MAX_STAS;
 
    enum mmwlan_status status = mmwlan_ap_enable(&ap_args);
    if (status == MMWLAN_SUCCESS)
    {
        printf("AP started successfully\n");
    }
    else
    {
        printf("Failed to start AP (status %d)\n", status);
    }
}