tools/helper/utils.c

#include "utils.h"
#include "common.h"
#include <rawrtc.h>
#include <rawrtcc.h>
#include <rawrtcdc.h>
#include <re.h>
#include <limits.h>  // ULONG_MAX
#include <stdlib.h>  // strto*
#include <string.h>  // strlen

#define DEBUG_MODULE "helper-utils"
#define DEBUG_LEVEL 7
#include <re_dbg.h>

/*
 * Convert string to uint16.
 */
bool str_to_uint16(uint16_t* const numberp, char* const str) {
    char* end;
    unsigned long number = strtoul(str, &end, 10);

    // Check result (this function is insane, srsly...)
    if (*end != '\0' || (number == ULONG_MAX && errno == ERANGE)) {
        return false;
    }

    // Check bounds
#if (ULONG_MAX > UINT16_MAX)
    if (number > UINT16_MAX) {
        return false;
    }
#endif

    // Done
    *numberp = (uint16_t) number;
    return true;
}

/*
 * Convert string to uint64.
 */
bool str_to_uint64(uint64_t* const numberp, char* const str) {
    char* end;
    unsigned long long number = strtoull(str, &end, 10);

    // Check result (this function is insane, srsly...)
    if (*end != '\0' || (number == ULONG_MAX && errno == ERANGE)) {
        return false;
    }

    // Check bounds
#if (ULONG_MAX > UINT64_MAX)
    if (number > UINT64_MAX) {
        return false;
    }
#endif

    // Done
    *numberp = (uint64_t) number;
    return true;
}

/*
 * Convert string to uint32.
 */
bool str_to_uint32(uint32_t* const numberp, char* const str) {
    uint64_t number;
    bool success = str_to_uint64(&number, str);

    // Validate
    if (!success || number > UINT32_MAX) {
        return false;
    }

    // Done
    *numberp = (uint32_t) number;
    return true;
}

/*
 * Get a dictionary entry and store it in `*valuep`.
 */
enum rawrtc_code dict_get_entry(
    void* const valuep,
    struct odict* const parent,
    char* const key,
    enum odict_type const type,
    bool required) {
    struct odict_entry const* entry;

    // Check arguments
    if (!valuep || !parent || !key) {
        return RAWRTC_CODE_INVALID_ARGUMENT;
    }

    // Do lookup
    entry = odict_lookup(parent, key);

    // Check for entry
    if (!entry) {
        if (required) {
            DEBUG_WARNING("'%s' missing\n", key);
            return RAWRTC_CODE_INVALID_ARGUMENT;
        } else {
            return RAWRTC_CODE_NO_VALUE;
        }
    }

    // Check for type
    if (entry->type != type) {
        DEBUG_WARNING("'%s' is of different type than expected\n", key);
        return RAWRTC_CODE_INVALID_ARGUMENT;
    }

    // Set value according to type
    switch (type) {
        case ODICT_OBJECT:
        case ODICT_ARRAY:
            *((struct odict * * const) valuep) = entry->u.odict;
            break;
        case ODICT_STRING:
            *((char** const) valuep) = entry->u.str;
            break;
        case ODICT_INT:
            *((int64_t* const) valuep) = entry->u.integer;
            break;
        case ODICT_DOUBLE:
            *((double* const) valuep) = entry->u.dbl;
            break;
        case ODICT_BOOL:
            *((bool* const) valuep) = entry->u.boolean;
            break;
        case ODICT_NULL:
            *((char** const) valuep) = NULL;  // meh!
            break;
        default:
            return RAWRTC_CODE_INVALID_ARGUMENT;
    }

    // Done
    return RAWRTC_CODE_SUCCESS;
}

/*
 * Get a uint32 entry and store it in `*valuep`.
 */
enum rawrtc_code dict_get_uint32(
    uint32_t* const valuep, struct odict* const parent, char* const key, bool required) {
    enum rawrtc_code error;
    int64_t value;

    // Check arguments
    if (!valuep || !parent || !key) {
        return RAWRTC_CODE_INVALID_ARGUMENT;
    }

    // Get int64_t
    error = dict_get_entry(&value, parent, key, ODICT_INT, required);
    if (error) {
        return error;
    }

    // Check bounds
    if (value < 0 || value > UINT32_MAX) {
        return RAWRTC_CODE_INVALID_ARGUMENT;
    }

    // Set value & done
    *valuep = (uint32_t) value;
    return RAWRTC_CODE_SUCCESS;
}

/*
 * Get a uint16 entry and store it in `*valuep`.
 */
enum rawrtc_code dict_get_uint16(
    uint16_t* const valuep, struct odict* const parent, char* const key, bool required) {
    enum rawrtc_code error;
    int64_t value;

    // Check arguments
    if (!valuep || !parent || !key) {
        return RAWRTC_CODE_INVALID_ARGUMENT;
    }

    // Get int64_t
    error = dict_get_entry(&value, parent, key, ODICT_INT, required);
    if (error) {
        return error;
    }

    // Check bounds
    if (value < 0 || value > UINT16_MAX) {
        return RAWRTC_CODE_INVALID_ARGUMENT;
    }

    // Set value & done
    *valuep = (uint16_t) value;
    return RAWRTC_CODE_SUCCESS;
}

/*
 * Get JSON from stdin and parse it to a dictionary.
 */
