summaryrefslogtreecommitdiff
path: root/ecp/src/core.h
blob: b1264309c39130dec5efd029f59be6d50ed20040 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
#include <sys/types.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>

#ifdef ECP_WITH_PTHREAD
#include <pthread.h>
#endif

#define ECP_MEM_TINY                1

#define ECP_OK                      0
#define ECP_ITER_NEXT               1

#define ECP_ERR                     -1
#define ECP_ERR_TIMEOUT             -2
#define ECP_ERR_ALLOC               -3
#define ECP_ERR_SIZE                -4
#define ECP_ERR_ITER                -5
#define ECP_ERR_BUSY                -6
#define ECP_ERR_EMPTY               -7
#define ECP_ERR_FULL                -8

#define ECP_ERR_MAX_SOCK_CONN       -10
#define ECP_ERR_MAX_CTYPE           -11
#define ECP_ERR_MAX_MTYPE           -12
#define ECP_ERR_NET_ADDR            -13

#define ECP_ERR_ECDH_KEY_DUP        -21
#define ECP_ERR_ECDH_IDX            -22
#define ECP_ERR_ECDH_IDX_LOCAL      -23
#define ECP_ERR_ECDH_IDX_REMOTE     -24
#define ECP_ERR_RNG                 -25
#define ECP_ERR_ENCRYPT             -26
#define ECP_ERR_DECRYPT             -27
#define ECP_ERR_SEND                -28
#define ECP_ERR_RECV                -29
#define ECP_ERR_SEQ                 -30
#define ECP_ERR_CLOSED              -31
#define ECP_ERR_NOT_IMPLEMENTED     -99

#define ECP_SIZE_PROTO              2
#define ECP_SIZE_SEQ                4

#define ECP_MAX_SOCK_CONN           16
#define ECP_MAX_SOCK_KEY            8
#define ECP_MAX_CONN_KEY            2
#define ECP_MAX_NODE_KEY            2
#define ECP_MAX_CTYPE               8
#define ECP_MAX_MTYPE               16
#define ECP_MAX_MTYPE_SYS           4
#define ECP_MAX_MTYPE_SOCK          ECP_MAX_MTYPE_SYS
#define ECP_MAX_SEQ_FWD             1024

#define ECP_SIZE_PKT_HDR            (ECP_SIZE_PROTO+1+ECP_ECDH_SIZE_KEY+ECP_AEAD_SIZE_NONCE)
#define ECP_SIZE_PLD_HDR            (ECP_SIZE_SEQ)

#define ECP_MAX_PKT                 1412
#define ECP_MAX_PLD                 (ECP_MAX_PKT-ECP_SIZE_PKT_HDR-ECP_AEAD_SIZE_TAG)
#define ECP_MAX_MSG                 (ECP_MAX_PLD-ECP_SIZE_PLD_HDR-1)

#define ECP_MIN_PKT                 (ECP_SIZE_PKT_HDR+ECP_SIZE_PLD_HDR+1+ECP_AEAD_SIZE_TAG)

#define ECP_POLL_TIMEOUT            500
#define ECP_ECDH_IDX_INV            0xFF
#define ECP_ECDH_IDX_PERMA          0x0F

#define ECP_MTYPE_FLAG_FRAG         0x80
#define ECP_MTYPE_FLAG_PTS          0x40
#define ECP_MTYPE_FLAG_REP          0x20
#define ECP_MTYPE_MASK              0x1f

#define ECP_MTYPE_OPEN              0x00
#define ECP_MTYPE_KGET              0x01
#define ECP_MTYPE_KPUT              0x02
#define ECP_MTYPE_DIR               0x03

#define ECP_MTYPE_OPEN_REQ          (ECP_MTYPE_OPEN)
#define ECP_MTYPE_OPEN_REP          (ECP_MTYPE_OPEN | ECP_MTYPE_FLAG_REP)
#define ECP_MTYPE_KGET_REQ          (ECP_MTYPE_KGET)
#define ECP_MTYPE_KGET_REP          (ECP_MTYPE_KGET | ECP_MTYPE_FLAG_REP)
#define ECP_MTYPE_KPUT_REQ          (ECP_MTYPE_KPUT)
#define ECP_MTYPE_KPUT_REP          (ECP_MTYPE_KPUT | ECP_MTYPE_FLAG_REP)
#define ECP_MTYPE_DIR_REQ           (ECP_MTYPE_DIR)
#define ECP_MTYPE_DIR_REP           (ECP_MTYPE_DIR  | ECP_MTYPE_FLAG_REP)

