diff options
43 files changed, 966 insertions, 2408 deletions
diff --git a/ecp/src/ecp/Makefile b/ecp/src/ecp/Makefile index c403829..af65ee0 100644 --- a/ecp/src/ecp/Makefile +++ b/ecp/src/ecp/Makefile @@ -1,11 +1,9 @@ include common.mk -obj = core.o timer.o -subdirs = crypto $(platform_dir) +obj += core.o timer.o +subdirs += crypto $(platform_dir) build_dir = ../../build-$(platform) -include $(platform_dir)/platform_obj.mk - %.o: %.c $(CC) $(CFLAGS) -c $< @@ -21,6 +19,7 @@ all: $(obj) install: all mkdir -p $(build_dir) + rm -f $(build_dir)/*.a install libecp.a $(build_dir) install crypto/libecpcr.a $(build_dir) install $(platform_dir)/libecptm.a $(build_dir) diff --git a/ecp/src/ecp/common.mk b/ecp/src/ecp/common.mk index 4c511f8..fbc935a 100644 --- a/ecp/src/ecp/common.mk +++ b/ecp/src/ecp/common.mk @@ -5,4 +5,45 @@ src_dir := $(abspath $(dir $(lastword $(MAKEFILE_LIST)))/..) platform_dir = $(abspath $(src_dir)/platform/$(platform)) include $(platform_dir)/platform.mk +include $(platform_dir)/features.mk CFLAGS += -I$(src_dir)/ecp -I$(platform_dir) + +ifeq ($(with_dirsrv),yes) +with_dir = yes +endif + +ifeq ($(with_pthread),yes) +CFLAGS += -DECP_WITH_PTHREAD=1 +endif + +ifeq ($(with_htable),yes) +CFLAGS += -DECP_WITH_HTABLE=1 +subdirs += htable +endif + +ifeq ($(with_vconn),yes) +CFLAGS += -DECP_WITH_VCONN=1 +subdirs += vconn +endif + +ifeq ($(with_rbuf),yes) +CFLAGS += -DECP_WITH_RBUF=1 +subdirs += ext +endif + +ifeq ($(with_msgq),yes) +CFLAGS += -DECP_WITH_MSGQ=1 +endif + +ifeq ($(with_dir),yes) +CFLAGS += -DECP_WITH_DIR=1 +subdirs += dir +endif + +ifeq ($(with_dirsrv),yes) +CFLAGS += -DECP_WITH_DIRSRV=1 +endif + +ifeq ($(with_debug),yes) +CFLAGS += -DECP_DEBUG=1 +endif diff --git a/ecp/src/ecp/core.c b/ecp/src/ecp/core.c index 3cb236f..536efff 100644 --- a/ecp/src/ecp/core.c +++ b/ecp/src/ecp/core.c @@ -24,6 +24,15 @@ #include "ht.h" #endif +int ecp_dhkey_gen(ECPDHKey *key) { + int rv; + + rv = ecp_ecdh_mkpair(&key->public, &key->private); + if (rv) return rv; + + key->valid = 1; + return ECP_OK; +} int ecp_ctx_init(ECPContext *ctx, ecp_err_handler_t handle_err, ecp_dir_handler_t handle_dir, ecp_conn_alloc_t conn_alloc, ecp_conn_free_t conn_free) { int rv; @@ -71,13 +80,19 @@ int ecp_node_init(ECPNode *node, ecp_ecdh_public_t *public, void *addr) { return ECP_OK; } -int ecp_dhkey_gen(ECPDHKey *key) { +void ecp_node_set_pub(ECPNode *node, ecp_ecdh_public_t *public) { + ECPDHPub *key = &node->key_perma; + + memcpy(&key->public, public, sizeof(key->public)); + key->valid = 1; +} + +int ecp_node_set_addr(ECPNode *node, void *addr) { int rv; - rv = ecp_ecdh_mkpair(&key->public, &key->private); - if (rv) return rv; + rv = ecp_tr_addr_set(&node->addr, addr); + if (rv) return ECP_ERR_NET_ADDR; - key->valid = 1; return ECP_OK; } @@ -127,31 +142,43 @@ static int conn_table_insert(ECPConnection *conn) { int i, rv = ECP_OK; if (ecp_conn_is_outb(conn)) { - if (!ecp_conn_is_open(conn)) rv = ecp_ht_insert(sock->conn_table.addrs, &conn->remote.addr, conn); - if (rv) return rv; + if (ecp_conn_is_root(conn) && !ecp_conn_is_open(conn)) { + rv = ecp_ht_insert(sock->conn_table.addrs, &conn->remote.addr, conn); + if (rv) return rv; + } for (i=0; i<ECP_MAX_CONN_KEY; i++) { - if (conn->key[i].valid) rv = ecp_ht_insert(sock->conn_table.keys, &conn->key[i].public, conn); - if (rv) { - int j; - - for (j=0; j<i; j++) { - if (conn->key[j].valid) ecp_ht_remove(sock->conn_table.keys, &conn->key[j].public); + if (conn->key[i].valid) { + rv = ecp_ht_insert(sock->conn_table.keys, &conn->key[i].public, conn); + if (rv) { + int j; + + for (j=0; j<i; j++) { + if (conn->key[j].valid) { + ecp_ht_remove(sock->conn_table.keys, &conn->key[j].public); + } + } + if (ecp_conn_is_root(conn) && !ecp_conn_is_open(conn)) { + ecp_ht_remove(sock->conn_table.addrs, &conn->remote.addr); + } + return rv; } - if (!ecp_conn_is_open(conn)) ecp_ht_remove(sock->conn_table.addrs, &conn->remote.addr); - return rv; } } } else { for (i=0; i<ECP_MAX_NODE_KEY; i++) { - if (conn->rkey[i].valid) rv = ecp_ht_insert(sock->conn_table.keys, &conn->rkey[i].public, conn); - if (rv) { - int j; - - for (j=0; j<i; j++) { - if (conn->rkey[j].valid) ecp_ht_remove(sock->conn_table.keys, &conn->rkey[j].public); + if (conn->rkey[i].valid) { + rv = ecp_ht_insert(sock->conn_table.keys, &conn->rkey[i].public, conn); + if (rv) { + int j; + + for (j=0; j<i; j++) { + if (conn->rkey[j].valid) { + ecp_ht_remove(sock->conn_table.keys, &conn->rkey[j].public); + } + } + return rv; } - return rv; } } } @@ -171,12 +198,18 @@ static void conn_table_remove(ECPConnection *conn) { #ifdef ECP_WITH_HTABLE if (ecp_conn_is_outb(conn)) { for (i=0; i<ECP_MAX_CONN_KEY; i++) { - if (conn->key[i].valid) ecp_ht_remove(sock->conn_table.keys, &conn->key[i].public); + if (conn->key[i].valid) { + ecp_ht_remove(sock->conn_table.keys, &conn->key[i].public); + } + } + if (ecp_conn_is_root(conn) && !ecp_conn_is_open(conn)) { + ecp_ht_remove(sock->conn_table.addrs, &conn->remote.addr); } - if (!ecp_conn_is_open(conn)) ecp_ht_remove(sock->conn_table.addrs, &conn->remote.addr); } else { for (i=0; i<ECP_MAX_NODE_KEY; i++) { - if (conn->rkey[i].valid) ecp_ht_remove(sock->conn_table.keys, &conn->rkey[i].public); + if (conn->rkey[i].valid) { + ecp_ht_remove(sock->conn_table.keys, &conn->rkey[i].public); + } } } #else @@ -202,7 +235,13 @@ static void conn_table_remove_addr(ECPConnection *conn) { #endif } -static ECPConnection *conn_table_search(ECPSocket *sock, unsigned char c_idx, ecp_ecdh_public_t *c_public, ecp_tr_addr_t *addr) { +static ECPConnection *conn_table_search(ECPSocket *sock, unsigned char c_idx, ecp_ecdh_public_t *c_public, ecp_tr_addr_t *addr, ECPConnection *parent) { +#ifdef ECP_WITH_VCONN + if ((c_public == NULL) && parent) { + return parent->next; + } +#endif + #ifdef ECP_WITH_HTABLE if (c_public) { return ecp_ht_search(sock->conn_table.keys, c_public); @@ -217,27 +256,33 @@ static ECPConnection *conn_table_search(ECPSocket *sock, unsigned char c_idx, ec if (c_public) { if (ecp_conn_is_outb(conn)) { - if (c_idx >= ECP_MAX_CONN_KEY) return ECP_ERR_ECDH_IDX; + if (c_idx >= ECP_MAX_CONN_KEY) return NULL; for (i=0; i<sock->conn_table.size; i++) { conn = sock->conn_table.arr[i]; - if (conn->key[c_idx].valid && ecp_ecdh_pub_eq(c_public, &conn->key[c_idx].public)) return conn; + if (conn->key[c_idx].valid && ecp_ecdh_pub_eq(c_public, &conn->key[c_idx].public)) { + return conn; + } } } else { - unsigned char *_c_idx; + unsigned char _c_idx; - if (c_idx & ~ECP_ECDH_IDX_MASK) return ECP_ERR_ECDH_IDX; + if (c_idx & ~ECP_ECDH_IDX_MASK) return NULL; _c_idx = c_idx % ECP_MAX_NODE_KEY; for (i=0; i<sock->conn_table.size; i++) { conn = sock->conn_table.arr[i]; - if (conn->rkey[_c_idx].valid && ecp_ecdh_pub_eq(c_public, &conn->rkey[_c_idx].public)) return conn; + if (conn->rkey[_c_idx].valid && ecp_ecdh_pub_eq(c_public, &conn->rkey[_c_idx].public)) { + return conn; + } } } } else if (addr) { for (i=0; i<sock->conn_table.size; i++) { conn = sock->conn_table.arr[i]; - if (ecp_conn_is_outb(conn) && ecp_tr_addr_eq(&conn->remote.addr, addr)) return conn; + if (ecp_conn_is_root(conn) && ecp_conn_is_outb(conn) && ecp_tr_addr_eq(&conn->remote.addr, addr)) { + return conn; + } } } @@ -399,51 +444,6 @@ int ecp_cookie_verify(ECPSocket *sock, unsigned char *cookie, unsigned char *pub return ECP_ERR_COOKIE; } -ECPConnection *ecp_sock_keys_search(ECPSocket *sock, ecp_ecdh_public_t *public) { - ECPConnection *conn; - -#ifdef ECP_WITH_PTHREAD - pthread_mutex_lock(&sock->conn_table.mutex); -#endif - - conn = ecp_ht_search(sock->conn_table.keys, public); - if (conn) ecp_conn_refcount_inc(conn); - -#ifdef ECP_WITH_PTHREAD - pthread_mutex_unlock(&sock->conn_table.mutex); -#endif - - return conn; -} - -int ecp_sock_keys_insert(ECPSocket *sock, ecp_ecdh_public_t *public, ECPConnection *conn) { - int rv; - -#ifdef ECP_WITH_PTHREAD - pthread_mutex_lock(&sock->conn_table.mutex); -#endif - - rv = ecp_ht_insert(sock->conn_table.keys, public, conn); - -#ifdef ECP_WITH_PTHREAD - pthread_mutex_unlock(&sock->conn_table.mutex); -#endif - - return rv; -} - -void ecp_sock_keys_remove(ECPSocket *sock, ecp_ecdh_public_t *public) { -#ifdef ECP_WITH_PTHREAD - pthread_mutex_lock(&sock->conn_table.mutex); -#endif - - ecp_ht_remove(sock->conn_table.keys, public); - -#ifdef ECP_WITH_PTHREAD - pthread_mutex_unlock(&sock->conn_table.mutex); -#endif -} - static int conn_dhkey_new(ECPConnection *conn, unsigned char idx, ECPDHKey *key) { ECPSocket *sock = conn->sock; @@ -498,7 +498,7 @@ static ECPDHKey *conn_dhkey_get(ECPConnection *conn, unsigned char idx) { static ECPDHPub *conn_dhkey_get_remote(ECPConnection *conn, unsigned char idx) { ECPDHPub *key = NULL; - if (ecp_conn_is_outb(conn) && (idx == ECP_ECDH_IDX_PERMA)) { + if (idx == ECP_ECDH_IDX_PERMA) { key = &conn->remote.key_perma; } else if ((idx & ECP_ECDH_IDX_MASK) == idx) { key = &conn->rkey[idx % ECP_MAX_NODE_KEY]; @@ -668,7 +668,6 @@ void ecp_conn_init(ECPConnection *conn, ECPSocket *sock, unsigned char ctype) { void ecp_conn_reinit(ECPConnection *conn) { conn->flags = 0; - conn->key_curr = ECP_ECDH_IDX_INV; conn->key_next = ECP_ECDH_IDX_INV; conn->rkey_curr = ECP_ECDH_IDX_INV; memset(&conn->key, 0, sizeof(conn->key)); @@ -772,16 +771,22 @@ int ecp_conn_init_inb(ECPConnection *conn, ECPConnection *parent, unsigned char int ecp_conn_init_outb(ECPConnection *conn, ECPNode *node) { ECPDHKey key; + unsigned char key_curr; int rv; + if (conn->key_curr == ECP_ECDH_IDX_INV) { + key_curr = 0; + } else { + key_curr = (conn->key_curr + 1) % ECP_MAX_CONN_KEY; + } rv = ecp_dhkey_gen(&key); if (rv) return rv; - rv = conn_dhkey_new(conn, 0, &key); + rv = conn_dhkey_new(conn, key_curr, &key); if (rv) return rv; if (node) conn->remote = *node; - conn->key_curr = 0; + conn->key_curr = key_curr; return ECP_OK; } @@ -913,7 +918,9 @@ void ecp_conn_refcount_inc(ECPConnection *conn) { #ifdef ECP_WITH_PTHREAD pthread_mutex_lock(&conn->mutex); #endif + conn->refcount++; + #ifdef ECP_WITH_PTHREAD pthread_mutex_unlock(&conn->mutex); #endif @@ -926,9 +933,11 @@ void ecp_conn_refcount_dec(ECPConnection *conn) { #ifdef ECP_WITH_PTHREAD pthread_mutex_lock(&conn->mutex); #endif + conn->refcount--; refcount = conn->refcount; is_reg = ecp_conn_is_reg(conn); + #ifdef ECP_WITH_PTHREAD pthread_mutex_unlock(&conn->mutex); #endif @@ -971,21 +980,44 @@ int ecp_conn_dhkey_new(ECPConnection *conn) { return ECP_OK; } -int ecp_conn_dhkey_get(ECPSocket *sock, unsigned char idx, ECPDHKey *key) { +int ecp_conn_dhkey_get(ECPConnection *conn, unsigned char idx, ECPDHKey *key) { int rv = ECP_OK; #ifdef ECP_WITH_PTHREAD - pthread_mutex_lock(&sock->mutex); + pthread_mutex_lock(&conn->mutex); #endif if (idx < ECP_MAX_CONN_KEY) { - *key = sock->key[idx]; + *key = conn->key[idx]; } else { rv = ECP_ERR_ECDH_IDX; } #ifdef ECP_WITH_PTHREAD - pthread_mutex_unlock(&sock->mutex); + pthread_mutex_unlock(&conn->mutex); +#endif + + if (!rv && !key->valid) rv = ECP_ERR_ECDH_IDX; + return rv; +} + +int ecp_conn_dhkey_get_remote(ECPConnection *conn, unsigned char idx, ECPDHPub *key) { + int rv = ECP_OK; + +#ifdef ECP_WITH_PTHREAD + pthread_mutex_lock(&conn->mutex); +#endif + + if (idx == ECP_ECDH_IDX_PERMA) { + *key = conn->remote.key_perma; + } else if ((idx & ECP_ECDH_IDX_MASK) == idx) { + *key = conn->rkey[idx % ECP_MAX_NODE_KEY]; + } else { + rv = ECP_ERR_ECDH_IDX; + } + +#ifdef ECP_WITH_PTHREAD + pthread_mutex_unlock(&conn->mutex); #endif if (!rv && !key->valid) rv = ECP_ERR_ECDH_IDX; @@ -1213,16 +1245,16 @@ ssize_t ecp_send_init_req(ECPConnection *conn) { return _send_ireq(conn, &ti); } -ssize_t ecp_handle_init_req(ECPSocket *sock, ECPConnection *parent, ecp_tr_addr_t *addr, unsigned char *public_buf, ecp_aead_key_t *shkey) { +ssize_t ecp_handle_init_req(ECPSocket *sock, ECPConnection *parent, ecp_tr_addr_t *addr, unsigned char c_idx, unsigned char *public_buf, ecp_aead_key_t *shkey) { ssize_t rv; - rv = ecp_send_init_rep(sock, parent, addr, public_buf, shkey); + rv = ecp_send_init_rep(sock, parent, addr, c_idx, public_buf, shkey); if (rv < 0) return rv; return 0; } -ssize_t ecp_send_init_rep(ECPSocket *sock, ECPConnection *parent, ecp_tr_addr_t *addr, unsigned char *public_buf, ecp_aead_key_t *shkey) { +ssize_t ecp_send_init_rep(ECPSocket *sock, ECPConnection *parent, ecp_tr_addr_t *addr, unsigned char c_idx, unsigned char *public_buf, ecp_aead_key_t *shkey) { ECPBuffer packet; ECPBuffer payload; ECPPktMeta pkt_meta; @@ -1251,12 +1283,12 @@ ssize_t ecp_send_init_rep(ECPSocket *sock, ECPConnection *parent, ecp_tr_addr_t ecp_sock_get_nonce(sock, &nonce); pkt_meta.cookie = NULL; - pkt_meta.public = NULL; pkt_meta.shkey = shkey; pkt_meta.nonce = &nonce; pkt_meta.ntype = ECP_NTYPE_INB; - pkt_meta.s_idx = 0xf; - pkt_meta.c_idx = 0xf; + pkt_meta.public = (ecp_ecdh_public_t *)public_buf; + pkt_meta.s_idx = ECP_ECDH_IDX_PERMA; + pkt_meta.c_idx = c_idx; rv = ecp_pld_send_irep(sock, parent, addr, &packet, &pkt_meta, &payload, ECP_SIZE_PLD(1+ECP_SIZE_ECDH_PUB+ECP_SIZE_COOKIE, ECP_MTYPE_INIT_REP), 0); return rv; @@ -1324,15 +1356,15 @@ ssize_t ecp_write_open_req(ECPConnection *conn, ECPBuffer *payload) { if (vbox) { ECPSocket *sock = conn->sock; ECPDHKey key; - ECPDHPub *remote_key; + ECPDHPub remote_key; ecp_ecdh_public_t public; ecp_aead_key_t vbox_shkey; ecp_nonce_t vbox_nonce; - remote_key = &conn->remote.key_perma; + _rv = ECP_OK; if (payload->size < ECP_SIZE_PLD(2+ECP_SIZE_VBOX, ECP_MTYPE_OPEN_REQ)) _rv = ECP_ERR_SIZE; - if (!_rv && !remote_key->valid) _rv = ECP_ERR; if (!_rv) _rv = ecp_sock_dhkey_get(sock, ECP_ECDH_IDX_PERMA, &key); + if (!_rv) _rv = ecp_conn_dhkey_get_remote(conn, ECP_ECDH_IDX_PERMA, &remote_key); if (!_rv) _rv = ecp_conn_dhkey_get_pub(conn, NULL, &public, 0); if (_rv) return _rv; @@ -1343,9 +1375,10 @@ ssize_t ecp_write_open_req(ECPConnection *conn, ECPBuffer *payload) { ecp_nonce2buf(msg, &vbox_nonce); msg += ECP_SIZE_NONCE; - ecp_ecdh_shkey(&vbox_shkey, &remote_key->public, &key.private); + ecp_ecdh_shkey(&vbox_shkey, &remote_key.public, &key.private); rv = ecp_aead_enc(msg, payload->size - (msg - payload->buffer), (unsigned char *)&public, ECP_SIZE_ECDH_PUB, &vbox_shkey, &vbox_nonce, ECP_NTYPE_VBOX); if (rv < 0) return rv; + rv += ECP_SIZE_ECDH_PUB + ECP_SIZE_NONCE; } return ECP_SIZE_PLD(2+rv, ECP_MTYPE_OPEN_REQ); @@ -1354,8 +1387,8 @@ ssize_t ecp_write_open_req(ECPConnection *conn, ECPBuffer *payload) { ssize_t ecp_send_open_req(ECPConnection *conn, unsigned char *cookie) { ECPBuffer packet; ECPBuffer payload; - unsigned char pkt_buf[ECP_SIZE_PKT_BUF_WCOOKIE(2+ECP_SIZE_VBOX, ECP_MTYPE_OPEN_REQ, conn)]; - unsigned char pld_buf[ECP_SIZE_PLD_BUF(2+ECP_SIZE_VBOX, ECP_MTYPE_OPEN_REQ, conn)]; + unsigned char pkt_buf[ECP_SIZE_PKT_BUF(2+ECP_SIZE_VBOX, ECP_MTYPE_OPEN_REQ, conn)+ECP_SIZE_COOKIE]; + unsigned char pld_buf[ECP_SIZE_PLD_BUF(2+ECP_SIZE_VBOX, ECP_MTYPE_OPEN_REQ, conn)+ECP_SIZE_COOKIE]; ssize_t rv; packet.buffer = pkt_buf; @@ -1500,12 +1533,14 @@ ssize_t ecp_handle_open(ECPConnection *conn, unsigned char mtype, unsigned char if (ecp_conn_is_inb(conn)) { ssize_t _rv; + ecp_tr_release(bufs->packet, 1); + _rv = ecp_send_open_rep(conn); if (_rv < 0) { ecp_conn_close(conn); return _rv; } - } else { + } else if (ecp_conn_is_root(conn)) { ecp_conn_remove_addr(conn); } return rsize; @@ -1563,7 +1598,7 @@ ssize_t ecp_send_keyx_rep(ECPConnection *conn) { return rv; } -ssize_t ecp_handle_keyx(ECPConnection *conn, unsigned char mtype, unsigned char *msg, size_t msg_size) { +ssize_t ecp_handle_keyx(ECPConnection *conn, unsigned char mtype, unsigned char *msg, size_t msg_size, ECP2Buffer *bufs) { ssize_t rv; int _rv; @@ -1579,6 +1614,8 @@ ssize_t ecp_handle_keyx(ECPConnection *conn, unsigned char mtype, unsigned char } else { if (ecp_conn_is_outb(conn)) return ECP_ERR; + ecp_tr_release(bufs->packet, 1); + rv = ecp_send_keyx_rep(conn); if (rv < 0) return rv; } @@ -1595,7 +1632,7 @@ ssize_t ecp_msg_handle(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, case ECP_MTYPE_KEYX_REQ: case ECP_MTYPE_KEYX_REP: - return ecp_handle_keyx(conn, mtype, msg, msg_size); + return ecp_handle_keyx(conn, mtype, msg, msg_size, bufs); default: return ecp_ext_msg_handle(conn, seq, mtype, msg, msg_size, bufs); @@ -1696,7 +1733,7 @@ ssize_t ecp_unpack(ECPSocket *sock, ECPConnection *parent, ecp_tr_addr_t *addr, pthread_mutex_lock(&sock->conn_table.mutex); #endif - conn = conn_table_search(sock, c_idx, (ecp_ecdh_public_t *)public_buf, addr); + conn = conn_table_search(sock, c_idx, (ecp_ecdh_public_t *)public_buf, addr, parent); #ifdef ECP_WITH_PTHREAD if (conn) pthread_mutex_lock(&conn->mutex); @@ -1827,7 +1864,13 @@ ssize_t ecp_unpack(ECPSocket *sock, ECPConnection *parent, ecp_tr_addr_t *addr, switch (mtype) { case ECP_MTYPE_INIT_REQ: { - rv = ecp_handle_init_req(sock, parent, addr, public_buf, &shkey); + unsigned char _public_buf[ECP_SIZE_ECDH_PUB]; + + /* we should release incoming packet before sending reply packet */ + memcpy(_public_buf, public_buf, sizeof(_public_buf)); + ecp_tr_release(bufs->packet, 1); + + rv = ecp_handle_init_req(sock, parent, addr, c_idx, _public_buf, &shkey); if (rv < 0) return rv; rv += hdr_size; @@ -1873,6 +1916,9 @@ ssize_t ecp_unpack(ECPSocket *sock, ECPConnection *parent, ecp_tr_addr_t *addr, switch (mtype) { case ECP_MTYPE_INIT_REP: { + /* we should release incoming packet before sending reply packet */ + ecp_tr_release(bufs->packet, 1); + rv = ecp_handle_init_rep(conn, msg, msg_size); if (rv < 0) goto unpack_err; @@ -2112,17 +2158,14 @@ static ssize_t _pack_conn(ECPConnection *conn, ECPBuffer *packet, unsigned char nonce = conn->nonce_out; conn->nonce_out++; } -#ifdef ECP_WITH_VCONN - if ((conn->parent == NULL) && addr) *addr = conn->remote.addr; -#else - if (addr) *addr = conn->remote.addr; -#endif + if (ecp_conn_is_root(conn) && addr) *addr = conn->remote.addr; pack_conn_fin: #ifdef ECP_WITH_PTHREAD pthread_mutex_unlock(&conn->mutex); #endif + if (rv) return rv; pkt_meta.cookie = cookie; @@ -2135,15 +2178,21 @@ pack_conn_fin: return _pack(packet, &pkt_meta, payload, pld_size); } -ssize_t ecp_pack(ECPConnection *parent, ECPBuffer *packet, ECPPktMeta *pkt_meta, ECPBuffer *payload, size_t pld_size, ecp_tr_addr_t *addr) { +ssize_t ecp_pack_irep(ECPConnection *parent, ECPBuffer *packet, ECPPktMeta *pkt_meta, ECPBuffer *payload, size_t pld_size, ecp_tr_addr_t *addr) { ssize_t rv; + if (parent == NULL) { + pkt_meta->public = NULL; + pkt_meta->c_idx = 0xf; + pkt_meta->s_idx = 0xf; + } + rv = _pack(packet, pkt_meta, payload, pld_size); if (rv < 0) return rv; #ifdef ECP_WITH_VCONN if (parent) { - rv = ecp_vconn_pack_parent(parent, packet, payload, rv, addr); + rv = ecp_vconn_pack_parent(parent, payload, packet, rv, addr); } #endif @@ -2158,7 +2207,7 @@ ssize_t ecp_pack_conn(ECPConnection *conn, ECPBuffer *packet, unsigned char s_id #ifdef ECP_WITH_VCONN if (conn->parent) { - rv = ecp_vconn_pack_parent(conn->parent, packet, payload, rv, addr); + rv = ecp_vconn_pack_parent(conn->parent, payload, packet, rv, addr); } #endif @@ -2291,7 +2340,7 @@ ssize_t ecp_pld_send_irep(ECPSocket *sock, ECPConnection *parent, ecp_tr_addr_t ecp_tr_addr_t _addr; ssize_t rv; - rv = ecp_pack(parent, packet, pkt_meta, payload, pld_size, addr ? NULL : &_addr); + rv = ecp_pack_irep(parent, packet, pkt_meta, payload, pld_size, addr ? NULL : &_addr); if (rv < 0) return rv; rv = ecp_pkt_send(sock, packet, rv, flags, NULL, addr ? addr : &_addr); diff --git a/ecp/src/ecp/core.h b/ecp/src/ecp/core.h index 6fb165f..85fc453 100644 --- a/ecp/src/ecp/core.h +++ b/ecp/src/ecp/core.h @@ -73,17 +73,20 @@ #else #define ECP_SIZE_PLD_BUF(X,T,C) (ECP_SIZE_PLD(X,T)) #endif - -#define ECP_SIZE_PKT_BUF(X,T,C) (ECP_SIZE_PLD_BUF(X,T,C)+ECP_SIZE_PKT_HDR+ECP_SIZE_AEAD_TAG) -#define ECP_SIZE_PKT_BUF_WCOOKIE(X,T,C) (ECP_SIZE_PKT_BUF(X,T,C)+ECP_SIZE_COOKIE) +#define ECP_SIZE_PKT_BUF(X,T,C) (ECP_SIZE_PKT_HDR+ECP_SIZE_PLD_BUF(X,T,C)+ECP_SIZE_AEAD_TAG) #ifdef ECP_WITH_VCONN #define ECP_SIZE_PLD_BUF_IREP(X,T,P) (ECP_SIZE_PLD(X,T)+((P) ? ((P)->pcount+1)*(ECP_SIZE_PKT_HDR+ECP_SIZE_MTYPE+ECP_SIZE_AEAD_TAG) : 0)) #else #define ECP_SIZE_PLD_BUF_IREP(X,T,P) (ECP_SIZE_PLD(X,T)) #endif +#define ECP_SIZE_PKT_BUF_IREP(X,T,P) (ECP_SIZE_PKT_HDR+ECP_SIZE_PLD_BUF_IREP(X,T,P)+ECP_SIZE_AEAD_TAG) -#define ECP_SIZE_PKT_BUF_IREP(X,T,P) (ECP_SIZE_PLD_BUF_IREP(X,T,P)+ECP_SIZE_PKT_HDR-ECP_SIZE_ECDH_PUB+ECP_SIZE_AEAD_TAG) +#ifdef ECP_WITH_VCONN +#define ecp_conn_is_root(C) ((C)->parent == NULL) +#else +#define ecp_conn_is_root(C) 1 +#endif #define ECP_SEND_TRIES 3 #define ECP_SEND_TIMEOUT 500 @@ -302,11 +305,15 @@ typedef struct ECPConnection { #endif } ECPConnection; +int ecp_dhkey_gen(ECPDHKey *key); + int ecp_init(ECPContext *ctx); int ecp_ctx_init(ECPContext *ctx, ecp_err_handler_t handle_err, ecp_dir_handler_t handle_dir, ecp_conn_alloc_t conn_alloc, ecp_conn_free_t conn_free); int ecp_ctx_set_handler(ECPContext *ctx, ECPConnHandler *handler, unsigned char ctype); + int ecp_node_init(ECPNode *node, ecp_ecdh_public_t *public, void *addr); -int ecp_dhkey_gen(ECPDHKey *key); +void ecp_node_set_pub(ECPNode *node, ecp_ecdh_public_t *public); +int ecp_node_set_addr(ECPNode *node, void *addr); int ecp_sock_init(ECPSocket *sock, ECPContext *ctx, ECPDHKey *key); int ecp_sock_create(ECPSocket *sock, ECPContext *ctx, ECPDHKey *key); @@ -321,10 +328,6 @@ void ecp_sock_get_nonce(ECPSocket *sock, ecp_nonce_t *nonce); int ecp_cookie_gen(ECPSocket *sock, unsigned char *cookie, unsigned char *public_buf); int ecp_cookie_verify(ECPSocket *sock, unsigned char *cookie, unsigned char *public_buf); -ECPConnection *ecp_sock_keys_search(ECPSocket *sock, ecp_ecdh_public_t *public); -int ecp_sock_keys_insert(ECPSocket *sock, ecp_ecdh_public_t *public, ECPConnection *conn); -void ecp_sock_keys_remove(ECPSocket *sock, ecp_ecdh_public_t *public); - int ecp_conn_alloc(ECPSocket *sock, unsigned char ctype, ECPConnection **_conn); void ecp_conn_free(ECPConnection *conn); @@ -354,7 +357,8 @@ void ecp_conn_refcount_inc(ECPConnection *conn); void ecp_conn_refcount_dec(ECPConnection *conn); int ecp_conn_dhkey_new(ECPConnection *conn); -int ecp_conn_dhkey_get(ECPSocket *sock, unsigned char idx, ECPDHKey *key); +int ecp_conn_dhkey_get(ECPConnection *conn, unsigned char idx, ECPDHKey *key); +int ecp_conn_dhkey_get_remote(ECPConnection *conn, unsigned char idx, ECPDHPub *key); int ecp_conn_dhkey_get_pub(ECPConnection *conn, unsigned char *idx, ecp_ecdh_public_t *public, int will_send); int ecp_conn_dhkey_set_pub(ECPConnection *conn, unsigned char idx, ecp_ecdh_public_t *public); void ecp_conn_dhkey_set_curr(ECPConnection *conn); @@ -367,8 +371,8 @@ ecp_dir_handler_t ecp_get_dir_handler(ECPConnection *conn); void ecp_err_handle(ECPConnection *conn, unsigned char mtype, int err); ssize_t ecp_send_init_req(ECPConnection *conn); -ssize_t ecp_handle_init_req(ECPSocket *sock, ECPConnection *parent, ecp_tr_addr_t *addr, unsigned char *public_buf, ecp_aead_key_t *shkey); -ssize_t ecp_send_init_rep(ECPSocket *sock, ECPConnection *parent, ecp_tr_addr_t *addr, unsigned char *public_buf, ecp_aead_key_t *shkey); +ssize_t ecp_handle_init_req(ECPSocket *sock, ECPConnection *parent, ecp_tr_addr_t *addr, unsigned char c_idx, unsigned char *public_buf, ecp_aead_key_t *shkey); +ssize_t ecp_send_init_rep(ECPSocket *sock, ECPConnection *parent, ecp_tr_addr_t *addr, unsigned char c_idx, unsigned char *public_buf, ecp_aead_key_t *shkey); ssize_t ecp_handle_init_rep(ECPConnection *conn, unsigned char *msg, size_t msg_size); ssize_t ecp_write_open_req(ECPConnection *conn, ECPBuffer *payload); ssize_t ecp_send_open_req(ECPConnection *conn, unsigned char *cookie); @@ -378,7 +382,7 @@ ssize_t ecp_handle_open(ECPConnection *conn, unsigned char mtype, unsigned char ssize_t ecp_send_keyx_req(ECPConnection *conn); ssize_t ecp_send_keyx_rep(ECPConnection *conn); -ssize_t ecp_handle_keyx(ECPConnection *conn, unsigned char mtype, unsigned char *msg, size_t msg_size); +ssize_t ecp_handle_keyx(ECPConnection *conn, unsigned char mtype, unsigned char *msg, size_t msg_size, ECP2Buffer *bufs); ssize_t ecp_msg_handle(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, unsigned char *msg, size_t msg_size, ECP2Buffer *bufs); ssize_t ecp_pld_handle_one(ECPConnection *conn, ecp_seq_t seq, unsigned char *payload, size_t pld_size, ECP2Buffer *bufs); @@ -392,7 +396,7 @@ ssize_t ecp_pkt_send(ECPSocket *sock, ECPBuffer *packet, size_t pkt_size, unsign void ecp_nonce2buf(unsigned char *b, ecp_nonce_t *n); void ecp_buf2nonce(ecp_nonce_t *n, unsigned char *b); int ecp_pkt_get_seq(unsigned char *pkt, size_t pkt_size, ecp_seq_t *s); -ssize_t ecp_pack(ECPConnection *parent, ECPBuffer *packet, ECPPktMeta *pkt_meta, ECPBuffer *payload, size_t pld_size, ecp_tr_addr_t *addr); +ssize_t ecp_pack_irep(ECPConnection *parent, ECPBuffer *packet, ECPPktMeta *pkt_meta, ECPBuffer *payload, size_t pld_size, ecp_tr_addr_t *addr); ssize_t ecp_pack_conn(ECPConnection *conn, ECPBuffer *packet, unsigned char s_idx, unsigned char c_idx, unsigned char *cookie, ecp_nonce_t *nonce, ECPBuffer *payload, size_t pld_size, ecp_tr_addr_t *addr); int ecp_pld_get_type(unsigned char *pld, size_t pld_size, unsigned char *mtype); diff --git a/ecp/src/ecp/dir/Makefile b/ecp/src/ecp/dir/Makefile index 9da375b..9283144 100644 --- a/ecp/src/ecp/dir/Makefile +++ b/ecp/src/ecp/dir/Makefile @@ -1,6 +1,10 @@ include ../common.mk -obj = dir.o dir_srv.o +obj = dir.o + +ifeq ($(with_dirsrv),yes) +obj += dir_srv.o +endif %.o: %.c diff --git a/ecp/src/ecp/ext.h b/ecp/src/ecp/ext.h index 811b6d1..995cf15 100644 --- a/ecp/src/ecp/ext.h +++ b/ecp/src/ecp/ext.h @@ -1,3 +1,5 @@ +#ifdef ECP_WITH_RBUF + int ecp_ext_err_handle(ECPConnection *conn, unsigned char mtype, int err); int ecp_ext_conn_open(ECPConnection *conn); void ecp_ext_conn_destroy(ECPConnection *conn); @@ -6,3 +8,16 @@ ssize_t ecp_ext_pld_store(ECPConnection *conn, ecp_seq_t seq, unsigned char *pay ssize_t ecp_ext_pld_handle(ECPConnection *conn, ecp_seq_t seq, unsigned char *payload, size_t pld_size, ECP2Buffer *bufs); ssize_t ecp_ext_pld_send(ECPConnection *conn, ECPBuffer *payload, size_t pld_size, ECPBuffer *packet, size_t pkt_size, unsigned char flags, ECPTimerItem *ti, ecp_tr_addr_t *addr); ssize_t ecp_ext_msg_send(ECPConnection *conn, unsigned char mtype, unsigned char *msg, size_t msg_size, ECPBuffer *packet, ECPBuffer *payload); + +#else + +#define ecp_ext_err_handle(c,t,e) (ECP_PASS) +#define ecp_ext_conn_open(c) (ECP_OK) +#define ecp_ext_conn_destroy(c) ; +#define ecp_ext_msg_handle(c,s,t,m,sz,b) (0) +#define ecp_ext_pld_store(c,s,p,sz,b) (0) +#define ecp_ext_pld_handle(c,s,p,sz,b) (0) +#define ecp_ext_pld_send(c,p1,sz1,p2,sz2,f,t,a) (0) +#define ecp_ext_msg_send(c,t,m,sz,p1,p2) (0) + +#endif
\ No newline at end of file diff --git a/ecp/src/ecp/tr.h b/ecp/src/ecp/tr.h index 5037b07..263577c 100644 --- a/ecp/src/ecp/tr.h +++ b/ecp/src/ecp/tr.h @@ -4,8 +4,6 @@ int ecp_tr_addr_eq(ecp_tr_addr_t *addr1, ecp_tr_addr_t *addr2); int ecp_tr_addr_set(ecp_tr_addr_t *addr, void *addr_s); int ecp_tr_open(ECPSocket *sock, void *addr_s); void ecp_tr_close(ECPSocket *sock); -ssize_t ecp_tr_send(ECPSocket *sock, ECPBuffer *packet, size_t msg_size, ecp_tr_addr_t *addr, unsigned char flags); +ssize_t ecp_tr_send(ECPSocket *sock, ECPBuffer *packet, size_t pkt_size, ecp_tr_addr_t *addr, unsigned char flags); ssize_t ecp_tr_recv(ECPSocket *sock, ECPBuffer *packet, ecp_tr_addr_t *addr, int timeout); void ecp_tr_release(ECPBuffer *packet, unsigned char more); -void ecp_tr_flag_set(unsigned char flags); -void ecp_tr_flag_clear(unsigned char flags); diff --git a/ecp/src/ecp/vconn/vconn.c b/ecp/src/ecp/vconn/vconn.c index bbed3c3..23e0466 100644 --- a/ecp/src/ecp/vconn/vconn.c +++ b/ecp/src/ecp/vconn/vconn.c @@ -3,79 +3,35 @@ #include <core.h> -#include "vconn.h" - -ssize_t ecp_vconn_send_open_req(ECPConnection *conn, unsigned char *cookie) { - if (conn->type == ECP_CTYPE_VCONN) { - ECPDHPub *key; - ECPBuffer packet; - ECPBuffer payload; - unsigned char pkt_buf[ECP_SIZE_PKT_BUF_WCOOKIE(2+ECP_SIZE_VBOX, ECP_MTYPE_OPEN_REQ, conn)+ECP_SIZE_PLD(ECP_SIZE_ECDH_PUB, ECP_MTYPE_NEXT)]; - unsigned char pld_buf[ECP_SIZE_PLD_BUF(2+ECP_SIZE_VBOX, ECP_MTYPE_OPEN_REQ, conn)+ECP_SIZE_PLD(ECP_SIZE_ECDH_PUB, ECP_MTYPE_NEXT)]; - unsigned char *msg; - unsigned char *_pld_buf; - size_t _pld_size; - ssize_t rv; - - if (conn->next == NULL) return ECP_ERR; - - key = &conn->next->remote.key_perma; - if (!key->valid) return ECP_ERR; - - 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; +#ifdef ECP_WITH_HTABLE +#include <ht.h> +#endif - _pld_buf = payload.buffer + rv; - _pld_size = payload.size - rv; +#include "vconn.h" - ecp_pld_set_type(_pld_buf, _pld_size, ECP_MTYPE_NEXT); - msg = ecp_pld_get_msg(_pld_buf, _pld_size); - memcpy(msg, &key->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; - } else { - return ecp_send_open_req(conn, cookie); - } -} +#ifdef ECP_WITH_HTABLE -static void insert_key_next(ECPConnection *conn, unsigned char idx, ecp_ecdh_public_t *public) { +static int insert_key_next(ECPConnection *conn, unsigned char c_idx, ecp_ecdh_public_t *public) { + ECPSocket *sock = conn->sock; ECPVConn *_conn = (ECPVConn *)conn; - ecp_ecdh_public_t to_remove; - unsigned char c_idx; - int do_insert = 0, do_remove = 0; - - if (idx == ECP_ECDH_IDX_INV) return; + ECPDHPub *key = NULL; + int rv = ECP_OK; - c_idx = (idx & 0x0F); - if (c_idx & ~ECP_ECDH_IDX_MASK) return; + if (c_idx & ~ECP_ECDH_IDX_MASK) return ECP_ERR_ECDH_IDX; #ifdef ECP_WITH_PTHREAD pthread_mutex_lock(&conn->mutex); #endif if (c_idx != _conn->key_next_curr) { - ECPDHPub *key; unsigned char _c_idx; _c_idx = c_idx % ECP_MAX_NODE_KEY; key = &_conn->key_next[_c_idx]; - if (!key->valid || (memcmp(public, &key->public, sizeof(key->public)) != 0)) { - if (key->valid) { - memcpy(&to_remove, &key->public, sizeof(key->public)); - do_remove = 1; - } - memcpy(&key->public, public, sizeof(key->public)); - key->valid = 1; - - _conn->key_next_curr = c_idx; - do_insert = 1; + if (key->valid && (memcmp(public, &key->public, sizeof(key->public)) == 0)) { + key = NULL; } } @@ -83,164 +39,162 @@ static void insert_key_next(ECPConnection *conn, unsigned char idx, ecp_ecdh_pub pthread_mutex_unlock(&conn->mutex); #endif - if (do_remove) ecp_sock_keys_remove(conn->sock, &to_remove); - if (do_insert) ecp_sock_keys_insert(conn->sock, public, conn); + if (key) { +#ifdef ECP_WITH_PTHREAD + pthread_mutex_lock(&sock->conn_table.mutex); + pthread_mutex_lock(&conn->mutex); +#endif + + if (key->valid) { + ecp_ht_remove(sock->conn_table.keys, &key->public); + key->valid = 0; + } + memcpy(&key->public, public, sizeof(key->public)); + rv = ecp_ht_insert(sock->conn_table.keys, &key->public, conn); + if (!rv) { + key->valid = 1; + _conn->key_next_curr = c_idx; + } + +#ifdef ECP_WITH_PTHREAD + pthread_mutex_unlock(&conn->mutex); + pthread_mutex_unlock(&sock->conn_table.mutex); +#endif + } + + return rv; } static ssize_t handle_next(ECPConnection *conn, unsigned char *msg, size_t msg_size, ECP2Buffer *b) { - ECPConnection *conn_next; + ECPSocket *sock = conn->sock; if (msg_size < ECP_SIZE_ECDH_PUB) return ECP_ERR_SIZE; + if (ecp_conn_is_outb(conn)) return ECP_ERR; - conn_next = ecp_sock_keys_search(conn->sock, (ecp_ecdh_public_t *)msg); - if (conn_next == NULL) return ECP_ERR; - - conn->next = conn_next; - - return ECP_SIZE_ECDH_PUB; -} +#ifdef ECP_WITH_PTHREAD + pthread_mutex_lock(&sock->conn_table.mutex); +#endif -static ssize_t handle_exec(ECPConnection *conn, unsigned char *msg, size_t msg_size, ECP2Buffer *b) { - ECPBuffer *packet; + conn->next = ecp_ht_search(sock->conn_table.keys, (ecp_ecdh_public_t *)msg); + if (conn->next) ecp_conn_refcount_inc(conn->next); - if (b == NULL) return ECP_ERR; +#ifdef ECP_WITH_PTHREAD + pthread_mutex_unlock(&sock->conn_table.mutex); +#endif - packet = b->packet; - if (packet->size < msg_size) return ECP_ERR_SIZE; + if (conn->next == NULL) return ECP_ERR; - memcpy(packet->buffer, msg, msg_size); - return ecp_pkt_handle(conn->sock, conn, NULL, b, msg_size); + return ECP_SIZE_ECDH_PUB; } static ssize_t handle_relay(ECPConnection *conn, unsigned char *msg, size_t msg_size, ECP2Buffer *b) { - ECPBuffer payload; + ECPSocket *sock = conn->sock; ECPConnection *conn_next; + ECPBuffer payload; + unsigned char idx, _idx; + unsigned char s_idx, c_idx; + size_t _msg_size = msg_size; ssize_t rv; + int _rv; if (msg_size < ECP_MIN_PKT) return ECP_ERR_SIZE; - if (conn->type == ECP_CTYPE_VCONN) { - if (ecp_conn_is_outb(conn)) return ECP_ERR; - conn_next = conn->next; - insert_key_next(conn, msg[ECP_SIZE_PROTO], (ecp_ecdh_public_t *)(msg+ECP_SIZE_PROTO+1)); - } else if (conn->type == ECP_CTYPE_VLINK) { - conn_next = ecp_sock_keys_search(conn->sock, (ecp_ecdh_public_t *)(msg+ECP_SIZE_PROTO+1)); - } + idx = msg[ECP_SIZE_PROTO]; + if (idx == ECP_ECDH_IDX_INV) return ECP_ERR_ECDH_IDX; - if (conn_next == NULL) return ECP_ERR; + switch (conn->type) { + /* forward message */ + case ECP_CTYPE_VCONN: { + if (ecp_conn_is_outb(conn)) return ECP_ERR; - payload.buffer = msg - ECP_SIZE_MTYPE; - payload.size = b->payload->size - (payload.buffer - b->payload->buffer); - - ecp_pld_set_type(payload.buffer, payload.size, ECP_MTYPE_EXEC); - rv = ecp_pld_send(conn_next, b->packet, &payload, ECP_SIZE_MTYPE + msg_size, ECP_SEND_FLAG_REPLY); - - if (conn->type == ECP_CTYPE_VLINK) { - ecp_conn_refcount_dec(conn_next); - } - - if (rv < 0) return rv; - return msg_size; -} - -ssize_t ecp_vconn_pack_parent(ECPConnection *conn, ECPBuffer *packet, ECPBuffer *payload, size_t pkt_size, ecp_tr_addr_t *addr) { - unsigned char *msg; - size_t hdr_size; - int rv; + conn_next = conn->next; + if (conn_next) { + _idx = (idx & 0x0F); - rv = ecp_pld_set_type(payload->buffer, payload->size, ECP_MTYPE_RELAY); - if (rv) return rv; + _rv = insert_key_next(conn, _idx, (ecp_ecdh_public_t *)(msg+ECP_SIZE_PROTO+1)); + if (_rv) return _rv; + } - msg = ecp_pld_get_msg(payload->buffer, payload->size); - if (msg == NULL) return ECP_ERR; + break; + } - hdr_size = msg - payload->buffer; - if (payload->size < pkt_size+hdr_size) return ECP_ERR_SIZE; + /* back message */ + case ECP_CTYPE_VLINK: { +#ifdef ECP_WITH_PTHREAD + pthread_mutex_lock(&sock->conn_table.mutex); +#endif - memcpy(msg, packet->buffer, pkt_size); - return ecp_pack_conn(conn, packet, ECP_ECDH_IDX_INV, ECP_ECDH_IDX_INV, NULL, NULL, payload, pkt_size+hdr_size, addr); -} + conn_next = ecp_ht_search(sock->conn_table.keys, (ecp_ecdh_public_t *)(msg+ECP_SIZE_PROTO+1)); + if (conn_next) ecp_conn_refcount_inc(conn_next); -int ecp_vconn_handle_open(ECPConnection *conn, ECP2Buffer *b) { - if (conn->type == ECP_CTYPE_VCONN) { - if (ecp_conn_is_outb(conn)) { - if (conn->next) { - int rv; +#ifdef ECP_WITH_PTHREAD + pthread_mutex_unlock(&sock->conn_table.mutex); +#endif - rv = ecp_conn_open(conn->next, NULL); - if (rv) ecp_err_handle(conn->next, ECP_MTYPE_INIT_REQ, rv); + _idx = (idx & 0xF0) >> 4; + if (conn_next && (_idx == ECP_ECDH_IDX_PERMA)) { + /* this is init reply */ + msg[ECP_SIZE_PROTO] = ECP_ECDH_IDX_INV; + memmove(msg+ECP_SIZE_PROTO+1, msg+ECP_SIZE_PROTO+1+ECP_SIZE_ECDH_PUB, msg_size-(ECP_SIZE_PROTO+1+ECP_SIZE_ECDH_PUB)); + _msg_size -= ECP_SIZE_ECDH_PUB; } - } - } else if (conn->type == ECP_CTYPE_VLINK) { - ECPDHPub *key = &conn->remote.key_perma; - if (key->valid) { - int rv; - - rv = ecp_sock_keys_insert(conn->sock, &key->public, conn); - if (rv) return rv; + break; } - } - return ECP_OK; -} - -void ecp_vconn_handle_close(ECPConnection *conn) { - if (conn->type == ECP_CTYPE_VCONN) { - if (ecp_conn_is_inb(conn)) { - ecp_vconn_destroy_inb((ECPVConn *)conn); - } - } else if (conn->type == ECP_CTYPE_VLINK) { - ECPDHPub *key = &conn->remote.key_perma; + default: + return ECP_ERR_CTYPE; - if (key->valid) { - ecp_sock_keys_remove(conn->sock, &key->public); - } } -} -ssize_t ecp_vconn_handle_msg(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, unsigned char *msg, size_t msg_size, ECP2Buffer *b) { - switch (mtype) { - case ECP_MTYPE_NEXT: - return handle_next(conn, msg, msg_size, b); + if (conn_next == NULL) return ECP_ERR; - case ECP_MTYPE_EXEC: - return handle_exec(conn, msg, msg_size, b); + payload.buffer = msg - ECP_SIZE_MTYPE; + payload.size = b->payload->size - (payload.buffer - b->payload->buffer); - case ECP_MTYPE_RELAY: - return handle_relay(conn, msg, msg_size, b); + ecp_pld_set_type(payload.buffer, payload.size, ECP_MTYPE_EXEC); + rv = ecp_pld_send(conn_next, b->packet, &payload, ECP_SIZE_MTYPE + _msg_size, ECP_SEND_FLAG_REPLY); - default: - return ECP_ERR_MTYPE; + if (conn->type == ECP_CTYPE_VLINK) { + ecp_conn_refcount_dec(conn_next); } + + if (rv < 0) return rv; + return msg_size; } -int ecp_vconn_create_inb(ECPVConn *conn, ECPSocket *sock) { - ECPConnection *_conn = &conn->b; - int rv; +#endif /* ECP_WITH_HTABLE */ - rv = ecp_conn_create_inb(_conn, sock, ECP_CTYPE_VCONN); - if (rv) return rv; +static ssize_t handle_exec(ECPConnection *conn, unsigned char *msg, size_t msg_size, ECP2Buffer *b) { + ECPBuffer *packet; - memset(conn->key_next, 0, sizeof(conn->key_next)); - conn->key_next_curr = ECP_ECDH_IDX_INV; + if (b == NULL) return ECP_ERR; - return ECP_OK; + packet = b->packet; + if (packet->size < msg_size) return ECP_ERR_SIZE; + + memcpy(packet->buffer, msg, msg_size); + return ecp_pkt_handle(conn->sock, conn, NULL, b, msg_size); } -void ecp_vconn_destroy_inb(ECPVConn *conn) { - ECPConnection *_conn = &conn->b; - int i; +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; + ssize_t rv; + int _rv; - for (i=0; i<ECP_MAX_NODE_KEY; i++) { - ECPDHPub *key; + _rv = ecp_pld_set_type(payload->buffer, payload->size, ECP_MTYPE_RELAY); + if (_rv) return _rv; - key = &conn->key_next[i]; - if (key->valid) { - ecp_sock_keys_remove(_conn->sock, &key->public); - } - } - if (_conn->next) ecp_conn_refcount_dec(_conn->next); + msg = ecp_pld_get_msg(payload->buffer, payload->size); + if (msg == NULL) return ECP_ERR; + + hdr_size = msg - payload->buffer; + if (payload->size < pkt_size+hdr_size) return ECP_ERR_SIZE; + + memcpy(msg, packet->buffer, pkt_size); + rv = ecp_pack_conn(conn, packet, ECP_ECDH_IDX_INV, ECP_ECDH_IDX_INV, NULL, NULL, payload, pkt_size+hdr_size, addr); + return rv; } static int vconn_create(ECPConnection vconn[], ecp_ecdh_public_t keys[], size_t vconn_size, ECPSocket *sock) { @@ -249,7 +203,7 @@ static int vconn_create(ECPConnection vconn[], ecp_ecdh_public_t keys[], size_t int rv; key.valid = 1; - for (i=0; i<vconn_size; j++) { + for (i=0; i<vconn_size; i++) { rv = ecp_conn_create(&vconn[i], sock, ECP_CTYPE_VCONN); if (rv) { for (j=0; j<i; j++) { @@ -272,7 +226,7 @@ int ecp_vconn_create(ECPConnection vconn[], ecp_ecdh_public_t keys[], size_t vco _conn = conn; pcount = vconn_size; - if (pcount >= ECP_MAX_PARENT) return ECP_ERR_MAX_PARENT; + if (pcount > ECP_MAX_PARENT) return ECP_ERR_MAX_PARENT; rv = vconn_create(vconn, keys, vconn_size, conn->sock); if (rv) return rv; @@ -289,6 +243,50 @@ int ecp_vconn_create(ECPConnection vconn[], ecp_ecdh_public_t keys[], size_t vco return ECP_OK; } +#ifdef ECP_WITH_HTABLE + +int ecp_vconn_create_inb(ECPVConn *conn, ECPSocket *sock) { + ECPConnection *_conn = &conn->b; + int rv; + + rv = ecp_conn_create_inb(_conn, sock, ECP_CTYPE_VCONN); + if (rv) return rv; + + memset(conn->key_next, 0, sizeof(conn->key_next)); + conn->key_next_curr = ECP_ECDH_IDX_INV; + + return ECP_OK; +} + +void ecp_vconn_destroy(ECPConnection *conn) { + ECPSocket *sock = conn->sock; + ECPVConn *_conn = (ECPVConn *)conn; + int i; + + if (ecp_conn_is_outb(conn)) return; + +#ifdef ECP_WITH_PTHREAD + pthread_mutex_lock(&sock->conn_table.mutex); +#endif + + for (i=0; i<ECP_MAX_NODE_KEY; i++) { + ECPDHPub *key; + + key = &_conn->key_next[i]; + if (key->valid) { + ecp_ht_remove(sock->conn_table.keys, &key->public); + } + } + +#ifdef ECP_WITH_PTHREAD + pthread_mutex_unlock(&sock->conn_table.mutex); +#endif + + if (conn->next) ecp_conn_refcount_dec(conn->next); +} + +#endif /* ECP_WITH_HTABLE */ + int ecp_vconn_open(ECPConnection *conn, ECPNode *node) { ECPConnection *vconn0; int rv; @@ -307,64 +305,195 @@ int ecp_vconn_open(ECPConnection *conn, ECPNode *node) { return rv; } -/* -int ecp_vconn_create_parent(ECPConnection *conn, ECPNode *conn_node, ECPVConnOut vconn[], ECPNode vconn_node[], int size) { +static int vconn_handle_open(ECPConnection *conn) { + int rv = ECP_OK; + + if (ecp_conn_is_outb(conn) && conn->next) { + rv = ecp_conn_open(conn->next, NULL); + if (rv) ecp_err_handle(conn->next, ECP_MTYPE_INIT_REQ, rv); + } + + return rv;; +} + +int ecp_vlink_create(ECPConnection *conn, ECPSocket *sock) { + int rv; + + rv = ecp_conn_create(conn, sock, ECP_CTYPE_VLINK); + if (!rv) ecp_conn_set_flags(conn, ECP_CONN_FLAG_VBOX); + return rv; +} + +#ifdef ECP_WITH_HTABLE + +int ecp_vlink_create_inb(ECPConnection *conn, ECPSocket *sock) { + int rv; + + rv = ecp_conn_create_inb(conn, sock, ECP_CTYPE_VLINK); + if (!rv) ecp_conn_set_flags(conn, ECP_CONN_FLAG_VBOX); + return rv; +} + +void ecp_vlink_destroy(ECPConnection *conn) { ECPSocket *sock = conn->sock; - int i, j, rv; + ECPDHPub *key = &conn->remote.key_perma; - conn->parent = (ECPConnection *)&vconn[size-1]; - conn->pcount = size; - for (i=0; i<size; i++) { - rv = ecp_conn_init((ECPConnection *)&vconn[i], sock, ECP_CTYPE_VCONN); - if (!rv) rv = ecp_conn_create_outb((ECPConnection *)&vconn[i], &vconn_node[i]); - if (!rv) { - rv = ecp_conn_insert((ECPConnection *)&vconn[i]); - if (rv) ecp_conn_destroy((ECPConnection *)&vconn[i]); - } - if (rv) { - for (j=0; j<i; j++) ecp_conn_close((ECPConnection *)&vconn[j]); - return rv; - } + if (key->valid) { +#ifdef ECP_WITH_PTHREAD + pthread_mutex_lock(&sock->conn_table.mutex); +#endif - if (i == 0) { - vconn[i].b.parent = NULL; - } else { - vconn[i].b.parent = (ECPConnection *)&vconn[i-1]; - } - vconn[i].b.pcount = i; + ecp_ht_remove(sock->conn_table.keys, &key->public); + +#ifdef ECP_WITH_PTHREAD + pthread_mutex_unlock(&sock->conn_table.mutex); +#endif + } +} + +static int vlink_handle_open(ECPConnection *conn) { + ECPSocket *sock = conn->sock; + ECPDHPub *key; + int rv = ECP_OK; + + key = &conn->remote.key_perma; - if (i == size - 1) { - vconn[i].next = conn; - } else { - vconn[i].next = (ECPConnection *)&vconn[i+1]; +#ifdef ECP_WITH_PTHREAD + pthread_mutex_lock(&sock->conn_table.mutex); + pthread_mutex_lock(&conn->mutex); +#endif + + if (key->valid) { + ECPConnection *_conn; + + /* check for duplicates */ + _conn = ecp_ht_search(sock->conn_table.keys, &key->public); + if (_conn) { +#ifdef ECP_WITH_PTHREAD + pthread_mutex_lock(&_conn->mutex); +#endif + + _conn->remote.key_perma.valid = 0; + +#ifdef ECP_WITH_PTHREAD + pthread_mutex_unlock(&_conn->mutex); +#endif + + ecp_ht_remove(sock->conn_table.keys, &key->public); } + rv = ecp_ht_insert(sock->conn_table.keys, &key->public, conn); } - return ECP_OK; +#ifdef ECP_WITH_PTHREAD + pthread_mutex_unlock(&conn->mutex); + pthread_mutex_unlock(&sock->conn_table.mutex); +#endif + + return rv; } -int ecp_vconn_open(ECPConnection *conn, ECPNode *conn_node, ECPVConnOut vconn[], ECPNode vconn_node[], int size) { +#endif /* ECP_WITH_HTABLE */ + +int ecp_vconn_handle_open(ECPConnection *conn, ECP2Buffer *b) { int rv; - ssize_t _rv; - rv = ecp_conn_create_outb(conn, conn_node); - if (rv) return rv; + switch (conn->type) { + case ECP_CTYPE_VCONN: + rv = vconn_handle_open(conn); + break; - rv = ecp_conn_insert(conn); - if (rv) { - ecp_conn_destroy(conn); - return rv; + case ECP_CTYPE_VLINK: +#ifdef ECP_WITH_HTABLE + rv = vlink_handle_open(conn); +#else + rv = ECP_OK; +#endif + break; + + default: + rv = ECP_ERR_CTYPE; + break; } - rv = ecp_vconn_create_parent(conn, conn_node, vconn, vconn_node, size); - if (rv) { - ecp_conn_close(conn); - return rv; + return rv; +} + +void ecp_vconn_handle_close(ECPConnection *conn) { + switch (conn->type) { +#ifdef ECP_WITH_HTABLE + case ECP_CTYPE_VCONN: + ecp_vconn_destroy(conn); + break; + + case ECP_CTYPE_VLINK: + ecp_vlink_destroy(conn); + break; +#endif } +} - _rv = ecp_timer_send((ECPConnection *)&vconn[0], _vconn_send_kget, ECP_MTYPE_KGET_REP, 3, 500); - if (_rv < 0) return _rv; +ssize_t ecp_vconn_handle_msg(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, unsigned char *msg, size_t msg_size, ECP2Buffer *b) { + ssize_t rv; - return ECP_OK; + switch (mtype) { +#ifdef ECP_WITH_HTABLE + case ECP_MTYPE_NEXT: + rv = handle_next(conn, msg, msg_size, b); + break; + + case ECP_MTYPE_RELAY: + rv = handle_relay(conn, msg, msg_size, b); + break; +#endif + + case ECP_MTYPE_EXEC: + rv = handle_exec(conn, msg, msg_size, b); + break; + + default: + rv = ECP_ERR_MTYPE; + break; + } + + return rv; +} + +ssize_t ecp_vconn_send_open_req(ECPConnection *conn, unsigned char *cookie) { + if (conn->type == ECP_CTYPE_VCONN) { + ECPDHPub key_next; + ECPBuffer packet; + ECPBuffer payload; + unsigned char pkt_buf[ECP_SIZE_PKT_BUF(2+ECP_SIZE_VBOX, ECP_MTYPE_OPEN_REQ, conn)+ECP_SIZE_COOKIE+ECP_SIZE_PLD(ECP_SIZE_ECDH_PUB, ECP_MTYPE_NEXT)]; + unsigned char pld_buf[ECP_SIZE_PLD_BUF(2+ECP_SIZE_VBOX, ECP_MTYPE_OPEN_REQ, conn)+ECP_SIZE_COOKIE+ECP_SIZE_PLD(ECP_SIZE_ECDH_PUB, ECP_MTYPE_NEXT)]; + unsigned char *msg; + unsigned char *_pld_buf; + size_t _pld_size; + ssize_t rv; + int _rv; + + if (conn->next == NULL) return ECP_ERR; + + _rv = ecp_conn_dhkey_get_remote(conn->next, ECP_ECDH_IDX_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; + } else { + return ecp_send_open_req(conn, cookie); + } } -*/
\ No newline at end of file diff --git a/ecp/src/ecp/vconn/vconn.h b/ecp/src/ecp/vconn/vconn.h index eec13d4..9e2749f 100644 --- a/ecp/src/ecp/vconn/vconn.h +++ b/ecp/src/ecp/vconn/vconn.h @@ -12,14 +12,22 @@ typedef struct ECPVConn { unsigned char key_next_curr; } ECPVConn; -ssize_t ecp_vconn_send_open_req(ECPConnection *conn, unsigned char *cookie); -ssize_t ecp_vconn_pack_parent(ECPConnection *conn, ECPBuffer *packet, ECPBuffer *payload, size_t pkt_size, ecp_tr_addr_t *addr); -int ecp_vconn_handle_open(ECPConnection *conn, ECP2Buffer *b); -void ecp_vconn_handle_close(ECPConnection *conn); -ssize_t ecp_vconn_handle_msg(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, unsigned char *msg, size_t msg_size, ECP2Buffer *b); - -int ecp_vconn_create_inb(ECPVConn *conn, ECPSocket *sock); -void ecp_vconn_destroy_inb(ECPVConn *conn); +ssize_t ecp_vconn_pack_parent(ECPConnection *conn, ECPBuffer *payload, ECPBuffer *packet, size_t pkt_size, ecp_tr_addr_t *addr); int ecp_vconn_create(ECPConnection vconn[], ecp_ecdh_public_t keys[], size_t vconn_size, ECPConnection *conn); +#ifdef ECP_WITH_HTABLE +int ecp_vconn_create_inb(ECPVConn *conn, ECPSocket *sock); +void ecp_vconn_destroy(ECPConnection *conn); +#endif int ecp_vconn_open(ECPConnection *conn, ECPNode *node); + +int ecp_vlink_create(ECPConnection *conn, ECPSocket *sock); +#ifdef ECP_WITH_HTABLE +int ecp_vlink_create_inb(ECPConnection *conn, ECPSocket *sock); +void ecp_vlink_destroy(ECPConnection *conn); +#endif + +int ecp_vconn_handle_open(ECPConnection *conn, ECP2Buffer *b); +void ecp_vconn_handle_close(ECPConnection *conn); +ssize_t ecp_vconn_handle_msg(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, unsigned char *msg, size_t msg_size, ECP2Buffer *b); +ssize_t ecp_vconn_send_open_req(ECPConnection *conn, unsigned char *cookie); diff --git a/ecp/src/platform/fe310/platform.mk b/ecp/src/platform/fe310/platform.mk index 0230f29..0ab0065 100644 --- a/ecp/src/platform/fe310/platform.mk +++ b/ecp/src/platform/fe310/platform.mk @@ -1,3 +1,3 @@ fe310_dir = $(abspath $(src_dir)/../../fw/fe310) include $(fe310_dir)/platform.mk -CFLAGS += -I$(fe310_dir) -DECP_WITH_VCONN=1 -DECP_DEBUG=1 -D__FE310__ +CFLAGS += -I$(fe310_dir) -D__FE310__ diff --git a/ecp/src/platform/fe310/platform_obj.mk b/ecp/src/platform/fe310/platform_obj.mk deleted file mode 100644 index 52e4bb1..0000000 --- a/ecp/src/platform/fe310/platform_obj.mk +++ /dev/null @@ -1 +0,0 @@ -subdirs += vconn diff --git a/ecp/src/platform/fe310/transport.c b/ecp/src/platform/fe310/transport.c index b551c51..2640ecf 100644 --- a/ecp/src/platform/fe310/transport.c +++ b/ecp/src/platform/fe310/transport.c @@ -1,5 +1,6 @@ #include <stdlib.h> #include <string.h> +#include <stdio.h> #include <core.h> #include <tr.h> @@ -7,43 +8,42 @@ #include <eos/eos.h> #include <eos/net.h> -static unsigned char _flags = 0; - ECPSocket *_ecp_tr_sock = NULL; +unsigned char pld_buf[ECP_MAX_PLD]; static void packet_handler(unsigned char type, unsigned char *buffer, uint16_t len) { - ecp_tr_addr_t addr; - ECP2Buffer bufs; ECPBuffer packet; ECPBuffer payload; - unsigned char pld_buf[ECP_MAX_PLD]; + ecp_tr_addr_t addr; + ssize_t rv; bufs.packet = &packet; bufs.payload = &payload; packet.buffer = buffer+EOS_SOCK_SIZE_UDP_HDR; - packet.size = ECP_MAX_PKT; + packet.size = EOS_NET_MTU-EOS_SOCK_SIZE_UDP_HDR; payload.buffer = pld_buf; payload.size = ECP_MAX_PLD; - if ((buffer == NULL) || (len < EOS_SOCK_SIZE_UDP_HDR)) { + if (len < EOS_SOCK_SIZE_UDP_HDR) { eos_net_free(buffer, 0); return; } - eos_sock_getfrom(buffer, &addr); - ssize_t rv = ecp_pkt_handle(_ecp_tr_sock, &addr, NULL, &bufs, len-EOS_SOCK_SIZE_UDP_HDR); + eos_sock_recvfrom(buffer, len, NULL, 0, &addr); + + rv = ecp_pkt_handle(_ecp_tr_sock, NULL, &addr, &bufs, len-EOS_SOCK_SIZE_UDP_HDR); #ifdef ECP_DEBUG if (rv < 0) { - char b[16]; - puts("ERR:"); - puts(itoa(rv, b, 10)); - puts("\n"); + printf("RCV ERR:%d\n", rv); } #endif - if (bufs.packet->buffer) eos_net_free(buffer, 0); - eos_net_release(); + if (bufs.packet->buffer) { + eos_net_free(buffer, 0); + } else { + eos_net_release(); + } } int ecp_tr_init(ECPContext *ctx) { @@ -66,38 +66,43 @@ int ecp_tr_addr_set(ecp_tr_addr_t *addr, void *addr_s) { } int ecp_tr_open(ECPSocket *sock, void *addr_s) { - sock->sock = eos_sock_open_udp(packet_handler); + sock->sock = eos_sock_open_udp(packet_handler, NULL); if (sock->sock < 0) { sock->sock = 0; - return ECP_ERR_SEND; + return ECP_ERR; } _ecp_tr_sock = sock; + return ECP_OK; } void ecp_tr_close(ECPSocket *sock) { - eos_sock_close(sock->sock); + eos_sock_close(sock->sock, NULL); _ecp_tr_sock = NULL; } -ssize_t ecp_tr_send(ECPSocket *sock, ECPBuffer *packet, size_t msg_size, ecp_tr_addr_t *addr, unsigned char flags) { +ssize_t ecp_tr_send(ECPSocket *sock, ECPBuffer *packet, size_t pkt_size, ecp_tr_addr_t *addr, unsigned char flags) { unsigned char *buf = NULL; + int reply; int rv; - flags |= _flags; - if (packet && packet->buffer) { - if (flags & ECP_SEND_FLAG_REPLY) { + reply = 0; + if (flags & ECP_SEND_FLAG_REPLY) { + if (flags & ECP_SEND_FLAG_MORE) return ECP_ERR; + if (packet->buffer) { buf = packet->buffer-EOS_SOCK_SIZE_UDP_HDR; packet->buffer = NULL; - } else { - buf = eos_net_alloc(); - memcpy(buf+EOS_SOCK_SIZE_UDP_HDR, packet->buffer, msg_size); + reply = 1; } + } else { + buf = eos_net_alloc(); } if (buf == NULL) return ECP_ERR; - rv = eos_sock_sendto(sock->sock, buf, msg_size+EOS_SOCK_SIZE_UDP_HDR, flags & ECP_SEND_FLAG_MORE, addr); + + rv = eos_sock_sendto_async(sock->sock, reply ? NULL : packet->buffer, pkt_size, addr, buf, !!(flags & ECP_SEND_FLAG_MORE)); if (rv) return ECP_ERR_SEND; - return msg_size; + + return pkt_size; } ssize_t ecp_tr_recv(ECPSocket *sock, ECPBuffer *packet, ecp_tr_addr_t *addr, int timeout) { @@ -105,18 +110,10 @@ ssize_t ecp_tr_recv(ECPSocket *sock, ECPBuffer *packet, ecp_tr_addr_t *addr, int } void ecp_tr_release(ECPBuffer *packet, unsigned char more) { - if (packet && packet->buffer) { + if (packet->buffer) { eos_net_free(packet->buffer-EOS_SOCK_SIZE_UDP_HDR, more); packet->buffer = NULL; } else if (!more) { eos_net_release(); } } - -void ecp_tr_flag_set(unsigned char flags) { - _flags |= flags; -} - -void ecp_tr_flag_clear(unsigned char flags) { - _flags &= ~flags; -} diff --git a/ecp/src/platform/fe310/transport.h b/ecp/src/platform/fe310/transport.h index 213ca11..1e0c526 100644 --- a/ecp/src/platform/fe310/transport.h +++ b/ecp/src/platform/fe310/transport.h @@ -1,4 +1,4 @@ #include <eos/sock.h> -typedef EOSNetAddr ecp_tr_addr_t; +typedef struct EOSNetAddr ecp_tr_addr_t; typedef int ecp_tr_sock_t; diff --git a/ecp/src/platform/posix/platform.mk b/ecp/src/platform/posix/platform.mk index 9dcfe37..8932ac4 100644 --- a/ecp/src/platform/posix/platform.mk +++ b/ecp/src/platform/posix/platform.mk @@ -1,2 +1,2 @@ -CFLAGS += -O3 -DECP_WITH_PTHREAD=1 -DECP_WITH_HTABLE=1 -DECP_WITH_VCONN=1 -DECP_WITH_DIR -DECP_WITH_DIRSRV -DECP_WITH_MSGQ=1 -DECP_DEBUG=1 +CFLAGS += -O3 LDFLAGS += -lm -pthread diff --git a/ecp/src/platform/posix/platform_obj.mk b/ecp/src/platform/posix/platform_obj.mk deleted file mode 100644 index 56a76c3..0000000 --- a/ecp/src/platform/posix/platform_obj.mk +++ /dev/null @@ -1 +0,0 @@ -subdirs += htable vconn ext dir diff --git a/ecp/src/platform/posix/transport.c b/ecp/src/platform/posix/transport.c index 30822b6..ebfbc7b 100644 --- a/ecp/src/platform/posix/transport.c +++ b/ecp/src/platform/posix/transport.c @@ -9,7 +9,7 @@ #include <core.h> #include <tr.h> -#define ADDR_S_MAX 32 +#define MAX_ADDR_STR 32 int ecp_tr_init(ECPContext *ctx) { return ECP_OK; @@ -28,13 +28,13 @@ int ecp_tr_addr_eq(ecp_tr_addr_t *addr1, ecp_tr_addr_t *addr2) { int ecp_tr_addr_set(ecp_tr_addr_t *addr, void *addr_s) { int rv; - char addr_c[ADDR_S_MAX]; + char addr_c[MAX_ADDR_STR]; char *colon = NULL; char *endptr = NULL; uint16_t hport; memset(addr_c, 0, sizeof(addr_c)); - strncpy(addr_c, addr_s, ADDR_S_MAX-1); + strncpy(addr_c, addr_s, sizeof(addr_c)-1); colon = strchr(addr_c, ':'); if (colon == NULL) return -1; *colon = '\0'; @@ -51,12 +51,14 @@ int ecp_tr_addr_set(ecp_tr_addr_t *addr, void *addr_s) { int ecp_tr_open(ECPSocket *sock, void *addr_s) { struct sockaddr_in _myaddr; + int rv; memset((char *)&_myaddr, 0, sizeof(_myaddr)); _myaddr.sin_family = AF_INET; if (addr_s) { ecp_tr_addr_t addr; - int rv = ecp_tr_addr_set(&addr, addr_s); + + rv = ecp_tr_addr_set(&addr, addr_s); if (rv) return rv; memcpy((void *)&_myaddr.sin_addr, addr.host, sizeof(addr.host)); @@ -69,11 +71,12 @@ int ecp_tr_open(ECPSocket *sock, void *addr_s) { sock->sock = socket(PF_INET, SOCK_DGRAM, 0); if (sock->sock < 0) return sock->sock; - int rv = bind(sock->sock, (struct sockaddr *)&_myaddr, sizeof(_myaddr)); + rv = bind(sock->sock, (struct sockaddr *)&_myaddr, sizeof(_myaddr)); if (rv < 0) { close(sock->sock); return rv; } + return ECP_OK; } @@ -81,14 +84,14 @@ void ecp_tr_close(ECPSocket *sock) { close(sock->sock); } -ssize_t ecp_tr_send(ECPSocket *sock, ECPBuffer *packet, size_t msg_size, ecp_tr_addr_t *addr, unsigned char flags) { +ssize_t ecp_tr_send(ECPSocket *sock, ECPBuffer *packet, size_t pkt_size, ecp_tr_addr_t *addr, unsigned char flags) { struct sockaddr_in servaddr; memset((void *)&servaddr, 0, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_port = addr->port; memcpy((void *)&servaddr.sin_addr, addr->host, sizeof(addr->host)); - return sendto(sock->sock, packet->buffer, msg_size, 0, (struct sockaddr *)&servaddr, sizeof(servaddr)); + return sendto(sock->sock, packet->buffer, pkt_size, 0, (struct sockaddr *)&servaddr, sizeof(servaddr)); } ssize_t ecp_tr_recv(ECPSocket *sock, ECPBuffer *packet, ecp_tr_addr_t *addr, int timeout) { @@ -97,8 +100,9 @@ ssize_t ecp_tr_recv(ECPSocket *sock, ECPBuffer *packet, ecp_tr_addr_t *addr, int struct pollfd fds[] = { {sock->sock, POLLIN, 0} }; + int rv; - int rv = poll(fds, 1, timeout); + rv = poll(fds, 1, timeout); memset((void *)&servaddr, 0, sizeof(servaddr)); if (rv == 1) { ssize_t recvlen = recvfrom(sock->sock, packet->buffer, packet->size, 0, (struct sockaddr *)&servaddr, &addrlen); @@ -111,9 +115,8 @@ ssize_t ecp_tr_recv(ECPSocket *sock, ECPBuffer *packet, ecp_tr_addr_t *addr, int } return recvlen; } + return ECP_ERR_TIMEOUT; } void ecp_tr_release(ECPBuffer *packet, unsigned char more) {} -void ecp_tr_flag_set(unsigned char flags) {} -void ecp_tr_flag_clear(unsigned char flags) {} diff --git a/ecp/test/Makefile b/ecp/test/Makefile index ce12a87..abda4e2 100644 --- a/ecp/test/Makefile +++ b/ecp/test/Makefile @@ -7,11 +7,23 @@ dep=../build-posix/*.a ../util/libecputil.a %.o: %.c $(CC) $(CFLAGS) -c $< -all: basic # dir server echo frag stress vcs vc_server vc_client vc_client_t +all: basic client server vcs vc_server vc_client # dir echo frag stress vc_client_t basic: basic.o init.o $(dep) $(CC) -o $@ $< init.o $(dep) $(LDFLAGS) +vcs: vcs.o init_vconn.o $(dep) + $(CC) -o $@ $< init_vconn.o $(dep) $(LDFLAGS) + +vc_server: vc_server.o init_vconn.o $(dep) + $(CC) -o $@ $< init_vconn.o $(dep) $(LDFLAGS) + +vc_server2: vc_server2.o init_vconn.o $(dep) + $(CC) -o $@ $< init_vconn.o $(dep) $(LDFLAGS) + +vc_client: vc_client.o init_vconn.o $(dep) + $(CC) -o $@ $< init_vconn.o $(dep) $(LDFLAGS) + dir: dir.o init.o $(dep) $(CC) -DWITH_DIR_SERVER -o $@ $< init.o $(dep) $(LDFLAGS) @@ -30,15 +42,6 @@ frag: frag.o init.o $(dep) stress: stress.o init.o $(dep) $(CC) -o $@ $< init.o $(dep) $(LDFLAGS) -vcs: vcs.o init_vconn.o $(dep) - $(CC) -o $@ $< init_vconn.o $(dep) $(LDFLAGS) - -vc_server: vc_server.o init_vconn.o $(dep) - $(CC) -o $@ $< init_vconn.o $(dep) $(LDFLAGS) - -vc_client: vc_client.o init_vconn.o $(dep) - $(CC) -o $@ $< init_vconn.o $(dep) $(LDFLAGS) - vc_client_t: vc_client_t.o init_vconn.o $(dep) $(CC) -o $@ $< init_vconn.o $(dep) $(LDFLAGS) diff --git a/ecp/test/basic.c b/ecp/test/basic.c index 2edb174..b266a07 100644 --- a/ecp/test/basic.c +++ b/ecp/test/basic.c @@ -1,26 +1,23 @@ -#include <stdio.h> #include <string.h> #include <unistd.h> +#include <stdio.h> #include <core.h> ECPContext ctx_s; ECPSocket sock_s; -ECPDHKey key_perma_s; ECPConnHandler handler_s; ECPContext ctx_c; ECPSocket sock_c; -ECPDHKey key_perma_c; ECPConnHandler handler_c; -ECPNode node; ECPConnection conn; #define CTYPE_TEST 0 #define MTYPE_MSG 0 -int handle_open_c(ECPConnection *conn, ECP2Buffer *b) { +static int handle_open_c(ECPConnection *conn, ECP2Buffer *b) { char *_msg = "PERA JE CAR!"; ssize_t rv; @@ -30,12 +27,12 @@ int handle_open_c(ECPConnection *conn, ECP2Buffer *b) { return ECP_OK; } -ssize_t handle_msg_c(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, unsigned char *msg, size_t msg_size, ECP2Buffer *b) { +static ssize_t handle_msg_c(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, unsigned char *msg, size_t msg_size, ECP2Buffer *b) { printf("MSG C:%s size:%ld\n", msg, msg_size); return msg_size; } -ssize_t handle_msg_s(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, unsigned char *msg, size_t msg_size, ECP2Buffer *b) { +static ssize_t handle_msg_s(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, unsigned char *msg, size_t msg_size, ECP2Buffer *b) { char *_msg = "VAISTINU JE CAR!"; ssize_t rv; @@ -46,6 +43,9 @@ ssize_t handle_msg_s(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, un } int main(int argc, char *argv[]) { + ECPDHKey key_perma_c; + ECPDHKey key_perma_s; + ECPNode node; int rv; /* server */ @@ -96,4 +96,4 @@ int main(int argc, char *argv[]) { printf("ecp_conn_open RV:%d\n", rv); while (1) sleep(1); -}
\ No newline at end of file +} diff --git a/ecp/test/client.c b/ecp/test/client.c index 577a888..d526f76 100644 --- a/ecp/test/client.c +++ b/ecp/test/client.c @@ -1,80 +1,78 @@ -#include <stdio.h> +#include <stdlib.h> #include <string.h> #include <unistd.h> -#include <stdlib.h> +#include <stdio.h> + +#include <core.h> -#include "core.h" -#include "util.h" +#include <util.h> ECPContext ctx; ECPSocket sock; ECPConnHandler handler; - -ECPNode node; ECPConnection conn; #define CTYPE_TEST 0 -#define MTYPE_MSG 8 - -ssize_t handle_open(ECPConnection *conn, ecp_seq_t sq, unsigned char t, unsigned char *p, ssize_t s, ECP2Buffer *b) { - uint32_t seq = 0; - - ecp_conn_handle_open(conn, sq, t, p, s, b); - if (s < 0) { - printf("OPEN ERR:%ld\n", s); - return s; - } - - char *msg = "PERA JE CAR!"; - unsigned char buf[1000]; - - strcpy((char *)buf, msg); - ssize_t _rv = ecp_send(conn, MTYPE_MSG, buf, 1000); - - return s; -} +#define MTYPE_MSG 0 + +static int handle_open(ECPConnection *conn, ECP2Buffer *b) { + char *_msg = "PERA JE CAR!"; + ssize_t rv; + + printf("OPEN\n"); + rv = ecp_msg_send(conn, MTYPE_MSG, (unsigned char *)_msg, strlen(_msg)+1); -ssize_t handle_msg(ECPConnection *conn, ecp_seq_t sq, unsigned char t, unsigned char *p, ssize_t s, ECP2Buffer *b) { - printf("MSG C:%s size:%ld\n", p, s); - return s; + return ECP_OK; } +static ssize_t handle_msg(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, unsigned char *msg, size_t msg_size, ECP2Buffer *b) { + printf("MSG C:%s size:%ld\n", msg, msg_size); + return msg_size; +} static void usage(char *arg) { - fprintf(stderr, "Usage: %s <node.pub>\n", arg); + fprintf(stderr, "Usage: %s <address> <node.pub>\n", arg); exit(1); } int main(int argc, char *argv[]) { + ECPDHKey key_perma; + ECPNode node; + ecp_ecdh_public_t node_pub; int rv; - - if (argc != 2) usage(argv[0]); - + + /* client */ + if (argc != 3) usage(argv[0]); + rv = ecp_init(&ctx); printf("ecp_init RV:%d\n", rv); - rv = ecp_conn_handler_init(&handler); - handler.msg[ECP_MTYPE_OPEN] = handle_open; - handler.msg[MTYPE_MSG] = handle_msg; - ctx.handler[CTYPE_TEST] = &handler; - - rv = ecp_sock_init(&sock, &ctx, NULL); - printf("ecp_sock_init RV:%d\n", rv); + ecp_conn_handler_init(&handler, handle_msg, handle_open, NULL, NULL); + ecp_ctx_set_handler(&ctx, &handler, CTYPE_TEST); + + rv = ecp_dhkey_gen(&key_perma); + printf("ecp_dhkey_gen RV:%d\n", rv); + + rv = ecp_sock_create(&sock, &ctx, &key_perma); + printf("ecp_sock_create RV:%d\n", rv); rv = ecp_sock_open(&sock, NULL); printf("ecp_sock_open RV:%d\n", rv); - + rv = ecp_start_receiver(&sock); printf("ecp_start_receiver RV:%d\n", rv); - rv = ecp_util_node_load(&ctx, &node, argv[1]); - printf("ecp_util_node_load RV:%d\n", rv); + rv = ecp_conn_create(&conn, &sock, CTYPE_TEST); + printf("ecp_conn_create RV:%d\n", rv); + + rv = ecp_util_load_pub(&node_pub, argv[2]); + printf("ecp_util_load_pub RV:%d\n", rv); - rv = ecp_conn_init(&conn, &sock, CTYPE_TEST); - printf("ecp_conn_init RV:%d\n", rv); + rv = ecp_node_init(&node, &node_pub, argv[1]); + printf("ecp_node_init RV:%d\n", rv); rv = ecp_conn_open(&conn, &node); printf("ecp_conn_open RV:%d\n", rv); - + while (1) sleep(1); -}
\ No newline at end of file +} diff --git a/ecp/test/dir.c b/ecp/test/dir.c deleted file mode 100644 index 0c2ac72..0000000 --- a/ecp/test/dir.c +++ /dev/null @@ -1,93 +0,0 @@ -#include <stdio.h> -#include <string.h> -#include <unistd.h> - -#include "core.h" -#include "cr.h" -#include "dir.h" -#include "dir_srv.h" - -ECPContext ctx_s; -ECPSocket sock_s; -ECPDHKey key_perma_s; - -ECPContext ctx_c; -ECPSocket sock_c; -ECPDHKey key_perma_c; -ECPConnHandler handler_c; - -ECPNode node; -ECPConnection conn; - -static ECPDirList dir_online; -static ECPDirList dir_shadow; - -#define CTYPE_TEST 0 - -ssize_t handle_dir(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, unsigned char *msg, ssize_t size, ECP2Buffer *b) { - ECPDirList dir; - ssize_t rv; - - dir.count = 0; - rv = ecp_dir_parse(&dir, msg, size); - if (rv < 0) return rv; - - printf("DIR: %s %ld\n", (char *)ecp_cr_dh_pub_get_buf(&dir.item[0].node.public), size); - - return rv; -} - -int main(int argc, char *argv[]) { - int rv; - - dir_online.count = 1; - strcpy((char *)ecp_cr_dh_pub_get_buf(&dir_online.item[0].node.public), "PERA"); - - rv = ecp_init(&ctx_s); - printf("ecp_init RV:%d\n", rv); - - rv = ecp_dir_init(&ctx_s, &dir_online, &dir_shadow); - printf("ecp_dir_init RV:%d\n", rv); - - rv = ecp_dhkey_gen(&ctx_s, &key_perma_s); - printf("ecp_dhkey_gen RV:%d\n", rv); - - rv = ecp_sock_init(&sock_s, &ctx_s, &key_perma_s); - printf("ecp_sock_init RV:%d\n", rv); - - rv = ecp_sock_open(&sock_s, "0.0.0.0:3000"); - printf("ecp_sock_open RV:%d\n", rv); - - rv = ecp_start_receiver(&sock_s); - printf("ecp_start_receiver RV:%d\n", rv); - - rv = ecp_init(&ctx_c); - printf("ecp_init RV:%d\n", rv); - - rv = ecp_conn_handler_init(&handler_c); - handler_c.msg[ECP_MTYPE_DIR] = handle_dir; - ctx_c.handler[CTYPE_TEST] = &handler_c; - - rv = ecp_dhkey_gen(&ctx_c, &key_perma_c); - printf("ecp_dhkey_gen RV:%d\n", rv); - - rv = ecp_sock_init(&sock_c, &ctx_c, &key_perma_c); - printf("ecp_sock_init RV:%d\n", rv); - - rv = ecp_sock_open(&sock_c, NULL); - printf("ecp_sock_open RV:%d\n", rv); - - rv = ecp_start_receiver(&sock_c); - printf("ecp_start_receiver RV:%d\n", rv); - - rv = ecp_node_init(&node, &key_perma_s.public, "127.0.0.1:3000"); - printf("ecp_node_init RV:%d\n", rv); - - rv = ecp_conn_init(&conn, &sock_c, CTYPE_TEST); - printf("ecp_conn_init RV:%d\n", rv); - - rv = ecp_conn_get_dirlist(&conn, &node); - printf("ecp_conn_get_dirlist RV:%d\n", rv); - - while (1) sleep(1); -}
\ No newline at end of file diff --git a/ecp/test/echo.c b/ecp/test/echo.c deleted file mode 100644 index f3057df..0000000 --- a/ecp/test/echo.c +++ /dev/null @@ -1,56 +0,0 @@ -#include <stdio.h> -#include <string.h> -#include <unistd.h> -#include <stdlib.h> - -#include "core.h" -#include "util.h" - -ECPContext ctx_s; -ECPSocket sock_s; -ECPDHKey key_perma_s; -ECPConnHandler handler_s; - -#define CTYPE_TEST 0 -#define MTYPE_MSG 8 - -ssize_t handle_msg_s(ECPConnection *conn, ecp_seq_t sq, unsigned char t, unsigned char *p, ssize_t s, ECP2Buffer *b) { - unsigned char buf[ECP_MAX_PLD]; - - memcpy(buf, p, s); - ssize_t _rv = ecp_send(conn, t, buf, s); - - return s; -} - -static void usage(char *arg) { - fprintf(stderr, "Usage: %s <address> <node.priv>\n", arg); - exit(1); -} - -int main(int argc, char *argv[]) { - int rv; - - if (argc != 3) usage(argv[0]); - - rv = ecp_init(&ctx_s); - printf("ecp_init RV:%d\n", rv); - - rv = ecp_conn_handler_init(&handler_s); - handler_s.msg[MTYPE_MSG] = handle_msg_s; - ctx_s.handler[CTYPE_TEST] = &handler_s; - - rv = ecp_util_key_load(&ctx_s, &key_perma_s, argv[2]); - printf("ecp_util_key_load RV:%d\n", rv); - - rv = ecp_sock_init(&sock_s, &ctx_s, &key_perma_s); - printf("ecp_sock_init RV:%d\n", rv); - - rv = ecp_sock_open(&sock_s, argv[1]); - printf("ecp_sock_open RV:%d\n", rv); - - rv = ecp_start_receiver(&sock_s); - printf("ecp_start_receiver RV:%d\n", rv); - - while (1) sleep(1); -}
\ No newline at end of file diff --git a/ecp/test/frag.c b/ecp/test/frag.c deleted file mode 100644 index 70b20de..0000000 --- a/ecp/test/frag.c +++ /dev/null @@ -1,122 +0,0 @@ -#include <stdio.h> -#include <string.h> -#include <unistd.h> - -#include "core.h" - -ECPContext ctx_s; -ECPSocket sock_s; -ECPDHKey key_perma_s; -ECPConnHandler handler_s; - -ECPContext ctx_c; -ECPSocket sock_c; -ECPDHKey key_perma_c; -ECPConnHandler handler_c; - -ECPNode node; -ECPConnection conn; - -ECPRBRecv rbuf_recv; -ECPRBMessage rbuf_r_msg[128]; -ECPFragIter frag_iter; -unsigned char frag_buffer[8192]; - -#define CTYPE_TEST 0 -#define MTYPE_MSG 8 - -ssize_t handle_open_c(ECPConnection *conn, ecp_seq_t sq, unsigned char t, unsigned char *p, ssize_t s, ECP2Buffer *b) { - uint32_t seq = 0; - - ecp_conn_handle_open(conn, sq, t, p, s, b); - if (s < 0) { - printf("OPEN ERR:%ld\n", s); - return s; - } - - unsigned char content[1000]; - char *msg = "PERA JE CAR!"; - - strcpy((char *)content, msg); - ssize_t _rv = ecp_send(conn, MTYPE_MSG, content, sizeof(content)); - return s; -} - -ssize_t handle_msg_c(ECPConnection *conn, ecp_seq_t sq, unsigned char t, unsigned char *p, ssize_t s, ECP2Buffer *b) { - printf("MSG C:%s size:%ld\n", p, s); - - ECPRBuffer *rbuf = &conn->rbuf.recv->rbuf; - printf("RBUF: %d %d %d %d\n", rbuf->seq_start, rbuf->seq_max, rbuf->idx_start, rbuf->arr_size); - return s; -} - -ssize_t handle_msg_s(ECPConnection *conn, ecp_seq_t sq, unsigned char t, unsigned char *p, ssize_t s, ECP2Buffer *b) { - printf("MSG S:%s size:%ld\n", p, s); - - unsigned char content[5000]; - char *msg = "VAISTINU JE CAR!"; - - strcpy((char *)content, msg); - ssize_t _rv = ecp_send(conn, MTYPE_MSG, content, sizeof(content)); - return s; -} - -int main(int argc, char *argv[]) { - int rv; - - rv = ecp_init(&ctx_s); - printf("ecp_init RV:%d\n", rv); - - rv = ecp_conn_handler_init(&handler_s); - handler_s.msg[MTYPE_MSG] = handle_msg_s; - ctx_s.handler[CTYPE_TEST] = &handler_s; - - rv = ecp_dhkey_gen(&ctx_s, &key_perma_s); - printf("ecp_dhkey_gen RV:%d\n", rv); - - rv = ecp_sock_init(&sock_s, &ctx_s, &key_perma_s); - printf("ecp_sock_init RV:%d\n", rv); - - rv = ecp_sock_open(&sock_s, "0.0.0.0:3000"); - printf("ecp_sock_open RV:%d\n", rv); - - rv = ecp_start_receiver(&sock_s); - printf("ecp_start_receiver RV:%d\n", rv); - - rv = ecp_init(&ctx_c); - printf("ecp_init RV:%d\n", rv); - - rv = ecp_conn_handler_init(&handler_c); - handler_c.msg[ECP_MTYPE_OPEN] = handle_open_c; - handler_c.msg[MTYPE_MSG] = handle_msg_c; - ctx_c.handler[CTYPE_TEST] = &handler_c; - - rv = ecp_dhkey_gen(&ctx_c, &key_perma_c); - printf("ecp_dhkey_gen RV:%d\n", rv); - - rv = ecp_sock_init(&sock_c, &ctx_c, &key_perma_c); - printf("ecp_sock_init RV:%d\n", rv); - - rv = ecp_sock_open(&sock_c, NULL); - printf("ecp_sock_open RV:%d\n", rv); - - rv = ecp_start_receiver(&sock_c); - printf("ecp_start_receiver RV:%d\n", rv); - - rv = ecp_node_init(&node, &key_perma_s.public, "127.0.0.1:3000"); - printf("ecp_node_init RV:%d\n", rv); - - rv = ecp_conn_init(&conn, &sock_c, CTYPE_TEST); - printf("ecp_conn_init RV:%d\n", rv); - - rv = ecp_rbuf_create(&conn, NULL, NULL, 0, &rbuf_recv, rbuf_r_msg, 128); - printf("ecp_rbuf_create RV:%d\n", rv); - - ecp_frag_iter_init(&frag_iter, frag_buffer, 8192); - rbuf_recv.frag_iter = &frag_iter; - - rv = ecp_conn_open(&conn, &node); - printf("ecp_conn_open RV:%d\n", rv); - - while (1) sleep(1); -}
\ No newline at end of file diff --git a/ecp/test/init_vconn.c b/ecp/test/init_vconn.c index 59e9517..88b6fa0 100644 --- a/ecp/test/init_vconn.c +++ b/ecp/test/init_vconn.c @@ -1,18 +1,12 @@ #include <stdlib.h> -#include <fcntl.h> #include <unistd.h> +#include <stdio.h> -#include "core.h" -#include "vconn/vconn.h" +#include <core.h> +#include <vconn/vconn.h> -static int v_rng(void *buf, size_t bufsize) { - int fd; - - if((fd = open("/dev/urandom", O_RDONLY)) < 0) return -1; - size_t nb = read(fd, buf, bufsize); - close(fd); - if (nb != bufsize) return -1; - return 0; +void handle_err(ECPConnection *conn, unsigned char mtype, int err) { + printf("ERR: CTYPE:0x%x MTYPE:0x%x ERR:%d\n", conn->type, mtype, err); } static ECPConnection *conn_alloc(ECPSocket *sock, unsigned char type) { @@ -21,40 +15,37 @@ static ECPConnection *conn_alloc(ECPSocket *sock, unsigned char type) { switch (type) { case ECP_CTYPE_VCONN: - conn = malloc(sizeof(ECPVConnIn)); + conn = malloc(sizeof(ECPVConn)); + if (conn) rv = ecp_vconn_create_inb((ECPVConn *)conn, sock); + break; + + case ECP_CTYPE_VLINK: + conn = malloc(sizeof(ECPConnection)); + if (conn) rv = ecp_vlink_create_inb(conn, sock); break; + default: conn = malloc(sizeof(ECPConnection)); + if (conn) rv = ecp_conn_create_inb(conn, sock, type); break; } - if (conn == NULL) return NULL; - rv = ecp_conn_init(conn, sock, type); + if (conn == NULL) return NULL; if (rv) { - printf("free1\n"); free(conn); return NULL; } + return conn; } static void conn_free(ECPConnection *conn) { - printf("free2\n"); free(conn); } int ecp_init(ECPContext *ctx) { int rv; - rv = ecp_ctx_init(ctx); - if (rv) return rv; - - rv = ecp_vconn_ctx_init(ctx); - if (rv) return rv; - - ctx->rng = v_rng; - ctx->conn_alloc = conn_alloc; - ctx->conn_free = conn_free; - - return ECP_OK; + rv = ecp_ctx_init(ctx, handle_err, NULL, conn_alloc, conn_free); + return rv; }
\ No newline at end of file diff --git a/ecp/test/server.c b/ecp/test/server.c index fabaf4e..228dbea 100644 --- a/ecp/test/server.c +++ b/ecp/test/server.c @@ -1,10 +1,11 @@ -#include <stdio.h> +#include <stdlib.h> #include <string.h> #include <unistd.h> -#include <stdlib.h> +#include <stdio.h> -#include "core.h" -#include "util.h" +#include <core.h> + +#include <util.h> ECPContext ctx; ECPSocket sock; @@ -12,18 +13,16 @@ ECPDHKey key_perma; ECPConnHandler handler; #define CTYPE_TEST 0 -#define MTYPE_MSG 8 - -ssize_t handle_msg(ECPConnection *conn, ecp_seq_t sq, unsigned char t, unsigned char *p, ssize_t s, ECP2Buffer *b) { - printf("MSG S:%s size:%ld\n", p, s); +#define MTYPE_MSG 0 - char *msg = "VAISTINU JE CAR!"; - unsigned char buf[1000]; +static ssize_t handle_msg(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, unsigned char *msg, size_t msg_size, ECP2Buffer *b) { + char *_msg = "VAISTINU JE CAR!"; + ssize_t rv; - strcpy((char *)buf, msg); - ssize_t _rv = ecp_send(conn, MTYPE_MSG, buf, 1000); + printf("MSG S:%s size:%ld\n", msg, msg_size); + rv = ecp_msg_send(conn, MTYPE_MSG, (unsigned char *)_msg, strlen(_msg)+1); - return s; + return msg_size; } static void usage(char *arg) { @@ -32,28 +31,30 @@ static void usage(char *arg) { } int main(int argc, char *argv[]) { + ECPDHKey key_perma; int rv; - + + /* server */ if (argc != 3) usage(argv[0]); - + rv = ecp_init(&ctx); printf("ecp_init RV:%d\n", rv); - - rv = ecp_conn_handler_init(&handler); - handler.msg[MTYPE_MSG] = handle_msg; - ctx.handler[CTYPE_TEST] = &handler; - - rv = ecp_util_key_load(&ctx, &key_perma, argv[2]); - printf("ecp_util_key_load RV:%d\n", rv); - - rv = ecp_sock_init(&sock, &ctx, &key_perma); - printf("ecp_sock_init RV:%d\n", rv); + + ecp_conn_handler_init(&handler, handle_msg, NULL, NULL, NULL); + ecp_ctx_set_handler(&ctx, &handler, CTYPE_TEST); + + rv = ecp_util_load_key(&key_perma.public, &key_perma.private, argv[2]); + printf("ecp_util_load_key RV:%d\n", rv); + key_perma.valid = 1; + + rv = ecp_sock_create(&sock, &ctx, &key_perma); + printf("ecp_sock_create RV:%d\n", rv); rv = ecp_sock_open(&sock, argv[1]); printf("ecp_sock_open RV:%d\n", rv); - + rv = ecp_start_receiver(&sock); printf("ecp_start_receiver RV:%d\n", rv); while (1) sleep(1); -}
\ No newline at end of file +} diff --git a/ecp/test/vc_client.c b/ecp/test/vc_client.c index cd0ea44..89602ca 100644 --- a/ecp/test/vc_client.c +++ b/ecp/test/vc_client.c @@ -1,70 +1,63 @@ -#include <stdio.h> +#include <stdlib.h> #include <string.h> #include <unistd.h> -#include <stdlib.h> +#include <stdio.h> + +#include <core.h> +#include <vconn/vconn.h> -#include "core.h" -#include "vconn/vconn.h" -#include "util.h" +#include <util.h> ECPContext ctx; ECPSocket sock; ECPConnHandler handler; - ECPConnection conn; -ECPNode node; - -ECPVConnOut vconn[20]; -ECPNode vconn_node[20]; +ECPConnection vconn[3]; #define CTYPE_TEST 0 -#define MTYPE_MSG 8 - -ssize_t handle_open(ECPConnection *conn, ecp_seq_t sq, unsigned char t, unsigned char *p, ssize_t s, ECP2Buffer *b) { - uint32_t seq = 0; - - ecp_conn_handle_open(conn, sq, t, p, s, b); - if (s < 0) { - printf("OPEN ERR:%ld\n", s); - return s; - } - - printf("OPEN!\n"); +#define MTYPE_MSG 0 - char *msg = "PERA JE CAR!"; - unsigned char buf[1156]; +static int handle_open(ECPConnection *conn, ECP2Buffer *b) { + char *_msg = "PERA JE CAR!"; + ssize_t rv; - strcpy((char *)buf, msg); - ssize_t _rv = ecp_send(conn, MTYPE_MSG, buf, 1156); + printf("OPEN\n"); + rv = ecp_msg_send(conn, MTYPE_MSG, (unsigned char *)_msg, strlen(_msg)+1); - return s; + return ECP_OK; } -ssize_t handle_msg(ECPConnection *conn, ecp_seq_t sq, unsigned char t, unsigned char *p, ssize_t s, ECP2Buffer *b) { - printf("MSG S:%s size:%ld\n", p, s); - return s; +static ssize_t handle_msg(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, unsigned char *msg, size_t msg_size, ECP2Buffer *b) { + printf("MSG:%s size:%ld\n", msg, msg_size); + + return msg_size; } static void usage(char *arg) { - fprintf(stderr, "Usage: %s <server.pub> <vcs1.pub> ... <vcsn.pub>\n", arg); + fprintf(stderr, "Usage: %s <server.pub> <address> <vcs0.pub> [ ... <vcsN.pub> ]\n", arg); exit(1); } int main(int argc, char *argv[]) { + ECPDHKey key_perma; + ECPNode node; + ecp_ecdh_public_t node_pub; + ecp_ecdh_public_t vconn_pub[3]; int rv, i; - if ((argc < 3) || (argc > 22)) usage(argv[0]); + if ((argc < 4) || (argc > 6)) usage(argv[0]); rv = ecp_init(&ctx); printf("ecp_init RV:%d\n", rv); - rv = ecp_conn_handler_init(&handler); - handler.msg[ECP_MTYPE_OPEN] = handle_open; - handler.msg[MTYPE_MSG] = handle_msg; - ctx.handler[CTYPE_TEST] = &handler; + ecp_conn_handler_init(&handler, handle_msg, handle_open, NULL, NULL); + ecp_ctx_set_handler(&ctx, &handler, CTYPE_TEST); - rv = ecp_sock_init(&sock, &ctx, NULL); - printf("ecp_sock_init RV:%d\n", rv); + rv = ecp_dhkey_gen(&key_perma); + printf("ecp_dhkey_gen RV:%d\n", rv); + + rv = ecp_sock_create(&sock, &ctx, &key_perma); + printf("ecp_sock_create RV:%d\n", rv); rv = ecp_sock_open(&sock, NULL); printf("ecp_sock_open RV:%d\n", rv); @@ -72,19 +65,25 @@ int main(int argc, char *argv[]) { rv = ecp_start_receiver(&sock); printf("ecp_start_receiver RV:%d\n", rv); - rv = ecp_util_node_load(&ctx, &node, argv[1]); - printf("ecp_util_node_load RV:%d\n", rv); - - for (i=0; i<argc-2; i++) { - rv = ecp_util_node_load(&ctx, &vconn_node[i], argv[i+2]); - printf("ecp_util_node_load RV:%d\n", rv); + for (i=3; i<argc; i++) { + rv = ecp_util_load_pub(&vconn_pub[i-3], argv[i]); + printf("ecp_util_load_pub RV:%d\n", rv); } - rv = ecp_conn_init(&conn, &sock, CTYPE_TEST); - printf("ecp_conn_init RV:%d\n", rv); + rv = ecp_conn_create(&conn, &sock, CTYPE_TEST); + printf("ecp_conn_create RV:%d\n", rv); - rv = ecp_vconn_open(&conn, &node, vconn, vconn_node, argc-2); + rv = ecp_vconn_create(vconn, vconn_pub, argc-3, &conn); + printf("ecp_vconn_create RV:%d\n", rv); + + rv = ecp_util_load_pub(&node_pub, argv[1]); + printf("ecp_util_load_pub RV:%d\n", rv); + + rv = ecp_node_init(&node, &node_pub, argv[2]); + printf("ecp_node_init RV:%d\n", rv); + + rv = ecp_vconn_open(&conn, &node); printf("ecp_vconn_open RV:%d\n", rv); while (1) sleep(1); -}
\ No newline at end of file +} diff --git a/ecp/test/vc_server.c b/ecp/test/vc_server.c index b86d7b0..de7f275 100644 --- a/ecp/test/vc_server.c +++ b/ecp/test/vc_server.c @@ -1,63 +1,63 @@ -#include <stdio.h> +#include <stdlib.h> #include <string.h> #include <unistd.h> -#include <stdlib.h> +#include <stdio.h> -#include "core.h" -#include "vconn/vconn.h" -#include "util.h" +#include <core.h> +#include <vconn/vconn.h> + +#include <util.h> ECPContext ctx; ECPSocket sock; -ECPDHKey key_perma; ECPConnHandler handler; - -ECPNode node; ECPConnection conn; +ECPConnection vconn[3]; #define CTYPE_TEST 0 -#define MTYPE_MSG 8 +#define MTYPE_MSG 0 -ssize_t handle_open(ECPConnection *conn, ecp_seq_t sq, unsigned char t, unsigned char *p, ssize_t s, ECP2Buffer *b) { - printf("OPEN RECEIVED\n"); - return ecp_conn_handle_open(conn, sq, t, p, s, b); -} +static int handle_open(ECPConnection *conn, ECP2Buffer *b) { + printf("OPEN\n"); -ssize_t handle_msg(ECPConnection *conn, ecp_seq_t sq, unsigned char t, unsigned char *p, ssize_t s, ECP2Buffer *b) { - printf("MSG S:%s size:%ld\n", p, s); + return ECP_OK; +} - char *msg = "VAISTINU JE CAR!"; - unsigned char buf[1000]; +static ssize_t handle_msg(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, unsigned char *msg, size_t msg_size, ECP2Buffer *b) { + char *_msg = "VAISTINU JE CAR!"; + ssize_t rv; - strcpy((char *)buf, msg); - ssize_t _rv = ecp_send(conn, MTYPE_MSG, buf, strlen(msg)+1); + printf("MSG:%s size:%ld\n", msg, msg_size); + rv = ecp_msg_send(conn, MTYPE_MSG, (unsigned char *)_msg, strlen(_msg)+1); - return s; + return msg_size; } static void usage(char *arg) { - fprintf(stderr, "Usage: %s <node.priv> <vcs.pub>\n", arg); + fprintf(stderr, "Usage: %s <server.priv> <address> <vcs0.pub> [ ... <vcsN.pub> ]\n", arg); exit(1); } int main(int argc, char *argv[]) { - int rv; + ECPDHKey key_perma; + ECPNode node; + ecp_ecdh_public_t node_pub; + int rv, i; - if (argc != 3) usage(argv[0]); + if ((argc < 4) || (argc > 7)) usage(argv[0]); rv = ecp_init(&ctx); printf("ecp_init RV:%d\n", rv); - rv = ecp_conn_handler_init(&handler); - handler.msg[ECP_MTYPE_OPEN] = handle_open; - handler.msg[MTYPE_MSG] = handle_msg; - ctx.handler[CTYPE_TEST] = &handler; + ecp_conn_handler_init(&handler, handle_msg, handle_open, NULL, NULL); + ecp_ctx_set_handler(&ctx, &handler, CTYPE_TEST); - rv = ecp_util_key_load(&ctx, &key_perma, argv[1]); - printf("ecp_util_key_load RV:%d\n", rv); + rv = ecp_util_load_key(&key_perma.public, &key_perma.private, argv[1]); + printf("ecp_util_load_key RV:%d\n", rv); + key_perma.valid = 1; - rv = ecp_sock_init(&sock, &ctx, &key_perma); - printf("ecp_sock_init RV:%d\n", rv); + rv = ecp_sock_create(&sock, &ctx, &key_perma); + printf("ecp_sock_create RV:%d\n", rv); rv = ecp_sock_open(&sock, NULL); printf("ecp_sock_open RV:%d\n", rv); @@ -65,14 +65,29 @@ int main(int argc, char *argv[]) { rv = ecp_start_receiver(&sock); printf("ecp_start_receiver RV:%d\n", rv); - rv = ecp_util_node_load(&ctx, &node, argv[2]); - printf("ecp_util_node_load RV:%d\n", rv); + rv = ecp_vlink_create(&conn, &sock); + printf("ecp_vlink_create RV:%d\n", rv); + + if (argc > 4) { + ecp_ecdh_public_t vconn_key[3]; + + for (i=3; i<argc-1; i++) { + rv = ecp_util_load_pub(&vconn_key[i-3], argv[i]); + printf("ecp_util_load_pub RV:%d\n", rv); + } - rv = ecp_conn_init(&conn, &sock, ECP_CTYPE_VLINK); - printf("ecp_conn_init RV:%d\n", rv); + rv = ecp_vconn_create(vconn, vconn_key, argc-4, &conn); + printf("ecp_vconn_create RV:%d\n", rv); + } - rv = ecp_conn_open(&conn, &node); - printf("ecp_conn_open RV:%d\n", rv); + rv = ecp_util_load_pub(&node_pub, argv[argc-1]); + printf("ecp_util_load_pub RV:%d\n", rv); + + rv = ecp_node_init(&node, &node_pub, argv[2]); + printf("ecp_node_init RV:%d\n", rv); + + rv = ecp_vconn_open(&conn, &node); + printf("ecp_vconn_open RV:%d\n", rv); while (1) sleep(1); -}
\ No newline at end of file +} diff --git a/ecp/test/vcs.c b/ecp/test/vcs.c index f3a0156..c4beed7 100644 --- a/ecp/test/vcs.c +++ b/ecp/test/vcs.c @@ -1,54 +1,60 @@ -#include <stdio.h> +#include <stdlib.h> #include <string.h> #include <unistd.h> -#include <stdlib.h> +#include <stdio.h> -#include "core.h" -#include "util.h" -#include "vconn/vconn.h" +#include <core.h> +#include <vconn/vconn.h> + +#include <util.h> ECPContext ctx; ECPSocket sock; -ECPDHKey key_perma; - -ECPNode node; ECPConnection conn; static void usage(char *arg) { - fprintf(stderr, "Usage: %s <address> <node.priv> [node.pub]\n", arg); + fprintf(stderr, "Usage: %s <my addr> <my.priv> [ <node addr> <node.pub> ]\n", arg); exit(1); } int main(int argc, char *argv[]) { + ECPDHKey key_perma; int rv; - - if ((argc < 3) || (argc > 4)) usage(argv[0]); - + + if ((argc < 3) || (argc > 5)) usage(argv[0]); + rv = ecp_init(&ctx); printf("ecp_init RV:%d\n", rv); - - rv = ecp_util_key_load(&ctx, &key_perma, argv[2]); - printf("ecp_util_key_load RV:%d\n", rv); - - rv = ecp_sock_init(&sock, &ctx, &key_perma); - printf("ecp_sock_init RV:%d\n", rv); + + rv = ecp_util_load_key(&key_perma.public, &key_perma.private, argv[2]); + printf("ecp_util_load_key RV:%d\n", rv); + key_perma.valid = 1; + + rv = ecp_sock_create(&sock, &ctx, &key_perma); + printf("ecp_sock_create RV:%d\n", rv); rv = ecp_sock_open(&sock, argv[1]); printf("ecp_sock_open RV:%d\n", rv); - + rv = ecp_start_receiver(&sock); printf("ecp_start_receiver RV:%d\n", rv); - - if (argc == 4) { - rv = ecp_util_node_load(&ctx, &node, argv[3]); - printf("ecp_util_node_load RV:%d\n", rv); - rv = ecp_conn_init(&conn, &sock, ECP_CTYPE_VLINK); - printf("ecp_conn_init RV:%d\n", rv); + if (argc == 5) { + ECPNode node; + ecp_ecdh_public_t node_pub; + + rv = ecp_vlink_create(&conn, &sock); + printf("ecp_vlink_create RV:%d\n", rv); + + rv = ecp_util_load_pub(&node_pub, argv[4]); + printf("ecp_util_load_pub RV:%d\n", rv); + + rv = ecp_node_init(&node, &node_pub, argv[3]); + printf("ecp_node_init RV:%d\n", rv); rv = ecp_conn_open(&conn, &node); printf("ecp_conn_open RV:%d\n", rv); } while (1) sleep(1); -}
\ No newline at end of file +} diff --git a/ecp/test/vid/Makefile b/ecp/test/vid/Makefile deleted file mode 100644 index a9b92eb..0000000 --- a/ecp/test/vid/Makefile +++ /dev/null @@ -1,23 +0,0 @@ -include ../../ecp/Makefile.platform - -LIBVPX_HOME = /opt/my/libvpx -CFLAGS += -D_V4L2_KERNEL_ -I/usr/src/linux-headers-$(uname -r) -I$(LIBVPX_HOME) -I/opt/local/include/SDL2 -I../../ecp -I../../util -Wno-int-to-void-pointer-cast -LDFLAGS += -L$(LIBVPX_HOME) -L/opt/local/lib - -dep=../init_vconn.o ../../ecp/build-posix/*.a ../../util/libecputil.a - -all: cap - -%.o: %.c - $(CC) $(CFLAGS) -c $< - -cap: cap.o enc.o tools.o server.o - $(CC) -o $@ $< enc.o tools.o server.o $(dep) -lvpx $(LDFLAGS) - -client: client.o display.o tools.o - $(CC) -o $@ $< display.o tools.o $(dep) -lvpx -lSDL2 $(LDFLAGS) - -clean: - rm -f *.o - rm -f cap client - diff --git a/ecp/test/vid/cap.c b/ecp/test/vid/cap.c deleted file mode 100644 index e37c28f..0000000 --- a/ecp/test/vid/cap.c +++ /dev/null @@ -1,576 +0,0 @@ -/* - * OpenCV BSD3 License - * videodev2.h BSD License (dual license) - * If you raise some license issue here simply don't use it and let us know - * - * Copyright (C) 2016 the contributors - * - * Luiz Vitor Martinez Cardoso - * Jules Thuillier - * @lex (avafinger) - * - * gcc cap.c -o cap $(pkg-config --libs --cflags opencv) -lm - * - * gcc -I/usr/src/linux-headers-VERSION/ cap.c -o cap $(pkg-config --libs --cflags opencv) -lm -O3 - * -*/ - -#include <stdlib.h> -#include <stdio.h> -#include <errno.h> -#include <fcntl.h> -#include <stdint.h> -#include <unistd.h> -#include <malloc.h> -#include <string.h> -#include <sys/mman.h> -#include <sys/time.h> -#include <sys/ioctl.h> - -/* ----------------------------------------------------------------------------- - * BananaPi M64 / Pine64+ (A64) or if you want to control Exposure,Hflip,Vflip - * ----------------------------------------------------------------------------- - * _V4L2_KERNEL_ should be defined and point to: /usr/src/linux-headers-version - * - * build with: gcc -I/usr/src/linux-headers-3.10.102/ cap.c -o cap $(pkg-config --libs --cflags opencv) -lm -O3 - * - * - * ----------------------------------------------------------------------------- - * OrangePi / BananaPi / NanoPi (H3) / BPI-M3 (A83T - ov5640 & ov8865) - * ----------------------------------------------------------------------------- - * _V4L2_KERNEL_ should not be defined unless you want Exposure, Hflip and Vflip - * - * build with: gcc cap.c -o cap $(pkg-config --libs --cflags opencv) -lm - * - * -*/ -//#define _V4L2_KERNEL_ // BananaPi M64 / Pine64+ only or for setting Exposure,Hflip,Vflip - -#ifdef _V4L2_KERNEL_ -/* --- A64 --- */ -#include <linux/videodev2.h> -#else -/* --- H3 / A83T --- */ -#include "videodev2.h" -#endif - -#ifdef _V4L2_KERNEL_ -#define V4L2_MODE_VIDEO 0x0002 /* video capture */ -#define V4L2_MODE_IMAGE 0x0003 /* image capture */ -#define V4L2_MODE_PREVIEW 0x0004 /* preview capture */ -#endif - -#define N_BUFFERS 4 -#define CAP_OK 0 -#define CAP_ERROR -1 -#define CAP_ERROR_RET(s) { \ - fprintf(stderr, "v4l2: %s\n", s); \ - return CAP_ERROR; \ - } -#define CAP_CLIP(val, min, max) (((val) > (max)) ? (max) : (((val) < (min)) ? (min) : (val))) - -#define CLEAR(x) memset (&(x), 0, sizeof (x)) -#define ALIGN_4K(x) (((x) + (4095)) & ~(4095)) -#define ALIGN_16B(x) (((x) + (15)) & ~(15)) - -#include "server.h" -#include "enc.h" - -typedef struct { - void *start; - size_t length; -} v4l2_buffer_t; - -int width; -int height; -v4l2_buffer_t *buffers = NULL; -int n_buffers = N_BUFFERS; -int sensor_video_mode; -int sensor_exposure; -int sensor_hflip; -int sensor_vflip; - -double get_wall_time() -{ - struct timeval time; - if (gettimeofday(&time, NULL)) - return 0.; - return (double) time.tv_sec + (double) time.tv_usec * .000001; -} - -int yuv420p_to_bgr(void *in, int length, unsigned char *out) -{ - uint8_t *yptr, *uptr, *vptr; - uint32_t x, y, p; - - if (length < (width * height * 3) / 2) - return CAP_ERROR; - - yptr = (uint8_t *) in; - uptr = yptr + (width * height); - vptr = uptr + (width * height / 4); - p = 0; - - for (y = 0; y < height; y++) { - for (x = 0; x < width; x++) { - int r, g, b; - int y, u, v; - - y = *(yptr++) << 8; - u = uptr[p] - 128; - v = vptr[p] - 128; - - r = (y + (359 * v)) >> 8; - g = (y - (88 * u) - (183 * v)) >> 8; - b = (y + (454 * u)) >> 8; - - *(out++) += CAP_CLIP(b, 0x00, 0xFF); - *(out++) += CAP_CLIP(g, 0x00, 0xFF); - *(out++) += CAP_CLIP(r, 0x00, 0xFF); - - if (x & 1) - p++; - } - - if (!(y & 1)) - p -= width / 2; - } - - return CAP_ERROR; -} - -static int xioctl(int fd, int request, void *arg) -{ - int r; - int tries = 3; - - do { - r = ioctl(fd, request, arg); - } while (--tries > 0 && -1 == r && EINTR == errno); - - return r; -} - -int v4l2_display_sizes_pix_format(int fd) -{ - int ret = 0; - int fsizeind = 0; /*index for supported sizes*/ - struct v4l2_frmsizeenum fsize; - - fprintf(stderr, "V4L2 pixel sizes:\n"); - - CLEAR(fsize); - fsize.index = 0; - fsize.pixel_format = V4L2_PIX_FMT_YUV420; - - while ((ret = xioctl(fd, VIDIOC_ENUM_FRAMESIZES, &fsize)) == 0) { - fsize.index++; - if (fsize.type == V4L2_FRMSIZE_TYPE_DISCRETE) { - fprintf(stderr, "( %u x %u ) Pixels\n", fsize.discrete.width, fsize.discrete.height); - fsizeind++; - } - } - return fsizeind; -} - -int v4l2_display_pix_format(int fd) -{ - struct v4l2_fmtdesc fmt; - int index; - - fprintf(stderr, "V4L2 pixel formats:\n"); - - index = 0; - CLEAR(fmt); - fmt.index = index; - fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; - - while (ioctl(fd, VIDIOC_ENUM_FMT, &fmt) != -1) { - fprintf(stderr, "%i: [0x%08X] '%c%c%c%c' (%s)\n", index, fmt.pixelformat, fmt.pixelformat >> 0, fmt.pixelformat >> 8, fmt.pixelformat >> 16, fmt.pixelformat >> 24, fmt.description); - - memset(&fmt, 0, sizeof(fmt)); - fmt.index = ++index; - fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; - } - // fprintf(stderr, "\n"); -} - -#ifdef _V4L2_KERNEL_ -int v4l2_set_exposure(int fd, int exposure) -{ - struct v4l2_queryctrl queryctrl; - struct v4l2_control control; - int rc; - - fprintf(stderr, "set Exposure: %d\n", exposure); - rc = 0; - memset(&control, 0, sizeof(control)); - control.id = V4L2_CID_EXPOSURE; - rc = xioctl(fd, VIDIOC_G_CTRL, &control); - fprintf(stderr, "rc: %d - get exposure: %d\n", rc, control.value); - control.value = exposure; - rc = xioctl(fd, VIDIOC_S_CTRL, &control); - fprintf(stderr, "rc: %d - new exposure: %d\n", rc, exposure); - return rc; -} - -int v4l2_set_hflip(int fd, int hflip) -{ - struct v4l2_queryctrl queryctrl; - struct v4l2_control control; - int rc; - - fprintf(stderr, "set Hflip: %d\n", hflip); - rc = 0; - memset(&control, 0, sizeof(control)); - control.id = V4L2_CID_HFLIP; - rc = xioctl(fd, VIDIOC_G_CTRL, &control); - fprintf(stderr, "rc: %d - get value: %d\n", rc, control.value); - control.value = hflip; - rc = xioctl(fd, VIDIOC_S_CTRL, &control); - fprintf(stderr, "rc: %d - new value: %d\n", rc, control.value); - return rc; -} - -int v4l2_set_vflip(int fd, int vflip) -{ - struct v4l2_queryctrl queryctrl; - struct v4l2_control control; - int rc; - - fprintf(stderr, "set Vflip: %d\n", vflip); - rc = 0; - memset(&control, 0, sizeof(control)); - control.id = V4L2_CID_VFLIP; - rc = xioctl(fd, VIDIOC_G_CTRL, &control); - fprintf(stderr, "rc: %d - get value: %d\n", rc, control.value); - control.value = vflip; - rc = xioctl(fd, VIDIOC_S_CTRL, &control); - fprintf(stderr, "rc: %d - new value: %d\n", rc, control.value); - return rc; -} -#endif - -int v4l2_init_camera(int fd) -{ - uint32_t i; - uint32_t index; - struct v4l2_streamparm parms; - struct v4l2_format fmt; - struct v4l2_input input; - struct v4l2_capability caps; - - CLEAR(fmt); - CLEAR(input); - CLEAR(caps); - - - if (xioctl(fd, VIDIOC_QUERYCAP, &caps) == -1) { - CAP_ERROR_RET("unable to query capabilities."); - } - - if (!(caps.capabilities & V4L2_CAP_VIDEO_CAPTURE)) { - CAP_ERROR_RET("doesn't support video capturing."); - } - - fprintf(stderr, "Driver: \"%s\"\n", caps.driver); - fprintf(stderr, "Card: \"%s\"\n", caps.card); - fprintf(stderr, "Bus: \"%s\"\n", caps.bus_info); - fprintf(stderr, "Version: %d.%d\n", (caps.version >> 16) && 0xff, (caps.version >> 24) && 0xff); - fprintf(stderr, "Capabilities: %08x\n", caps.capabilities); - - input.index = 0; - if (xioctl(fd, VIDIOC_ENUMINPUT, &input) == -1) { - CAP_ERROR_RET("unable to enumerate input."); - } - - fprintf(stderr, "Input: %d\n", input.index); - if (xioctl(fd, VIDIOC_S_INPUT, &input.index) == -1) { - CAP_ERROR_RET("unable to set input."); - } - - parms.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; - parms.parm.capture.capturemode = sensor_video_mode ? V4L2_MODE_VIDEO : V4L2_MODE_IMAGE; - parms.parm.capture.timeperframe.numerator = 1; - parms.parm.capture.timeperframe.denominator = sensor_video_mode ? 30 : 7; - if (-1 == xioctl(fd, VIDIOC_S_PARM, &parms)) { - CAP_ERROR_RET("unable to set stream parm."); - } - - v4l2_display_pix_format(fd); - v4l2_display_sizes_pix_format(fd); - fprintf(stderr, "\n"); - - fmt.fmt.pix.width = width; - fmt.fmt.pix.height = height; - fmt.fmt.pix.field = V4L2_FIELD_NONE; // V4L2_FIELD_ANY; - fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; - fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV420; - //fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB24; - - if (xioctl(fd, VIDIOC_TRY_FMT, &fmt) == -1) { - CAP_ERROR_RET("failed trying to set pixel format."); - } - - if (fmt.fmt.pix.width != width || fmt.fmt.pix.height != height) { - width = fmt.fmt.pix.width; - height = fmt.fmt.pix.height; - fprintf(stderr, "Sensor size adjusted to: %dx%d pixels\n", width, height); - } else { - fprintf(stderr, "Sensor size: %dx%d pixels\n", width, height); - } - - if (xioctl(fd, VIDIOC_S_FMT, &fmt) == -1) { - CAP_ERROR_RET("failed to set pixel format."); - } - - switch (fmt.fmt.pix.pixelformat) { - case V4L2_PIX_FMT_RGB24: - fprintf(stderr, "Pixel Format: V4L2_PIX_FMT_RGB24 [0x%08X]\n",fmt.fmt.pix.pixelformat); - break; - - case V4L2_PIX_FMT_YUV420: - fprintf(stderr, "Pixel Format: V4L2_PIX_FMT_YUV420 [0x%08X]\n",fmt.fmt.pix.pixelformat); - break; - - } - - return CAP_OK; -} - -int v4l2_set_mmap(int fd, int *buffers_count) -{ - int i; - int nbf; - enum v4l2_buf_type type; - struct v4l2_requestbuffers req; - struct v4l2_buffer buf; - - CLEAR(req); - req.count = sensor_video_mode ? n_buffers : 1; - req.memory = V4L2_MEMORY_MMAP; - req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; - if (xioctl(fd, VIDIOC_REQBUFS, &req) == -1) { - CAP_ERROR_RET("failed requesting buffers."); - } - nbf = req.count; - if (n_buffers != nbf) { - CAP_ERROR_RET("insufficient buffer memory."); - } - - buffers = (v4l2_buffer_t *) calloc(nbf, sizeof(v4l2_buffer_t)); - if (!buffers) { - CAP_ERROR_RET("failed to allocated buffers memory."); - } - - for (i = 0; i < nbf; i++) { - CLEAR(buf); - buf.index = i; - buf.memory = V4L2_MEMORY_MMAP; - buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; - if (xioctl(fd, VIDIOC_QUERYBUF, &buf) == -1) { - CAP_ERROR_RET("failed to query buffer."); - } - buffers[i].length = buf.length; - buffers[i].start = mmap(NULL, buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, buf.m.offset); - if (MAP_FAILED == buffers[i].start) { - CAP_ERROR_RET("failed to mmap buffer."); - } - } - - for (i = 0; i < nbf; i++) { - CLEAR(buf); - buf.index = i; - buf.memory = V4L2_MEMORY_MMAP; - buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; - - if (xioctl(fd, VIDIOC_QBUF, &buf) == -1) { - CAP_ERROR_RET("failed to queue buffer."); - } - } - - type = V4L2_BUF_TYPE_VIDEO_CAPTURE; - if (xioctl(fd, VIDIOC_STREAMON, &type) == -1) { - CAP_ERROR_RET("failed to stream on."); - } - - *buffers_count = nbf; - - return CAP_OK; -} - -int v4l2_retrieve_frame(int fd, int buffers_count, vpx_image_t *raw, vpx_codec_ctx_t *codec, int frame_index, int kframe_interval) -{ - int sz; - fd_set fds; - unsigned char *frame_yuv; - struct timeval tv; - struct v4l2_buffer buf; - int rc; - char err_msg[128]; - int flags = 0; - - CLEAR(tv); - CLEAR(buf); - - rc = 1; - while (rc > 0) { - FD_ZERO(&fds); - FD_SET(fd, &fds); - - tv.tv_sec = 2; - tv.tv_usec = 0; - - rc = select(fd + 1, &fds, NULL, NULL, &tv); - if (-1 == rc) { - if (EINTR == errno) { - rc = 1; // try again - continue; - } - CAP_ERROR_RET("failed to select frame."); - } - /* we got something */ - break; - } - if (rc <= 0) { - sprintf(err_msg, "errno: %d - check sensor, something wrong.", errno); - CAP_ERROR_RET(err_msg); - } - - buf.memory = V4L2_MEMORY_MMAP; - buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; - if (xioctl(fd, VIDIOC_DQBUF, &buf) == -1) { - CAP_ERROR_RET("failed to retrieve frame."); - } - - // fprintf(stderr, "Length: %d \tBytesused: %d \tAddress: %p\n", buf.length, buf.bytesused, &buffers[buf.index]); - - sz = ALIGN_16B(width) * height * 3 / 2; - if (!vpx_img_read(raw, buffers[buf.index].start, sz)) { - die_codec(NULL, "Failed to read image."); - } - if (frame_index % kframe_interval == 0) flags |= VPX_EFLAG_FORCE_KF; - vpx_encode_frame(codec, raw, frame_index, flags); - - if (xioctl(fd, VIDIOC_QBUF, &buf) == -1) { - CAP_ERROR_RET("failed to queue buffer."); - } - - return CAP_OK; -} - -int v4l2_close_camera(int fd, int buffers_count) -{ - int i; - enum v4l2_buf_type type; - - type = V4L2_BUF_TYPE_VIDEO_CAPTURE; - if (xioctl(fd, VIDIOC_STREAMOFF, &type) == -1) { - CAP_ERROR_RET("failed to stream off."); - } - - for (i = 0; i < buffers_count; i++) - munmap(buffers[i].start, buffers[i].length); - - close(fd); -} - -int main(int argc, char *argv[]) -{ - int fd; - int target_bitrate = 200; - double after; - double before; - double avg, fps; - int buffers_count; - int kframe_interval; - vpx_codec_er_flags_t err_resilient; - char *address; - char *my_key; - char *vcs_key; - - if (argc != 14) { - CAP_ERROR_RET("./cap <width> <height> <buffers [4,8]> <video mode [0,1]> <exposure [-4,4]> <hflip [0,1]> <vflip [0,1]> <kframe interval> <bitrate> <err resilient> <address> <my key> <vcs pub key>") - } - width = (int) atoi(argv[1]); - height = (int) atoi(argv[2]); - n_buffers = (int) atoi(argv[3]); - if (n_buffers < 4) - n_buffers = 4; - if (n_buffers > 8) - n_buffers = 8; // enough in VIDEO MODE!!! - - sensor_video_mode = (int) atoi(argv[4]); - if (!sensor_video_mode) - n_buffers = 1; - sensor_exposure = (int) atoi(argv[5]); - sensor_hflip = (int) atoi(argv[6]); - sensor_vflip = (int) atoi(argv[7]); - kframe_interval = (int) atoi(argv[8]); - target_bitrate = (int) atoi(argv[9]); - err_resilient = strtoul(argv[10], NULL, 0); - address = argv[11]; - my_key = argv[12]; - vcs_key = argv[13]; - - fprintf(stderr, "---- cap parameters -----\nwidth: %d\nheight: %d\nv4l2 buffers: %d\nexposure: %d\nhflip: %d\nvflip: %d\nMode: %s\n", width, height, n_buffers, sensor_exposure, sensor_hflip, sensor_vflip, sensor_video_mode ? "V4L2_MODE_VIDEO" : "V4L2_MODE_IMAGE"); - - fd = open("/dev/video0", O_RDWR | O_NONBLOCK); - if (fd == -1) { - CAP_ERROR_RET("failed to open the camera."); - } - - if (v4l2_init_camera(fd) == -1) { - CAP_ERROR_RET("failed to init camera."); - } -#ifdef _V4L2_KERNEL_ - if (sensor_exposure != -999) { - v4l2_set_exposure(fd, sensor_exposure); - } - if (sensor_hflip != -1) { - v4l2_set_hflip(fd, sensor_hflip); - } - - if (sensor_vflip != -1) { - v4l2_set_vflip(fd, sensor_vflip); - } -#endif - - if (v4l2_set_mmap(fd, &buffers_count) == -1) { - CAP_ERROR_RET("failed to mmap."); - } - - int n = 0; - int _fps = 30; - const char *codec_arg = "vp9"; - vpx_codec_ctx_t codec; - vpx_image_t raw; - - vpx_open(codec_arg, width, height, _fps, target_bitrate, err_resilient, &codec, &raw); - init_server(address, my_key, vcs_key); - - while (1) { - if (!conn_is_open()) { - sleep(1); - continue; - } - before = get_wall_time(); - if (v4l2_retrieve_frame(fd, buffers_count, &raw, &codec, n, kframe_interval)) { - CAP_ERROR_RET("failed to retrieve frame."); - } - after = get_wall_time(); - fps = 1.0 / (after - before); - avg += fps; - n++; - // fprintf(stderr, "FPS[%d]: %.2f\n", i, fps); - } - - vpx_close(&codec, &raw); - v4l2_close_camera(fd, buffers_count); - - if (n) { - fprintf(stderr, "\n------- Avg FPS: %.2f --------\n\n", (double) (avg / (double) n)); - } - - return CAP_OK; -} diff --git a/ecp/test/vid/cap.sh b/ecp/test/vid/cap.sh deleted file mode 100755 index bfd933e..0000000 --- a/ecp/test/vid/cap.sh +++ /dev/null @@ -1,3 +0,0 @@ -#!/bin/sh - -./cap 640 480 8 1 -999 -1 -1 25 256 1 0.0.0.0:3000 ../../keys/pine64-home.priv ../../keys/majstor.org.pub diff --git a/ecp/test/vid/client.c b/ecp/test/vid/client.c deleted file mode 100644 index 017967b..0000000 --- a/ecp/test/vid/client.c +++ /dev/null @@ -1,123 +0,0 @@ -#include <stdio.h> -#include <string.h> -#include <unistd.h> -#include <stdlib.h> - -#include "vpx/vpx_decoder.h" -#include "vpx/vp8cx.h" -#include "tools.h" -#include "display.h" - -#include "core.h" -#include "vconn/vconn.h" -#include "util.h" - -#define CTYPE_TEST 0 -#define MTYPE_MSG 8 - -#define FRAG_BUF_SIZE 8192 -#define RBUF_MSG_SIZE 128 - -ECPContext ctx; -ECPSocket sock; -ECPConnHandler handler; - -ECPNode node; -ECPConnection conn; - -ECPVConnection vconn; -ECPNode vconn_node; - -vpx_codec_ctx_t codec; - -ECPRBRecv rbuf_recv; -ECPRBMessage rbuf_r_msg[RBUF_MSG_SIZE]; -ECPFragIter frag_iter; -unsigned char frag_buffer[FRAG_BUF_SIZE]; - -SDLCanvas sdl_canvas; - -ssize_t handle_msg(ECPConnection *conn, ecp_seq_t sq, unsigned char t, unsigned char *f, ssize_t sz, ECP2Buffer *b) { - vpx_codec_iter_t iter = NULL; - vpx_image_t *img = NULL; - - if (vpx_codec_decode(&codec, f, (unsigned int)sz, NULL, 0)) { - fprintf(stderr, "\n%lu\n", sz); - fprintf(stderr, "ERROR!\n"); - // die_codec(&codec, "Failed to decode frame."); - } - - while ((img = vpx_codec_get_frame(&codec, &iter)) != NULL) { - if (!vpx_img_write(img, sdl_canvas.yuvBuffer, sdl_canvas.yPlaneSz + 2 * sdl_canvas.uvPlaneSz)) die_codec(NULL, "Failed to write image."); - } - sdl_display_frame(&sdl_canvas); - - return sz; -} - -static void usage(char *arg) { - fprintf(stderr, "Usage: %s <node.pub> <vcs.pub>\n", arg); - exit(1); -} - -int main(int argc, char *argv[]) { - int rv; - - if (argc != 3) usage(argv[0]); - - rv = ecp_init(&ctx); - fprintf(stderr, "ecp_init RV:%d\n", rv); - - if (!rv) rv = ecp_conn_handler_init(&handler); - if (!rv) { - handler.msg[MTYPE_MSG] = handle_msg; - ctx.handler[CTYPE_TEST] = &handler; - } - - if (!rv) rv = ecp_sock_create(&sock, &ctx, NULL); - fprintf(stderr, "ecp_sock_create RV:%d\n", rv); - - if (!rv) rv = ecp_sock_open(&sock, NULL); - fprintf(stderr, "ecp_sock_open RV:%d\n", rv); - - if (!rv) rv = ecp_start_receiver(&sock); - fprintf(stderr, "ecp_start_receiver RV:%d\n", rv); - - if (!rv) rv = ecp_util_node_load(&ctx, &node, argv[1]); - fprintf(stderr, "ecp_util_node_load RV:%d\n", rv); - - if (!rv) rv = ecp_util_node_load(&ctx, &vconn_node, argv[2]); - printf("ecp_util_node_load RV:%d\n", rv); - - if (!rv) rv = ecp_conn_create(&conn, &sock, CTYPE_TEST); - fprintf(stderr, "ecp_conn_create RV:%d\n", rv); - - if (!rv) rv = ecp_rbuf_create(&conn, NULL, NULL, 0, &rbuf_recv, rbuf_r_msg, RBUF_MSG_SIZE); - fprintf(stderr, "ecp_rbuf_create RV:%d\n", rv); - - if (!rv) { - ecp_frag_iter_init(&frag_iter, frag_buffer, FRAG_BUF_SIZE); - rbuf_recv.frag_iter = &frag_iter; - } - - const char *codec_arg = "vp9"; - const VpxInterface *decoder = get_vpx_decoder_by_name(codec_arg); - if (!decoder) die_codec(NULL, "Unknown input codec."); - - fprintf(stderr, "Using %s\n", vpx_codec_iface_name(decoder->codec_interface())); - - if (vpx_codec_dec_init(&codec, decoder->codec_interface(), NULL, 0)) - die_codec(&codec, "Failed to initialize decoder."); - - sdl_open(&sdl_canvas, 640, 480); - - // if (!rv) rv = ecp_conn_open(&conn, &node); - // fprintf(stderr, "ecp_conn_open RV:%d\n", rv); - - if (!rv) rv = ecp_vconn_open(&conn, &node, &vconn, &vconn_node, 1); - printf("ecp_vconn_open RV:%d\n", rv); - - sdl_loop(); - sdl_close(&sdl_canvas); - if (vpx_codec_destroy(&codec)) die_codec(&codec, "Failed to destroy codec"); -}
\ No newline at end of file diff --git a/ecp/test/vid/display.c b/ecp/test/vid/display.c deleted file mode 100644 index d378431..0000000 --- a/ecp/test/vid/display.c +++ /dev/null @@ -1,68 +0,0 @@ -#include <stdio.h> - -#include "display.h" - -void sdl_open(SDLCanvas *o, int img_width, int img_height) { - // Initialize the SDL - if (SDL_Init(SDL_INIT_VIDEO) != 0) { - fprintf(stderr, "SDL_Init() Failed: %s\n", SDL_GetError()); - exit(1); - } - - o->display = SDL_CreateWindow("SDL Tutorial", - SDL_WINDOWPOS_UNDEFINED, - SDL_WINDOWPOS_UNDEFINED, - img_width, img_height, 0); - if (o->display == NULL) { - fprintf(stderr, "SDL_SetVideoMode() Failed: %s\n", SDL_GetError()); - exit(1); - } - - o->renderer = SDL_CreateRenderer(o->display, -1, 0); - if (o->renderer == NULL) { - fprintf(stderr, "SDL_CreateRenderer() Failed: %s\n", SDL_GetError()); - exit(1); - } - - o->texture = SDL_CreateTexture(o->renderer, SDL_PIXELFORMAT_YV12, SDL_TEXTUREACCESS_STREAMING, img_width, img_height); - if (o->texture == NULL) { - fprintf(stderr, "SDL_CreateTextureFromSurface() Failed: %s\n", SDL_GetError()); - exit(1); - } - - o->yPlaneSz = img_width * img_height; - o->uvPlaneSz = img_width * img_height / 4; - o->yuvBuffer = (Uint8*)malloc(o->yPlaneSz + 2 * o->uvPlaneSz); - o->yPitch = img_width; - o->uvPitch = img_width / 2; -} - -void sdl_close(SDLCanvas *o) { - free(o->yuvBuffer); - SDL_DestroyTexture(o->texture); - SDL_DestroyRenderer(o->renderer); - SDL_DestroyWindow(o->display); - SDL_Quit(); -} - -void sdl_display_frame(SDLCanvas *o) { - SDL_UpdateYUVTexture(o->texture, NULL, o->yuvBuffer, o->yPitch, o->yuvBuffer + o->yPlaneSz, o->uvPitch, o->yuvBuffer + o->yPlaneSz + o->uvPlaneSz, o->uvPitch); - SDL_RenderClear(o->renderer); - SDL_RenderCopy(o->renderer, o->texture, NULL, NULL); - SDL_RenderPresent(o->renderer); -} - -void sdl_loop(void) { - SDL_Event event; - - while(1) { - // Check for messages - if (SDL_PollEvent(&event)) { - // Check for the quit message - if (event.type == SDL_QUIT) { - // Quit the program - break; - } - } - } -} diff --git a/ecp/test/vid/display.h b/ecp/test/vid/display.h deleted file mode 100644 index 38e07be..0000000 --- a/ecp/test/vid/display.h +++ /dev/null @@ -1,17 +0,0 @@ -#include "SDL.h" - -typedef struct SDLCanvas { - SDL_Window *display; - SDL_Renderer *renderer; - SDL_Texture *texture; - Uint8 *yuvBuffer; - size_t yPlaneSz; - size_t uvPlaneSz; - int yPitch; - int uvPitch; -} SDLCanvas; - -void sdl_open(SDLCanvas *o, int img_width, int img_height); -void sdl_close(SDLCanvas *o); -void sdl_display_frame(SDLCanvas *o); -void sdl_loop(void); diff --git a/ecp/test/vid/enc.c b/ecp/test/vid/enc.c deleted file mode 100644 index 34d0be8..0000000 --- a/ecp/test/vid/enc.c +++ /dev/null @@ -1,168 +0,0 @@ -/* - * Copyright (c) 2010 The WebM project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -// Simple Encoder -// ============== -// -// This is an example of a simple encoder loop. It takes an input file in -// YV12 format, passes it through the encoder, and writes the compressed -// frames to disk in IVF format. Other decoder examples build upon this -// one. -// -// The details of the IVF format have been elided from this example for -// simplicity of presentation, as IVF files will not generally be used by -// your application. In general, an IVF file consists of a file header, -// followed by a variable number of frames. Each frame consists of a frame -// header followed by a variable length payload. The length of the payload -// is specified in the first four bytes of the frame header. The payload is -// the raw compressed data. -// -// Standard Includes -// ----------------- -// For encoders, you only have to include `vpx_encoder.h` and then any -// header files for the specific codecs you use. In this case, we're using -// vp8. -// -// Getting The Default Configuration -// --------------------------------- -// Encoders have the notion of "usage profiles." For example, an encoder -// may want to publish default configurations for both a video -// conferencing application and a best quality offline encoder. These -// obviously have very different default settings. Consult the -// documentation for your codec to see if it provides any default -// configurations. All codecs provide a default configuration, number 0, -// which is valid for material in the vacinity of QCIF/QVGA. -// -// Updating The Configuration -// --------------------------------- -// Almost all applications will want to update the default configuration -// with settings specific to their usage. Here we set the width and height -// of the video file to that specified on the command line. We also scale -// the default bitrate based on the ratio between the default resolution -// and the resolution specified on the command line. -// -// Initializing The Codec -// ---------------------- -// The encoder is initialized by the following code. -// -// Encoding A Frame -// ---------------- -// The frame is read as a continuous block (size width * height * 3 / 2) -// from the input file. If a frame was read (the input file has not hit -// EOF) then the frame is passed to the encoder. Otherwise, a NULL -// is passed, indicating the End-Of-Stream condition to the encoder. The -// `frame_cnt` is reused as the presentation time stamp (PTS) and each -// frame is shown for one frame-time in duration. The flags parameter is -// unused in this example. The deadline is set to VPX_DL_REALTIME to -// make the example run as quickly as possible. - -// Forced Keyframes -// ---------------- -// Keyframes can be forced by setting the VPX_EFLAG_FORCE_KF bit of the -// flags passed to `vpx_codec_control()`. In this example, we force a -// keyframe every <keyframe-interval> frames. Note, the output stream can -// contain additional keyframes beyond those that have been forced using the -// VPX_EFLAG_FORCE_KF flag because of automatic keyframe placement by the -// encoder. -// -// Processing The Encoded Data -// --------------------------- -// Each packet of type `VPX_CODEC_CX_FRAME_PKT` contains the encoded data -// for this frame. We write a IVF frame header, followed by the raw data. -// -// Cleanup -// ------- -// The `vpx_codec_destroy` call frees any memory allocated by the codec. -// -// Error Handling -// -------------- -// This example does not special case any error return codes. If there was -// an error, a descriptive message is printed and the program exits. With -// few exeptions, vpx_codec functions return an enumerated error status, -// with the value `0` indicating success. -// -// Error Resiliency Features -// ------------------------- -// Error resiliency is controlled by the g_error_resilient member of the -// configuration structure. Use the `decode_with_drops` example to decode with -// frames 5-10 dropped. Compare the output for a file encoded with this example -// versus one encoded with the `simple_encoder` example. - -#include <stdio.h> -#include <stdlib.h> -#include <string.h> - -#include "enc.h" -#include "server.h" - -int vpx_encode_frame(vpx_codec_ctx_t *codec, vpx_image_t *img, int frame_index, int flags) { - int got_pkts = 0; - vpx_codec_iter_t iter = NULL; - const vpx_codec_cx_pkt_t *pkt = NULL; - const vpx_codec_err_t res = - vpx_codec_encode(codec, img, frame_index, 1, flags, VPX_DL_REALTIME); - if (res != VPX_CODEC_OK) die_codec(codec, "Failed to encode frame"); - - while ((pkt = vpx_codec_get_cx_data(codec, &iter)) != NULL) { - got_pkts = 1; - - if (pkt->kind == VPX_CODEC_CX_FRAME_PKT) { - const int keyframe = (pkt->data.frame.flags & VPX_FRAME_IS_KEY) != 0; - if (send_frame(pkt->data.frame.buf, pkt->data.frame.sz, pkt->data.frame.pts) < 0) { - die_codec(codec, "Failed to write compressed frame"); - } - fprintf(stderr, keyframe ? "K" : "."); - fflush(stdout); - } - } - - return got_pkts; -} - - -void vpx_open(const char *codec_arg, int width, int height, int fps, int bitrate, vpx_codec_er_flags_t err_resilient, vpx_codec_ctx_t *codec, vpx_image_t *raw) { - vpx_codec_enc_cfg_t cfg; - vpx_codec_err_t res; - - const VpxInterface *encoder = get_vpx_encoder_by_name(codec_arg); - if (!encoder) die_codec(NULL, "Unsupported codec."); - - fprintf(stderr, "Using %s\n", vpx_codec_iface_name(encoder->codec_interface())); - - if (!vpx_img_alloc(raw, VPX_IMG_FMT_I420, width, height, 1)) - die_codec(NULL, "Failed to allocate image."); - - res = vpx_codec_enc_config_default(encoder->codec_interface(), &cfg, 0); - if (res) die_codec(NULL, "Failed to get default codec config."); - - cfg.g_w = width; - cfg.g_h = height; - cfg.g_timebase.num = 1; - cfg.g_timebase.den = fps; - cfg.rc_target_bitrate = bitrate; - cfg.g_error_resilient = err_resilient; - cfg.g_lag_in_frames = 0; - cfg.rc_end_usage = VPX_CBR; - - if (vpx_codec_enc_init(codec, encoder->codec_interface(), &cfg, 0)) - die_codec(codec, "Failed to initialize encoder"); - - if (vpx_codec_control(codec, VP8E_SET_CPUUSED, 8)) - die_codec(codec, "Failed to initialize cpuused"); -} - -void vpx_close(vpx_codec_ctx_t *codec, vpx_image_t *raw) { - // Flush encoder. - while (vpx_encode_frame(codec, NULL, -1, 0)) { - } - - vpx_img_free(raw); - if (vpx_codec_destroy(codec)) die_codec(codec, "Failed to destroy codec."); -} diff --git a/ecp/test/vid/enc.h b/ecp/test/vid/enc.h deleted file mode 100644 index 5acd8ce..0000000 --- a/ecp/test/vid/enc.h +++ /dev/null @@ -1,7 +0,0 @@ -#include "vpx/vpx_encoder.h" -#include "vpx/vp8cx.h" -#include "tools.h" - -int vpx_encode_frame(vpx_codec_ctx_t *codec, vpx_image_t *img, int frame_index, int flags); -void vpx_open(const char *codec_arg, int width, int height, int fps, int bitrate, vpx_codec_er_flags_t err_resilient, vpx_codec_ctx_t *codec, vpx_image_t *raw); -void vpx_close(vpx_codec_ctx_t *codec, vpx_image_t *raw); diff --git a/ecp/test/vid/server.c b/ecp/test/vid/server.c deleted file mode 100644 index 9d43b7a..0000000 --- a/ecp/test/vid/server.c +++ /dev/null @@ -1,76 +0,0 @@ -#include <stdio.h> -#include <string.h> -#include <unistd.h> -#include <stdlib.h> - -#include "server.h" - -static ECPContext ctx; -static ECPSocket sock; -static ECPDHKey key_perma; -static ECPConnHandler handler; - -static ECPConnection *conn_in; -static int is_open = 0; - -#define CTYPE_TEST 0 -#define MTYPE_MSG 8 - -ECPNode node; -ECPConnection conn; - -static ssize_t handle_open(ECPConnection *c, ecp_seq_t sq, unsigned char t, unsigned char *m, ssize_t sz, ECP2Buffer *b) { - fprintf(stderr, "IS OPEN!\n"); - - ssize_t rv = ecp_conn_handle_open(c, sq, t, m, sz, b); - if (rv < 0) return rv; - - conn_in = c; - is_open = 1; - - return rv; -} - -ssize_t send_frame(unsigned char *buffer, size_t size, ecp_pts_t pts) { - return ecp_send(conn_in, MTYPE_MSG, buffer, size); -} - -int conn_is_open(void) { - return is_open; -} - -int init_server(char *address, char *my_key, char *vcs_key) { - int rv; - - rv = ecp_init(&ctx); - fprintf(stderr, "ecp_init RV:%d\n", rv); - - if (!rv) rv = ecp_conn_handler_init(&handler); - if (!rv) { - handler.msg[ECP_MTYPE_OPEN] = handle_open; - ctx.handler[CTYPE_TEST] = &handler; - } - - if (!rv) rv = ecp_util_key_load(&ctx, &key_perma, my_key); - fprintf(stderr, "ecp_util_key_load RV:%d\n", rv); - - if (!rv) rv = ecp_sock_create(&sock, &ctx, &key_perma); - fprintf(stderr, "ecp_sock_create RV:%d\n", rv); - - if (!rv) rv = ecp_sock_open(&sock, address); - fprintf(stderr, "ecp_sock_open RV:%d\n", rv); - - if (!rv) rv = ecp_start_receiver(&sock); - fprintf(stderr, "ecp_start_receiver RV:%d\n", rv); - - if (!rv) rv = ecp_util_node_load(&ctx, &node, vcs_key); - printf("ecp_util_node_load RV:%d\n", rv); - - if (!rv) rv = ecp_conn_create(&conn, &sock, ECP_CTYPE_VLINK); - printf("ecp_conn_create RV:%d\n", rv); - - if (!rv) rv = ecp_conn_open(&conn, &node); - printf("ecp_conn_open RV:%d\n", rv); - - return rv; -} diff --git a/ecp/test/vid/server.h b/ecp/test/vid/server.h deleted file mode 100644 index 2158b38..0000000 --- a/ecp/test/vid/server.h +++ /dev/null @@ -1,7 +0,0 @@ -#include "core.h" -#include "vconn/vconn.h" -#include "util.h" - -ssize_t send_frame(unsigned char *buffer, size_t size, ecp_pts_t pts); -int conn_is_open(void); -int init_server(char *address, char *my_key, char *vcs_key); diff --git a/ecp/test/vid/tools.c b/ecp/test/vid/tools.c deleted file mode 100644 index 0307ef6..0000000 --- a/ecp/test/vid/tools.c +++ /dev/null @@ -1,165 +0,0 @@ -#include <stdio.h> -#include <stdarg.h> -#include <stdlib.h> -#include <string.h> - -#include "tools.h" - -static const VpxInterface vpx_encoders[] = { - { "vp8", VP8_FOURCC, &vpx_codec_vp8_cx }, - { "vp9", VP9_FOURCC, &vpx_codec_vp9_cx }, -}; - -int get_vpx_encoder_count(void) { - return sizeof(vpx_encoders) / sizeof(vpx_encoders[0]); -} - -const VpxInterface *get_vpx_encoder_by_index(int i) { return &vpx_encoders[i]; } - -const VpxInterface *get_vpx_encoder_by_name(const char *name) { - int i; - - for (i = 0; i < get_vpx_encoder_count(); ++i) { - const VpxInterface *encoder = get_vpx_encoder_by_index(i); - if (strcmp(encoder->name, name) == 0) return encoder; - } - - return NULL; -} - -static const VpxInterface vpx_decoders[] = { - { "vp8", VP8_FOURCC, &vpx_codec_vp8_dx }, - { "vp9", VP9_FOURCC, &vpx_codec_vp9_dx }, -}; - -int get_vpx_decoder_count(void) { - return sizeof(vpx_decoders) / sizeof(vpx_decoders[0]); -} - -const VpxInterface *get_vpx_decoder_by_index(int i) { return &vpx_decoders[i]; } - -const VpxInterface *get_vpx_decoder_by_name(const char *name) { - int i; - - for (i = 0; i < get_vpx_decoder_count(); ++i) { - const VpxInterface *const decoder = get_vpx_decoder_by_index(i); - if (strcmp(decoder->name, name) == 0) return decoder; - } - - return NULL; -} - -void die_codec(vpx_codec_ctx_t *ctx, const char *s) { - if (ctx) { - const char *detail = vpx_codec_error_detail(ctx); - - fprintf(stderr, "%s: %s\n", s, vpx_codec_error(ctx)); - if (detail) fprintf(stderr, " %s\n", detail); - } else { - fprintf(stderr, "%s", s); - } - exit(EXIT_FAILURE); -} - -// TODO(dkovalev): move this function to vpx_image.{c, h}, so it will be part -// of vpx_image_t support -int vpx_img_plane_width(const vpx_image_t *img, int plane) { - if (plane > 0 && img->x_chroma_shift > 0) - return (img->d_w + 1) >> img->x_chroma_shift; - else - return img->d_w; -} - -int vpx_img_plane_height(const vpx_image_t *img, int plane) { - if (plane > 0 && img->y_chroma_shift > 0) - return (img->d_h + 1) >> img->y_chroma_shift; - else - return img->d_h; -} - -int vpx_img_read(vpx_image_t *img, void *img_buf, int sz) { - int plane; - int off = 0; - - for (plane = 0; plane < 3; ++plane) { - unsigned char *buf = img->planes[plane]; - const int stride = img->stride[plane]; - const int w = vpx_img_plane_width(img, plane) * - ((img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1); - const int h = vpx_img_plane_height(img, plane); - int y; - - for (y = 0; y < h; ++y) { - if (off + w > sz) return 0; - memcpy(buf, img_buf + off, w); - off += w; - buf += stride; - } - } - - return 1; -} - -int vpx_img_write(const vpx_image_t *img, void *img_buf, int sz) { - int plane; - int off = 0; - - for (plane = 0; plane < 3; ++plane) { - const unsigned char *buf = img->planes[plane]; - const int stride = img->stride[plane]; - const int w = vpx_img_plane_width(img, plane) * - ((img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1); - const int h = vpx_img_plane_height(img, plane); - int y; - - for (y = 0; y < h; ++y) { - if (off + w > sz) return 0; - memcpy(img_buf + off, buf, w); - off += w; - buf += stride; - } - } - - return 1; -} - -int vpx_img_read_f(vpx_image_t *img, FILE *file) { - int plane; - - for (plane = 0; plane < 3; ++plane) { - unsigned char *buf = img->planes[plane]; - const int stride = img->stride[plane]; - const int w = vpx_img_plane_width(img, plane) * - ((img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1); - const int h = vpx_img_plane_height(img, plane); - int y; - - for (y = 0; y < h; ++y) { - if (fread(buf, 1, w, file) != (size_t)w) return 0; - buf += stride; - } - } - - return 1; -} - -int vpx_img_write_f(const vpx_image_t *img, FILE *file) { - int plane; - - for (plane = 0; plane < 3; ++plane) { - const unsigned char *buf = img->planes[plane]; - const int stride = img->stride[plane]; - const int w = vpx_img_plane_width(img, plane) * - ((img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1); - const int h = vpx_img_plane_height(img, plane); - int y; - - for (y = 0; y < h; ++y) { - if (fwrite(buf, 1, w, file) != (size_t)w) return 0; - buf += stride; - } - } - - return 1; -} - diff --git a/ecp/test/vid/tools.h b/ecp/test/vid/tools.h deleted file mode 100644 index 645d5ba..0000000 --- a/ecp/test/vid/tools.h +++ /dev/null @@ -1,37 +0,0 @@ -#ifndef TOOLS_COMMON_H_ -#define TOOLS_COMMON_H_ - -#include "vpx/vpx_codec.h" -#include "vpx/vpx_image.h" -#include "vpx/vp8cx.h" -#include "vpx/vp8dx.h" - -#define VP8_FOURCC 0x30385056 -#define VP9_FOURCC 0x30395056 - -struct VpxRational { - int numerator; - int denominator; -}; - -typedef struct VpxInterface { - const char *const name; - const uint32_t fourcc; - vpx_codec_iface_t *(*const codec_interface)(); -} VpxInterface; - -const VpxInterface *get_vpx_encoder_by_index(int i); -const VpxInterface *get_vpx_encoder_by_name(const char *name); - -const VpxInterface *get_vpx_decoder_by_index(int i); -const VpxInterface *get_vpx_decoder_by_name(const char *name); - -void die_codec(vpx_codec_ctx_t *ctx, const char *s); - -int vpx_img_read(vpx_image_t *img, void *img_buf, int sz); -int vpx_img_write(const vpx_image_t *img, void *img_buf, int sz); - -int vpx_img_read_f(vpx_image_t *img, FILE *file); -int vpx_img_write_f(const vpx_image_t *img, FILE *file); - -#endif
\ No newline at end of file diff --git a/ecp/test/voip.c b/ecp/test/voip.c deleted file mode 100644 index b0a9207..0000000 --- a/ecp/test/voip.c +++ /dev/null @@ -1,196 +0,0 @@ -#include <stdio.h> -#include <string.h> -#include <unistd.h> -#include <stdlib.h> -#include <alsa/asoundlib.h> - -#include <opus.h> - -#include "core.h" -#include "util.h" - -ECPContext ctx_c; -ECPSocket sock_c; -ECPConnHandler handler_c; - -ECPNode node; -ECPConnection conn; -int open_done = 0; - -snd_pcm_t *handle_plb; -snd_pcm_t *handle_cpt; -OpusEncoder *opus_enc; -OpusDecoder *opus_dec; -// 2.5, 5, 10, 20, 40 or 60 ms -snd_pcm_uframes_t alsa_frames = 160; -unsigned char *alsa_out_buf = NULL; -unsigned char *alsa_in_buf = NULL; - -#define CTYPE_TEST 0 -#define MTYPE_MSG 8 - -int a_open(char *dev_name, snd_pcm_t **handle, snd_pcm_hw_params_t **hw_params, snd_pcm_stream_t stream, snd_pcm_format_t format, unsigned int *nchannels, unsigned int *sample_rate, snd_pcm_uframes_t *frames, size_t *buf_size) { - int bits, err = 0; - unsigned int fragments = 2; - unsigned int frame_size; - - err = snd_pcm_open(handle, dev_name, stream, 0); - if (!err) err = snd_pcm_hw_params_malloc(hw_params); - if (!err) err = snd_pcm_hw_params_any(*handle, *hw_params); - if (!err) err = snd_pcm_hw_params_set_access(*handle, *hw_params, SND_PCM_ACCESS_RW_INTERLEAVED); - if (!err) err = snd_pcm_hw_params_set_format(*handle, *hw_params, format); - if (!err) err = snd_pcm_hw_params_set_rate_near(*handle, *hw_params, sample_rate, 0); - if (!err) err = snd_pcm_hw_params_set_channels_near(*handle, *hw_params, nchannels); - if (!err) err = snd_pcm_hw_params_set_periods_near(*handle, *hw_params, &fragments, 0); - if (!err) err = snd_pcm_hw_params_set_period_size_near(*handle, *hw_params, frames, 0); - if (!err) err = snd_pcm_hw_params(*handle, *hw_params); - if (err) return err; - - bits = snd_pcm_hw_params_get_sbits(*hw_params); - if (bits < 0) return bits; - - frame_size = *nchannels * (bits / 8); - *buf_size = frame_size * *frames; - - return ECP_OK; -} - -int a_prepare(snd_pcm_t *handle, snd_pcm_hw_params_t *hw_params, unsigned char *buf, snd_pcm_uframes_t frames) { - snd_pcm_drop(handle); - snd_pcm_prepare(handle); - - if (snd_pcm_stream(handle) == SND_PCM_STREAM_PLAYBACK) { - int i, err; - unsigned int fragments; - - err = snd_pcm_hw_params_get_periods(hw_params, &fragments, NULL); - if (err) return err; - - for (i=0; i<fragments; i++) snd_pcm_writei(handle, buf, frames); - } - return ECP_OK; -} - -opus_int32 a_read(snd_pcm_t *handle, unsigned char *buf, snd_pcm_uframes_t frames, OpusEncoder *enc, unsigned char *opus_buf, opus_int32 opus_size) { - snd_pcm_sframes_t frames_in; - - while ((frames_in = snd_pcm_readi(handle, buf, frames)) < 0) { - if (frames_in == -EAGAIN) - continue; - snd_pcm_prepare(handle); - } - return opus_encode(enc, (opus_int16 *)buf, frames_in, opus_buf, opus_size); -} - -snd_pcm_sframes_t a_write(OpusDecoder *dec, unsigned char *opus_buf, opus_int32 opus_size, snd_pcm_t *handle, unsigned char *buf, snd_pcm_uframes_t frames) { - snd_pcm_sframes_t frames_in, frames_out; - - frames_in = opus_decode(dec, opus_buf, opus_size, (opus_int16 *)buf, frames, 0); - while ((frames_out = snd_pcm_writei(handle, buf, frames_in)) < 0) { - if (frames_out == -EAGAIN) - continue; - snd_pcm_prepare(handle); - } - return frames_out; -} - -int a_init(void) { - char *dev_name = "hw:1,0"; - unsigned int nchannels = 1; - unsigned int sample_rate = 16000; - - snd_pcm_hw_params_t *hw_params_plb; - snd_pcm_hw_params_t *hw_params_cpt; - size_t buf_size; - - a_open(dev_name, &handle_plb, &hw_params_plb, SND_PCM_STREAM_PLAYBACK, SND_PCM_FORMAT_S16_LE, &nchannels, &sample_rate, &alsa_frames, &buf_size); - alsa_out_buf = malloc(buf_size); - memset(alsa_out_buf, 0, buf_size); - a_prepare(handle_plb, hw_params_plb, alsa_out_buf, alsa_frames); - - a_open(dev_name, &handle_cpt, &hw_params_cpt, SND_PCM_STREAM_CAPTURE, SND_PCM_FORMAT_S16_LE, &nchannels, &sample_rate, &alsa_frames, &buf_size); - alsa_in_buf = malloc(buf_size); - memset(alsa_in_buf, 0, buf_size); - a_prepare(handle_cpt, hw_params_cpt, alsa_in_buf, alsa_frames); - - int size; - size = opus_encoder_get_size(nchannels); - opus_enc = malloc(size); - opus_encoder_init(opus_enc, sample_rate, nchannels, OPUS_APPLICATION_VOIP); - - size = opus_decoder_get_size(nchannels); - opus_dec = malloc(size); - opus_decoder_init(opus_dec, sample_rate, nchannels); - - return ECP_OK; -} - -ssize_t handle_open_c(ECPConnection *conn, ecp_seq_t sq, unsigned char t, unsigned char *p, ssize_t s, ECP2Buffer *b) { - uint32_t seq = 0; - - ecp_conn_handle_open(conn, sq, t, p, s, b); - if (s < 0) { - printf("OPEN ERR:%ld\n", s); - return s; - } - - a_init(); - open_done = 1; - return s; -} - -ssize_t handle_msg_c(ECPConnection *conn, ecp_seq_t sq, unsigned char t, unsigned char *p, ssize_t s, ECP2Buffer *b) { - a_write(opus_dec, p, s, handle_plb, alsa_out_buf, alsa_frames); - return s; -} - - -static void usage(char *arg) { - fprintf(stderr, "Usage: %s <node.pub>\n", arg); - exit(1); -} - -int main(int argc, char *argv[]) { - int rv; - - if (argc != 2) usage(argv[0]); - - rv = ecp_init(&ctx_c); - printf("ecp_init RV:%d\n", rv); - - rv = ecp_conn_handler_init(&handler_c); - handler_c.msg[ECP_MTYPE_OPEN] = handle_open_c; - handler_c.msg[MTYPE_MSG] = handle_msg_c; - ctx_c.handler[CTYPE_TEST] = &handler_c; - - rv = ecp_sock_init(&sock_c, &ctx_c, NULL); - printf("ecp_sock_init RV:%d\n", rv); - - rv = ecp_sock_open(&sock_c, NULL); - printf("ecp_sock_open RV:%d\n", rv); - - rv = ecp_start_receiver(&sock_c); - printf("ecp_start_receiver RV:%d\n", rv); - - rv = ecp_util_node_load(&ctx_c, &node, argv[1]); - printf("ecp_util_node_load RV:%d\n", rv); - - rv = ecp_conn_init(&conn, &sock_c, CTYPE_TEST); - printf("ecp_conn_init RV:%d\n", rv); - - rv = ecp_conn_open(&conn, &node); - printf("ecp_conn_open RV:%d\n", rv); - - while(!open_done) sleep(1); - - unsigned char payload[ECP_MAX_PLD]; - unsigned char *opus_buf; - - while(1) { - ecp_pld_set_type(payload, MTYPE_MSG); - opus_buf = ecp_pld_get_buf(payload, 0); - opus_int32 len = a_read(handle_cpt, alsa_in_buf, alsa_frames, opus_enc, opus_buf, ECP_MAX_MSG); - if (len < 0) continue; - ssize_t _rv = ecp_pld_send(&conn, payload, len); - } -}
\ No newline at end of file diff --git a/ecp/util/mknode.c b/ecp/util/mknode.c index 885a4c0..764ac18 100644 --- a/ecp/util/mknode.c +++ b/ecp/util/mknode.c @@ -4,7 +4,8 @@ #include <stdio.h> #include <string.h> -#include "core.h" +#include <core.h> + #include "util.h" #define FN_LEN 256 @@ -18,12 +19,16 @@ static void usage(char *arg) { } int main(int argc, char *argv[]) { + char *addr; ECPDHKey key; ECPNode node; int rv; if ((argc < 2) || (argc > 3)) usage(argv[0]); + addr = NULL; + if (argc == 3) addr = argv[2]; + if (strlen(argv[1]) > FN_LEN - 6) usage(argv[0]); strcpy(fn_node, argv[1]); strcpy(fn_key, argv[1]); @@ -33,14 +38,19 @@ int main(int argc, char *argv[]) { rv = ecp_dhkey_gen(&key); if (rv) goto err; - rv = ecp_node_init(&node, &key.public, (argc == 3) ? argv[2] : NULL); + rv = ecp_node_init(&node, &key.public, addr); if (rv) goto err; - rv = ecp_util_key_save(&key, fn_key); + rv = ecp_util_save_key(&key.public, &key.private, fn_key); if (rv) goto err; - rv = ecp_util_node_save(&node, fn_node); - if (rv) goto err; + if (addr) { + rv = ecp_util_save_node(&node, fn_node); + if (rv) goto err; + } else { + rv = ecp_util_save_pub(&key.public, fn_node); + if (rv) goto err; + } return 0; diff --git a/ecp/util/util.c b/ecp/util/util.c index ee51c73..2b67127 100644 --- a/ecp/util/util.c +++ b/ecp/util/util.c @@ -3,24 +3,22 @@ #include <unistd.h> #include <sys/stat.h> -#include "core.h" -#include "cr.h" +#include <core.h> + #include "util.h" -int ecp_util_key_save(ECPDHKey *key, char *filename) { +int ecp_util_load_key(ecp_ecdh_public_t *public, ecp_ecdh_private_t *private, char *filename) { int fd; ssize_t rv; - if (!key->valid) return ECP_ERR; - - if ((fd = open(filename, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR)) < 0) return ECP_ERR; - rv = write(fd, &key->public, sizeof(key->public)); - if (rv != sizeof(key->public)) { + if ((fd = open(filename, O_RDONLY)) < 0) return ECP_ERR; + rv = read(fd, public, sizeof(ecp_ecdh_public_t)); + if (rv != sizeof(ecp_ecdh_public_t)) { close(fd); return ECP_ERR; } - rv = write(fd, &key->private, sizeof(key->private)); - if (rv != sizeof(key->private)) { + rv = read(fd, private, sizeof(ecp_ecdh_private_t)); + if (rv != sizeof(ecp_ecdh_private_t)) { close(fd); return ECP_ERR; } @@ -28,41 +26,46 @@ int ecp_util_key_save(ECPDHKey *key, char *filename) { return ECP_OK; } -int ecp_util_key_load(ECPDHKey *key, char *filename) { +int ecp_util_save_key(ecp_ecdh_public_t *public, ecp_ecdh_private_t *private, char *filename) { int fd; ssize_t rv; - if ((fd = open(filename, O_RDONLY)) < 0) return ECP_ERR; - rv = read(fd, &key->public, sizeof(key->public)); - if (rv != sizeof(key->public)) { + if ((fd = open(filename, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR)) < 0) return ECP_ERR; + rv = write(fd, public, sizeof(ecp_ecdh_public_t)); + if (rv != sizeof(ecp_ecdh_public_t)) { close(fd); return ECP_ERR; } - rv = read(fd, &key->private, sizeof(key->private)); - if (rv != sizeof(key->private)) { + rv = write(fd, private, sizeof(ecp_ecdh_private_t)); + if (rv != sizeof(ecp_ecdh_private_t)) { close(fd); return ECP_ERR; } close(fd); - - key->valid = 1; return ECP_OK; } -int ecp_util_node_save(ECPNode *node, char *filename) { +int ecp_util_load_pub(ecp_ecdh_public_t *public, char *filename) { int fd; ssize_t rv; - if (!node->key_perma.valid) return ECP_ERR; - - if ((fd = open(filename, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR)) < 0) return ECP_ERR; - rv = write(fd, &node->key_perma.public, sizeof(node->key_perma.public)); - if (rv != sizeof(node->key_perma.public)) { + if ((fd = open(filename, O_RDONLY)) < 0) return ECP_ERR; + rv = read(fd, public, sizeof(ecp_ecdh_public_t)); + if (rv != sizeof(ecp_ecdh_public_t)) { close(fd); return ECP_ERR; } - rv = write(fd, &node->addr, sizeof(node->addr)); - if (rv != sizeof(node->addr)) { + close(fd); + return ECP_OK; +} + +int ecp_util_save_pub(ecp_ecdh_public_t *public, char *filename) { + int fd; + ssize_t rv; + + if ((fd = open(filename, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR)) < 0) return ECP_ERR; + rv = write(fd, public, sizeof(ecp_ecdh_public_t)); + if (rv != sizeof(ecp_ecdh_public_t)) { close(fd); return ECP_ERR; } @@ -70,7 +73,7 @@ int ecp_util_node_save(ECPNode *node, char *filename) { return ECP_OK; } -int ecp_util_node_load(ECPNode *node, char *filename) { +int ecp_util_load_node(ECPNode *node, char *filename) { int fd; ssize_t rv; @@ -89,4 +92,25 @@ int ecp_util_node_load(ECPNode *node, char *filename) { node->key_perma.valid = 1; return ECP_OK; -}
\ No newline at end of file +} + +int ecp_util_save_node(ECPNode *node, char *filename) { + int fd; + ssize_t rv; + + if (!node->key_perma.valid) return ECP_ERR; + + if ((fd = open(filename, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR)) < 0) return ECP_ERR; + rv = write(fd, &node->key_perma.public, sizeof(node->key_perma.public)); + if (rv != sizeof(node->key_perma.public)) { + close(fd); + return ECP_ERR; + } + rv = write(fd, &node->addr, sizeof(node->addr)); + if (rv != sizeof(node->addr)) { + close(fd); + return ECP_ERR; + } + close(fd); + return ECP_OK; +} diff --git a/ecp/util/util.h b/ecp/util/util.h index 631a808..83c4c14 100644 --- a/ecp/util/util.h +++ b/ecp/util/util.h @@ -1,5 +1,8 @@ -int ecp_util_key_save(ECPDHKey *key, char *filename); -int ecp_util_key_load(ECPDHKey *key, char *filename); +int ecp_util_load_key(ecp_ecdh_public_t *public, ecp_ecdh_private_t *private, char *filename); +int ecp_util_save_key(ecp_ecdh_public_t *public, ecp_ecdh_private_t *private, char *filename); -int ecp_util_node_save(ECPNode *node, char *filename); -int ecp_util_node_load(ECPNode *node, char *filename);
\ No newline at end of file +int ecp_util_load_pub(ecp_ecdh_public_t *public, char *filename); +int ecp_util_save_pub(ecp_ecdh_public_t *public, char *filename); + +int ecp_util_load_node(ECPNode *node, char *filename); +int ecp_util_save_node(ECPNode *node, char *filename); |