diff --git a/configure b/configure index 8cbc200e..57bd7c1d 100755 --- a/configure +++ b/configure @@ -640,6 +640,8 @@ PTHREAD_LIBS PTHREAD_CC acx_pthread_config LIBOBJS +BUILD_REDIRECTOR_FALSE +BUILD_REDIRECTOR_TRUE CPP OTOOL64 OTOOL @@ -12542,8 +12544,30 @@ fi -# Checks for libraries. -# AC_SEARCH_LIBS([ev_io_start], [ev], [ ], AC_MSG_ERROR([libev not found.])) +# Checks for host. + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for what kind of host" >&5 +$as_echo_n "checking for what kind of host... " >&6; } +case $host in + *-linux*) + os_support=linux + { $as_echo "$as_me:${as_lineno-$LINENO}: result: Linux" >&5 +$as_echo "Linux" >&6; } + ;; + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: transparent proxy does not support for $host" >&5 +$as_echo "transparent proxy does not support for $host" >&6; } + ;; +esac + + if test "$os_support" = "linux"; then + BUILD_REDIRECTOR_TRUE= + BUILD_REDIRECTOR_FALSE='#' +else + BUILD_REDIRECTOR_TRUE='#' + BUILD_REDIRECTOR_FALSE= +fi + # Checks for header files. for ac_header in stdint.h inttypes.h arpa/inet.h fcntl.h langinfo.h locale.h netdb.h netinet/in.h stdlib.h string.h strings.h sys/socket.h unistd.h @@ -14399,6 +14423,10 @@ if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then as_fn_error $? "conditional \"am__fastdepCC\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi +if test -z "${BUILD_REDIRECTOR_TRUE}" && test -z "${BUILD_REDIRECTOR_FALSE}"; then + as_fn_error $? "conditional \"BUILD_REDIRECTOR\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi : "${CONFIG_STATUS=./config.status}" diff --git a/configure.ac b/configure.ac index f222a750..8c18ac09 100755 --- a/configure.ac +++ b/configure.ac @@ -18,8 +18,20 @@ AC_PROG_MAKE_SET m4_include([libev/libev.m4]) -# Checks for libraries. -# AC_SEARCH_LIBS([ev_io_start], [ev], [ ], AC_MSG_ERROR([libev not found.])) +# Checks for host. + +AC_MSG_CHECKING(for what kind of host) +case $host in + *-linux*) + os_support=linux + AC_MSG_RESULT(Linux) + ;; + *) + AC_MSG_RESULT(transparent proxy does not support for $host) + ;; +esac + +AM_CONDITIONAL(BUILD_REDIRECTOR, test "$os_support" = "linux") # Checks for header files. AC_CHECK_HEADERS([stdint.h inttypes.h arpa/inet.h fcntl.h langinfo.h locale.h netdb.h netinet/in.h stdlib.h string.h strings.h sys/socket.h unistd.h]) diff --git a/src/Makefile.am b/src/Makefile.am index 6689d889..ad7cc6f4 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -6,9 +6,17 @@ ss_server_SOURCES = utils.c jconf.c json.c \ rc4.c md5.c encrypt.c \ server.c ss_local_LDADD = $(top_builddir)/libev/libev.la -ss_local_LDADD += $(top_builddir)/libasyncns/libasyncns.la ss_server_LDADD = $(top_builddir)/libev/libev.la ss_server_LDADD += $(top_builddir)/libasyncns/libasyncns.la + +if BUILD_REDIRECTOR +bin_PROGRAMS += ss-redir +ss_redir_SOURCES = utils.c jconf.c json.c \ + rc4.c md5.c encrypt.c \ + redir.c +ss_redir_LDADD = $(top_builddir)/libev/libev.la +endif + AM_CFLAGS = -g -O2 -Wall -fno-strict-aliasing AM_LDFLAGS = -static AM_CFLAGS += -I$(top_builddir)/libev diff --git a/src/Makefile.in b/src/Makefile.in index 0020aed5..6d1d1bd5 100644 --- a/src/Makefile.in +++ b/src/Makefile.in @@ -50,7 +50,8 @@ PRE_UNINSTALL = : POST_UNINSTALL = : build_triplet = @build@ host_triplet = @host@ -bin_PROGRAMS = ss-local$(EXEEXT) ss-server$(EXEEXT) +bin_PROGRAMS = ss-local$(EXEEXT) ss-server$(EXEEXT) $(am__EXEEXT_1) +@BUILD_REDIRECTOR_TRUE@am__append_1 = ss-redir subdir = src DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in \ $(top_srcdir)/depcomp @@ -66,13 +67,22 @@ mkinstalldirs = $(install_sh) -d CONFIG_HEADER = $(top_builddir)/config.h CONFIG_CLEAN_FILES = CONFIG_CLEAN_VPATH_FILES = +@BUILD_REDIRECTOR_TRUE@am__EXEEXT_1 = ss-redir$(EXEEXT) am__installdirs = "$(DESTDIR)$(bindir)" PROGRAMS = $(bin_PROGRAMS) am_ss_local_OBJECTS = utils.$(OBJEXT) jconf.$(OBJEXT) json.$(OBJEXT) \ rc4.$(OBJEXT) md5.$(OBJEXT) encrypt.$(OBJEXT) local.$(OBJEXT) ss_local_OBJECTS = $(am_ss_local_OBJECTS) -ss_local_DEPENDENCIES = $(top_builddir)/libev/libev.la \ - $(top_builddir)/libasyncns/libasyncns.la +ss_local_DEPENDENCIES = $(top_builddir)/libev/libev.la +am__ss_redir_SOURCES_DIST = utils.c jconf.c json.c rc4.c md5.c \ + encrypt.c redir.c +@BUILD_REDIRECTOR_TRUE@am_ss_redir_OBJECTS = utils.$(OBJEXT) \ +@BUILD_REDIRECTOR_TRUE@ jconf.$(OBJEXT) json.$(OBJEXT) \ +@BUILD_REDIRECTOR_TRUE@ rc4.$(OBJEXT) md5.$(OBJEXT) \ +@BUILD_REDIRECTOR_TRUE@ encrypt.$(OBJEXT) redir.$(OBJEXT) +ss_redir_OBJECTS = $(am_ss_redir_OBJECTS) +@BUILD_REDIRECTOR_TRUE@ss_redir_DEPENDENCIES = \ +@BUILD_REDIRECTOR_TRUE@ $(top_builddir)/libev/libev.la am_ss_server_OBJECTS = utils.$(OBJEXT) jconf.$(OBJEXT) json.$(OBJEXT) \ rc4.$(OBJEXT) md5.$(OBJEXT) encrypt.$(OBJEXT) server.$(OBJEXT) ss_server_OBJECTS = $(am_ss_server_OBJECTS) @@ -91,8 +101,9 @@ CCLD = $(CC) LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \ $(LDFLAGS) -o $@ -SOURCES = $(ss_local_SOURCES) $(ss_server_SOURCES) -DIST_SOURCES = $(ss_local_SOURCES) $(ss_server_SOURCES) +SOURCES = $(ss_local_SOURCES) $(ss_redir_SOURCES) $(ss_server_SOURCES) +DIST_SOURCES = $(ss_local_SOURCES) $(am__ss_redir_SOURCES_DIST) \ + $(ss_server_SOURCES) am__can_run_installinfo = \ case $$AM_UPDATE_INFO_DIR in \ n|no|NO) false;; \ @@ -226,10 +237,14 @@ ss_server_SOURCES = utils.c jconf.c json.c \ rc4.c md5.c encrypt.c \ server.c -ss_local_LDADD = $(top_builddir)/libev/libev.la \ - $(top_builddir)/libasyncns/libasyncns.la +ss_local_LDADD = $(top_builddir)/libev/libev.la ss_server_LDADD = $(top_builddir)/libev/libev.la \ $(top_builddir)/libasyncns/libasyncns.la +@BUILD_REDIRECTOR_TRUE@ss_redir_SOURCES = utils.c jconf.c json.c \ +@BUILD_REDIRECTOR_TRUE@ rc4.c md5.c encrypt.c \ +@BUILD_REDIRECTOR_TRUE@ redir.c + +@BUILD_REDIRECTOR_TRUE@ss_redir_LDADD = $(top_builddir)/libev/libev.la AM_CFLAGS = -g -O2 -Wall -fno-strict-aliasing -I$(top_builddir)/libev \ -I$(top_builddir)/libasyncns AM_LDFLAGS = -static @@ -316,6 +331,9 @@ clean-binPROGRAMS: ss-local$(EXEEXT): $(ss_local_OBJECTS) $(ss_local_DEPENDENCIES) $(EXTRA_ss_local_DEPENDENCIES) @rm -f ss-local$(EXEEXT) $(LINK) $(ss_local_OBJECTS) $(ss_local_LDADD) $(LIBS) +ss-redir$(EXEEXT): $(ss_redir_OBJECTS) $(ss_redir_DEPENDENCIES) $(EXTRA_ss_redir_DEPENDENCIES) + @rm -f ss-redir$(EXEEXT) + $(LINK) $(ss_redir_OBJECTS) $(ss_redir_LDADD) $(LIBS) ss-server$(EXEEXT): $(ss_server_OBJECTS) $(ss_server_DEPENDENCIES) $(EXTRA_ss_server_DEPENDENCIES) @rm -f ss-server$(EXEEXT) $(LINK) $(ss_server_OBJECTS) $(ss_server_LDADD) $(LIBS) @@ -332,6 +350,7 @@ distclean-compile: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/local.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/md5.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rc4.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/redir.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/server.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/utils.Po@am__quote@ diff --git a/src/local.c b/src/local.c index e203aefa..1d9104e1 100644 --- a/src/local.c +++ b/src/local.c @@ -99,18 +99,11 @@ static void server_recv_cb (EV_P_ ev_io *w, int revents) { return; } - char *buf = remote->buf; - int *buf_len = &remote->buf_len; - if (server->stage != 5) { - buf = server->buf; - buf_len = &server->buf_len; - } - - ssize_t r = recv(server->fd, buf, BUF_SIZE, 0); + ssize_t r = recv(server->fd, remote->buf, BUF_SIZE, 0); if (r == 0) { // connection closed - *buf_len = 0; + remote->buf_len = 0; close_and_free_server(EV_A_ server); if (remote != NULL) { ev_io_start(EV_A_ &remote->send_ctx->io); @@ -162,7 +155,7 @@ static void server_recv_cb (EV_P_ ev_io *w, int revents) { server->stage = 1; return; } else if (server->stage == 1) { - struct socks5_request *request = (struct socks5_request *)server->buf; + struct socks5_request *request = (struct socks5_request *)remote->buf; if (request->cmd != 1) { LOGE("unsupported cmd: %d", request->cmd); @@ -186,24 +179,24 @@ static void server_recv_cb (EV_P_ ev_io *w, int revents) { if (request->atyp == 1) { // IP V4 size_t in_addr_len = sizeof(struct in_addr); - memcpy(addr_to_send + addr_len, server->buf + 4, in_addr_len + 2); + memcpy(addr_to_send + addr_len, remote->buf + 4, in_addr_len + 2); addr_len += in_addr_len + 2; } else if (request->atyp == 3) { // Domain name - uint8_t name_len = *(uint8_t *)(server->buf + 4); + uint8_t name_len = *(uint8_t *)(remote->buf + 4); addr_to_send[addr_len++] = name_len; - memcpy(addr_to_send + addr_len, server->buf + 4 + 1, name_len); + memcpy(addr_to_send + addr_len, remote->buf + 4 + 1, name_len); addr_len += name_len; // get port - addr_to_send[addr_len++] = *(uint8_t *)(server->buf + 4 + 1 + name_len); - addr_to_send[addr_len++] = *(uint8_t *)(server->buf + 4 + 1 + name_len + 1); + addr_to_send[addr_len++] = *(uint8_t *)(remote->buf + 4 + 1 + name_len); + addr_to_send[addr_len++] = *(uint8_t *)(remote->buf + 4 + 1 + name_len + 1); } else if (request->atyp == 4) { // IP V6 size_t in6_addr_len = sizeof(struct in6_addr); - memcpy(addr_to_send + addr_len, server->buf + 4, in6_addr_len + 2); + memcpy(addr_to_send + addr_len, remote->buf + 4, in6_addr_len + 2); addr_len += in6_addr_len + 2; } else { @@ -214,7 +207,13 @@ static void server_recv_cb (EV_P_ ev_io *w, int revents) { } encrypt_ctx(addr_to_send, addr_len, server->e_ctx); - send(remote->fd, addr_to_send, addr_len, 0); + 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; + } // Fake reply struct socks5_response response; @@ -230,9 +229,9 @@ static void server_recv_cb (EV_P_ ev_io *w, int revents) { memset(server->buf + 4, 0, sizeof(struct in_addr) + sizeof(uint16_t)); int reply_size = 4 + sizeof(struct in_addr) + sizeof(uint16_t); - int s = send(server->fd, server->buf, reply_size, 0); + s = send(server->fd, server->buf, reply_size, 0); if (s < reply_size) { - LOGE("header not complete sent"); + LOGE("failed to send fake reply."); close_and_free_remote(EV_A_ remote); close_and_free_server(EV_A_ server); return; diff --git a/src/redir.c b/src/redir.c new file mode 100644 index 00000000..97373b58 --- /dev/null +++ b/src/redir.c @@ -0,0 +1,633 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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; +} + diff --git a/src/redir.h b/src/redir.h new file mode 100644 index 00000000..6013fd2e --- /dev/null +++ b/src/redir.h @@ -0,0 +1,65 @@ +#ifndef _LOCAL_H +#define _LOCAL_H + +#include +#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