#define ECP_CONN_FLAG_OUTB          0x01
#define ECP_CONN_FLAG_NEW           0x02
#define ECP_CONN_FLAG_REG           0x04
#define ECP_CONN_FLAG_OPEN          0x08

#define ECP_SEND_FLAG_REPLY         0x01
#define ECP_SEND_FLAG_MORE          0x02

#define ecp_conn_is_inb(conn)     (!((conn)->flags_im & ECP_CONN_FLAG_OUTB))
#define ecp_conn_is_outb(conn)      ((conn)->flags_im & ECP_CONN_FLAG_OUTB)
#define ecp_conn_is_new(conn)       ((conn)->flags_im & ECP_CONN_FLAG_NEW)
#define ecp_conn_is_reg(conn)       ((conn)->flags    & ECP_CONN_FLAG_REG)
#define ecp_conn_is_open(conn)      ((conn)->flags    & ECP_CONN_FLAG_OPEN)

#define ecp_conn_set_outb(conn)     ((conn)->flags_im |= ECP_CONN_FLAG_OUTB)
#define ecp_conn_set_new(conn)      ((conn)->flags_im |= ECP_CONN_FLAG_NEW)
#define ecp_conn_set_reg(conn)      ((conn)->flags    |= ECP_CONN_FLAG_REG)
#define ecp_conn_set_open(conn)     ((conn)->flags    |= ECP_CONN_FLAG_OPEN)

#define ecp_conn_clr_outb(conn)     ((conn)->flags_im &= ~ECP_CONN_FLAG_OUTB)
#define ecp_conn_clr_new(conn)      ((conn)->flags_im &= ~ECP_CONN_FLAG_NEW)
#define ecp_conn_clr_reg(conn)      ((conn)->flags    &= ~ECP_CONN_FLAG_REG)
#define ecp_conn_clr_open(conn)     ((conn)->flags    &= ~ECP_CONN_FLAG_OPEN)

// typedef long ssize_t;

typedef uint32_t ecp_ack_t;
#define ECP_SIZE_ACKB               (sizeof(ecp_ack_t)*8)
#define ECP_ACK_FULL                (~(ecp_ack_t)0)

typedef uint32_t ecp_cts_t;
#define ECP_CTS_HALF                ((ecp_cts_t)1 << (sizeof(ecp_cts_t) * 8 - 1))
#define ECP_CTS_LT(a,b)             ((ecp_cts_t)((ecp_cts_t)(a) - (ecp_cts_t)(b)) > ECP_CTS_HALF)
#define ECP_CTS_LTE(a,b)            ((ecp_cts_t)((ecp_cts_t)(b) - (ecp_cts_t)(a)) < ECP_CTS_HALF)

typedef uint32_t ecp_pts_t;
#define ECP_PTS_HALF                ((ecp_pts_t)1 << (sizeof(ecp_pts_t) * 8 - 1))
#define ECP_PTS_LT(a,b)             ((ecp_pts_t)((ecp_pts_t)(a) - (ecp_pts_t)(b)) > ECP_PTS_HALF)
#define ECP_PTS_LTE(a,b)            ((ecp_pts_t)((ecp_pts_t)(b) - (ecp_pts_t)(a)) < ECP_PTS_HALF)

typedef uint32_t ecp_seq_t;
#define ECP_SEQ_HALF                ((ecp_seq_t)1 << (sizeof(ecp_seq_t) * 8 - 1))
#define ECP_SEQ_LT(a,b)             ((ecp_seq_t)((ecp_seq_t)(a) - (ecp_seq_t)(b)) > ECP_SEQ_HALF)
#define ECP_SEQ_LTE(a,b)            ((ecp_seq_t)((ecp_seq_t)(b) - (ecp_seq_t)(a)) < ECP_SEQ_HALF)