enum rawrtc_code get_json_stdin(struct odict** const dictp  // de-referenced
) {
    char buffer[PARAMETERS_MAX_LENGTH];
    size_t length;

    // Get message from stdin
    if (!fgets((char*) buffer, PARAMETERS_MAX_LENGTH, stdin)) {
        EWE("Error polling stdin");
    }
    length = strlen(buffer);

    // Exit?
    if (length == 1 && buffer[0] == '\n') {
        return RAWRTC_CODE_NO_VALUE;
    }

    // Decode JSON
    EOR(json_decode_odict(dictp, 16, buffer, length, 3));
    return RAWRTC_CODE_SUCCESS;
}

/*
 * Get the ICE role from a string.
 */
enum rawrtc_code get_ice_role(
    enum rawrtc_ice_role* const rolep,  // de-referenced
    char const* const str) {
    // Get ICE role
    switch (str[0]) {
        case '0':
            *rolep = RAWRTC_ICE_ROLE_CONTROLLED;
            return RAWRTC_CODE_SUCCESS;
        case '1':
            *rolep = RAWRTC_ICE_ROLE_CONTROLLING;
            return RAWRTC_CODE_SUCCESS;
        default:
            return RAWRTC_CODE_INVALID_ARGUMENT;
    }
}

/*
 * Get the congestion control algorithm from a string.
 */
enum rawrtc_code get_congestion_control_algorithm(
    enum rawrtc_sctp_transport_congestion_ctrl* const algorithmp,  // de-referenced
    char const* const str) {
    if (str_casecmp(str, "RFC2581") == 0) {
        *algorithmp = RAWRTC_SCTP_TRANSPORT_CONGESTION_CTRL_RFC2581;
        return RAWRTC_CODE_SUCCESS;
    } else if (str_casecmp(str, "HSTCP") == 0) {
        *algorithmp = RAWRTC_SCTP_TRANSPORT_CONGESTION_CTRL_HSTCP;
        return RAWRTC_CODE_SUCCESS;
    } else if (str_casecmp(str, "HTCP") == 0) {
        *algorithmp = RAWRTC_SCTP_TRANSPORT_CONGESTION_CTRL_HTCP;
        return RAWRTC_CODE_SUCCESS;
    } else if (str_casecmp(str, "RTCC") == 0) {
        *algorithmp = RAWRTC_SCTP_TRANSPORT_CONGESTION_CTRL_RTCC;
        return RAWRTC_CODE_SUCCESS;
    } else {
        return RAWRTC_CODE_INVALID_ARGUMENT;
    }
}

static void data_channel_helper_destroy(void* arg) {
    struct data_channel_helper* const channel = arg;

    // Unset handler argument & handlers of the channel
    if (channel->channel) {
        EOE(rawrtc_data_channel_unset_handlers(channel->channel));
    }

    // Remove from list
    list_unlink(&channel->le);

    // Un-reference
    mem_deref(channel->arg);
    mem_deref(channel->label);
    mem_deref(channel->channel);
}

/*
 * Create a data channel helper instance.
 */
void data_channel_helper_create(
    struct data_channel_helper** const channel_helperp,  // de-referenced
    struct client* const client,
    char* const label) {
    // Allocate
    struct data_channel_helper* const channel =
        mem_zalloc(sizeof(*channel), data_channel_helper_destroy);
    if (!channel) {
        EOE(RAWRTC_CODE_NO_MEMORY);
        return;
    }

    // Set fields
    channel->client = client;
    EOE(rawrtc_strdup(&channel->label, label));

    // Set pointer & done
    *channel_helperp = channel;
}

/*
 * Create a data channel helper instance from parameters.
 */
void data_channel_helper_create_from_channel(
    struct data_channel_helper** const channel_helperp,  // de-referenced
    struct rawrtc_data_channel* channel,
    struct client* const client,
    void* const arg  // nullable
) {
    enum rawrtc_code error;
    struct rawrtc_data_channel_parameters* parameters;
    char* label;

    // Allocate
    struct data_channel_helper* const channel_helper =
        mem_zalloc(sizeof(*channel_helper), data_channel_helper_destroy);
    if (!channel_helper) {
        EOE(RAWRTC_CODE_NO_MEMORY);
        return;
    }

    // Get parameters
    EOE(rawrtc_data_channel_get_parameters(&parameters, channel));

    // Get & set label
    error = rawrtc_data_channel_parameters_get_label(&label, parameters);
    switch (error) {
        case RAWRTC_CODE_SUCCESS:
            EOE(rawrtc_strdup(&channel_helper->label, label));
            mem_deref(label);
            break;
        case RAWRTC_CODE_NO_VALUE:
            EOE(rawrtc_strdup(&channel_helper->label, "n/a"));
            break;
        default:
            EOE(error);
    }

    // Set fields
    channel_helper->client = client;
    channel_helper->channel = channel;
    channel_helper->arg = mem_ref(arg);

    // Set pointer
    *channel_helperp = channel_helper;

    // Un-reference & done
    mem_deref(parameters);
}

/*
 * Add the ICE candidate to the remote ICE transport if the ICE
 * candidate type is enabled.
 */
void add_to_other_if_ice_candidate_type_enabled(
    struct client* const client,
    struct rawrtc_ice_candidate* const candidate,
    struct rawrtc_ice_transport* const transport) {
    if (candidate) {
        enum rawrtc_ice_candidate_type type;

        // Get ICE candidate type
        EOE(rawrtc_ice_candidate_get_type(&type, candidate));

        // Add to other client as remote candidate (if type enabled)
        if (ice_candidate_type_enabled(client, type)) {
            EOE(rawrtc_ice_transport_add_remote_candidate(transport, candidate));
        }
    } else {
        // Last candidate is always being added
        EOE(rawrtc_ice_transport_add_remote_candidate(transport, candidate));
    }
}