patty/src/route.c

#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <errno.h>

#include <patty/hash.h>

#include <patty/ax25.h>

patty_ax25_route *patty_ax25_route_new(patty_ax25_if *iface,
                                       const char *callsign) {
    patty_ax25_route *route;

    if ((route = malloc(sizeof(*route))) == NULL) {
        goto error_malloc_route;
    }

    memset(route, '\0', sizeof(*route));

    if (callsign) {
        if (patty_ax25_pton(callsign, &route->dest) < 0) {
            goto error_pton;
        }
    }

    route->iface = iface;

    return route;

error_pton:
    free(route);

error_malloc_route:
    return NULL;
}

patty_ax25_route *patty_ax25_route_new_default(patty_ax25_if *iface) {
    return patty_ax25_route_new(iface, NULL);
}
    
int patty_ax25_route_add_hop(patty_ax25_route *route,
                             const char *callsign) {
    if (route->nhops == PATTY_AX25_MAX_HOPS) {
        errno = ENOMEM;

        goto error_max_hops;
    }

    return patty_ax25_pton(callsign, &route->hops[route->nhops++]);

error_max_hops:
    return -1;
}

patty_ax25_route_table *patty_ax25_route_table_new() {
    return patty_dict_new();
}

void patty_ax25_route_table_destroy(patty_ax25_route_table *table) {
    patty_dict_destroy(table);
}

patty_ax25_route *patty_ax25_route_table_find(patty_ax25_route_table *table,
                                              patty_ax25_addr *dest) {
    patty_ax25_route *route;
    uint32_t hash;

    patty_hash_init(&hash);
    patty_ax25_addr_hash(&hash, dest);
    patty_hash_end(&hash);

    route = patty_dict_get(table, hash);

    if (route) {
        return route;
    }

    return patty_ax25_route_table_default(table);
}

patty_ax25_route *patty_ax25_route_table_default(patty_ax25_route_table *table) {
    patty_ax25_addr empty;

    uint32_t hash;

    memset(&empty, '\0', sizeof(empty));

    patty_hash_init(&hash);
    patty_ax25_addr_hash(&hash, &empty);
    patty_hash_end(&hash);

    return patty_dict_get(table, hash);
}

int patty_ax25_route_table_add(patty_ax25_route_table *table,
                               patty_ax25_route *route) {
    uint32_t hash;

    patty_hash_init(&hash);
    patty_ax25_addr_hash(&hash, &route->dest);
    patty_hash_end(&hash);

    if (patty_ax25_route_table_find(table, &route->dest) != NULL) {
        errno = EEXIST;

        goto error_exists;
    }

    if (patty_dict_set(table, hash, route) == NULL) {
        goto error_dict_set;
    }

    return 0;

error_dict_set:
error_exists:
    return -1;
}

int patty_ax25_route_table_delete(patty_ax25_route_table *route,
                                  patty_ax25_addr *dest) {
    uint32_t hash;

    patty_hash_init(&hash);
    patty_ax25_addr_hash(&hash, dest);
    patty_hash_end(&hash);

    return patty_dict_delete(route, hash);
}