#define ECP_SIZE_MT_FRAG(F)         ((F) & ECP_MTYPE_FLAG_FRAG ? 2 + sizeof(uint16_t) : 0)
#define ECP_SIZE_MT_PTS(F)          ((F) & ECP_MTYPE_FLAG_PTS ? sizeof(ecp_pts_t) : 0)
#define ECP_SIZE_MT_FLAG(F)         (ECP_SIZE_MT_FRAG(F)+ECP_SIZE_MT_PTS(F))
#define ECP_SIZE_PLD(X,F)           ((X) + ECP_SIZE_PLD_HDR+1+ECP_SIZE_MT_FLAG(F))
#define ECP_SIZE_PKT(X,F)           (ECP_SIZE_PKT_HDR+ECP_SIZE_PLD(X,F)+ECP_AEAD_SIZE_TAG)

#define ECP_SIZE_MSG_BUF(T,P)       ((P) && ecp_conn_is_outb(P) && (((T) == ECP_MTYPE_OPEN_REQ) || ((T) == ECP_MTYPE_KGET_REQ)) ? ECP_SIZE_PLD_HDR+3+2*ECP_ECDH_SIZE_KEY : ECP_SIZE_PLD_HDR+1)

#define ECP_SIZE_PLD_BUF(X,T,C)     (ECP_SIZE_PLD(X,T)+(C)->pcount*(ECP_SIZE_PKT_HDR+ECP_SIZE_MSG_BUF(T,(C)->parent)+ECP_AEAD_SIZE_TAG))
#define ECP_SIZE_PKT_BUF(X,T,C)     (ECP_SIZE_PLD_BUF(X,T,C)+ECP_SIZE_PKT_HDR+ECP_AEAD_SIZE_TAG)

#define ECP_SIZE_PLD_BUF_TR(X,T,P)  (ECP_SIZE_PLD(X,T)+((P) ? ((P)->pcount+1)*(ECP_SIZE_PKT_HDR+ECP_SIZE_MSG_BUF(T,P)+ECP_AEAD_SIZE_TAG) : 0))
#define ECP_SIZE_PKT_BUF_TR(X,T,P)  (ECP_SIZE_PLD_BUF_TR(X,T,P)+ECP_SIZE_PKT_HDR+ECP_AEAD_SIZE_TAG)

#ifdef ECP_DEBUG
#include <stdio.h>
#endif

struct ECPBuffer;
struct ECP2Buffer;
struct ECPContext;
struct ECPSocket;
struct ECPConnection;
struct ECPSeqItem;
struct ECPPktMeta;
struct ECPDirList;

#include "crypto/crypto.h"
#include "transport.h"
#include "timer.h"

#ifdef ECP_WITH_RBUF
#include "rbuf.h"
#endif

typedef int (*ecp_rng_t) (void *, size_t);

typedef ssize_t (*ecp_sock_msg_handler_t) (struct ECPSocket *s, ECPNetAddr *a, struct ECPConnection *p, unsigned char *msg, size_t sz, struct ECPPktMeta *m, struct ECP2Buffer *b, struct ECPConnection **c);
typedef ssize_t (*ecp_conn_msg_handler_t) (struct ECPConnection *c, ecp_seq_t s, unsigned char t, unsigned char *msg, ssize_t sz, struct ECP2Buffer *b);

typedef struct ECPConnection * (*ecp_conn_alloc_t) (struct ECPSocket *s, unsigned char t);
typedef void (*ecp_conn_free_t) (struct ECPConnection *c);
typedef ssize_t (*ecp_conn_open_t) (struct ECPConnection *c);
typedef void (*ecp_conn_close_t) (struct ECPConnection *c);

typedef struct ECPBuffer {
    unsigned char *buffer;
    size_t size;
} ECPBuffer;

typedef struct ECP2Buffer {
    ECPBuffer *packet;
    ECPBuffer *payload;
} ECP2Buffer;

typedef struct ECPDHKey {
    ecp_dh_public_t public;
    ecp_dh_private_t private;
    unsigned char valid;
} ECPDHKey;

typedef struct ECPDHRKey {
    unsigned char idx;
    ecp_dh_public_t public;
} ECPDHRKey;

typedef struct ECPDHShared {
    ecp_aead_key_t secret;
    unsigned char valid;
} ECPDHShared;

typedef struct ECPDHRKeyBucket {
    ECPDHRKey key[ECP_MAX_NODE_KEY];
    unsigned char key_curr;
    unsigned char key_idx_map[ECP_MAX_SOCK_KEY];
} ECPDHRKeyBucket;

typedef struct ECPNode {
    ECPNetAddr addr;
    ecp_dh_public_t public;
} ECPNode;

