resolve domain name asynchronously

Author: wangyuntao

.gitignore

@@ -18,4 +18,6 @@
 /s5-1.0.tar.gz
 
 /.#*
-/*.o
+/*.o
+
+/core

Makefile.am

@@ -2,6 +2,7 @@
 AM_CFLAGS = -pedantic -Wall -Werror # -std=c11 # TODO
 
 SHARED_SRCS = \
+  s5_type.h \
   s5_server.c \
   s5_server.h \
   s5_conn.c \
@@ -12,6 +13,10 @@ SHARED_SRCS = \
   s5_conn_relay.h \
   s5_conn_shutdown.c \
   s5_conn_shutdown.h \
+  s5_dns_resolver.c \
+  s5_dns_resolver.h \
+  s5_signal.c \
+  s5_signal.h \
   s5_util.h \
   s5_util_epoll.c \
   s5_util_epoll.h \

configure.ac

@@ -8,7 +8,7 @@ AM_INIT_AUTOMAKE([-Wall -Werror foreign])
 
 AC_PROG_CC
 
-dnl AC_CHECK_LIB([pthread], [pthread_mutex_init])
+AC_CHECK_LIB([pthread], [pthread_mutex_init])
 
 AC_CONFIG_FILES([Makefile])
 

s5.c

@@ -1,40 +1,47 @@
 #include <stdlib.h>
+#include <unistd.h>
+#include "s5_dns_resolver.h"
 #include "s5_server.h"
+#include "s5_signal.h"
 #include "s5_util.h"
 
+static int parse_args(int argc, char** argv, int* port) {
+  if (argc != 2) {
+    return -1;
+  }
+  *port = atoi(argv[1]);
+  return 0;
+}
+
 // https://tools.ietf.org/rfc/rfc1928
 int main(int argc, char** argv) {
   int err, port;
 
-  if (argc != 2) {
-    printf("Usage: ./s5 <port>\n");
+  err = parse_args(argc, argv, &port);
+  if (err) {
+    printf("Usage: %s <port>\n", *argv);
     return -1;
   }
-  port = atoi(argv[1]);
 
-  err = signal_ignore(SIGPIPE);
-  if (err) {
-    perror_and_exit("signal_ignore");
-  }
+  s5_signal_init();
 
   s5_epoll_t* ep = s5_epoll_create();
   assert(ep);
 
-  s5_server_t* s = s5_server_create(port);
+  s5_server_t* s = s5_server_create(port, ep);
   assert(s);
 
-  err = s5_server_listen(s);
-  if (err) {
-    perror_and_exit("s5_server_listen");
-  }
+  err = s5_dns_resolver_start(s, ep);
+  assert(!err);
 
-  err = s5_epoll_add(ep, s->fd, s);
+  err = s5_server_start(s, ep);
   if (err) {
-    perror_and_exit("s5_epoll_add");
+    perror_and_exit("s5_server_start");
   }
 
   s5_epoll_run(ep);
-  s5_epoll_destroy(ep);
 
+  // TODO destory other?
+  s5_epoll_destroy(ep);
   return 0;
 }

s5_conn.c

@@ -1,76 +1,98 @@
 #include "s5_conn.h"
 #include "s5_conn_negotiate.h"
 #include "s5_conn_relay.h"
+#include "s5_conn_shutdown.h"
 
 #define BUF_SIZE 4096  // 必须要足够大到放下每条negotiation消息
 #define BUF_SIZE_MIN (256 * 2 + 1)  // Username/Password Authentication Req
 
-static void s5_conn_close(void *p) {
-  s5_conn_t *c = p;
-  s5_epoll_item_null_hdlr(c);
-  s5_epoll_item_null_hdlr(c->peer);
-}
+static s5_epoll_item_hdlr hdlrs[] = {
+    // SELECT_METHOD_REQ
+    h_select_method_req,
+    NULL,
 
-static void s5_conn_destroy0(s5_conn_t *c) {
-  if (c->fd >= 0) {
-    s5_close(c->fd);
-    c->fd = -1;
-  }
+    // SELECT_METHOD_REPLY
+    NULL,
+    h_select_method_reply,
 
-  if (c->buf) {
-    s5_buf_destroy(c->buf);
-    c->buf = NULL;
-  }
+    // CONNECT_REQ
+    h_connect_req,
+    NULL,
 
-  c->peer = NULL;
-  s5_epoll_item_free(c);
-}
+    // RESOLVE_DOMAIN_NAME
+    NULL,
+    NULL,
 
-static void s5_conn_destroy(void *p) {
-  s5_conn_t *c1 = p;
-  s5_conn_t *c2 = c1->peer;
+    // CONNECT_TARGET
+    NULL,
+    h_target_connected,
 
-  assert(c2->peer == c1);
-  S5_DEBUG("s5_conn_destroy: %p, %d -> %d\n", p, c1->fd, c2->fd);
+    // CONNECT_REPLY
+    NULL,
+    NULL,
 
-  s5_conn_destroy0(c1);
-  s5_conn_destroy0(c2);
-}
+    // RELAY
+    h_relay_in,
+    h_relay_out,
+
+    // SHUTDOWN
+    h_shutdown,
+    h_shutdown,
+};
 
-static s5_conn_t *s5_conn_create0(int fd) {
-  s5_conn_t *c = s5_epoll_item_alloc(sizeof(s5_conn_t));
+static s5_conn_t *s5_conn_create0(int fd, s5_epoll_t *ep, s5_server_t *s) {
+  s5_conn_t *c = s5_epoll_item_create(sizeof(s5_conn_t), hdlrs, -1, ep);
   if (!c) {
     return NULL;
   }
 
-  s5_epoll_item_init(c, h_select_method_req, NULL, s5_conn_close,
-                     s5_conn_destroy);
   c->fd = fd;
 
   assert(BUF_SIZE >= BUF_SIZE_MIN);
   c->buf = s5_buf_create(BUF_SIZE);
   if (!c->buf) {
-    s5_epoll_item_free(c);
+    s5_epoll_item_destroy(c, ep);
     return NULL;
   }
 
   c->peer = NULL;
+  c->s = s;
+  c->dn2ip_req_l = 0;
   return c;
 }
 
-s5_conn_t *s5_conn_create(int fd) {
-  s5_conn_t *c1 = s5_conn_create0(fd);
+static void s5_conn_destroy0(s5_conn_t *c, s5_epoll_t *ep) {
+  if (c->fd >= 0) {
+    s5_close(c->fd);
+    c->fd = -1;
+  }
+  if (c->buf) {
+    s5_buf_destroy(c->buf);
+    c->buf = NULL;
+  }
+  c->peer = NULL;
+  c->s = NULL;
+  s5_epoll_item_destroy(c, ep);
+}
+
+s5_conn_t *s5_conn_create(int fd, s5_epoll_t *ep, s5_server_t *s) {
+  s5_conn_t *c1 = s5_conn_create0(fd, ep, s);
   if (!c1) {
     return NULL;
   }
 
-  s5_conn_t *c2 = s5_conn_create0(-1);
+  s5_conn_t *c2 = s5_conn_create0(-1, ep, s);
   if (!c2) {
-    s5_conn_destroy0(c1);
+    s5_epoll_item_destroy(c1, NULL);
     return NULL;
   }
 
   c1->peer = c2;
   c2->peer = c1;
   return c1;
 }
+
+void s5_conn_destroy(s5_conn_t *c, s5_epoll_t *ep) {
+  s5_conn_destroy0(c->peer, ep);
+  s5_conn_destroy0(c, ep);
+}

s5_conn.h

@@ -1,14 +1,29 @@
 #ifndef _S5_CONN_H
 #define _S5_CONN_H
 
+#include "s5_type.h"
 #include "s5_util.h"
 
-typedef struct s5_conn {
+struct s5_conn {
   int fd;
   s5_buf_t *buf;
-  struct s5_conn *peer;
-} s5_conn_t;
+  s5_conn_t *peer;
+  s5_server_t *s;
+  uintptr_t dn2ip_req_l;
+};
 
-s5_conn_t *s5_conn_create(int fd);
+enum s5_conn_state {
+  SELECT_METHOD_REQ,
+  SELECT_METHOD_REPLY,
+  CONNECT_REQ,
+  RESOLVE_DOMAIN_NAME,
+  CONNECT_TARGET,
+  CONNECT_REPLY,
+  RELAY,
+  SHUTDOWN,
+};
+
+s5_conn_t *s5_conn_create(int fdc, s5_epoll_t *ep, s5_server_t *s);
+void s5_conn_destroy(s5_conn_t *c, s5_epoll_t *ep);
 
 #endif