path: root/ecp/src/ecp/vconn/vconn.c

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

#include <ecp/core.h>
#include <ecp/tr.h>

#ifdef ECP_WITH_HTABLE
#include <ecp/ht.h>
#endif

#include "vconn.h"


#ifdef ECP_WITH_HTABLE

static int insert_vconn_next(ECPVConnInb *vconn, unsigned char c_idx, ecp_ecdh_public_t *public) {
    ECPConnection *conn = &vconn->b;
    ECPSocket *sock = conn->sock;
    ECPDHPub *key = NULL;
    int rv = ECP_OK;

#ifdef ECP_WITH_PTHREAD
    pthread_mutex_lock(&conn->mutex);
#endif

    key = &vconn->vconn_next[c_idx % ECP_MAX_NODE_KEY];
    if (key->valid && (memcmp(public, &key->public, sizeof(key->public)) == 0)) {
        key = NULL;
    }

#ifdef ECP_WITH_PTHREAD
    pthread_mutex_unlock(&conn->mutex);
#endif

    if (key == NULL) return ECP_OK;

#ifdef ECP_WITH_PTHREAD
    pthread_mutex_lock(&sock->vconn_table.vconn_keys_mutex);
    pthread_mutex_lock(&conn->mutex);
#endif

    if (key->valid) {
        ecp_ht_remove(sock->vconn_table.vconn_keys, &key->public);
        key->valid = 0;
    }
    memcpy(&key->public, public, sizeof(key->public));
    rv = ecp_ht_insert(sock->vconn_table.vconn_keys, &key->public, conn);
    if (!rv) {
        key->valid = 1;
        vconn->vconn_next_curr = c_idx;
    }

#ifdef ECP_WITH_PTHREAD
    pthread_mutex_unlock(&conn->mutex);
    pthread_mutex_unlock(&sock->vconn_table.vconn_keys_mutex);
#endif

    return rv;
}

static ssize_t handle_next(ECPConnection *conn, unsigned char *msg, size_t msg_size, ECP2Buffer *bufs) {
    ECPVConnInb *vconn = (ECPVConnInb *)conn;
    ECPSocket *sock = conn->sock;

    if (msg_size < ECP_SIZE_ECDH_PUB) return ECP_ERR_SIZE;
    if (ecp_conn_is_outb(conn)) return ECP_ERR;
    if (ecp_conn_is_open(conn)) return ECP_ERR;

    memcpy(&vconn->vlink_next.public, msg, sizeof(vconn->vlink_next.public));
    vconn->vlink_next.valid = 1;

    return ECP_SIZE_ECDH_PUB;
}