typedef struct ECPSeqItem {
    ecp_seq_t seq;
    unsigned char seq_w;
#ifdef ECP_WITH_RBUF
    unsigned char rb_pass;
    unsigned char rb_mtype;
    unsigned short rb_idx;
#endif
} ECPSeqItem;

typedef struct ECPFragIter {
    ecp_seq_t seq;
    unsigned char frag_cnt;
    unsigned char *buffer;
    size_t buf_size;
    size_t msg_size;
} ECPFragIter;

typedef struct ECPPktMeta {
    ecp_aead_key_t shsec;
    ecp_seq_t seq;
    unsigned char public[ECP_ECDH_SIZE_KEY];
    unsigned char nonce[ECP_AEAD_SIZE_NONCE];
    unsigned char s_idx;
    unsigned char c_idx;
} ECPPktMeta;

typedef struct ECPConnHandler {
    ecp_conn_msg_handler_t msg[ECP_MAX_MTYPE];
    ecp_conn_close_t conn_close;
} ECPConnHandler;

typedef struct ECPSockCTable {
#ifdef ECP_WITH_HTABLE
    void *htable;
#else
    struct ECPConnection *array[ECP_MAX_SOCK_CONN];
    unsigned short size;
#endif
#ifdef ECP_WITH_PTHREAD
    pthread_mutex_t mutex;
#endif
} ECPSockCTable;

typedef struct ECPContext {
    ecp_rng_t rng;
    ecp_conn_alloc_t conn_alloc;
    ecp_conn_free_t conn_free;
    ECPConnHandler *handler[ECP_MAX_CTYPE];
#ifdef ECP_WITH_DIRSRV
    struct ECPDirList *dir_online;
    struct ECPDirList *dir_shadow;
#endif
} ECPContext;

typedef struct ECPSocket {
    ECPContext *ctx;
    unsigned char running;
    int poll_timeout;
    ECPNetSock sock;
    ECPDHKey key_perma;
    ECPDHKey key[ECP_MAX_SOCK_KEY];
    unsigned char key_curr;
    ECPSockCTable conn;
    ECPTimer timer;
    ecp_sock_msg_handler_t handler[ECP_MAX_MTYPE_SOCK];
#ifdef ECP_WITH_PTHREAD
    pthread_t rcvr_thd;
    pthread_mutex_t mutex;
#endif
} ECPSocket;

typedef struct ECPConnection {
    unsigned char type;
    unsigned char flags;
    unsigned char flags_im;
    unsigned short refcount;
    ecp_seq_t seq_out;
    ecp_seq_t seq_in;
    ecp_ack_t seq_in_map;
    ECPSocket *sock;
    ECPNode node;
    ECPDHRKeyBucket remote;
    ECPDHKey key[ECP_MAX_CONN_KEY];
    unsigned char key_curr;
    unsigned char key_idx[ECP_MAX_NODE_KEY];
    unsigned char key_idx_curr;
    unsigned char key_idx_map[ECP_MAX_SOCK_KEY];
    ECPDHShared shared[ECP_MAX_NODE_KEY][ECP_MAX_NODE_KEY];
    unsigned char nonce[ECP_AEAD_SIZE_NONCE];
#ifdef ECP_WITH_RBUF
    ECPConnRBuffer rbuf;
#endif
#ifdef ECP_WITH_PTHREAD
    pthread_mutex_t mutex;
#endif
    struct ECPConnection *parent;
    unsigned short pcount;
    void *conn_data;
} ECPConnection;

int ecp_init(ECPContext *ctx);
int ecp_ctx_init(ECPContext *ctx);
int ecp_node_init(ECPNode *node, ecp_dh_public_t *public, void *addr);
int ecp_seq_item_init(ECPSeqItem *seq_item);
int ecp_frag_iter_init(ECPFragIter *iter, unsigned char *buffer, size_t buf_size);
void ecp_frag_iter_reset(ECPFragIter *iter);
int ecp_dhkey_gen(ECPContext *ctx, ECPDHKey *key);

