add trasparent proxy support

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}"

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])

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

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@
 

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;

src/redir.c

@@ -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;
+}
+

src/redir.h

@@ -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