static ssize_t handle_relay(ECPConnection *conn, unsigned char *_msg, size_t msg_size, ECP2Buffer *bufs) {
    ECPSocket *sock = conn->sock;
    ECPConnection *conn_next;
    ECPBuffer payload;
    unsigned char idx, _idx;
    unsigned char *msg = _msg;
    uint16_t pkt_size;
    size_t _pkt_size;
    ssize_t rv;
    int _rv;

    if (msg_size < sizeof(uint16_t)) return ECP_ERR_SIZE;

    pkt_size  = (uint16_t)msg[0] << 8;
    pkt_size |= (uint16_t)msg[1];
    msg += sizeof(uint16_t);

    if (msg_size < sizeof(uint16_t) + pkt_size) return ECP_ERR_SIZE;

    idx = msg[ECP_SIZE_PROTO];
    if (idx == ECP_KEYID_INV) return ECP_ERR_KEYID;

    switch (conn->type) {
        /* forward message */
        case ECP_CTYPE_VCONN: {
            ECPVConnInb *vconn = (ECPVConnInb *)conn;
            int insert_next = 0;

            if (ecp_conn_is_outb(conn)) return ECP_ERR;

            _idx = (idx & 0x0F);
            conn_next = NULL;

            if (_idx & ~ECP_KEYID_MASK) return ECP_ERR_KEYID;

#ifdef ECP_WITH_PTHREAD
            pthread_mutex_lock(&sock->vconn_table.vlink_keys_mutex);
            pthread_mutex_lock(&conn->mutex);
#endif

            if (_idx != vconn->vconn_next_curr) insert_next = 1;

#ifdef ECP_WITH_PTHREAD
            pthread_mutex_unlock(&conn->mutex);
#endif

            if (vconn->vlink_next.valid) {
                conn_next = ecp_ht_search(sock->vconn_table.vlink_keys, &vconn->vlink_next.public);
                if (conn_next) {
                    _rv = ecp_conn_refcount_inc(conn_next);
                    if (_rv) conn_next = NULL;
                }
            }

#ifdef ECP_WITH_PTHREAD
            pthread_mutex_unlock(&sock->vconn_table.vlink_keys_mutex);
#endif

            if (conn_next == NULL) return ECP_ERR_NEXT;

            if (insert_next) {
                _rv = insert_vconn_next(vconn, _idx, (ecp_ecdh_public_t *)(msg+ECP_SIZE_PROTO+1));
                if (_rv) return _rv;
            }

            break;
        }

        /* back message */
        case ECP_CTYPE_VLINK: {
#ifdef ECP_WITH_PTHREAD
            pthread_mutex_lock(&sock->vconn_table.vconn_keys_mutex);
#endif

            conn_next = ecp_ht_search(sock->vconn_table.vconn_keys, (ecp_ecdh_public_t *)(msg+ECP_SIZE_PROTO+1));
            if (conn_next) {
                _rv = ecp_conn_refcount_inc(conn_next);
                if (_rv) conn_next = NULL;
            }

#ifdef ECP_WITH_PTHREAD
            pthread_mutex_unlock(&sock->vconn_table.vconn_keys_mutex);
#endif

            if (conn_next == NULL) return ECP_ERR_NEXT;

            _idx = (idx & 0xF0) >> 4;
            if (_idx == ECP_KEYID_PERMA) {
                /* this is init reply */
                msg[ECP_SIZE_PROTO] = (ECP_KEYID_PERMA << 4) | ECP_KEYID_NOKEY;
                memmove(msg+ECP_SIZE_PROTO+1, msg+ECP_SIZE_PROTO+1+ECP_SIZE_ECDH_PUB, pkt_size-(ECP_SIZE_PROTO+1+ECP_SIZE_ECDH_PUB));
                pkt_size -= ECP_SIZE_ECDH_PUB;
                _msg[0] = pkt_size >> 8;
                _msg[1] = pkt_size;
            }

            break;
        }

        default:
            return ECP_ERR_CTYPE;
    }

    payload.buffer = ecp_msg_get_pld(ECP_MTYPE_RELAY, _msg);
    payload.size = bufs->payload->size - (payload.buffer - bufs->payload->buffer);

    ecp_pld_set_type(payload.buffer, payload.size, ECP_MTYPE_EXEC);

    if (conn_next->parent) {
        _pkt_size = 0;
    } else {
        _pkt_size = ECP_SIZE_VCONN_PKT;
    }

    rv = ecp_pld_send_wsize(conn_next, bufs->packet, &payload, ECP_SIZE_MTYPE + sizeof(uint16_t) + pkt_size, ECP_SEND_FLAG_REPLY, _pkt_size);
    ecp_conn_refcount_dec(conn_next);
    if (rv < 0) return rv;

    /* payload buffer is reused, so we must return msg_size */
    return msg_size;
}

#endif  /* ECP_WITH_HTABLE */

static ssize_t handle_exec(ECPConnection *conn, unsigned char *msg, size_t msg_size, ECP2Buffer *bufs) {
    ECPBuffer *packet;
    uint16_t pkt_size;
    ssize_t rv;

    if (msg_size < sizeof(uint16_t)) return ECP_ERR_SIZE;

    pkt_size  = (uint16_t)msg[0] << 8;
    pkt_size |= (uint16_t)msg[1];
    msg += sizeof(uint16_t);

    if (msg_size < sizeof(uint16_t) + pkt_size) return ECP_ERR_SIZE;

    packet = bufs->packet;
    if (packet->size < pkt_size) return ECP_ERR_SIZE;

    memcpy(packet->buffer, msg, pkt_size);
    rv = ecp_pkt_handle(conn->sock, conn, NULL, bufs, pkt_size);
    if (rv < 0) return rv;

    /* payload buffer can be reused, so we must return msg_size */
    return msg_size;
}