int ecp_sock_init(ECPSocket *sock, ECPContext *ctx, ECPDHKey *key);
int ecp_sock_create(ECPSocket *sock);
void ecp_sock_destroy(ECPSocket *sock);
int ecp_sock_open(ECPSocket *sock, void *myaddr);
void ecp_sock_close(ECPSocket *sock);
ecp_sock_msg_handler_t ecp_sock_get_msg_handler(ECPSocket *sock, unsigned char mtype);
int ecp_sock_dhkey_get_curr(ECPSocket *sock, unsigned char *idx, unsigned char *public);
int ecp_sock_dhkey_new(ECPSocket *sock);

int ecp_conn_init(ECPConnection *conn, ECPSocket *sock, unsigned char ctype);
int ecp_conn_create(ECPConnection *conn);
void ecp_conn_destroy(ECPConnection *conn);
int ecp_conn_create_inb(ECPConnection *conn, ECPConnection *parent, unsigned char c_idx, unsigned char *public);
int ecp_conn_create_outb(ECPConnection *conn, ECPNode *node);
int ecp_conn_insert(ECPConnection *conn);
int ecp_conn_register(ECPConnection *conn);
void ecp_conn_unregister(ECPConnection *conn, unsigned short *refcount);

int ecp_conn_get_dirlist(ECPConnection *conn, ECPNode *node);
int ecp_conn_open(ECPConnection *conn, ECPNode *node);
int ecp_conn_close(ECPConnection *conn);
int ecp_conn_reset(ECPConnection *conn);
void ecp_conn_refcount_inc(ECPConnection *conn);
void ecp_conn_refcount_dec(ECPConnection *conn);
int ecp_conn_handler_init(ECPConnHandler *handler);
ecp_conn_msg_handler_t ecp_conn_get_msg_handler(ECPConnection *conn, unsigned char mtype);
ecp_conn_close_t ecp_conn_get_close_handler(ECPConnection *conn);

int ecp_conn_dhkey_new(ECPConnection *conn);
int ecp_conn_dhkey_new_pub(ECPConnection *conn, unsigned char idx, unsigned char *public);
int ecp_conn_dhkey_get_curr(ECPConnection *conn, unsigned char *idx, unsigned char *public);

ssize_t ecp_conn_send_open(ECPConnection *conn);
ssize_t ecp_conn_send_kget(ECPConnection *conn);
ssize_t ecp_conn_send_kput(ECPConnection *conn);
ssize_t ecp_conn_send_dir(ECPConnection *conn);

ssize_t _ecp_conn_handle_open(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, unsigned char *msg, ssize_t size, ECP2Buffer *b, int *was_open);
ssize_t ecp_conn_handle_open(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, unsigned char *msg, ssize_t size, ECP2Buffer *b);
ssize_t _ecp_conn_handle_kget(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, unsigned char *msg, ssize_t size, ECP2Buffer *b, ecp_conn_open_t conn_open);
ssize_t ecp_conn_handle_kget(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, unsigned char *msg, ssize_t size, ECP2Buffer *b);
ssize_t ecp_conn_handle_kput(ECPConnection *conn, ecp_seq_t seq, unsigned char mtype, unsigned char *msg, ssize_t size, ECP2Buffer *b);
ssize_t ecp_conn_handle_msg(ECPConnection *conn, ecp_seq_t seq, unsigned char *msg, size_t msg_size, ECP2Buffer *bufs);
ssize_t ecp_sock_handle_open(ECPSocket *sock, ECPNetAddr *addr, ECPConnection *parent, unsigned char *msg, size_t msg_size, ECPPktMeta *pkt_meta, ECP2Buffer *bufs, ECPConnection **_conn);
ssize_t ecp_sock_handle_kget(ECPSocket *sock, ECPNetAddr *addr, ECPConnection *parent, unsigned char *msg, size_t msg_size, ECPPktMeta *pkt_meta, ECP2Buffer *bufs, ECPConnection **_conn);

ssize_t _ecp_pack(ECPContext *ctx, unsigned char *packet, size_t pkt_size, ECPPktMeta *pkt_meta, unsigned char *payload, size_t pld_size);
ssize_t ecp_pack(ECPContext *ctx, ECPConnection *parent, ECPBuffer *packet, ECPPktMeta *pkt_meta, ECPBuffer *payload, size_t pld_size, ECPNetAddr *addr) ;

