patty/src/if.c

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

#include <patty/ax25.h>

static patty_ax25_if *create_tnc(const char *device) {
    patty_ax25_if *iface;

    static char * prefix = "kiss";
    static int    number = 0;

    if ((iface = malloc(sizeof(*iface))) == NULL) {
        goto error_malloc_iface;
    }

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

    if ((iface->tnc = patty_kiss_tnc_open(device)) == NULL) {
        goto error_kiss_tnc_open;
    }

    iface->type = PATTY_AX25_IF_KISS_TNC;

    snprintf(iface->name, sizeof(iface->name), "%s%d", prefix, number++);

    return iface;

error_kiss_tnc_open:
    free(iface);

error_malloc_iface:
    return NULL;
}

static void destroy_tnc(patty_ax25_if *iface) {
    patty_kiss_tnc_close(iface->tnc);
}

patty_ax25_if *patty_ax25_if_create(int opts, void *info) {
    patty_ax25_if *iface;

    switch (PATTY_AX25_IF_OPT_TYPE(opts)) {
        case PATTY_AX25_IF_KISS_TNC: {
            iface = create_tnc((const char *)info);
            
            break;
        }

        default: {
            errno = EINVAL;

            goto error;
        }
    }

    if (iface == NULL) {
        goto error;
    }

    if ((iface->addrs = patty_list_new()) == NULL) {
        goto error;
    }

    return iface;

error:
    return NULL;
}

void patty_ax25_if_destroy(patty_ax25_if *iface) {
    switch (iface->type) {
        case PATTY_AX25_IF_KISS_TNC: {
            destroy_tnc(iface); break;
        }

        default: break;
    }
}

int patty_ax25_if_each_addr(patty_ax25_if *iface,
                            int (*callback)(char *, uint8_t, void *), void *ctx) {
    patty_list_iterator *iter;
    patty_ax25_addr *addr;

    if ((iter = patty_list_start(iface->addrs)) == NULL) {
        goto error_list_start;
    }

    while ((addr = patty_list_next(iter)) != NULL) {
        char buf[7];
        uint8_t ssid;

        if (patty_ax25_ntop(addr, buf, &ssid, sizeof(buf)) < 0) {
            goto error_ntop;
        }

        if (callback(buf, ssid, ctx) < 0) {
            goto error_callback;
        }
    }

    patty_list_finish(iter);

    return 0;

error_callback:
error_ntop:
    patty_list_finish(iter);

error_list_start:
    return -1;
}

static patty_ax25_addr *find_addr(patty_ax25_if *iface,
                                  const char *callsign,
                                  uint8_t ssid) {
    patty_list_iterator *iter;
    patty_ax25_addr *addr;

    if ((iter = patty_list_start(iface->addrs)) == NULL) {
        goto error_list_start;
    }

    while ((addr = patty_list_next(iter)) != NULL) {
        char buf[7];
        uint8_t addr_ssid;

        if (patty_ax25_ntop(addr, buf, &addr_ssid, sizeof(buf)) < 0) {
            goto error_ntop;
        }

        if (strncmp(buf, callsign, sizeof(buf)) != 0) {
            continue;
        }

        
        if (addr_ssid != ssid) {
            continue;
        }

        patty_list_finish(iter);

        return addr;
    }

    patty_list_finish(iter);

error_ntop:
    patty_list_finish(iter);

error_list_start:
    return NULL;
}

int patty_ax25_if_add_addr(patty_ax25_if *iface,
                           const char *callsign,
                           uint8_t ssid) {
    patty_ax25_addr *addr;

    if (find_addr(iface, callsign, ssid) != NULL) {
        errno = EEXIST;

        goto error_exists;
    }

    if ((addr = malloc(sizeof(*addr))) == NULL) {
        goto error_malloc_addr;
    }

    if (patty_ax25_pton(callsign, ssid, addr) < 0) {
        goto error_pton;
    }

    if ((patty_list_append(iface->addrs, addr)) == NULL) {
        goto error_list_append;
    }

    return 0;

error_list_append:
error_pton:
    free(addr);

error_malloc_addr:
error_exists:
    return -1;
}

int patty_ax25_if_delete_addr(patty_ax25_if *iface,
                              const char *callsign,
                              uint8_t ssid) {
    patty_list_item *item = iface->addrs->first;
    int i = 0;

    while (item) {
        char buf[7];
        uint8_t addr_ssid;

        patty_ax25_addr *addr = item->value;

        if (patty_ax25_ntop(addr, buf, &addr_ssid, sizeof(buf)) < 0) {
            goto error_ntop;
        }

        if (strncmp(buf, callsign, sizeof(buf)) == 0 && addr_ssid == ssid) {
            if (patty_list_splice(iface->addrs, i) == NULL) {
                goto error_list_splice;
            }
        }

        item = item->next;
        i++;
    }

    return 0;

error_list_splice:
error_ntop:
    return -1;
}