ssize_t ecp_vconn_pack_parent(ECPConnection *conn, ECPBuffer *payload, ECPBuffer *packet, size_t pkt_size, ecp_tr_addr_t *addr) {
    unsigned char *msg;
    size_t hdr_size, _pkt_size;
    ssize_t rv;
    int _rv;

    _rv = ecp_pld_set_type(payload->buffer, payload->size, ECP_MTYPE_RELAY);
    if (_rv) return _rv;

    msg = ecp_pld_get_msg(payload->buffer, payload->size);
    if (msg == NULL) return ECP_ERR;

    hdr_size = msg - payload->buffer;
    if (payload->size < hdr_size + sizeof(uint16_t) + pkt_size) return ECP_ERR_SIZE;

    msg[0] = pkt_size >> 8;
    msg[1] = pkt_size;
    memcpy(msg + sizeof(uint16_t), packet->buffer, pkt_size);

    if (conn->parent) {
        _pkt_size = 0;
    } else {
        _pkt_size = ECP_SIZE_VCONN_PKT;
    }

    rv = ecp_pack_conn(conn, packet, _pkt_size, ECP_KEYID_INV, ECP_KEYID_INV, 0, NULL, NULL, payload, hdr_size + sizeof(uint16_t) + pkt_size, addr);
    return rv;
}

void ecp_vconn_init(ECPVConnOutb vconn[], size_t vconn_size, ECPConnection *conn, ECPSocket *sock) {
    int i;

    for (i=0; i<vconn_size; i++) {
        ecp_conn_init(&vconn[i].b, sock, ECP_CTYPE_VCONN);
        if (i != 0) ecp_conn_set_flags(&vconn[i].b, ECP_CONN_FLAG_NOFREE);
        if (i != vconn_size - 1) {
            vconn[i].next = &vconn[i + 1].b;
        } else {
            vconn[i].next = conn;
        }
    }
}

void ecp_vconn_init_vlink(ECPVConnOutb vconn[], size_t vconn_size, ECPSocket *sock) {
    int i;

    for (i=0; i<vconn_size; i++) {
        if (i != vconn_size - 1) {
            ecp_conn_init(&vconn[i].b, sock, ECP_CTYPE_VCONN);
        } else {
            ecp_vlink_init(&vconn[i].b, sock);
        }
        if (i != 0) ecp_conn_set_flags(&vconn[i].b, ECP_CONN_FLAG_NOFREE);
        if (i != vconn_size - 1) {
            vconn[i].next = &vconn[i + 1].b;
        } else {
            vconn[i].next = NULL;
        }
    }
}

#ifdef ECP_WITH_HTABLE

void ecp_vconn_init_inb(ECPVConnInb *vconn, ECPSocket *sock) {
    ECPConnection *conn = &vconn->b;

    ecp_conn_init(conn, sock, ECP_CTYPE_VCONN);
    memset(&vconn->vlink_next, 0, sizeof(vconn->vlink_next));
    memset(&vconn->vconn_next, 0, sizeof(vconn->vconn_next));
    vconn->vconn_next_curr = ECP_KEYID_INV;
}

#endif  /* ECP_WITH_HTABLE */

int ecp_vconn_open(ECPVConnOutb *vconn, ecp_ecdh_public_t vconn_pub[], ecp_tr_addr_t *addr, ecp_ecdh_public_t *public) {
    ECPConnection *conn;
    int i, rv;

    i = 0;
    conn = &vconn->b;
    while (conn->type == ECP_CTYPE_VCONN) {
        ecp_conn_set_remote_key(conn, &vconn_pub[i]);
        conn = ((ECPVConnOutb *)conn)->next;
        i++;
    }
    if (public) ecp_conn_set_remote_key(conn, public);
    if (addr) ecp_conn_set_remote_addr(&vconn->b, addr);

    rv = _ecp_conn_open(&vconn->b, NULL, 1);
    return rv;
}

