DAWN/src/utils/dawn_uci.c

#include <uci.h>
#include <stdlib.h>
#include <datastorage.h>

#include "dawn_uci.h"


static struct uci_context *uci_ctx;
static struct uci_package *uci_pkg;

// why is this not included in uci lib...?!
// fund here: https://github.com/br101/pingcheck/blob/master/uci.c
static int uci_lookup_option_int(struct uci_context *uci, struct uci_section *s,
                                 const char *name)
{
    const char* str = uci_lookup_option_string(uci, s, name);
    return str == NULL ? -1 : atoi(str);
}

struct time_config_s uci_get_time_config() {
    struct time_config_s ret;

    printf("Loading Times!");

    struct uci_element *e;
    uci_foreach_element(&uci_pkg->sections, e) {
        struct uci_section *s = uci_to_section(e);

        if (strcmp(s->type, "times") == 0)
        {
            ret.update_client = uci_lookup_option_int(uci_ctx, s, "update_client");
            ret.remove_client = uci_lookup_option_int(uci_ctx, s, "remove_client");
            ret.remove_probe = uci_lookup_option_int(uci_ctx, s, "remove_probe");
            ret.update_hostapd = uci_lookup_option_int(uci_ctx, s, "update_hostapd");
            ret.remove_ap = uci_lookup_option_int(uci_ctx, s, "remove_ap");
            return ret;
        }
    }

    return ret;
}

struct probe_metric_s uci_get_dawn_metric() {
    struct probe_metric_s ret;

    struct uci_element *e;
    uci_foreach_element(&uci_pkg->sections, e) {
        struct uci_section *s = uci_to_section(e);

        if (strcmp(s->type, "metric") == 0)
        {
            ret.ht_support = uci_lookup_option_int(uci_ctx, s, "ht_support");
            ret.vht_support = uci_lookup_option_int(uci_ctx, s, "vht_support");
            ret.no_ht_support = uci_lookup_option_int(uci_ctx, s, "no_ht_support");
            ret.no_vht_support = uci_lookup_option_int(uci_ctx, s, "no_vht_support");
            ret.rssi = uci_lookup_option_int(uci_ctx, s, "rssi");
            ret.freq = uci_lookup_option_int(uci_ctx, s, "freq");
            ret.rssi_val = uci_lookup_option_int(uci_ctx, s, "rssi_val");
            ret.chan_util = uci_lookup_option_int(uci_ctx, s, "chan_util");
            ret.max_chan_util = uci_lookup_option_int(uci_ctx, s, "max_chan_util");
            ret.chan_util_val = uci_lookup_option_int(uci_ctx, s, "chan_util_val");
            ret.max_chan_util_val = uci_lookup_option_int(uci_ctx, s, "max_chan_util_val");
            ret.min_probe_count = uci_lookup_option_int(uci_ctx, s, "min_probe_count");
            ret.low_rssi = uci_lookup_option_int(uci_ctx, s, "low_rssi");
            ret.low_rssi_val = uci_lookup_option_int(uci_ctx, s, "low_rssi_val");
            ret.bandwith_threshold = uci_lookup_option_int(uci_ctx, s, "bandwith_threshold");
            ret.use_station_count = uci_lookup_option_int(uci_ctx, s, "use_station_count");
            ret.eval_probe_req = uci_lookup_option_int(uci_ctx, s, "eval_probe_req");
            return ret;
        }
    }

    return ret;
}

struct network_config_s uci_get_dawn_network() {
    struct network_config_s ret;

    struct uci_element *e;
    uci_foreach_element(&uci_pkg->sections, e) {
        struct uci_section *s = uci_to_section(e);

        if (strcmp(s->type, "network") == 0)
        {
            printf("Fronund network entry!\n");
            ret.broadcast_ip = uci_lookup_option_string(uci_ctx, s, "broadcast_ip");
            printf("BROADCAST: %s\n", ret.broadcast_ip);
            ret.broadcast_port = uci_lookup_option_int(uci_ctx, s, "broadcast_port");
            ret.bool_multicast = uci_lookup_option_int(uci_ctx, s, "multicast");
            printf("multicast: %s\n", ret.broadcast_ip);
            ret.shared_key = uci_lookup_option_string(uci_ctx, s, "shared_key");
            ret.iv = uci_lookup_option_string(uci_ctx, s, "iv");
            return ret;
        }
    }

    return ret;
}
const char* uci_get_dawn_hostapd_dir() {
    struct uci_element *e;
    uci_foreach_element(&uci_pkg->sections, e)
    {
        struct uci_section *s = uci_to_section(e);

        if (strcmp(s->type, "hostapd") == 0) {
            return uci_lookup_option_string(uci_ctx, s, "hostapd_dir");
        }
    }
    return NULL;
}

const char* uci_get_dawn_sort_order() {
    struct uci_element *e;
    uci_foreach_element(&uci_pkg->sections, e) {
        struct uci_section *s = uci_to_section(e);

        if (strcmp(s->type, "ordering") == 0)
        {
            return uci_lookup_option_string(uci_ctx, s, "sort_order");
        }
    }
    return NULL;
}

int uci_init()
{
    struct uci_context *ctx = uci_ctx;

    if (!ctx) {
        ctx = uci_alloc_context();
        uci_ctx = ctx;

        ctx->flags &= ~UCI_FLAG_STRICT;
    } else {
        // shouldn't happen?
        uci_pkg = uci_lookup_package(ctx, "dawn");
        if (uci_pkg)
            uci_unload(ctx, uci_pkg);
    }

    if (uci_load(ctx, "dawn", &uci_pkg))
        return -1;

    return 1;
}

int uci_clear()
{
    if(uci_pkg != NULL)
    {
        uci_unload(uci_ctx, uci_pkg);
    }
    if(uci_ctx != NULL)
    {
        uci_free_context(uci_ctx);
    }
    return 1;
}