Max Lv
12 years ago
7 changed files with 795 additions and 31 deletions
Split View
Diff Options
-
32configure
-
16configure.ac
-
10src/Makefile.am
-
33src/Makefile.in
-
37src/local.c
-
633src/redir.c
-
65src/redir.h
@ -0,0 +1,633 @@ |
|||
#include <sys/socket.h> |
|||
#include <sys/stat.h> |
|||
#include <sys/types.h> |
|||
#include <arpa/inet.h> |
|||
#include <errno.h> |
|||
#include <fcntl.h> |
|||
#include <locale.h> |
|||
#include <netdb.h> |
|||
#include <netinet/in.h> |
|||
#include <netinet/tcp.h> |
|||
#include <pthread.h> |
|||
#include <signal.h> |
|||
#include <stdio.h> |
|||
#include <stdlib.h> |
|||
#include <string.h> |
|||
#include <strings.h> |
|||
#include <time.h> |
|||
#include <unistd.h> |
|||
|
|||
#include "utils.h" |
|||
#include "redir.h" |
|||
|
|||
#ifdef HAVE_CONFIG_H |
|||
#include "config.h" |
|||
#endif |
|||
|
|||
#ifndef EAGAIN |
|||
#define EAGAIN EWOULDBLOCK |
|||
#endif |
|||
|
|||
#ifndef EWOULDBLOCK |
|||
#define EWOULDBLOCK EAGAIN |
|||
#endif |
|||
|
|||
#define min(a,b) (((a)<(b))?(a):(b)) |
|||
|
|||
int getdestaddr(int fd, struct sockaddr_in *destaddr) { |
|||
socklen_t socklen = sizeof(*destaddr); |
|||
int error; |
|||
|
|||
error = getsockopt(fd, SOL_IP, SO_ORIGINAL_DST, destaddr, &socklen); |
|||
if (error) { |
|||
log_errno(LOG_WARNING, "getsockopt"); |
|||
return -1; |
|||
} |
|||
return 0; |
|||
} |
|||
|
|||
int setnonblocking(int fd) { |
|||
int flags; |
|||
if (-1 ==(flags = fcntl(fd, F_GETFL, 0))) |
|||
flags = 0; |
|||
return fcntl(fd, F_SETFL, flags | O_NONBLOCK); |
|||
} |
|||
|
|||
int create_and_bind(const char *port) { |
|||
struct addrinfo hints; |
|||
struct addrinfo *result, *rp; |
|||
int s, listen_sock; |
|||
|
|||
memset(&hints, 0, sizeof(struct addrinfo)); |
|||
hints.ai_family = AF_UNSPEC; /* Return IPv4 and IPv6 choices */ |
|||
hints.ai_socktype = SOCK_STREAM; /* We want a TCP socket */ |
|||
|
|||
s = getaddrinfo("0.0.0.0", port, &hints, &result); |
|||
if (s != 0) { |
|||
LOGD("getaddrinfo: %s", gai_strerror(s)); |
|||
return -1; |
|||
} |
|||
|
|||
for (rp = result; rp != NULL; rp = rp->ai_next) { |
|||
listen_sock = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol); |
|||
if (listen_sock == -1) |
|||
continue; |
|||
|
|||
int opt = 1; |
|||
int err = setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); |
|||
if (err) { |
|||
ERROR("setsocket"); |
|||
} |
|||
|
|||
s = bind(listen_sock, rp->ai_addr, rp->ai_addrlen); |
|||
if (s == 0) { |
|||
/* We managed to bind successfully! */ |
|||
break; |
|||
} else { |
|||
ERROR("bind"); |
|||
} |
|||
|
|||
close(listen_sock); |
|||
} |
|||
|
|||
if (rp == NULL) { |
|||
LOGE("Could not bind"); |
|||
return -1; |
|||
} |
|||
|
|||
freeaddrinfo(result); |
|||
|
|||
return listen_sock; |
|||
} |
|||
|
|||
static void server_recv_cb (EV_P_ ev_io *w, int revents) { |
|||
struct server_ctx *server_recv_ctx = (struct server_ctx *)w; |
|||
struct server *server = server_recv_ctx->server; |
|||
struct remote *remote = server->remote; |
|||
|
|||
if (remote == NULL) { |
|||
close_and_free_server(EV_A_ server); |
|||
return; |
|||
} |
|||
|
|||
char *buf = remote->buf; |
|||
int *buf_len = &remote->buf_len; |
|||
|
|||
ssize_t r = recv(server->fd, buf, BUF_SIZE, 0); |
|||
|
|||
if (r == 0) { |
|||
// connection closed |
|||
*buf_len = 0; |
|||
close_and_free_server(EV_A_ server); |
|||
if (remote != NULL) { |
|||
ev_io_start(EV_A_ &remote->send_ctx->io); |
|||
} |
|||
return; |
|||
} else if(r < 0) { |
|||
if (errno == EAGAIN || errno == EWOULDBLOCK) { |
|||
// no data |
|||
// continue to wait for recv |
|||
return; |
|||
} else { |
|||
ERROR("server recv"); |
|||
close_and_free_remote(EV_A_ remote); |
|||
close_and_free_server(EV_A_ server); |
|||
return; |
|||
} |
|||
} |
|||
|
|||
encrypt_ctx(remote->buf, r, server->e_ctx); |
|||
|
|||
int s = send(remote->fd, remote->buf, r, 0); |
|||
if(s == -1) { |
|||
if (errno == EAGAIN || errno == EWOULDBLOCK) { |
|||
// no data, wait for send |
|||
remote->buf_len = r; |
|||
ev_io_stop(EV_A_ &server_recv_ctx->io); |
|||
ev_io_start(EV_A_ &remote->send_ctx->io); |
|||
return; |
|||
} else { |
|||
ERROR("send"); |
|||
close_and_free_remote(EV_A_ remote); |
|||
close_and_free_server(EV_A_ server); |
|||
return; |
|||
} |
|||
} else if(s < r) { |
|||
remote->buf_len = r - s; |
|||
memcpy(remote->buf, remote->buf + s, remote->buf_len); |
|||
ev_io_stop(EV_A_ &server_recv_ctx->io); |
|||
ev_io_start(EV_A_ &remote->send_ctx->io); |
|||
return; |
|||
} |
|||
|
|||
} |
|||
|
|||
static void server_send_cb (EV_P_ ev_io *w, int revents) { |
|||
struct server_ctx *server_send_ctx = (struct server_ctx *)w; |
|||
struct server *server = server_send_ctx->server; |
|||
struct remote *remote = server->remote; |
|||
if (server->buf_len == 0) { |
|||
// close and free |
|||
close_and_free_remote(EV_A_ remote); |
|||
close_and_free_server(EV_A_ server); |
|||
return; |
|||
} else { |
|||
// has data to send |
|||
ssize_t s = send(server->fd, server->buf, |
|||
server->buf_len, 0); |
|||
if (s < 0) { |
|||
if (errno != EAGAIN && errno != EWOULDBLOCK) { |
|||
ERROR("send"); |
|||
close_and_free_remote(EV_A_ remote); |
|||
close_and_free_server(EV_A_ server); |
|||
} |
|||
return; |
|||
} else if (s < server->buf_len) { |
|||
// partly sent, move memory, wait for the next time to send |
|||
server->buf_len -= s; |
|||
memcpy(server->buf, server->buf + s, server->buf_len); |
|||
return; |
|||
} else { |
|||
// all sent out, wait for reading |
|||
ev_io_stop(EV_A_ &server_send_ctx->io); |
|||
if (remote != NULL) { |
|||
ev_io_start(EV_A_ &remote->recv_ctx->io); |
|||
} else { |
|||
close_and_free_remote(EV_A_ remote); |
|||
close_and_free_server(EV_A_ server); |
|||
return; |
|||
} |
|||
} |
|||
} |
|||
|
|||
} |
|||
|
|||
static void remote_timeout_cb(EV_P_ ev_timer *watcher, int revents) { |
|||
struct remote_ctx *remote_ctx = (struct remote_ctx *) (((void*)watcher) |
|||
- sizeof(ev_io)); |
|||
struct remote *remote = remote_ctx->remote; |
|||
struct server *server = remote->server; |
|||
|
|||
LOGD("remote timeout"); |
|||
|
|||
ev_timer_stop(EV_A_ watcher); |
|||
|
|||
if (server == NULL) { |
|||
close_and_free_remote(EV_A_ remote); |
|||
return; |
|||
} |
|||
close_and_free_remote(EV_A_ remote); |
|||
close_and_free_server(EV_A_ server); |
|||
} |
|||
|
|||
static void remote_recv_cb (EV_P_ ev_io *w, int revents) { |
|||
struct remote_ctx *remote_recv_ctx = (struct remote_ctx *)w; |
|||
struct remote *remote = remote_recv_ctx->remote; |
|||
struct server *server = remote->server; |
|||
if (server == NULL) { |
|||
close_and_free_remote(EV_A_ remote); |
|||
return; |
|||
} |
|||
|
|||
ssize_t r = recv(remote->fd, server->buf, BUF_SIZE, 0); |
|||
|
|||
if (r == 0) { |
|||
// connection closed |
|||
server->buf_len = 0; |
|||
close_and_free_remote(EV_A_ remote); |
|||
if (server != NULL) { |
|||
ev_io_start(EV_A_ &server->send_ctx->io); |
|||
} |
|||
return; |
|||
} else if(r < 0) { |
|||
if (errno == EAGAIN || errno == EWOULDBLOCK) { |
|||
// no data |
|||
// continue to wait for recv |
|||
return; |
|||
} else { |
|||
ERROR("remote recv"); |
|||
close_and_free_remote(EV_A_ remote); |
|||
close_and_free_server(EV_A_ server); |
|||
return; |
|||
} |
|||
} |
|||
|
|||
decrypt_ctx(server->buf, r, server->d_ctx); |
|||
int s = send(server->fd, server->buf, r, 0); |
|||
|
|||
if (s == -1) { |
|||
if (errno == EAGAIN || errno == EWOULDBLOCK) { |
|||
// no data, wait for send |
|||
server->buf_len = r; |
|||
ev_io_stop(EV_A_ &remote_recv_ctx->io); |
|||
ev_io_start(EV_A_ &server->send_ctx->io); |
|||
return; |
|||
} else { |
|||
ERROR("send"); |
|||
close_and_free_remote(EV_A_ remote); |
|||
close_and_free_server(EV_A_ server); |
|||
return; |
|||
} |
|||
} else if (s < r) { |
|||
server->buf_len = r - s; |
|||
memcpy(server->buf, server->buf + s, server->buf_len); |
|||
ev_io_stop(EV_A_ &remote_recv_ctx->io); |
|||
ev_io_start(EV_A_ &server->send_ctx->io); |
|||
return; |
|||
} |
|||
} |
|||
|
|||
static void remote_send_cb (EV_P_ ev_io *w, int revents) { |
|||
struct remote_ctx *remote_send_ctx = (struct remote_ctx *)w; |
|||
struct remote *remote = remote_send_ctx->remote; |
|||
struct server *server = remote->server; |
|||
|
|||
if (!remote_send_ctx->connected) { |
|||
|
|||
struct sockaddr_storage addr; |
|||
socklen_t len = sizeof addr; |
|||
int r = getpeername(remote->fd, (struct sockaddr*)&addr, &len); |
|||
if (r == 0) { |
|||
remote_send_ctx->connected = 1; |
|||
ev_io_stop(EV_A_ &remote_send_ctx->io); |
|||
ev_timer_stop(EV_A_ &remote_send_ctx->watcher); |
|||
ev_io_start(EV_A_ &server->recv_ctx->io); |
|||
ev_io_start(EV_A_ &remote->recv_ctx->io); |
|||
|
|||
// send destaddr |
|||
char addr_to_send[256]; |
|||
uint8_t addr_len = 0; |
|||
addr_to_send[addr_len++] = 1; |
|||
|
|||
// handle IP V4 only |
|||
size_t in_addr_len = sizeof(struct in_addr); |
|||
memcpy(addr_to_send + addr_len, &server->destaddr.sin_addr, in_addr_len); |
|||
addr_len += in_addr_len; |
|||
memcpy(addr_to_send + addr_len, &server->destaddr.sin_port, 2); |
|||
addr_len += 2; |
|||
encrypt_ctx(addr_to_send, addr_len, server->e_ctx); |
|||
|
|||
int s = send(remote->fd, addr_to_send, addr_len, 0); |
|||
if (s < addr_len) { |
|||
LOGE("failed to send remote addr."); |
|||
close_and_free_remote(EV_A_ remote); |
|||
close_and_free_server(EV_A_ server); |
|||
} |
|||
|
|||
return; |
|||
} else { |
|||
ERROR("getpeername"); |
|||
// not connected |
|||
close_and_free_remote(EV_A_ remote); |
|||
close_and_free_server(EV_A_ server); |
|||
return; |
|||
} |
|||
} else { |
|||
if (remote->buf_len == 0) { |
|||
// close and free |
|||
close_and_free_remote(EV_A_ remote); |
|||
close_and_free_server(EV_A_ server); |
|||
return; |
|||
} else { |
|||
// has data to send |
|||
ssize_t s = send(remote->fd, remote->buf, |
|||
remote->buf_len, 0); |
|||
if (s < 0) { |
|||
if (errno != EAGAIN && errno != EWOULDBLOCK) { |
|||
ERROR("send"); |
|||
// close and free |
|||
close_and_free_remote(EV_A_ remote); |
|||
close_and_free_server(EV_A_ server); |
|||
} |
|||
return; |
|||
} else if (s < remote->buf_len) { |
|||
// partly sent, move memory, wait for the next time to send |
|||
remote->buf_len -= s; |
|||
memcpy(remote->buf, remote->buf + s, remote->buf_len); |
|||
return; |
|||
} else { |
|||
// all sent out, wait for reading |
|||
ev_io_stop(EV_A_ &remote_send_ctx->io); |
|||
if (server != NULL) { |
|||
ev_io_start(EV_A_ &server->recv_ctx->io); |
|||
} else { |
|||
close_and_free_remote(EV_A_ remote); |
|||
close_and_free_server(EV_A_ server); |
|||
return; |
|||
} |
|||
} |
|||
} |
|||
|
|||
} |
|||
} |
|||
|
|||
struct remote* new_remote(int fd, int timeout) { |
|||
struct remote *remote; |
|||
remote = malloc(sizeof(struct remote)); |
|||
remote->recv_ctx = malloc(sizeof(struct remote_ctx)); |
|||
remote->send_ctx = malloc(sizeof(struct remote_ctx)); |
|||
remote->fd = fd; |
|||
ev_io_init(&remote->recv_ctx->io, remote_recv_cb, fd, EV_READ); |
|||
ev_io_init(&remote->send_ctx->io, remote_send_cb, fd, EV_WRITE); |
|||
ev_timer_init(&remote->send_ctx->watcher, remote_timeout_cb, timeout, 0); |
|||
remote->recv_ctx->remote = remote; |
|||
remote->recv_ctx->connected = 0; |
|||
remote->send_ctx->remote = remote; |
|||
remote->send_ctx->connected = 0; |
|||
remote->buf_len = 0; |
|||
return remote; |
|||
} |
|||
|
|||
void free_remote(struct remote *remote) { |
|||
if (remote != NULL) { |
|||
if (remote->server != NULL) { |
|||
remote->server->remote = NULL; |
|||
} |
|||
free(remote->recv_ctx); |
|||
free(remote->send_ctx); |
|||
free(remote); |
|||
} |
|||
} |
|||
|
|||
void close_and_free_remote(EV_P_ struct remote *remote) { |
|||
if (remote != NULL) { |
|||
ev_timer_stop(EV_A_ &remote->send_ctx->watcher); |
|||
ev_io_stop(EV_A_ &remote->send_ctx->io); |
|||
ev_io_stop(EV_A_ &remote->recv_ctx->io); |
|||
close(remote->fd); |
|||
free_remote(remote); |
|||
} |
|||
} |
|||
|
|||
struct server* new_server(int fd) { |
|||
struct server *server; |
|||
server = malloc(sizeof(struct server)); |
|||
server->recv_ctx = malloc(sizeof(struct server_ctx)); |
|||
server->send_ctx = malloc(sizeof(struct server_ctx)); |
|||
server->fd = fd; |
|||
ev_io_init(&server->recv_ctx->io, server_recv_cb, fd, EV_READ); |
|||
ev_io_init(&server->send_ctx->io, server_send_cb, fd, EV_WRITE); |
|||
server->recv_ctx->server = server; |
|||
server->recv_ctx->connected = 0; |
|||
server->send_ctx->server = server; |
|||
server->send_ctx->connected = 0; |
|||
if (enc_conf.method == RC4) { |
|||
server->e_ctx = malloc(sizeof(struct rc4_state)); |
|||
server->d_ctx = malloc(sizeof(struct rc4_state)); |
|||
enc_ctx_init(server->e_ctx, 1); |
|||
enc_ctx_init(server->d_ctx, 0); |
|||
} else { |
|||
server->e_ctx = NULL; |
|||
server->d_ctx = NULL; |
|||
} |
|||
server->buf_len = 0; |
|||
return server; |
|||
} |
|||
|
|||
void free_server(struct server *server) { |
|||
if (server != NULL) { |
|||
if (server->remote != NULL) { |
|||
server->remote->server = NULL; |
|||
} |
|||
if (enc_conf.method == RC4) { |
|||
free(server->e_ctx); |
|||
free(server->d_ctx); |
|||
} |
|||
free(server->recv_ctx); |
|||
free(server->send_ctx); |
|||
free(server); |
|||
} |
|||
} |
|||
|
|||
void close_and_free_server(EV_P_ struct server *server) { |
|||
if (server != NULL) { |
|||
ev_io_stop(EV_A_ &server->send_ctx->io); |
|||
ev_io_stop(EV_A_ &server->recv_ctx->io); |
|||
close(server->fd); |
|||
free_server(server); |
|||
} |
|||
} |
|||
|
|||
static void accept_cb (EV_P_ ev_io *w, int revents) { |
|||
struct listen_ctx *listener = (struct listen_ctx *)w; |
|||
struct sockaddr_in destaddr; |
|||
int err; |
|||
|
|||
int clientfd = accept(listener->fd, NULL, NULL); |
|||
if (clientfd == -1) { |
|||
ERROR("accept"); |
|||
return; |
|||
} |
|||
|
|||
err = getdestaddr(clientfd, &destaddr); |
|||
if (err) { |
|||
ERROR("getdestaddr"); |
|||
return; |
|||
} |
|||
|
|||
setnonblocking(clientfd); |
|||
|
|||
struct addrinfo hints, *res; |
|||
int sockfd; |
|||
memset(&hints, 0, sizeof hints); |
|||
hints.ai_family = AF_UNSPEC; |
|||
hints.ai_socktype = SOCK_STREAM; |
|||
int index = clock() % listener->remote_num; |
|||
int err = getaddrinfo(listener->remote_host[index], listener->remote_port, &hints, &res); |
|||
if (err) { |
|||
ERROR("getaddrinfo"); |
|||
return; |
|||
} |
|||
|
|||
sockfd = socket(res->ai_family, res->ai_socktype, res->ai_protocol); |
|||
if (sockfd < 0) { |
|||
ERROR("socket"); |
|||
close(sockfd); |
|||
freeaddrinfo(res); |
|||
return; |
|||
} |
|||
|
|||
struct timeval timeout; |
|||
timeout.tv_sec = listener->timeout; |
|||
timeout.tv_usec = 0; |
|||
err = setsockopt(sockfd, SOL_SOCKET, |
|||
SO_RCVTIMEO, (char *)&timeout, sizeof(timeout)); |
|||
if (err) ERROR("setsockopt"); |
|||
err = setsockopt(sockfd, SOL_SOCKET, |
|||
SO_SNDTIMEO, (char *)&timeout, sizeof(timeout)); |
|||
if (err) ERROR("setsockopt"); |
|||
setnonblocking(sockfd); |
|||
|
|||
struct server *server = new_server(clientfd); |
|||
struct remote *remote = new_remote(sockfd, listener->timeout); |
|||
server->remote = remote; |
|||
remote->server = server; |
|||
server->destaddr = destaddr; |
|||
|
|||
connect(sockfd, res->ai_addr, res->ai_addrlen); |
|||
freeaddrinfo(res); |
|||
// listen to remote connected event |
|||
ev_io_start(EV_A_ &remote->send_ctx->io); |
|||
ev_timer_start(EV_A_ &remote->send_ctx->watcher); |
|||
} |
|||
|
|||
int main (int argc, char **argv) { |
|||
|
|||
int i, c; |
|||
int pid_flags = 0; |
|||
char *local_port = NULL; |
|||
char *password = NULL; |
|||
char *timeout = NULL; |
|||
char *method = NULL; |
|||
char *pid_path = NULL; |
|||
char *conf_path = NULL; |
|||
|
|||
int remote_num = 0; |
|||
char *remote_host[MAX_REMOTE_NUM]; |
|||
char *remote_port = NULL; |
|||
|
|||
opterr = 0; |
|||
|
|||
while ((c = getopt (argc, argv, "f:s:p:l:k:t:m:c:")) != -1) { |
|||
switch (c) { |
|||
case 's': |
|||
remote_host[remote_num++] = optarg; |
|||
break; |
|||
case 'p': |
|||
remote_port = optarg; |
|||
break; |
|||
case 'l': |
|||
local_port = optarg; |
|||
break; |
|||
case 'k': |
|||
password = optarg; |
|||
break; |
|||
case 'f': |
|||
pid_flags = 1; |
|||
pid_path = optarg; |
|||
break; |
|||
case 't': |
|||
timeout = optarg; |
|||
break; |
|||
case 'm': |
|||
method = optarg; |
|||
break; |
|||
case 'c': |
|||
conf_path = optarg; |
|||
break; |
|||
} |
|||
} |
|||
|
|||
if (opterr) { |
|||
usage(); |
|||
exit(EXIT_FAILURE); |
|||
} |
|||
|
|||
if (conf_path != NULL) { |
|||
jconf_t *conf = read_jconf(conf_path); |
|||
if (remote_num == 0) { |
|||
remote_num = conf->remote_num; |
|||
for (i = 0; i < remote_num; i++) { |
|||
remote_host[i] = conf->remote_host[i]; |
|||
} |
|||
} |
|||
if (remote_port == NULL) remote_port = conf->remote_port; |
|||
if (local_port == NULL) local_port = conf->local_port; |
|||
if (password == NULL) password = conf->password; |
|||
if (method == NULL) method = conf->method; |
|||
if (timeout == NULL) timeout = conf->timeout; |
|||
} |
|||
|
|||
if (remote_num == 0 || remote_port == NULL || |
|||
local_port == NULL || password == NULL) { |
|||
usage(); |
|||
exit(EXIT_FAILURE); |
|||
} |
|||
|
|||
if (timeout == NULL) timeout = "10"; |
|||
|
|||
if (pid_flags) { |
|||
demonize(pid_path); |
|||
} |
|||
|
|||
// ignore SIGPIPE |
|||
signal(SIGPIPE, SIG_IGN); |
|||
|
|||
// Setup keys |
|||
LOGD("calculating ciphers..."); |
|||
enc_conf_init(password, method); |
|||
|
|||
// Setup socket |
|||
int listenfd; |
|||
listenfd = create_and_bind(local_port); |
|||
if (listenfd < 0) { |
|||
FATAL("bind() error.."); |
|||
} |
|||
if (listen(listenfd, SOMAXCONN) == -1) { |
|||
FATAL("listen() error."); |
|||
} |
|||
setnonblocking(listenfd); |
|||
LOGD("server listening at port %s.", local_port); |
|||
|
|||
// Setup proxy context |
|||
struct listen_ctx listen_ctx; |
|||
listen_ctx.remote_num = remote_num; |
|||
listen_ctx.remote_host = malloc(sizeof(char *) * remote_num); |
|||
while (remote_num > 0) { |
|||
int index = --remote_num; |
|||
listen_ctx.remote_host[index] = strdup(remote_host[index]); |
|||
} |
|||
listen_ctx.remote_port = strdup(remote_port); |
|||
listen_ctx.timeout = atoi(timeout); |
|||
listen_ctx.fd = listenfd; |
|||
|
|||
struct ev_loop *loop = ev_default_loop(0); |
|||
if (!loop) { |
|||
FATAL("ev_loop error."); |
|||
} |
|||
ev_io_init (&listen_ctx.io, accept_cb, listenfd, EV_READ); |
|||
ev_io_start (loop, &listen_ctx.io); |
|||
ev_run (loop, 0); |
|||
return 0; |
|||
} |
|||
|
|||
@ -0,0 +1,65 @@ |
|||
#ifndef _LOCAL_H |
|||
#define _LOCAL_H |
|||
|
|||
#include <ev.h> |
|||
#include "encrypt.h" |
|||
#include "jconf.h" |
|||
|
|||
struct listen_ctx { |
|||
ev_io io; |
|||
char **remote_host; |
|||
int remote_num; |
|||
char *remote_port; |
|||
int timeout; |
|||
int fd; |
|||
struct sockaddr sock; |
|||
}; |
|||
|
|||
struct server_ctx { |
|||
ev_io io; |
|||
int connected; |
|||
struct server *server; |
|||
}; |
|||
|
|||
struct server { |
|||
int fd; |
|||
char buf[BUF_SIZE]; // server send from, remote recv into |
|||
int buf_len; |
|||
struct sockaddr_in destaddr; |
|||
struct rc4_state *e_ctx; |
|||
struct rc4_state *d_ctx; |
|||
struct server_ctx *recv_ctx; |
|||
struct server_ctx *send_ctx; |
|||
struct remote *remote; |
|||
}; |
|||
|
|||
struct remote_ctx { |
|||
ev_io io; |
|||
ev_timer watcher; |
|||
int connected; |
|||
struct remote *remote; |
|||
}; |
|||
|
|||
struct remote { |
|||
int fd; |
|||
char buf[BUF_SIZE]; // remote send from, server recv into |
|||
int buf_len; |
|||
struct remote_ctx *recv_ctx; |
|||
struct remote_ctx *send_ctx; |
|||
struct server *server; |
|||
}; |
|||
|
|||
|
|||
static void accept_cb (EV_P_ ev_io *w, int revents); |
|||
static void server_recv_cb (EV_P_ ev_io *w, int revents); |
|||
static void server_send_cb (EV_P_ ev_io *w, int revents); |
|||
static void remote_recv_cb (EV_P_ ev_io *w, int revents); |
|||
static void remote_send_cb (EV_P_ ev_io *w, int revents); |
|||
struct remote* new_remote(int fd, int timeout); |
|||
void free_remote(struct remote *remote); |
|||
void close_and_free_remote(EV_P_ struct remote *remote); |
|||
struct server* new_server(int fd); |
|||
void free_server(struct server *server); |
|||
void close_and_free_server(EV_P_ struct server *server); |
|||
|
|||
#endif // _LOCAL_H |
|||
Write
Preview
Loading…
Cancel
Save