int ecp_vconn_open_vlink(ECPVConnOutb *vconn, ecp_ecdh_public_t vconn_pub[], ecp_tr_addr_t *addr) {
    ECPConnection *conn;
    int i, rv;

    i = 0;
    conn = &vconn->b;
    while (conn->type == ECP_CTYPE_VCONN) {
        ecp_conn_set_remote_key(conn, &vconn_pub[i]);
        conn = ((ECPVConnOutb *)conn)->next;
        i++;
    }
    ecp_conn_set_remote_key(conn, &vconn_pub[i]);
    if (addr) ecp_conn_set_remote_addr(&vconn->b, addr);

    rv = _ecp_conn_open(&vconn->b, NULL, 1);
    return rv;
}

static void vconn_close(ECPVConnOutb *vconn) {
    ECPConnection *conn, *parent, *next;

    conn = vconn->next;
    while (conn->type == ECP_CTYPE_VCONN) {
        next = ((ECPVConnOutb *)conn)->next;
        ecp_conn_free(conn);
        conn = next;
    }
    conn = &vconn->b;
    while (conn) {
        parent = conn->parent;
        ecp_conn_close(conn);
        conn = parent;
    }
}

void ecp_vconn_close(ECPConnection *conn) {
    ECPVConnOutb *vconn;

    vconn = (ECPVConnOutb *)conn->parent;
    if (vconn) vconn_close(vconn);
}

int ecp_vconn_handle_open(ECPConnection *conn, ECP2Buffer *bufs) {
    ECPVConnOutb *vconn = (ECPVConnOutb *)conn;
    int rv;

    if (ecp_conn_is_inb(conn)) return ECP_OK;
    if (vconn->next == NULL) return ECP_ERR_NEXT;

    /* we should release incoming packet before sending next open packet */
    ecp_tr_release(bufs->packet, 1);
    rv = _ecp_conn_open(vconn->next, conn, 1);
    /* err will be handled by ecp_vconn_handle_err */

    return rv;
}

#ifdef ECP_WITH_HTABLE

void ecp_vconn_handle_close(ECPConnection *conn) {
    ECPVConnInb *vconn = (ECPVConnInb *)conn;
    ECPSocket *sock = conn->sock;
    int i;

    if (ecp_conn_is_outb(conn)) return;

#ifdef ECP_WITH_PTHREAD
    pthread_mutex_lock(&sock->vconn_table.vconn_keys_mutex);
#endif

    for (i=0; i<ECP_MAX_NODE_KEY; i++) {
        ECPDHPub *key;

        key = &vconn->vconn_next[i];
        if (key->valid) {
            ecp_ht_remove(sock->vconn_table.vconn_keys, &key->public);
        }
    }

#ifdef ECP_WITH_PTHREAD
    pthread_mutex_unlock(&sock->vconn_table.vconn_keys_mutex);
#endif
}

#endif  /* ECP_WITH_HTABLE */

void ecp_vconn_handle_err(ECPConnection *conn, unsigned char mtype, int err) {
    if (ecp_conn_is_outb(conn) && (mtype == ECP_MTYPE_OPEN_REP)) {
        ECPVConnOutb *vconn = (ECPVConnOutb *)conn;

        while (vconn) {
            ECPConnection *_conn = &vconn->b;

            if (_conn->type != ECP_CTYPE_VCONN) {
                ecp_err_handle(_conn, mtype, err);
                break;
            }
            vconn = (ECPVConnOutb *)vconn->next;
        }
        vconn = (ECPVConnOutb *)conn;
        vconn_close(vconn);
    } else {
        ECPContext *ctx = conn->sock->ctx;

        if (ctx->handle_err) {
            ctx->handle_err(conn, mtype, err);
        }
    }
}

