forked from lei.chen/myxce
141 lines
4.5 KiB
C
141 lines
4.5 KiB
C
#if !defined(_NETIO_H_)
|
|
|
|
#define _NETIO_H_ 1
|
|
|
|
#include <openssl/err.h>
|
|
#include <openssl/ssl.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <sys/epoll.h>
|
|
#include <sys/socket.h>
|
|
|
|
#include "dataq.h"
|
|
#include "mylock.h"
|
|
#include "xce/types.h"
|
|
|
|
typedef int (*conn_handler_t)(struct epoll_event*);
|
|
typedef int (*msg_handler_t)(void*);
|
|
typedef int (*err_handler_t)(void*);
|
|
|
|
#define IO_MON_INPUT (0x01)
|
|
#define IO_MON_OUTPUT (0x02)
|
|
|
|
typedef struct {
|
|
data_item_t link;
|
|
uint16_t sz;
|
|
char* data;
|
|
} io_packet_t;
|
|
|
|
#define ITPTR_TO_PACKET(it) \
|
|
((io_packet_t*)(((char*)it) - offsetof(io_packet_t, link)))
|
|
|
|
typedef struct {
|
|
mylock_t lock;
|
|
int epoll_fd;
|
|
struct epoll_event ev;
|
|
pthread_t worker;
|
|
SSL_CTX* ssl_ctx;
|
|
} iomgr_t;
|
|
|
|
typedef enum {
|
|
FSM_IO_READ = 0,
|
|
FSM_IO_WRITE
|
|
} io_fsm_op_t;
|
|
|
|
typedef enum {
|
|
FSM_STATE_INIT = 0,
|
|
FSM_STATE_READ_PKT_HEAD,
|
|
FSM_STATE_READ_PKT,
|
|
FSM_STATE_WRITE_PKT_HEAD,
|
|
FSM_STATE_WRITE_PKT,
|
|
FSM_STATE_DONE,
|
|
FSM_STATE_ERROR
|
|
} io_fsm_state_t;
|
|
|
|
typedef struct {
|
|
void* ep;
|
|
io_fsm_op_t op;
|
|
io_fsm_state_t state;
|
|
io_packet_t* pkt;
|
|
size_t iocount;
|
|
} io_fsm_t;
|
|
|
|
typedef struct {
|
|
mylock_t lock;
|
|
iomgr_t* iomgr;
|
|
SSL* ssl;
|
|
int fd;
|
|
int idx;
|
|
int flags;
|
|
unsigned int busy : 1;
|
|
unsigned int ssl_handshake_done : 1;
|
|
dataq_t outq;
|
|
uint64_t seq;
|
|
conn_handler_t conn_handler;
|
|
void* owner;
|
|
void* data;
|
|
io_fsm_t fsm_in;
|
|
io_fsm_t fsm_out;
|
|
xce_peerinfo_t* peer;
|
|
msg_handler_t msg_handler;
|
|
err_handler_t err_handler;
|
|
time_t ts_last_in;
|
|
time_t ts_last_out;
|
|
} endpoint_t;
|
|
|
|
#define INVOKE_MSG_HANDLER(ep) \
|
|
do { \
|
|
TRACE("%s msg handler %p", __func__, (ep)->msg_handler); \
|
|
if ((ep)->msg_handler != NULL) { \
|
|
(ep)->msg_handler(ep); \
|
|
/* passing ownership of packet to upper layer */ \
|
|
(ep)->fsm_in.pkt = NULL; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define INVOKE_ERR_HANDLER(ep) \
|
|
do { \
|
|
if ((ep)->err_handler != NULL) { \
|
|
(ep)->err_handler(ep); \
|
|
} \
|
|
} while (0)
|
|
|
|
typedef struct {
|
|
endpoint_t* ep;
|
|
io_packet_t* pkt;
|
|
} io_task_data_t;
|
|
|
|
extern int alloc_packet(io_packet_t*);
|
|
extern void free_packet(io_packet_t*);
|
|
|
|
extern endpoint_t* endpoint_get(void);
|
|
extern int endpoint_init(endpoint_t*, int, int, int, int);
|
|
extern int endpoint_connect(endpoint_t*, char*, int);
|
|
extern int endpoint_accept(endpoint_t*, endpoint_t*);
|
|
extern int endpoint_set_conn_handler(endpoint_t*, conn_handler_t);
|
|
extern int endpoint_enq(endpoint_t*, data_item_t*);
|
|
extern data_item_t* endpoint_deq(endpoint_t*);
|
|
extern uint64_t endpoint_getseq(endpoint_t*);
|
|
extern void endpoint_block_tasks(endpoint_t*);
|
|
extern void endpoint_unblock_tasks(endpoint_t*);
|
|
extern int endpoint_is_task_blocked(endpoint_t*);
|
|
extern int endpoint_set_owner(endpoint_t*, void*);
|
|
extern int endpoint_set_msg_handler(endpoint_t*, msg_handler_t);
|
|
extern int endpoint_set_err_handler(endpoint_t*, err_handler_t);
|
|
extern void endpoint_fini(endpoint_t*);
|
|
extern int endpoint_set_peer(endpoint_t*, xce_peerinfo_t*);
|
|
|
|
extern int io_fsm_start(io_fsm_t*, io_packet_t*);
|
|
|
|
extern void initialize_openssl(void);
|
|
extern void cleanup_openssl(void);
|
|
extern SSL_CTX* create_ssl_context(char*, char*);
|
|
extern void iomgr_set_ssl_ctx(iomgr_t*, SSL_CTX*);
|
|
|
|
extern int iomgr_init(iomgr_t*);
|
|
extern int iomgr_monitor(endpoint_t*);
|
|
extern int iomgr_unmonitor(iomgr_t*, endpoint_t*);
|
|
extern int iomgr_start(iomgr_t*);
|
|
extern int iomgr_fini(iomgr_t*);
|
|
extern int iomgr_stop(iomgr_t*);
|
|
#endif
|