ssize_t _ecp_pack_conn(ECPConnection *conn, unsigned char *packet, size_t pkt_size, unsigned char s_idx, unsigned char c_idx, unsigned char *payload, size_t pld_size, ECPNetAddr *addr, ECPSeqItem *si);
ssize_t ecp_pack_conn(ECPConnection *conn, ECPBuffer *packet, unsigned char s_idx, unsigned char c_idx, ECPBuffer *payload, size_t pld_size, ECPNetAddr *addr, ECPSeqItem *si);

ssize_t ecp_unpack(ECPSocket *sock, ECPNetAddr *addr, ECPConnection *parent, ECP2Buffer *bufs, size_t pkt_size, ECPConnection **_conn, ecp_seq_t *_seq);
ssize_t ecp_pkt_handle(ECPSocket *sock, ECPNetAddr *addr, ECPConnection *parent, ECP2Buffer *bufs, size_t pkt_size);
ssize_t ecp_pkt_send(ECPSocket *sock, ECPNetAddr *addr, ECPBuffer *packet, size_t pkt_size, unsigned char flags);

int ecp_msg_get_type(unsigned char *msg, size_t msg_size, unsigned char *mtype);
int ecp_msg_set_type(unsigned char *msg, size_t msg_size, unsigned char mtype);
int ecp_msg_get_frag(unsigned char *msg, size_t msg_size, unsigned char *frag_cnt, unsigned char *frag_tot, uint16_t *frag_size);
int ecp_msg_set_frag(unsigned char *msg, size_t msg_size, unsigned char frag_cnt, unsigned char frag_tot, uint16_t frag_size);
int ecp_msg_get_pts(unsigned char *msg, size_t msg_size, ecp_pts_t *pts);
int ecp_msg_set_pts(unsigned char *msg, size_t msg_size, ecp_pts_t pts);
unsigned char *ecp_msg_get_content(unsigned char *msg, size_t msg_size);
int ecp_msg_defrag(ECPFragIter *iter, ecp_seq_t seq, unsigned char mtype, unsigned char *msg_in, size_t msg_in_size, unsigned char **msg_out, size_t *msg_out_size);

int ecp_pld_get_type(unsigned char *payload, size_t pld_size, unsigned char *mtype);
int ecp_pld_set_type(unsigned char *payload, size_t pld_size, unsigned char mtype);
int ecp_pld_get_frag(unsigned char *payload, size_t pld_size, unsigned char *frag_cnt, unsigned char *frag_tot, uint16_t *frag_size);
int ecp_pld_set_frag(unsigned char *payload, size_t pld_size, unsigned char frag_cnt, unsigned char frag_tot, uint16_t frag_size);
int ecp_pld_get_pts(unsigned char *payload, size_t pld_size, ecp_pts_t *pts);
int ecp_pld_set_pts(unsigned char *payload, size_t pld_size, ecp_pts_t pts);
unsigned char *ecp_pld_get_buf(unsigned char *payload, size_t pld_size);

ssize_t __ecp_pld_send(ECPConnection *conn, ECPBuffer *packet, unsigned char s_idx, unsigned char c_idx, ECPBuffer *payload, size_t pld_size, unsigned char flags, ECPTimerItem *ti, ECPSeqItem *si);
ssize_t _ecp_pld_send(ECPConnection *conn, ECPBuffer *packet, unsigned char s_idx, unsigned char c_idx, ECPBuffer *payload, size_t pld_size, unsigned char flags, ECPTimerItem *ti);
ssize_t ecp_pld_send(ECPConnection *conn, ECPBuffer *packet, ECPBuffer *payload, size_t pld_size, unsigned char flags);
ssize_t ecp_pld_send_wtimer(ECPConnection *conn, ECPBuffer *packet, ECPBuffer *payload, size_t pld_size, unsigned char flags, ECPTimerItem *ti);
ssize_t ecp_pld_send_tr(ECPSocket *sock, ECPNetAddr *addr, ECPConnection *parent, ECPBuffer *packet, ECPPktMeta *pkt_meta, ECPBuffer *payload, size_t pld_size, unsigned char flags);

ssize_t ecp_send(ECPConnection *conn, unsigned char mtype, unsigned char *content, size_t content_size);
ssize_t ecp_receive(ECPConnection *conn, unsigned char mtype, unsigned char *msg, size_t msg_size, ecp_cts_t timeout);

int ecp_receiver(ECPSocket *sock);
int ecp_start_receiver(ECPSocket *sock);
int ecp_stop_receiver(ECPSocket *sock);