ssize_t ecp_vconn_handle_msg(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, unsigned char *msg, size_t msg_size, ECP2Buffer *bufs) {
    ssize_t rv;

    switch (mtype) {
#ifdef ECP_WITH_HTABLE
        case ECP_MTYPE_NEXT:
            rv = handle_next(conn, msg, msg_size, bufs);
            break;

        case ECP_MTYPE_RELAY:
            rv = handle_relay(conn, msg, msg_size, bufs);
            break;
#endif

        case ECP_MTYPE_EXEC:
            rv = handle_exec(conn, msg, msg_size, bufs);
            break;

        default:
            rv = ECP_ERR_MTYPE;
            break;
    }

    return rv;
}

ssize_t ecp_vconn_send_open_req(ECPConnection *conn, unsigned char *cookie) {
    ECPVConnOutb *vconn = (ECPVConnOutb *)conn;
    ECPDHPub key_next;
    ECPBuffer packet;
    ECPBuffer payload;
    unsigned char pkt_buf[ECP_SIZE_PKT_BUF_OREQ(ECP_SIZE_PLD(2+ECP_SIZE_VBOX, ECP_MTYPE_OPEN_REQ)+ECP_SIZE_PLD(ECP_SIZE_ECDH_PUB, ECP_MTYPE_NEXT), conn)];
    unsigned char pld_buf[ECP_SIZE_PLD_BUF_OREQ(ECP_SIZE_PLD(2+ECP_SIZE_VBOX, ECP_MTYPE_OPEN_REQ)+ECP_SIZE_PLD(ECP_SIZE_ECDH_PUB, ECP_MTYPE_NEXT), conn)];
    unsigned char *msg;
    unsigned char *_pld_buf;
    size_t _pld_size;
    ssize_t rv;
    int _rv;

    if (vconn->next == NULL) return ECP_ERR_NEXT;

    _rv = ecp_conn_dhkey_get_remote(vconn->next, ECP_KEYID_PERMA, &key_next);
    if (_rv) return _rv;

    packet.buffer = pkt_buf;
    packet.size = sizeof(pkt_buf);
    payload.buffer = pld_buf;
    payload.size = sizeof(pld_buf);

    rv = ecp_write_open_req(conn, &payload);
    if (rv < 0) return rv;

    _pld_buf = payload.buffer + rv;
    _pld_size = payload.size - rv;

    ecp_pld_set_type(_pld_buf, _pld_size, ECP_MTYPE_NEXT);
    msg = ecp_pld_get_msg(_pld_buf, _pld_size);
    memcpy(msg, &key_next.public, ECP_SIZE_ECDH_PUB);

    rv = ecp_pld_send_wcookie(conn, &packet, &payload, rv+ECP_SIZE_PLD(ECP_SIZE_ECDH_PUB, ECP_MTYPE_NEXT), 0, cookie);
    return rv;
}

void ecp_vlink_init(ECPConnection *conn, ECPSocket *sock) {
    ecp_conn_init(conn, sock, ECP_CTYPE_VLINK);
    ecp_conn_set_flags(conn, ECP_CONN_FLAG_VBOX);
}

#ifdef ECP_WITH_HTABLE

int ecp_vlink_handle_open(ECPConnection *conn, ECP2Buffer *bufs) {
    ECPSocket *sock = conn->sock;
    ECPDHPub *key;
    int rv;

    if ((conn->parent == NULL) && ecp_conn_is_inb(conn)) return ECP_OK;

    key = &conn->remote.key_perma;
    if (!key->valid) return ECP_OK;

#ifdef ECP_WITH_PTHREAD
    pthread_mutex_lock(&sock->vconn_table.vlink_keys_mutex);
#endif

    ecp_ht_remove(sock->vconn_table.vlink_keys, &key->public);
    rv = ecp_ht_insert(sock->vconn_table.vlink_keys, &key->public, conn);

#ifdef ECP_WITH_PTHREAD
    pthread_mutex_unlock(&sock->vconn_table.vlink_keys_mutex);
#endif

    return rv;
}

void ecp_vlink_handle_close(ECPConnection *conn) {
    ECPSocket *sock = conn->sock;
    ECPDHPub *key;

    if ((conn->parent == NULL) && ecp_conn_is_inb(conn)) return;

    key = &conn->remote.key_perma;
    if (!key->valid) return;

#ifdef ECP_WITH_PTHREAD
    pthread_mutex_lock(&sock->vconn_table.vlink_keys_mutex);
#endif

    ecp_ht_remove_kv(sock->vconn_table.vlink_keys, &key->public, conn);

#ifdef ECP_WITH_PTHREAD
    pthread_mutex_unlock(&sock->vconn_table.vlink_keys_mutex);
#endif
}

