Max Lv
10 years ago
15 changed files with 1065 additions and 284 deletions
Unified View
Diff Options
-
54Makefile.in
-
10aclocal.m4
-
5config.h.in
-
296configure
-
24libasyncns/Makefile.in
-
24libev/Makefile.in
-
29src/Makefile.in
-
2src/jconf.c
-
5src/jconf.h
-
4src/local.c
-
2src/local.h
-
4src/redir.c
-
2src/redir.h
-
813src/tunnel.c
-
75src/tunnel.h
@ -0,0 +1,813 @@ |
|||||
|
#include <sys/stat.h> |
||||
|
#include <sys/types.h> |
||||
|
#include <fcntl.h> |
||||
|
#include <locale.h> |
||||
|
#include <signal.h> |
||||
|
#include <string.h> |
||||
|
#include <strings.h> |
||||
|
#include <unistd.h> |
||||
|
|
||||
|
#ifndef __MINGW32__ |
||||
|
#include <errno.h> |
||||
|
#include <arpa/inet.h> |
||||
|
#include <netdb.h> |
||||
|
#include <netinet/in.h> |
||||
|
#include <netinet/tcp.h> |
||||
|
#include <pthread.h> |
||||
|
#endif |
||||
|
|
||||
|
#ifdef HAVE_CONFIG_H |
||||
|
#include "config.h" |
||||
|
#endif |
||||
|
|
||||
|
#if defined(HAVE_SYS_IOCTL_H) && defined(HAVE_NET_IF_H) && defined(__linux__) |
||||
|
#include <net/if.h> |
||||
|
#include <sys/ioctl.h> |
||||
|
#define SET_INTERFACE |
||||
|
#endif |
||||
|
|
||||
|
#ifdef __MINGW32__ |
||||
|
#include "win32.h" |
||||
|
#endif |
||||
|
|
||||
|
#include "utils.h" |
||||
|
#include "tunnel.h" |
||||
|
|
||||
|
#ifndef EAGAIN |
||||
|
#define EAGAIN EWOULDBLOCK |
||||
|
#endif |
||||
|
|
||||
|
#ifndef EWOULDBLOCK |
||||
|
#define EWOULDBLOCK EAGAIN |
||||
|
#endif |
||||
|
|
||||
|
#ifndef BUF_SIZE |
||||
|
#define BUF_SIZE 512 |
||||
|
#endif |
||||
|
|
||||
|
int verbose = 0; |
||||
|
int udprelay = 0; |
||||
|
|
||||
|
#ifndef __MINGW32__ |
||||
|
static int setnonblocking(int fd) |
||||
|
{ |
||||
|
int flags; |
||||
|
if (-1 ==(flags = fcntl(fd, F_GETFL, 0))) |
||||
|
flags = 0; |
||||
|
return fcntl(fd, F_SETFL, flags | O_NONBLOCK); |
||||
|
} |
||||
|
#endif |
||||
|
|
||||
|
#ifdef SET_INTERFACE |
||||
|
int setinterface(int socket_fd, const char* interface_name) |
||||
|
{ |
||||
|
struct ifreq interface; |
||||
|
memset(&interface, 0, sizeof(interface)); |
||||
|
strncpy(interface.ifr_name, interface_name, IFNAMSIZ); |
||||
|
int res = setsockopt(socket_fd, SOL_SOCKET, SO_BINDTODEVICE, &interface, sizeof(struct ifreq)); |
||||
|
return res; |
||||
|
} |
||||
|
#endif |
||||
|
|
||||
|
int create_and_bind(const char *addr, 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(addr, 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; |
||||
|
setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); |
||||
|
setsockopt(listen_sock, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt)); |
||||
|
#ifdef SO_NOSIGPIPE |
||||
|
setsockopt(listen_sock, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof(opt)); |
||||
|
#endif |
||||
|
|
||||
|
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; |
||||
|
} |
||||
|
|
||||
|
ssize_t r = recv(server->fd, remote->buf, BUF_SIZE, 0); |
||||
|
|
||||
|
if (r == 0) |
||||
|
{ |
||||
|
// connection closed |
||||
|
remote->buf_len = 0; |
||||
|
remote->buf_idx = 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; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
remote->buf = ss_encrypt(BUF_SIZE, remote->buf, &r, server->e_ctx); |
||||
|
if (remote->buf == NULL) |
||||
|
{ |
||||
|
LOGE("invalid password or cipher"); |
||||
|
close_and_free_remote(EV_A_ remote); |
||||
|
close_and_free_server(EV_A_ server); |
||||
|
return; |
||||
|
} |
||||
|
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; |
||||
|
remote->buf_idx = 0; |
||||
|
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; |
||||
|
remote->buf_idx = s; |
||||
|
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_idx, |
||||
|
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; |
||||
|
server->buf_idx += s; |
||||
|
return; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
// all sent out, wait for reading |
||||
|
server->buf_len = 0; |
||||
|
server->buf_idx = 0; |
||||
|
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; |
||||
|
server->buf_idx = 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; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
server->buf = ss_decrypt(BUF_SIZE, server->buf, &r, server->d_ctx); |
||||
|
if (server->buf == NULL) |
||||
|
{ |
||||
|
LOGE("invalid password or cipher"); |
||||
|
close_and_free_remote(EV_A_ remote); |
||||
|
close_and_free_server(EV_A_ server); |
||||
|
return; |
||||
|
} |
||||
|
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; |
||||
|
server->buf_idx = 0; |
||||
|
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; |
||||
|
server->buf_idx = s; |
||||
|
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); |
||||
|
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_idx, |
||||
|
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; |
||||
|
remote->buf_idx += s; |
||||
|
return; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
// all sent out, wait for reading |
||||
|
remote->buf_len = 0; |
||||
|
remote->buf_idx = 0; |
||||
|
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->buf = malloc(BUF_SIZE); |
||||
|
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; |
||||
|
remote->buf_idx = 0; |
||||
|
return remote; |
||||
|
} |
||||
|
|
||||
|
static void free_remote(struct remote *remote) |
||||
|
{ |
||||
|
if (remote != NULL) |
||||
|
{ |
||||
|
if (remote->server != NULL) |
||||
|
{ |
||||
|
remote->server->remote = NULL; |
||||
|
} |
||||
|
if (remote->buf) |
||||
|
{ |
||||
|
free(remote->buf); |
||||
|
} |
||||
|
free(remote->recv_ctx); |
||||
|
free(remote->send_ctx); |
||||
|
free(remote); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
static 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, int method) |
||||
|
{ |
||||
|
struct server *server; |
||||
|
server = malloc(sizeof(struct server)); |
||||
|
server->buf = malloc(BUF_SIZE); |
||||
|
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; |
||||
|
server->stage = 0; |
||||
|
if (method) |
||||
|
{ |
||||
|
server->e_ctx = malloc(sizeof(struct enc_ctx)); |
||||
|
server->d_ctx = malloc(sizeof(struct enc_ctx)); |
||||
|
enc_ctx_init(method, server->e_ctx, 1); |
||||
|
enc_ctx_init(method, server->d_ctx, 0); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
server->e_ctx = NULL; |
||||
|
server->d_ctx = NULL; |
||||
|
} |
||||
|
server->buf_len = 0; |
||||
|
server->buf_idx = 0; |
||||
|
return server; |
||||
|
} |
||||
|
|
||||
|
static void free_server(struct server *server) |
||||
|
{ |
||||
|
if (server != NULL) |
||||
|
{ |
||||
|
if (server->remote != NULL) |
||||
|
{ |
||||
|
server->remote->server = NULL; |
||||
|
} |
||||
|
if (server->e_ctx != NULL) |
||||
|
{ |
||||
|
cipher_context_release(&server->e_ctx->evp); |
||||
|
free(server->e_ctx); |
||||
|
} |
||||
|
if (server->d_ctx != NULL) |
||||
|
{ |
||||
|
cipher_context_release(&server->d_ctx->evp); |
||||
|
free(server->d_ctx); |
||||
|
} |
||||
|
if (server->buf) |
||||
|
{ |
||||
|
free(server->buf); |
||||
|
} |
||||
|
free(server->recv_ctx); |
||||
|
free(server->send_ctx); |
||||
|
free(server); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
static 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; |
||||
|
int serverfd = accept(listener->fd, NULL, NULL); |
||||
|
if (serverfd == -1) |
||||
|
{ |
||||
|
ERROR("accept"); |
||||
|
return; |
||||
|
} |
||||
|
setnonblocking(serverfd); |
||||
|
int opt = 1; |
||||
|
setsockopt(serverfd, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt)); |
||||
|
#ifdef SO_NOSIGPIPE |
||||
|
setsockopt(serverfd, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof(opt)); |
||||
|
#endif |
||||
|
|
||||
|
struct addrinfo hints, *res; |
||||
|
int sockfd; |
||||
|
memset(&hints, 0, sizeof hints); |
||||
|
hints.ai_family = AF_UNSPEC; |
||||
|
hints.ai_socktype = SOCK_STREAM; |
||||
|
int index = rand() % listener->remote_num; |
||||
|
if (verbose) |
||||
|
{ |
||||
|
LOGD("connect to %s:%s", listener->remote_addr[index].host, listener->remote_addr[index].port); |
||||
|
} |
||||
|
int err = getaddrinfo(listener->remote_addr[index].host, listener->remote_addr[index].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; |
||||
|
} |
||||
|
|
||||
|
setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt)); |
||||
|
#ifdef SO_NOSIGPIPE |
||||
|
setsockopt(sockfd, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof(opt)); |
||||
|
#endif |
||||
|
|
||||
|
// Setup |
||||
|
setnonblocking(sockfd); |
||||
|
#ifdef SET_INTERFACE |
||||
|
if (listener->iface) setinterface(sockfd, listener->iface); |
||||
|
#endif |
||||
|
|
||||
|
struct server *server = new_server(serverfd, listener->method); |
||||
|
struct remote *remote = new_remote(sockfd, listener->timeout); |
||||
|
server->remote = remote; |
||||
|
remote->server = server; |
||||
|
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 *local_addr = NULL; |
||||
|
char *password = NULL; |
||||
|
char *timeout = NULL; |
||||
|
char *method = NULL; |
||||
|
char *pid_path = NULL; |
||||
|
char *conf_path = NULL; |
||||
|
char *iface = NULL; |
||||
|
|
||||
|
int remote_num = 0; |
||||
|
addr_t remote_addr[MAX_REMOTE_NUM]; |
||||
|
char *remote_port = NULL; |
||||
|
|
||||
|
addr_t tunnel_addr = {.host = NULL, .port = NULL}; |
||||
|
|
||||
|
opterr = 0; |
||||
|
|
||||
|
while ((c = getopt (argc, argv, "f:s:p:l:k:t:m:i:c:b:uv")) != -1) |
||||
|
{ |
||||
|
switch (c) |
||||
|
{ |
||||
|
case 's': |
||||
|
remote_addr[remote_num].host = optarg; |
||||
|
remote_addr[remote_num++].port = NULL; |
||||
|
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; |
||||
|
case 'i': |
||||
|
iface = optarg; |
||||
|
break; |
||||
|
case 'b': |
||||
|
local_addr = optarg; |
||||
|
break; |
||||
|
case 'u': |
||||
|
udprelay = 1; |
||||
|
break; |
||||
|
case "L": |
||||
|
tunnel_addr.host = optarg; |
||||
|
break; |
||||
|
case 'v': |
||||
|
verbose = 1; |
||||
|
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_addr[i] = conf->remote_addr[i]; |
||||
|
} |
||||
|
} |
||||
|
if (remote_port == NULL) remote_port = conf->remote_port; |
||||
|
if (local_addr == NULL) local_addr = conf->local_addr; |
||||
|
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 (local_addr == NULL) local_addr = "0.0.0.0"; |
||||
|
|
||||
|
if (pid_flags) |
||||
|
{ |
||||
|
USE_SYSLOG(argv[0]); |
||||
|
demonize(pid_path); |
||||
|
} |
||||
|
|
||||
|
if (tunnel_addr.host != NULL) { |
||||
|
parse_addr(tunnel_addr.host, &tunnel_addr); |
||||
|
} |
||||
|
|
||||
|
#ifdef __MINGW32__ |
||||
|
winsock_init(); |
||||
|
#else |
||||
|
// ignore SIGPIPE |
||||
|
signal(SIGPIPE, SIG_IGN); |
||||
|
signal(SIGABRT, SIG_IGN); |
||||
|
#endif |
||||
|
|
||||
|
// Setup keys |
||||
|
LOGD("initialize ciphers... %s", method); |
||||
|
int m = enc_init(password, method); |
||||
|
|
||||
|
// Setup socket |
||||
|
int listenfd; |
||||
|
listenfd = create_and_bind(local_addr, 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.tunnel_addr = tunnel_addr; |
||||
|
listen_ctx.remote_num = remote_num; |
||||
|
listen_ctx.remote_addr = malloc(sizeof(addr_t) * remote_num); |
||||
|
while (remote_num > 0) |
||||
|
{ |
||||
|
int index = --remote_num; |
||||
|
if (remote_addr[index].port == NULL) remote_addr[index].port = remote_port; |
||||
|
listen_ctx.remote_addr[index] = remote_addr[index]; |
||||
|
} |
||||
|
listen_ctx.timeout = atoi(timeout); |
||||
|
listen_ctx.fd = listenfd; |
||||
|
listen_ctx.iface = iface; |
||||
|
listen_ctx.method = m; |
||||
|
|
||||
|
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); |
||||
|
|
||||
|
// Setup UDP |
||||
|
if (udprelay) |
||||
|
{ |
||||
|
LOGD("udprelay enabled."); |
||||
|
udprelay_init(local_addr, local_port, remote_addr[0].host, remote_addr[0].port, m, listen_ctx.timeout, iface); |
||||
|
} |
||||
|
|
||||
|
ev_run (loop, 0); |
||||
|
|
||||
|
#ifdef __MINGW32__ |
||||
|
winsock_cleanup(); |
||||
|
#endif |
||||
|
|
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
@ -0,0 +1,75 @@ |
|||||
|
#ifndef _LOCAL_H |
||||
|
#define _LOCAL_H |
||||
|
|
||||
|
#include <ev.h> |
||||
|
#include "encrypt.h" |
||||
|
#include "jconf.h" |
||||
|
|
||||
|
#include "include.h" |
||||
|
|
||||
|
struct listen_ctx |
||||
|
{ |
||||
|
ev_io io; |
||||
|
addr_t tunnel_addr; |
||||
|
addr_t *remote_addr; |
||||
|
char *iface; |
||||
|
int remote_num; |
||||
|
int method; |
||||
|
int timeout; |
||||
|
int fd; |
||||
|
struct sockaddr sock; |
||||
|
}; |
||||
|
|
||||
|
struct server_ctx |
||||
|
{ |
||||
|
ev_io io; |
||||
|
int connected; |
||||
|
struct server *server; |
||||
|
}; |
||||
|
|
||||
|
struct server |
||||
|
{ |
||||
|
int fd; |
||||
|
int buf_len; |
||||
|
int buf_idx; |
||||
|
char *buf; // server send from, remote recv into |
||||
|
struct enc_ctx *e_ctx; |
||||
|
struct enc_ctx *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; |
||||
|
int buf_len; |
||||
|
int buf_idx; |
||||
|
char *buf; // remote send from, server recv into |
||||
|
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); |
||||
|
static void free_remote(struct remote *remote); |
||||
|
static void close_and_free_remote(EV_P_ struct remote *remote); |
||||
|
static void free_server(struct server *server); |
||||
|
static void close_and_free_server(EV_P_ struct server *server); |
||||
|
|
||||
|
struct remote* new_remote(int fd, int timeout); |
||||
|
struct server* new_server(int fd, int method); |
||||
|
|
||||
|
#endif // _TUNNEL_H |
||||
Write
Preview
Loading…
Cancel
Save