#endif  /* ECP_WITH_HTABLE */

ssize_t ecp_vlink_handle_msg(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, unsigned char *msg, size_t msg_size, ECP2Buffer *bufs) {
    ssize_t rv;

    switch (mtype) {
#ifdef ECP_WITH_HTABLE
        case ECP_MTYPE_RELAY:
            rv = handle_relay(conn, msg, msg_size, bufs);
            break;
#endif

        case ECP_MTYPE_EXEC:
            rv = handle_exec(conn, msg, msg_size, bufs);
            break;

        default:
            rv = ECP_ERR_MTYPE;
            break;
    }

    return rv;
}

int ecp_vconn_sock_create(ECPSocket *sock) {
    int rv = ECP_OK;

#ifdef ECP_WITH_HTABLE

    memset(&sock->vconn_table, 0, sizeof(sock->vconn_table));

#ifdef ECP_WITH_PTHREAD
    rv = pthread_mutex_init(&sock->vconn_table.vconn_keys_mutex, NULL);
    if (rv) {
        return ECP_ERR;
    }

    rv = pthread_mutex_init(&sock->vconn_table.vlink_keys_mutex, NULL);
    if (rv) {
        pthread_mutex_destroy(&sock->vconn_table.vconn_keys_mutex);
        return ECP_ERR;
    }
#endif

    sock->vconn_table.vconn_keys = ecp_ht_create_keys();
    if (sock->vconn_table.vconn_keys == NULL) rv = ECP_ERR_ALLOC;

    if (!rv) {
        sock->vconn_table.vlink_keys = ecp_ht_create_keys();
        if (sock->vconn_table.vlink_keys == NULL) rv = ECP_ERR_ALLOC;
    }

    if (rv) {
#ifdef ECP_WITH_PTHREAD
        pthread_mutex_destroy(&sock->vconn_table.vlink_keys_mutex);
        pthread_mutex_destroy(&sock->vconn_table.vconn_keys_mutex);
#endif

        if (sock->vconn_table.vlink_keys) ecp_ht_destroy(sock->vconn_table.vlink_keys);
        if (sock->vconn_table.vconn_keys) ecp_ht_destroy(sock->vconn_table.vconn_keys);
    }

#endif  /* ECP_WITH_HTABLE */

    return rv;
}

void ecp_vconn_sock_destroy(ECPSocket *sock) {
#ifdef ECP_WITH_HTABLE

    ecp_ht_destroy(sock->vconn_table.vlink_keys);
    ecp_ht_destroy(sock->vconn_table.vconn_keys);

#ifdef ECP_WITH_PTHREAD
    pthread_mutex_destroy(&sock->vconn_table.vlink_keys_mutex);
    pthread_mutex_destroy(&sock->vconn_table.vconn_keys_mutex);
#endif

#endif  /* ECP_WITH_HTABLE */
}

int ecp_vconn_handler_init(ECPContext *ctx, ECPConnHandler *vconn_handler) {
    int rv;

    ecp_conn_handler_init(vconn_handler, ecp_vconn_handle_open, ecp_vconn_handle_close, ecp_vconn_handle_msg, ecp_vconn_handle_err);
    ecp_conn_handler_set_oreq_f(vconn_handler, ecp_vconn_send_open_req);
    rv = ecp_ctx_set_handler(ctx, ECP_CTYPE_VCONN, vconn_handler);
    return rv;
}

int ecp_vlink_handler_init(ECPContext *ctx, ECPConnHandler *vlink_handler) {
    int rv;

    ecp_conn_handler_init(vlink_handler, ecp_vlink_handle_open, ecp_vlink_handle_close, ecp_vlink_handle_msg, NULL);
    rv = ecp_ctx_set_handler(ctx, ECP_CTYPE_VLINK, vlink_handler);
    return rv;
}