CProxy.conf

@@ -1,44 +1,33 @@
 global {
     uid=3004;
-    timeout=60;
     process=2;
+    timeout=10;
+    encode=128;
     tcp_listen=0124;
+    tcp6_listen=0124;
     dns_listen=0126;
-    udp_listen = 10010;
 }
 
 http {
-    http_ip="43.142.66.71";
+    http_ip="47.240.75.93";
-    http_port=129;
+    http_port=127;
-    http_del="Host,";
+    http_del="Host";
-    http_first="[M] [U] [V]\r\nHost: [H]\r\n";
+    http_first="[M] http://[host][U] [V]\r\nHost: [H]\r\n";
-    strrep="Windows NT 10.0" -> "Linux";
+    //strrep="Windows NT 10.0->Linux";
-    strrep="Linux" -> "aixiao.me";
+    //regrep="Host:*.+?->Host: [host]:80";
-    strrep="aixiao.me" -> "AIXIAO.ME";
-    regrep="Accept-Encoding*.+?" -> "Accept-Encoding: GZIP, deflate";
-    regrep="Connection*.+?" -> "Connection: KEEP-alive";
-    encode=129;
 }
 
 https {
-    https_ip="43.142.66.71";
+    https_ip="47.240.75.93";
-    https_port=129;
+    https_port=127;
-    https_del="Host,host,x-online-host,Proxy-Connection";
+    https_del="Host,host,x-online-host";
-    https_first="[M] [U] [V]\r\nHost: [host]:[port]\r\n";
+    https_first="[M] [U] [V]\r\nHost: [host]\r\n";
-    strrep="Windows NT 10.0" -> "Linux";
+    //strrep="Windows NT 10.0->Linux";
-    strrep="Linux" -> "aixiao.me";
+    //regrep="Host*.+?->host: [host]:443";
-    strrep="aixiao.me" -> "AIXIAO.ME";
-    regrep="Accept-Encoding*.+?" -> "Accept-Encoding: GZIP, deflate";
-    regrep="Connection*.+?" -> "Connection: KEEP-alive";
-    encode=129;
 }
 
 httpdns {
-    addr = 119.29.29.29:80;
+    addr=119.29.29.29:53;
-    http_req = "[M] [U] [V]\r\nHost: [H]\r\n\r\n";
+    http_req="[M] http://wap.10010.com/d?dn=[D] [V]\r\nHost: wap.10010.com\r\n";
-}
+    encode = 0;
-
-httpudp {
-    addr = 47.240.75.93:10010;
-    http_req = "[M] [U] [V]\r\nHost: [H]\r\n";
 }

CProxy.conf.explain

@@ -1,90 +1,69 @@
-
-//global模块
 global {
-    //进程UID
     uid=3004;
-    
+    process=2;
-    //超时时间(秒)
     timeout=60;
-    
+    sslencoding=128;
-    //TCP, DNS, UDP监听地址
     tcp_listen=0124;
-    dns_listen=0126;
+    tcp6_listen=0124;
-    udp_listen = 10010;
+    dns_listen=0125;
 }
 
-//http模块
 http {
-    //http模块关键字: [M], [method], [uri], [U], [V], [version], [H], [host], [port], \r, \n, \v, \f, \b, \t, \a. 如果原本请求头含有关键字也会被替换.
+    http_ip=cproxy.aixiao.me;
-    //[M]、[method] 原请求方法
+    http_port=124;
-    //[U] 原请求url
+    http_del="x-online-host,X-Online-Host,host,Host";
-    //[uri] 原请求uri(http 模块)
-    //[V]、[version] 原请求协议版本
-    //[host] 原请求host
-    //[port] 原请求端口
-    //[H] 原请求[host]:[port]
-    
-    
-    //指定HTTP服务器IP
-    http_ip="aixiao.me";
-    
-    //指定HTTP服务器端口
-    http_port=129;
-    
-    //删除HTTP头字段,逗号分开
-    http_del="Host,";
-    
-    //自定义HTTP请求头
     http_first="[M] [U] [V]\r\nHost: [H]\r\n";
-    
+    //strrep="Windows NT 10.0->Linux";
-    //字符串替换, 以"->"为分界符,"Windows NT 10.0"字符串替换为"Linux"字符串.(可以有多个)
+    //regrep="Host*.+?->Host: hu60.cn:443";
-    strrep="Windows NT 10.0" -> "Linux";
-    strrep="Linux" -> "aixiao.me";
-    strrep="aixiao.me" -> "AIXIAO.ME";
-    
-    //正则表达式替换, 以"->"为分界符,匹配到的内容"Accept-Encoding*.+?"替换为"Accept-Encoding: GZIP, deflate"字符串.(可以有多个)
-    regrep="Accept-Encoding*.+?" -> "Accept-Encoding: GZIP, deflate";
-    regrep="Connection*.+?" -> "Connection: KEEP-alive";
-    
-    // 编码, 代码128-255要与服务端一致，默认为0不编码
-    encode=129;
 }
 
-//https模块
 https {
-    
+    https_ip=cproxy.aixiao.me;
-    https_ip="aixiao.me";
+    https_port=124;
-    https_port=129;
     https_del="Host,host,x-online-host";
-    https_first="[M] [U] [V]\r\nHost: [host]:[port]\r\n";
+    https_first="[M] [U] [V]\r\nhost: [host]\r\n";
-    encode=129;
+    strrep="Windows NT 10.0->Linux";
+    //regrep="Host*.+?->Host: hu60.cn:443";
 }
 
-//httpdns模块
 httpdns {
-    //httpdns 模块关键字: [M], [D], [V], \r, \n, \v, \f, \b, \t, \a.
+    addr=119.29.29.29:53;
-    //默认 [M] 为 GET
+    http_req="[M] http://wap.10010.com/d?dn=[D] [V]\r\nHost: wap.10010.com\r\n";
-    //默认 [V] 为 HTTP/1.0
-    
-    
-    //HTTPDNS服务器IP
-    addr = 119.29.29.29:80;
-    
-    //自定义HTTPDNS请求头
-    http_req = "[M] [U] [V]\r\nHost: [H]\r\n\r\n";
 }
 
-//httpudp模块
+
-httpudp {
+global模块
-    //httpudp 模块关键字: [M], [U], [V], [H].
+uid=3004;   //进程UID
-    //默认 [M] 为 CONNECT
+process=2;  //进程数量（已经弃用）
-    //默认 [V] 为 HTTP/1.1
+timeout=60; //超时时间（秒）
+sslencoding=128;    //编码（非零生效）
+tcp_listen=0124;    //TCP监听端口
+tcp6_listen=0124;   //TCP6监听端口 (TCP和TCP6可以使用同一个端口, IPV4的数据走内部IPV4程序结构, IPV6数据走内部IPV6程序结构.)
+dns_listen=0125;    //UDP监听端口
 
 
-    //HTTPUDP服务器IP
+http、https模块
-    addr = 47.240.75.93:10010;
+http、https 模块关键字: [M], [method], [uri], [U], [V], [version], [H], [host], [port], \r, \n, \v, \f, \b, \t, \a. 如果原本请求头含有关键字也会被替换.
+[M]、[method] 原请求方法
+[U] 原请求url
+[uri] 原请求uri(http 模块)
+[V]、[version] 原请求协议版本
+[host] 原请求host
+[port] 原请求端口
+[H] 原请求[host]:[port]
 
-    //自定义HTTPUDP请求头
+http_ip=cproxy.aixiao.me;   //指定HTTP服务器IP
-    http_req = "[M] [U] [V]\r\nHost: [H]\r\n";
+http_port=124;              //指定HTTP服务器端口
-}
+http_del="x-online-host,X-Online-Host,host,Host";       //删除HTTP头字段,逗号分开
+http_first="[M] [U] [V]\r\nHost: [H]\r\n";              //自定义HTTP头
+关键字strrep替换字符串指令.
+strrep = "Mi MIX 2->Linux"; 以"->"为分界符,"Mi MIX 2"字符串替换为"Linux"字符串.
+关键字regrep正则匹配替换字符串.
+regrep = "Host*.+?->Host: iread.wo.cn:443"; 以"->"为分界符,匹配到的内容"Host*.+?"替换为"Host: iread.wo.cn:443"字符串.
+
+httpdns模块
+httpdns 模块关键字: [M], [D], [V], \r, \n, \v, \f, \b, \t, \a.
+默认 [M] 为 GET
+默认 [V] 为 HTTP/1.0
+addr=119.29.29.29:53; //HTTPDNS服务器IP
 

Makefile

@@ -5,14 +5,14 @@ CFLAGS += -g -O2 -Wall -pthread
 LIBS = 
 OBJ := CProxy
 
-all: main.o http_proxy.o http_request.o httpdns.o httpudp.o conf.o
+all: main.o http_proxy.o httpdns.o http_request.o conf.o timeout.o kill.o help.o
 	$(CC) $(CFLAGS) -o $(OBJ) $^ $(LIBS)
 .c.o:
-	$(CC) $(CFLAGS) -c $<
+	$(CC) $(CFLAGS) -c $< $(LIBS)
 
 clean:
 	rm -rf *.o
 	rm $(OBJ)
 
 android:
-	/usr/lib/android-ndk/ndk-build NDK_PROJECT_PATH=. NDK_APPLICATION_MK=Application.mk APP_BUILD_SCRIPT=Android.mk
+	ndk-build NDK_PROJECT_PATH=. NDK_APPLICATION_MK=Application.mk APP_BUILD_SCRIPT=Android.mk

README.md

@@ -4,8 +4,7 @@
     可以修改HTTP协议消息头(request).  
     可以修改HTTP协议CONNECT方法消息头.  
     可以修改HTTP协议GET方法消息头.  
-    HttpTCP支持IPV4/IPV6.
+    支持IPV6.
-    支持HttpDNS、HttpUDP代理
 
 ## Build
 
@@ -23,8 +22,8 @@
 
 ## Help Information
 
-    C Proxy Server
+    CProxy proxy server
-    Author: AIXIAO@AIXIAO.ME
+    Author: aixiao@aixiao.me
     Usage: [-?h] [-s signal] [-c filename]
 
     Options:
@@ -32,6 +31,7 @@
         -c --config            : set configuration file, default: CProxy.conf
         -? -h --? --help       : help information
 
+    Dec 19 2020 09:18:15 Compile、link.
 
     #启动
     ./CProxy -c CProxy.conf

conf.c

@@ -1,25 +1,17 @@
 #include "conf.h"
-#include "http_request.h"
 
-/* 字符串预处理，设置转义字符 */
+char *strncpy_(char *dest, const char *src, size_t n)
-static void string_pretreatment(char *str, int *len)
 {
-    char *lf, *p, *ori_strs[] = { "\\r", "\\n", "\\b", "\\v", "\\f", "\\t", "\\a", "\\b", "\\0" }, to_chrs[] = { '\r', '\n', '\b', '\v', '\f', '\t', '\a', '\b', '\0' };
+    int size = sizeof(char) * (n + 1);
-    int i;
+    char *tmp = (char *)malloc(size); // 开辟大小为n+1的临时内存tmp
-
+    if (tmp) {
-    while ((lf = strchr(str, '\n')) != NULL) {
+        memset(tmp, '\0', size); // 将内存初始化为0
-        for (p = lf + 1; *p == ' ' || *p == '\t' || *p == '\n' || *p == '\r'; p++)
+        memcpy(tmp, src, size - 1); // 将src的前n个字节拷贝到tmp
-            *len -= 1;
+        memcpy(dest, tmp, size); // 将临时空间tmp的内容拷贝到dest
-        strcpy(lf, p);
+        free(tmp);              // 释放内存
-        *len -= 1;
+        return dest;
-    }
+    } else {
-    for (i = 0; i < sizeof(to_chrs); i++) {
+        return NULL;
-        for (p = strstr(str, ori_strs[i]); p; p = strstr(p, ori_strs[i])) {
-            //支持\\r
-            *(p - 1) == '\\' ? (*p--) : (*p = to_chrs[i]);
-            memmove(p + 1, p + 2, strlen(p + 2));
-            (*len)--;
-        }
     }
 }
 
@@ -79,7 +71,6 @@ static char *set_var_val_lineEnd(char *content, char **var, char **val_begin, ch
         val_len = strlen(*val_begin);
         *val_end = lineEnd = *val_begin + val_len;
     }
-    string_pretreatment(*val_begin, &val_len);
     *val_end = *val_begin + val_len;
     //printf("var[%s]\nbegin[%s]\n\n", *var, *val_begin);
     return lineEnd;
@@ -131,8 +122,6 @@ static void parse_global_module(char *content, conf * p)
             p->tcp6_listen = atoi(val_begin);
         } else if (strcasecmp(var, "dns_listen") == 0) {
             p->dns_listen = atoi(val_begin);
-        } else if (strcasecmp(var, "udp_listen") == 0) {
-            p->udp_listen = atoi(val_begin);;
         }
 
         content = strchr(lineEnd + 1, '\n');
@@ -142,95 +131,76 @@ static void parse_global_module(char *content, conf * p)
 static void parse_http_module(char *content, conf * p)
 {
     char *var, *val_begin, *val_end, *lineEnd;
-    tcp *http_node = NULL;
+    int val_begin_len;
-    char *p1 = NULL, *s = NULL, *t = NULL;
-    char *p2 = NULL;
 
     while ((lineEnd = set_var_val_lineEnd(content, &var, &val_begin, &val_end)) != NULL) {
         if (strcasecmp(var, "http_ip") == 0) {
-            p->http_ip_len = val_end - val_begin;
+            val_begin_len = strlen(val_begin) + 1;
-            if (copy_new_mem(val_begin, p->http_ip_len, &p->http_ip) != 0)
+            p->http_ip = (char *)malloc(val_begin_len);
-                return;
+            memset(p->http_ip, 0, val_begin_len);
-        } else if (strcasecmp(var, "encode") == 0) {
+            memcpy(p->http_ip, val_begin, val_begin_len);
-            p->http_encode = atoi(val_begin);
         } else if (strcasecmp(var, "http_port") == 0) {
             p->http_port = atoi(val_begin);
         } else if (strcasecmp(var, "http_del") == 0) {
-            p->http_del_len = val_end - val_begin;
+            val_begin_len = strlen(val_begin) + 1;
-            if (copy_new_mem(val_begin, p->http_del_len, &p->http_del) != 0)
+            p->http_del = (char *)malloc(val_begin_len);
-                return;
+            memset(p->http_del, 0, val_begin_len);
+            memcpy(p->http_del, val_begin, val_begin_len);
+            p->http_del_len = val_begin_len;
         } else if (strcasecmp(var, "http_first") == 0) {
-            p->http_first_len = val_end - val_begin;
+            val_begin_len = strlen(val_begin) + 1;
-            if (copy_new_mem(val_begin, p->http_first_len, &p->http_first) != 0)
+            p->http_first = (char *)malloc(val_begin_len);
-                return;
+            memset(p->http_first, 0, val_begin_len);
+            memcpy(p->http_first, val_begin, val_begin_len);
+            p->http_first_len = val_begin_len;
         } else if (strcasecmp(var, "strrep") == 0) {
-            http_node = (tcp *) malloc(sizeof(struct tcp));
+            val_begin_len = strlen(val_begin) + 1;
-            if (http_node == NULL)
-                return;
-            memset(http_node, 0, sizeof(struct tcp));
-            http_node->strrep = strdup(val_begin);
-            http_node->strrep_len = val_end - val_begin;
 
-            p1 = strstr(val_begin, "->");
+            p->http_strrep = (char *)malloc(val_begin_len);
-            for (t = p1; *t != '"'; ++t) ;
+            if (p->http_strrep == NULL)
-            http_node->strrep_t = strdup(t + 1);
+                free(p->http_strrep);
-            p2 = strchr(t + 1, '\0');
+            memset(p->http_strrep, 0, val_begin_len);
-            http_node->strrep_t_len = p2 - (t + 1);
+            memcpy(p->http_strrep, val_begin, val_begin_len);
 
-            for (s = p1 - 1; *s == ' '; s--) {
+            char *p1 = strstr(val_begin, "->");
-                if (s == val_begin)
+            p->http_strrep_aim = (char *)malloc(val_begin_len - strlen(p1 + 2) - 2 + 1);
-                    return;
+            if (p->http_strrep_aim == NULL) {
+                free(p->http_strrep_aim);
             }
-            if (*s == '"')
+            memset(p->http_strrep_aim, 0, val_begin_len - strlen(p1 + 2) - 2 + 1);
-                s--;
+            strncpy_(p->http_strrep_aim, val_begin, val_begin_len - strlen(p1 + 2) - 3); // 实际 val_begin_len 多1
-
+            p->http_strrep_obj = (char *)malloc(strlen(p1 + 2) + 1);
-            http_node->strrep_s = strndup(val_begin, s - val_begin + 1);
+            if (p->http_strrep_obj == NULL) {
-            http_node->strrep_s_len = s - val_begin + 1;
+                free(p->http_strrep_obj);
-
-            http_node->next = NULL;
-            if (http_head_strrep == NULL) {
-                http_head_strrep = http_node;
-            } else {
-                http_node->next = http_head_strrep;
-                http_head_strrep = http_node;
-
-                //http_node->next = http_head_strrep->next;
-                //http_head_strrep->next = http_node;
             }
+            memset(p->http_strrep_obj, 0, strlen(p1 + 2) + 1);
+            strncpy_(p->http_strrep_obj, p1 + 2, strlen(p1 + 2));
+            p->http_strrep_aim_len = strlen(p->http_strrep_aim);
+            p->http_strrep_obj_len = strlen(p->http_strrep_obj);
         } else if (strcasecmp(var, "regrep") == 0) {
-            http_node = (tcp *) malloc(sizeof(struct tcp));
+            val_begin_len = strlen(val_begin) + 1;
-            if (http_node == NULL)
-                return;
-            memset(http_node, 0, sizeof(struct tcp));
-            http_node->regrep = strdup(val_begin);
-            http_node->regrep_len = val_end - val_begin;
 
-            p1 = strstr(val_begin, "->");
+            p->http_regrep = (char *)malloc(val_begin_len);
-            for (t = p1; *t != '"'; ++t) ;
+            if (p->http_regrep == NULL)
-            http_node->regrep_t = strdup(t + 1);
+                free(p->http_regrep);
-            p2 = strchr(t + 1, '\0');
+            memset(p->http_regrep, 0, val_begin_len);
-            http_node->regrep_t_len = p2 - (t + 1);
+            memcpy(p->http_regrep, val_begin, val_begin_len);
 
-            for (s = p1 - 1; *s == ' '; s--) {
+            char *p1 = strstr(val_begin, "->");
-                if (s == val_begin)
+            p->http_regrep_aim = (char *)malloc(val_begin_len - strlen(p1 + 2) - 2 + 1);
-                    return;
+            if (p->http_regrep_aim == NULL) {
+                free(p->http_regrep_aim);
             }
-            if (*s == '"')
+            memset(p->http_regrep_aim, 0, val_begin_len - strlen(p1 + 2) - 2 + 1);
-                s--;
+            strncpy_(p->http_regrep_aim, val_begin, val_begin_len - strlen(p1 + 2) - 3);
-
+            p->http_regrep_obj = (char *)malloc(strlen(p1 + 2) + 1);
-            http_node->regrep_s = strndup(val_begin, s - val_begin + 1);
+            if (p->http_regrep_obj == NULL) {
-            http_node->regrep_s_len = s - val_begin + 1;
+                free(p->http_regrep_obj);
-
-            http_node->next = NULL;
-            if (http_head_regrep == NULL) {
-                http_head_regrep = http_node;
-            } else {
-                http_node->next = http_head_regrep;
-                http_head_regrep = http_node;
-
-                //http_node->next = http_head_regrep->next;
-                //http_head_regrep->next = http_node;
             }
+            memset(p->http_regrep_obj, 0, strlen(p1 + 2) + 1);
+            strncpy_(p->http_regrep_obj, p1 + 2, strlen(p1 + 2));
+            p->http_regrep_aim_len = strlen(p->http_regrep_aim);
+            p->http_regrep_obj_len = strlen(p->http_regrep_obj);
         }
 
         content = strchr(lineEnd + 1, '\n');
@@ -240,259 +210,160 @@ static void parse_http_module(char *content, conf * p)
 static void parse_https_module(char *content, conf * p)
 {
     char *var, *val_begin, *val_end, *lineEnd;
-    tcp *https_node = NULL;
+    int val_begin_len;
-    char *p1 = NULL, *s = NULL, *t = NULL;
-    char *p2 = NULL;
 
     while ((lineEnd = set_var_val_lineEnd(content, &var, &val_begin, &val_end)) != NULL) {
         if (strcasecmp(var, "https_ip") == 0) {
-            p->https_ip_len = val_end - val_begin;
+            val_begin_len = strlen(val_begin) + 1;
-            if (copy_new_mem(val_begin, p->https_ip_len, &p->https_ip) != 0)
+            p->https_ip = (char *)malloc(val_begin_len);
-                return;
+            memset(p->https_ip, 0, val_begin_len);
-        } else if (strcasecmp(var, "encode") == 0) {
+            memcpy(p->https_ip, val_begin, val_begin_len);
-            p->https_encode = atoi(val_begin);
         } else if (strcasecmp(var, "https_port") == 0) {
             p->https_port = atoi(val_begin);
         } else if (strcasecmp(var, "https_del") == 0) {
-            p->https_del_len = val_end - val_begin;
+            val_begin_len = strlen(val_begin) + 1;
-            if (copy_new_mem(val_begin, p->https_del_len, &p->https_del) != 0)
+            p->https_del = (char *)malloc(val_begin_len);
-                return;
+            memset(p->https_del, 0, val_begin_len);
+            memcpy(p->https_del, val_begin, val_begin_len);
+            p->https_del_len = val_begin_len;
         } else if (strcasecmp(var, "https_first") == 0) {
-
+            val_begin_len = strlen(val_begin) + 1;
-            p->https_first_len = val_end - val_begin;
+            p->https_first = (char *)malloc(val_begin_len);
-            if (copy_new_mem(val_begin, p->https_first_len, &p->https_first) != 0)
+            memset(p->https_first, 0, val_begin_len);
-                return;
+            memcpy(p->https_first, val_begin, val_begin_len);
-
+            p->https_first_len = val_begin_len;
         } else if (strcasecmp(var, "strrep") == 0) {
-            // 链表操作,支持多个相同配置KEY
+            val_begin_len = strlen(val_begin) + 1;
-            https_node = (tcp *) malloc(sizeof(struct tcp));
-            if (https_node == NULL)
-                return;
-            memset(https_node, 0, sizeof(struct tcp));
-            https_node->strrep = strdup(val_begin);
-            https_node->strrep_len = val_end - val_begin;
 
-            p1 = strstr(val_begin, "->");
+            p->https_strrep = (char *)malloc(val_begin_len);
-            for (t = p1; *t != '"'; ++t) ;
+            if (p->https_strrep == NULL)
-            https_node->strrep_t = strdup(t + 1);
+                free(p->https_strrep);
-            p2 = strchr(t + 1, '\0');
+            memset(p->https_strrep, 0, val_begin_len);
-            https_node->strrep_t_len = p2 - (t + 1);
+            memcpy(p->https_strrep, val_begin, val_begin_len);
 
-            for (s = p1 - 1; *s == ' '; s--) {
+            char *p1 = strstr(val_begin, "->");
-                if (s == val_begin)
+            p->https_strrep_aim = (char *)malloc(val_begin_len - strlen(p1 + 2) - 2 + 1);
-                    return;
+            if (p->https_strrep_aim == NULL) {
+                free(p->https_strrep_aim);
             }
-            if (*s == '"')
+            memset(p->https_strrep_aim, 0, val_begin_len - strlen(p1 + 2) - 2 + 1);
-                s--;
+            strncpy_(p->https_strrep_aim, val_begin, val_begin_len - strlen(p1 + 2) - 3);
-
+            p->https_strrep_obj = (char *)malloc(strlen(p1 + 2) + 1);
-            https_node->strrep_s = strndup(val_begin, s - val_begin + 1);
+            if (p->https_strrep_obj == NULL) {
-            https_node->strrep_s_len = s - val_begin + 1;
+                free(p->https_strrep_obj);
-
-            https_node->next = NULL;
-
-            if (https_head_strrep == NULL) {
-                https_head_strrep = https_node;
-            } else {
-                https_node->next = https_head_strrep;
-                https_head_strrep = https_node;
-
-                //https_node->next = https_head_strrep->next;
-                //https_head_strrep->next = https_node;
             }
+            memset(p->https_strrep_obj, 0, strlen(p1 + 2) + 1);
+            strncpy_(p->https_strrep_obj, p1 + 2, strlen(p1 + 2));
+            p->https_strrep_aim_len = strlen(p->https_strrep_aim);
+            p->https_strrep_obj_len = strlen(p->https_strrep_obj);
         } else if (strcasecmp(var, "regrep") == 0) {
-            https_node = (tcp *) malloc(sizeof(struct tcp));
+            val_begin_len = strlen(val_begin) + 1;
-            if (https_node == NULL)
-                return;
-            memset(https_node, 0, sizeof(struct tcp));
-            https_node->regrep = strdup(val_begin);
-            https_node->regrep_len = val_end - val_begin;
 
-            p1 = strstr(val_begin, "->");
+            p->https_regrep = (char *)malloc(val_begin_len);
-            for (t = p1; *t != '"'; ++t) ;
+            if (p->https_regrep == NULL)
-            https_node->regrep_t = strdup(t + 1);
+                free(p->https_regrep);
-            p2 = strchr(t + 1, '\0');
+            memset(p->https_regrep, 0, val_begin_len);
-            https_node->regrep_t_len = p2 - (t + 1);
+            memcpy(p->https_regrep, val_begin, val_begin_len);
 
-            for (s = p1 - 1; *s == ' '; s--) {
+            char *p1 = strstr(val_begin, "->");
-                if (s == val_begin)
+            p->https_regrep_aim = (char *)malloc(val_begin_len - strlen(p1 + 2) - 2 + 1);
-                    return;
+            if (p->https_regrep_aim == NULL)
-            }
+                free(p->https_regrep_aim);
-            if (*s == '"')
+            memset(p->https_regrep_aim, 0, val_begin_len - strlen(p1 + 2) - 2 + 1);
-                s--;
+            strncpy_(p->https_regrep_aim, val_begin, val_begin_len - strlen(p1 + 2) - 3);
-
+            p->https_regrep_obj = (char *)malloc(strlen(p1 + 2) + 1);
-            https_node->regrep_s = strndup(val_begin, s - val_begin + 1);
+            if (p->https_regrep_obj == NULL)
-            https_node->regrep_s_len = s - val_begin + 1;
+                free(p->https_regrep_obj);
-
+            memset(p->https_regrep_obj, 0, strlen(p1 + 2) + 1);
-            https_node->next = NULL;
+            strncpy_(p->https_regrep_obj, p1 + 2, strlen(p1 + 2));
-            if (https_head_regrep == NULL) {
+            p->https_regrep_aim_len = strlen(p->https_regrep_aim);
-                https_head_regrep = https_node;
+            p->https_regrep_obj_len = strlen(p->https_regrep_obj);
-            } else {
-                https_node->next = https_head_regrep;
-                https_head_regrep = https_node;
-
-                //https_node->next = https_head_regrep->next;
-                //https_head_regrep->next = https_node;
-            }
         }
 
         content = strchr(lineEnd + 1, '\n');
     }
 }
 
-// 打印tcp链表
-void print_tcp(tcp * p)
-{
-    tcp *temp = p;
-    while (temp) {
-        if (temp->strrep)
-            printf("%s %d\n", temp->strrep, temp->strrep_len);
-        if (temp->strrep_s)
-            printf("%s %d\n", temp->strrep_s, temp->strrep_s_len);
-        if (temp->strrep_t)
-            printf("%s %d\n", temp->strrep_t, temp->strrep_t_len);
-
-        if (temp->regrep)
-            printf("%s %d\n", temp->regrep, temp->regrep_len);
-        if (temp->regrep_s)
-            printf("%s %d\n", temp->regrep_s, temp->regrep_s_len);
-        if (temp->regrep_t)
-            printf("%s %d\n", temp->regrep_t, temp->regrep_t_len);
-
-        temp = temp->next;
-    }
-}
-
-tcp *local_reverse(tcp * head)
-{
-    tcp *beg = NULL;
-    tcp *end = NULL;
-    if (head == NULL || head->next == NULL) {
-        return head;
-    }
-    beg = head;
-    end = head->next;
-    while (end != NULL) {
-        //将 end 从链表中摘除
-        beg->next = end->next;
-        //将 end 移动至链表头
-        end->next = head;
-        head = end;
-        //调整 end 的指向，另其指向 beg 后的一个节点，为反转下一个节点做准备
-        end = beg->next;
-    }
-    return head;
-}
-
-// Free tcp 链表
-void free_tcp(tcp ** conf_head)
-{
-    tcp *t;
-    while (*conf_head != NULL) {
-        t = *conf_head;
-        *conf_head = t->next;
-
-        if (t->strrep)
-            free(t->strrep);
-        if (t->strrep_s)
-            free(t->strrep_s);
-        if (t->strrep_t)
-            free(t->strrep_t);
-
-        if (t->regrep)
-            free(t->regrep);
-        if (t->regrep_s)
-            free(t->regrep_s);
-        if (t->regrep_t)
-            free(t->regrep_t);
-        if (t)
-            free(t);
-    }
-}
-
 static void parse_httpdns_module(char *content, conf * p)
 {
     char *var, *val_begin, *val_end, *lineEnd;
+    int val_begin_len;
 
     while ((lineEnd = set_var_val_lineEnd(content, &var, &val_begin, &val_end)) != NULL) {
         if (strcasecmp(var, "addr") == 0) {
-            p->httpdns_addr_len = val_end - val_begin;
+            val_begin_len = strlen(val_begin) + 1;
-            if (copy_new_mem(val_begin, p->httpdns_addr_len, &p->httpdns_addr) != 0)
+            p->addr = (char *)malloc(val_begin_len);
-                return;
+            memset(p->addr, 0, val_begin_len);
+            memcpy(p->addr, val_begin, val_begin_len);
         } else if (strcasecmp(var, "http_req") == 0) {
-            p->httpdns_http_req_len = val_end - val_begin;
+            val_begin_len = strlen(val_begin) + 1;
-            if (copy_new_mem(val_begin, p->httpdns_http_req_len, &p->httpdns_http_req) != 0)
+            p->http_req = (char *)malloc(val_begin_len);
-                return;
+            memset(p->http_req, 0, val_begin_len);
+            memcpy(p->http_req, val_begin, val_begin_len);
+            p->http_req_len = val_begin_len;
         } else if (strcasecmp(var, "encode") == 0) {
             p->encode = atoi(val_begin);
         }
-
-        content = strchr(lineEnd + 1, '\n');
-    }
-}
-
-static void parse_httpudp_module(char *content, conf * p)
-{
-    char *var, *val_begin, *val_end, *lineEnd;
-
-    while ((lineEnd = set_var_val_lineEnd(content, &var, &val_begin, &val_end)) != NULL) {
-        if (strcasecmp(var, "addr") == 0) {
-            p->httpudp_addr_len = val_end - val_begin;
-            if (copy_new_mem(val_begin, p->httpudp_addr_len, &p->httpudp_addr) != 0)
-                return;
-        } else if (strcasecmp(var, "http_req") == 0) {
-            p->httpudp_http_req_len = val_end - val_begin;
-            if (copy_new_mem(val_begin, p->httpudp_http_req_len, &p->httpudp_http_req) != 0)
-                return;
-        } else if (strcasecmp(var, "encode") == 0) {
-            p->httpudp_encode = atoi(val_begin);
-        }
-
         content = strchr(lineEnd + 1, '\n');
     }
 }
 
 void free_conf(conf * p)
 {
-    // http module
     if (p->http_ip)
         free(p->http_ip);
     if (p->http_del)
         free(p->http_del);
     if (p->http_first)
         free(p->http_first);
+    if (p->http_strrep)
+        free(p->http_strrep);
+    if (p->http_strrep_aim)
+        free(p->http_strrep_aim);
+    if (p->http_strrep_obj)
+        free(p->http_strrep_obj);
+    if (p->http_regrep)
+        free(p->http_regrep);
+    if (p->http_regrep_aim)
+        free(p->http_regrep_aim);
+    if (p->http_regrep_obj)
+        free(p->http_regrep_obj);
 
-    // https module
     if (p->https_ip)
         free(p->https_ip);
     if (p->https_del)
         free(p->https_del);
     if (p->https_first)
         free(p->https_first);
+    if (p->https_strrep)
+        free(p->https_strrep);
+    if (p->https_strrep_aim)
+        free(p->https_strrep_aim);
+    if (p->https_strrep_obj)
+        free(p->https_strrep_obj);
+    if (p->https_regrep)
+        free(p->https_regrep);
+    if (p->https_regrep_aim)
+        free(p->https_regrep_aim);
+    if (p->https_regrep_obj)
+        free(p->https_regrep_obj);
 
-    // httpdns module
+    if (p->addr)
-    if (p->httpdns_addr)
+        free(p->addr);
-        free(p->httpdns_addr);
+    if (p->http_req)
-    if (p->httpdns_http_req)
+        free(p->http_req);
-        free(p->httpdns_http_req);
-
-    // httpudp module
-    if (p->httpudp_addr)
-        free(p->httpudp_addr);
-    if (p->httpudp_http_req)
-        free(p->httpudp_http_req);
-
     return;
 }
 
 void read_conf(char *filename, conf * configure)
 {
-    char *buff, *global_content, *http_content, *https_content, *httpdns_content, *httpudp_content;
+    char *buff, *global_content, *http_content, *https_content, *httpdns_content;
     FILE *file;
     long file_size;
 
     file = fopen(filename, "r");
     if (file == NULL) {
-        perror("cannot open config file.");
+        printf("cannot open config file.");
         exit(-1);
     }
     fseek(file, 0, SEEK_END);
@@ -509,31 +380,21 @@ void read_conf(char *filename, conf * configure)
 
     if ((global_content = read_module(buff, "global")) == NULL)
         perror("read global module error");
-    else
+    parse_global_module(global_content, configure);
-        parse_global_module(global_content, configure);
     free(global_content);
 
     if ((http_content = read_module(buff, "http")) == NULL)
         perror("read http module error");
-    else
+    parse_http_module(http_content, configure);
-        parse_http_module(http_content, configure);
     free(http_content);
 
     if ((https_content = read_module(buff, "https")) == NULL)
         perror("read https module error");
-    else
+    parse_https_module(https_content, configure);
-        parse_https_module(https_content, configure);
     free(https_content);
 
     if ((httpdns_content = read_module(buff, "httpdns")) == NULL)
         perror("read httpdns module error");
-    else
+    parse_httpdns_module(httpdns_content, configure);
-        parse_httpdns_module(httpdns_content, configure);
     free(httpdns_content);
-
-    if ((httpudp_content = read_module(buff, "httpudp")) == NULL)
-        perror("read httpdns module error");
-    else
-        parse_httpudp_module(httpudp_content, configure);
-    free(httpudp_content);
 }

conf.h

@@ -18,61 +18,40 @@ typedef struct CONF {
     int tcp_listen;
     int tcp6_listen;
     int dns_listen;
-    int udp_listen;
 
     // http module
     int http_port;
     char *http_ip, *http_del, *http_first;
     int http_ip_len, http_del_len, http_first_len;
-    int http_encode;
+    char *http_strrep, *http_regrep;
+    int http_strrep_len, http_regrep_len;
+
+    char *http_strrep_aim, *http_strrep_obj;
+    int http_strrep_aim_len, http_strrep_obj_len;
+
+    char *http_regrep_aim, *http_regrep_obj;
+    int http_regrep_aim_len, http_regrep_obj_len;
 
     // https module
     int https_port;
     char *https_ip, *https_del, *https_first;
     int https_ip_len, https_del_len, https_first_len;
-    int https_encode;
+    char *https_strrep, *https_regrep;
+    int https_strrep_len, https_regrep_len;
 
-    // httpdns module
+    char *https_strrep_aim, *https_strrep_obj;
-    char *httpdns_addr;
+    int https_strrep_aim_len, https_strrep_obj_len;
-    char *httpdns_http_req;
+
-    int httpdns_addr_len;
+    char *https_regrep_aim, *https_regrep_obj;
-    int httpdns_http_req_len;
+    int https_regrep_aim_len, https_regrep_obj_len;
+
+    // http dns_listen
+    char *addr;
+    char *http_req;
+    int http_req_len;
     int encode;
-
-    // httpudp module
-    char *httpudp_addr;
-    char *httpudp_http_req;
-    int httpudp_addr_len;
-    int httpudp_http_req_len;
-    int httpudp_encode;
 } conf;
 
-typedef struct tcp {
-    char *strrep;
-    int strrep_len;
-    char *strrep_s, *strrep_t;
-    int strrep_s_len, strrep_t_len;
-
-    char *regrep;
-    int regrep_len;
-    char *regrep_s, *regrep_t;
-    int regrep_s_len, regrep_t_len;
-
-    struct tcp *next;
-} tcp;
-
-extern tcp *http_head_strrep;
-extern tcp *http_head_regrep;
-extern tcp *http_node;
-
-extern tcp *https_head_strrep;
-extern tcp *https_head_regrep;
-extern tcp *https_node;
-
-extern void print_tcp(tcp * p);
-extern void free_tcp(tcp ** p);
-extern tcp *local_reverse(tcp * head);
-
 char *strncpy_(char *dest, const char *src, size_t n);
 void read_conf(char *file, conf * p);
 void free_conf(conf * p);

help.c

@@ -0,0 +1,36 @@
+#include "help.h"
+
+char help_information(void)
+{
+    static const char name[] = "CProxy";
+    static const char subject[] = "proxy server";
+    static const struct {
+        const char *email;
+    } author = {
+        "aixiao@aixiao.me",
+    };
+
+    static const char usage[] = "Usage: [-?h] [-s signal] [-c filename]";
+    static const char *s_help[] = {
+        "",
+        "Options:",
+        "    -s --signal            : send signal to a master process: stop, quit, restart, reload, status",
+        "    -c --config            : set configuration file, default: CProxy.conf",
+        "    -? -h --? --help       : help information",
+        "",
+        0
+    };
+
+    fprintf(stderr, "%s %s\n", name, subject);
+    fprintf(stderr, "Author: %s\n", author.email);
+    fprintf(stderr, "%s\n", usage);
+
+    int l;
+    for (l = 0; s_help[l]; l++) {
+        fprintf(stderr, "%s\n", s_help[l]);
+    }
+
+    BUILD("Compile、link.\n");
+
+    return 0;
+}

help.h

@@ -0,0 +1,9 @@
+#ifndef HELP_H
+#define HELP_H
+
+#include <stdio.h>
+#define BUILD(fmt...)  do { fprintf(stderr,"%s %s ",__DATE__,__TIME__); fprintf(stderr, ##fmt); } while(0)
+
+char help_information(void);
+
+#endif

http_proxy.c

@@ -4,30 +4,13 @@
 int sslEncodeCode;
 int remote_port;
 char remote_host[CACHE_SIZE];
-int timeout_minute;
 
 /* 对数据进行编码 */
-void dataEncode(char *data, int data_len, unsigned code)
+void dataEncode(char *data, int data_len)
 {
-    while (data_len-- > 0)
+    if (sslEncodeCode)
-        data[data_len] ^= code;
+        while (data_len-- > 0)
-}
+            data[data_len] ^= sslEncodeCode;
-
-void *tcp_timeout_check(void *nullPtr)
-{
-    int i;
-
-    for (i = 0; i < MAX_CONNECTION; i += 2) {
-        if (cts[i].fd > -1) {
-            if (cts[i].timer >= timeout_minute) {
-                printf("关闭连接\n");
-                close_connection(cts + i);
-            } else
-                cts[i].timer++;
-        }
-    }
-
-    return NULL;
 }
 
 static char *read_data(conn_t * in, char *data, int *data_len)
@@ -43,7 +26,7 @@ static char *read_data(conn_t * in, char *data, int *data_len)
         }
         data = new_data;
         read_len = read(in->fd, data + *data_len, BUFFER_SIZE);
-        /* 判断是否关闭连接 */
+        // 判断是否关闭连接
         if (read_len <= 0) {
             if (read_len == 0 || *data_len == 0 || errno != EAGAIN) {
                 free(data);
@@ -86,7 +69,7 @@ static void serverToClient(conn_t * server)
 
     client = server - 1;
     while ((server->ready_data_len = read(server->fd, server->ready_data, BUFFER_SIZE)) > 0) {
-        dataEncode(server->ready_data, server->ready_data_len, sslEncodeCode);
+        dataEncode(server->ready_data, server->ready_data_len);
         write_len = write(client->fd, server->ready_data, server->ready_data_len);
         if (write_len <= 0) {
             if (write_len == 0 || errno != EAGAIN)
@@ -162,14 +145,12 @@ int check_ipversion(char *address)
             return AF_INET6;
         }
     }
-
     return 0;
 }
 
 int create_connection6(char *remote_host, int remote_port)
 {
-    struct addrinfo hints;
+    struct addrinfo hints, *res = NULL;
-    
     int sock;
     int validfamily = 0;
     char portstr[CACHE_SIZE];
@@ -185,12 +166,9 @@ int create_connection6(char *remote_host, int remote_port)
     // check for numeric IP to specify IPv6 or IPv4 socket
     if ((validfamily = check_ipversion(remote_host)) != 0) {
         hints.ai_family = validfamily;
-        hints.ai_flags |= AI_NUMERICHOST;
+        hints.ai_flags |= AI_NUMERICHOST; // remote_host是有效的数字ip，跳过解析
     }
-    
+    // 检查指定的主机是否有效。 如果remote_host是主机名，尝试解析地址
-    
-/*
-    struct addrinfo *res = NULL;
     if (getaddrinfo(remote_host, portstr, &hints, &res) != 0) {
         errno = EFAULT;
         perror("getaddrinfo");
@@ -209,81 +187,6 @@ int create_connection6(char *remote_host, int remote_port)
 
     if (res != NULL)
         freeaddrinfo(res);
-*/
-
-
-    //通用sockaddr_storage结构体
-    struct sockaddr_storage remote_addr;
-    memset(&remote_addr, 0, sizeof(struct sockaddr_storage));
-    if (validfamily == AF_INET) {
-        struct sockaddr_in *addr_v4 = (struct sockaddr_in *)&remote_addr;
-        addr_v4->sin_family = AF_INET;
-        addr_v4->sin_port = htons(remote_port);
-        inet_aton(remote_host, &(addr_v4->sin_addr));
-        if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
-            perror("socket");
-            return -1;
-        }
-    } 
-    else
-    {
-        struct sockaddr_in6 *addr_v6 = (struct sockaddr_in6 *)&remote_addr;
-        addr_v6->sin6_family = AF_INET6;
-        addr_v6->sin6_port = htons(remote_port);
-        inet_pton(AF_INET6, remote_host, &(addr_v6->sin6_addr));
-        if ((sock = socket(AF_INET6, SOCK_STREAM, 0)) < 0) {
-            perror("socket");
-            return -1;
-        }
-    }
-
-    if (connect(sock, (struct sockaddr *)&remote_addr, sizeof(struct sockaddr_storage)) < 0)
-    {
-            perror("connect");
-            return -1;
-    }
-
-
-/*
-    //普通方法
-    if (validfamily == AF_INET) {
-        struct sockaddr_in remote_addr;
-        memset(&remote_addr, 0, sizeof(remote_addr));
-        remote_addr.sin_family = AF_INET;
-        remote_addr.sin_port = htons(remote_port);
-        remote_addr.sin_addr.s_addr = inet_addr(remote_host);
-        
-        if ((sock = socket(validfamily, SOCK_STREAM, 0)) < 0) {
-            perror("socket");
-            return -1;
-        }
-        
-        if (connect(sock, (struct sockaddr *)&remote_addr, sizeof(remote_addr)) < 0) {
-            perror("connect");
-            return -1;
-        }
-        
-        return sock;
-    } else {
-        struct sockaddr_in6 remote_addr;
-        memset(&remote_addr, 0, sizeof(remote_addr));
-        remote_addr.sin6_family = AF_INET6;
-        remote_addr.sin6_port = htons(remote_port);
-        inet_pton(AF_INET6, remote_host, &(remote_addr.sin6_addr));
-        
-        if ((sock = socket(AF_INET6, SOCK_STREAM, 0)) < 0) {
-            perror("socket");
-            return -1;
-        }
-        
-        if (connect(sock, (struct sockaddr *)&remote_addr, sizeof(remote_addr)) < 0) {
-            perror("connect");
-            return -1;
-        }
-        
-        return sock;
-    }
-*/
 
     return sock;
 }
@@ -291,8 +194,7 @@ int create_connection6(char *remote_host, int remote_port)
 /* 读取到的数据全部就绪，将incomplete_data复制到ready_data */
 static int8_t copy_data(conn_t * ct)
 {
-    dataEncode(ct->incomplete_data, ct->incomplete_data_len, sslEncodeCode);
+    dataEncode(ct->incomplete_data, ct->incomplete_data_len);
-
     if (ct->ready_data) {
         char *new_data;
 
@@ -307,6 +209,7 @@ static int8_t copy_data(conn_t * ct)
         ct->ready_data = ct->incomplete_data;
         ct->ready_data_len = ct->incomplete_data_len;
     }
+
     ct->incomplete_data = NULL;
     ct->incomplete_data_len = 0;
 
@@ -316,7 +219,6 @@ static int8_t copy_data(conn_t * ct)
 void tcp_in(conn_t * in, conf * configure)
 {
     conn_t *server;
-    char *headerEnd;
 
     if (in->fd < 0)
         return;
@@ -330,51 +232,30 @@ void tcp_in(conn_t * in, conf * configure)
 
     in->timer = (in + 1)->timer = 0;
     in->incomplete_data = read_data(in, in->incomplete_data, &in->incomplete_data_len);
+
+    //printf("%s", in->incomplete_data);
     if (in->incomplete_data == NULL) {
         close_connection(in);
         return;
     }
-
     server = in + 1;
     server->request_type = in->request_type = request_type(in->incomplete_data);
-    if (in->request_type == OTHER_TYPE) {
-        //如果是第一次读取数据，并且不是HTTP请求的，关闭连接。复制数据失败的也关闭连接
-        if (in->reread_data == 0 || copy_data(in) != 0) {
-            close_connection(in);
-            return;
-        }
-        goto handle_data_complete;
-    }
-
-    headerEnd = strstr(in->incomplete_data, "\n\r");
-    //请求头不完整，等待下次读取
-    if (headerEnd == NULL)
-        return;
-
-    if (in->reread_data == 0) {
-        in->reread_data = 1;
 
+    if (request_type(in->incomplete_data) == HTTP_TYPE) {
         in->incomplete_data = request_head(in, configure);
         server->fd = create_connection6(remote_host, remote_port);
-
+        if (server->fd < 0)
-        if (server->fd < 0) {
             printf("remote->fd ERROR!\n");
-            close_connection(in);
-            return;
-        }
         fcntl(server->fd, F_SETFL, O_NONBLOCK);
         ev.events = EPOLLIN | EPOLLOUT | EPOLLET;
         ev.data.ptr = server;
         epoll_ctl(epollfd, EPOLL_CTL_ADD, server->fd, &ev);
-
     }
 
     if (in->incomplete_data == NULL || copy_data(in) != 0) {
-        close_connection(server);
+        close_connection(in);
         return;
     }
-    // 数据处理完毕，可以发送
-handle_data_complete:
     // 这个判断是防止 多次读取客户端数据，但是没有和服务端建立连接，导致报错
     if (server->fd >= 0)
         tcp_out(server);
@@ -392,7 +273,6 @@ void tcp_out(conn_t * to)
     else
         from = to + 1;
     from->timer = to->timer = 0;
-
     write_len = write(to->fd, from->ready_data + from->sent_len, from->ready_data_len - from->sent_len);
     if (write_len == from->ready_data_len - from->sent_len) {
         //服务端的数据可能没全部写入到客户端

http_proxy.h

@@ -8,6 +8,10 @@
 #define HTTP_TYPE 0
 #define OTHER_TYPE 1
 
+extern int remote_port;
+extern char remote_host[CACHE_SIZE];
+extern int sslEncodeCode;
+
 typedef struct tcp_connection {
     char *ready_data, *incomplete_data;
     int fd, ready_data_len, incomplete_data_len, sent_len, timer;
@@ -15,16 +19,12 @@ typedef struct tcp_connection {
     unsigned reread_data:1, request_type:1, keep_alive:1;
 } conn_t;
 
-extern int remote_port;
-extern char remote_host[CACHE_SIZE];
-extern int sslEncodeCode;
 extern conn_t cts[MAX_CONNECTION];
 extern void tcp_in(conn_t * in, conf * configure);
 extern void tcp_out(conn_t * out);
 extern void close_connection(conn_t * conn);
+
 extern char *request_head(conn_t * in, conf * configure);
-extern void dataEncode(char *data, int data_len, unsigned code);
+void dataEncode(char *data, int data_len);
-extern int timeout_minute;
-void *tcp_timeout_check(void *nullPtr);
 
 #endif

http_request.c

@@ -1,22 +1,5 @@
 #include "http_request.h"
 
-void errors(const char *error_info)
-{
-    fprintf(stderr, "%s\n\n", error_info);
-    exit(1);
-}
-
-int8_t copy_new_mem(char *src, int src_len, char **dest)
-{
-    *dest = (char *)malloc(src_len + 1);
-    if (*dest == NULL)
-        return 1;
-    memcpy(*dest, src, src_len);
-    *((*dest) + src_len) = '\0';
-
-    return 0;
-}
-
 // 字符串替换
 char *replace(char *replace_memory, int *replace_memory_len, const char *src, const int src_len, const char *dest, const int dest_len)
 {
@@ -136,9 +119,47 @@ static char *regrep(char *str, int *str_len, const char *src, char *dest, int de
     return str;
 }
 
+// 删除字符串head中第一位到 character 处并拼接 string, character 为空返回原字符串.(string 字符替换第一个字符到 character 处)
+char *splice_head(char *head, const char *character, char *string)
+{
+    int first_len = strlen(string);
+    char *_p1 = strstr(head, character);
+    if (_p1 == NULL) {
+        return head;
+    }
+    _p1 = _p1 + 1;
+    char temporary[first_len + strlen(_p1) + 1];
+    memset(temporary, 0, (first_len + strlen(_p1) + 1));
+    strcpy(temporary, string);
+    strcat(temporary, _p1);
+    memset(head, 0, strlen(head));
+    return strcpy(head, temporary);
+}
+
+// 删除字符串 head 中 character 到 string 处, character 为空返回原字符串.
+char *delete_head(char *head, const char *character, int string)
+{
+    int head_len = strlen(head);
+    char *_p1 = strstr(head, character);
+    if (_p1 == NULL) {
+        return head;
+    }
+    char *_p2 = strchr(_p1, string);
+    if (_p2 == NULL) {
+        return head;
+    }
+    char temporary[head_len];
+    memset(temporary, 0, head_len);
+    memcpy(temporary, head, (head_len - strlen(_p1) - 1));
+    strcat(temporary, _p2);
+    memset(head, 0, strlen(head));
+    return memcpy(head, temporary, head_len);
+}
+
 int extract_host(char *header, char *host, char *port)
 {
-
+    memset(port, 0, strlen(port));
+    memset(host, 0, strlen(host));
 //printf("%s\n", header);
     char *_p = strstr(header, "CONNECT"); // 在 CONNECT 方法中解析 隧道主机名称及端口号
     if (_p) {
@@ -146,10 +167,10 @@ int extract_host(char *header, char *host, char *port)
         if (strchr(header, '[') || strchr(header, ']')) { // IPv6
             char *_p1 = strchr(header, '[');
             char *_p2 = strchr(_p1 + 1, ']');
-            memcpy(host, _p1 + 1, (int)(_p2 - _p1) - 1);
+            strncpy(host, _p1 + 1, (int)(_p2 - _p1) - 1);
 
             char *_p3 = strchr(_p2 + 1, ' ');
-            memcpy(port, _p2 + 2, (int)(_p3 - _p2) - 1);
+            strncpy(port, _p2 + 2, (int)(_p3 - _p2) - 1);
 
             return 0;
         }
@@ -164,108 +185,86 @@ int extract_host(char *header, char *host, char *port)
         } else {                // 如果_p2等于空就返回-1
             return -1;
         }
-
         return 0;
     } else {
 
-        char *_p = strstr(header, "Host:");
+        char *p = strstr(header, "Host:");
-        if (_p == NULL) {
+        if (!p) {
-            _p = strstr(header, "host:");
+            return -1;
         }
-        if (_p == NULL) {       // 都为空时
+        char *p1 = strchr(p, '\n');
+        if (!p1) {
             return -1;
         }
 
-        char *_p1 = strchr(_p, '\n'); // 指向末尾'\n'
+        char *p2 = strchr(p + 5, ':');          // 5是指'Host:'的长度
-        if (!_p1) {
-            return -1;
-        }
 
-        char *_p2 = strchr(_p + 5, ':'); // 5是指'Host:'的长度
+        int h_len = (int)(p1 - p - 6);
-        int h_len = (int)(_p1 - _p - 6);
         char s_host[h_len];
-        memcpy(s_host, _p + 6, _p1 - _p - 6);
+        strncpy(s_host, p + 6, p1 - p - 6);
         s_host[h_len] = '\0';
+        char *p3 = strchr(s_host, ':');
+        char *p4 = NULL;
+        if (p3)
+            p4 = strchr(p3 + 1, ':');
 
-        char *_p3 = strchr(s_host, ':');
+        if (p4 != NULL) {                       // IPV6
-        char *_p4 = NULL;
+            char *p5 = NULL;
-        if (_p3)
+            char *p6 = NULL;
-            _p4 = strchr(_p3 + 1, ':'); // 二次确认':'
+            p5 = strchr(header, ' ');
-        {                       // IPV6
+            if (p5)
-            if (_p4 != NULL) {
+                p6 = strchr(p5 + 1, ' ');
-                char *_p5 = NULL;
-                char *_p6 = NULL;
-                _p5 = strchr(header, ' ');
-                if (_p5)
-                    _p6 = strchr(_p5 + 1, ' ');
 
-                char url[_p6 - _p5 - 1];
+            char url[p6 - p5 - 1];
-                memset(url, 0, _p6 - _p5 - 1);
+            memset(url, 0, p6 - p5 - 1);
-                memcpy(url, _p5 + 1, _p6 - _p5 - 1);
+            strncpy(url, p5 + 1, p6 - p5 - 1);
-                url[_p6 - _p5 - 1] = '\0';
+            url[p6 - p5 - 1] = '\0';
             
-                if (strstr(url, "http") != NULL) { // 去除 'http://'
+            if (strstr(url, "http") != NULL) {          // 去除 'http://'
-                    memcpy(url, url + 7, (_p6 - _p5 - 1) - 7);
+                memcpy(url, url + 7, strlen(url) - 7);
-                    url[(_p6 - _p5 - 1) - 7] = '\0';
+                url[strlen(url) - 7] = '\0';
-                    char *_p7 = strchr(url, '/');
+                char *p7 = strchr(url, '/');
-                    if (_p7)    // 去除 uri
+                if (p7)                                 // 去除 uri
-                        url[_p7 - url] = '\0';
+                    url[p7 - url] = '\0';
                 
-                    char *_p8 = strchr(url, ']');
+                char *p8 = strchr(url, ']');
-                    char *_p9 = strchr(url, '\0');
+                if (p8) {
-                    if (_p8) {
+                    strcpy(port, p8 + 2);
-                        if ((_p9 - _p8) == 1) { // 如果不带端口就默认80, 并结束
+                    strncpy(host, url + 1, strlen(url) - strlen(p8) - 1);
-                            memcpy(port, "80", 2);
-                            memcpy(host, url + 1, _p8 - (url + 1));
-                            return 0;
-                        }
 
-                        memcpy(port, _p8 + 2, _p9 - (_p8 + 2));
+                    if (strlen(p8) < 3) {
-                        memcpy(host, url + 1, _p8 - (url + 1));
+                        strcpy(port, "80");
+                        strncpy(host, url + 1, strlen(url) - strlen(p8) - 1);
                     }
-                    return 0;
-                } else {        // HTTP头为不规范的url时处理Host, 主要Proxifier转发url为'/'时
-                    //printf("s_host: %s\n", s_host);
-                    char *_p1 = strchr(s_host, '[');
-                    if (_p1 == NULL) // 涉及到自定义的Host, 不带'['、']'时, 默认截取最后为端口
-                    {
-                        char *_p2 = strrchr(s_host, ':');
-                        remote_port = atoi(_p2 + 1);
-                        memcpy(remote_host, s_host, _p2 - s_host);
-                        return 0;
-                    }
-
-                    char *_p2 = strchr(_p1 + 1, ']');
-                    char *_p3 = strchr(s_host, '\0');
-                    if (_p1 && _p2) {
-                        memcpy(host, _p1 + 1, _p2 - _p1 - 1);
-                        if ((_p3-(_p2+1)) < 2) {
-                            memcpy(port, "80", 2);
-                        } else {
-                            memcpy(port, _p2 + 2, _p3 - (_p2 + 2));
-                        }
-
-                    }
-                    return 0;
                 }
+                return 0;
+            } else {                                   // HTTP头为不规范的url时处理Host, 主要Proxifier转发url为'/'时
+                //printf("s_host: %s\n", s_host);
+                char *_p1 = strchr(s_host, '[');
+                char *_p2 = strchr(_p1+1, ']');
+                if (_p1 && _p2) {
+                    memcpy(host, _p1+1, _p2 - _p1 -1);
+                    if (strlen(_p2) < 3) {
+                        strcpy(port, "80");
+                    } else {
+                        strcpy(port, _p2+2);
+                    }
                     
-                return -1;
+                }
+                return 0;
             }
+            
+            
+
+            return -1;
         }
-        // HTTP 非 CONNECT 方法
+
-        {
+        if (p2 && p2 < p1) {
-            if (_p2 && _p2 < _p1) { // 带端口, p2指向':', p1指向末尾'\n', _p指向Host
+            memcpy(port, p2 + 1, (int)(p1 - p2 - 1));
-                memcpy(port, _p2 + 1, (int)(_p1 - _p2 - 1));
+            memcpy(host, p + 5 + 1, (int)(p2 - p - 5 - 1));
-                memcpy(host, _p + 5 + 1, (int)(_p2 - _p - 5 - 1));
+        } else {
-            } else {            // 不带端口
+            memcpy(host, p + 5 + 1, (int)(p1 - p - 5 - 1 - 1));
-                if (0 < (int)(_p1 - _p - 5 - 1 - 1)) {
+            memcpy(port, "80", 2);
-                    memcpy(host, _p + 5 + 1, (_p1 - _p - 5 - 1 - 1));
-                    memcpy(port, "80", 2);
-                } else {
-                    memcpy(host, _p + 5 + 1, (_p1 - _p) - 6);
-                    memcpy(port, "80", 2);
-                }
-            }
         }
 
         return 0;
@@ -274,82 +273,29 @@ int extract_host(char *header, char *host, char *port)
     return 0;
 }
 
-char *get_http_path(char *url, int url_len, char *path)
+char *get_http_path(char *url, char *path)
 {
-    char *_p0, *_p1;
+    char *_p0;
-    _p0 = _p1 = NULL;
+    _p0 = NULL;
-
+    if (url) {
-    _p1 = strchr(url, '\0');
+        _p0 = strstr(url + 7, "/");
-
+        if (_p0)
-    if (url_len > 7) {
+            return memcpy(path, _p0, (int)strlen(_p0));
-        if (url) {
+        else
-            _p0 = strstr(url + 7, "/");
+            memcpy(path, "/", 1);               // 如果没有资源路径就默认"/"
-            if (_p0)
-                return memcpy(path, _p0, _p1 - _p0);
-            else
-                return memcpy(path, "/", 1); // 如果没有资源路径就默认"/"
-        }
-    } else {
-        return memcpy(path, "/", 1);
     }
 
     return NULL;
 }
 
-void get_http_host_port_len(char *head, int *host_len, int *port_len)
-{
-    *host_len = 0;
-    *port_len = 0;
-    char *_p1 = strstr(head, "Host"); // 判断Host行
-    if (_p1) {                  // 为真时
-        char *_p2 = strstr(_p1, "\n");
-        *host_len = (int)(_p2 - _p1);
-
-        char host[*host_len + 1];
-        memcpy(host, _p1, *host_len);
-        host[*host_len] = '\0';
-
-        char *_p3 = strrchr(host, ':');
-        char *_p4 = strchr(host, '\0');
-        if (_p3) {
-            *port_len = _p4 - (_p3 + 1);
-        } else {
-            *port_len = *host_len;
-        }
-    } else {                    // 为假时
-        char *_p1 = strstr(head, "host");
-        if (_p1) {
-            char *_p2 = strstr(_p1, "\n");
-            *host_len = (int)(_p2 - _p1);
-
-            char host[*host_len + 1];
-            memcpy(host, _p1, *host_len);
-            host[*host_len] = '\0';
-
-            char *_p3 = strrchr(host, ':');
-            char *_p4 = strchr(host, '\0');
-            if (_p3) {
-                *port_len = _p4 - (_p3 + 1);
-            } else {
-                *port_len = *host_len;
-            }
-        } else {                // 未找到时使用HTTP_HEAD_CACHE_SIZE大小
-            *host_len = HTTP_HEAD_HOST_CACHE_SIZE;
-            *port_len = HTTP_HEAD_HOST_CACHE_SIZE / 10;
-        }
-    }
-
-    return;
-}
-
 void free_http_request(struct http_request *http_request)
 {
-    if (http_request->method)
+    if (http_request->M)
-        free(http_request->method);
+        free(http_request->M);
     if (http_request->U)
         free(http_request->U);
-    if (http_request->version)
+    if (http_request->V)
-        free(http_request->version);
+        free(http_request->V);
     if (http_request->host)
         free(http_request->host);
     if (http_request->port)
@@ -362,304 +308,247 @@ void free_http_request(struct http_request *http_request)
         free(http_request->uri);
 }
 
+void get_http_host_port_len(char *head, int *host_len, int *port_len) {
+    *host_len = 0;
+    *port_len = 0;
+    char *_p1 = strstr(head, "Host");           // 判断Host行
+    if (_p1) {                                  // 为真时
+        char *_p2 = strstr(_p1, "\n");
+        *host_len = (int)(_p2 - _p1);
+        
+        char host[*host_len+1];
+        memcpy(host, _p1, *host_len);
+        host[*host_len] = '\0';
+        
+        char *_p3 = strrchr(host, ':');
+        if (_p3) {
+            *port_len = strlen(_p3+1);
+        } else {
+            *port_len = *host_len;
+        }
+    } else {                                    // 为假时
+        char *_p1 = strstr(head, "host");
+        if (_p1) {
+            char *_p2 = strstr(_p1, "\n");
+            *host_len = (int)(_p2 - _p1);
+            
+            char host[*host_len+1];
+            memcpy(host, _p1, *host_len);
+            host[*host_len] = '\0';
+            
+            char *_p3 = strrchr(host, ':');
+            if (_p3) {
+                *port_len = strlen(_p3+1);
+            } else {
+                *port_len = *host_len;
+            }
+        } else {                                // 未找到时使用HTTP_HEAD_CACHE_SIZE大小
+            *host_len = HTTP_HEAD_CACHE_SIZE;
+            *port_len = HTTP_HEAD_CACHE_SIZE;
+        }
+    }
+
+    return ;
+}
+
 void parse_request_head(char *http_request_line, struct http_request *http_request)
 {
-    char *p, *head, *m, *u;
+    char *p;
+    char *head;
     size_t head_len;
-    int host_len, port_len, uri_len;
+    char *m, *u;
-    host_len = port_len = uri_len = 0;
+    int host_len = 0;
+    int port_len = 0;
+    int uri_len = 0;
 
     p = strstr(http_request_line, "\r\n"); // 查找"\r\n"
     if (p == NULL) {
         return;
     }
 
-    head_len = p - http_request_line;
+    head_len = strlen(http_request_line) - strlen(p);
-    head = (char *)malloc(sizeof(char) * head_len + 1);
+    head = (char *)malloc(sizeof(char) * head_len * 2);
     if (head == NULL)
         free(head);
-    memset(head, 0, sizeof(char) * head_len + 1);
+    memset(head, 0, head_len * 2);
     memcpy(head, http_request_line, head_len);
 
-    http_request->method = (char *)malloc(sizeof(char) * 8);
+    http_request->M = (char *)malloc(sizeof(char) * 7);
-    http_request->U = (char *)malloc(sizeof(char) * head_len);
+    http_request->U = (char *)malloc(sizeof(char) * HTTP_HEAD_CACHE_SIZE);
-    http_request->version = (char *)malloc(10);
+    http_request->V = (char *)malloc(10);
-    if (http_request->method == NULL)
+    if (http_request->M == NULL) {
         perror("malloc");
-    if (http_request->U == NULL)
+    }
+    if (http_request->U == NULL) {
         perror("malloc");
-    if (http_request->version == NULL)
+    }
+    if (http_request->V == NULL) {
         perror("malloc");
-    memset(http_request->method, 0, 8);
+    }
-    memset(http_request->U, 0, sizeof(char) * head_len);
+    memset(http_request->M, 0, 7);
-    memset(http_request->version, 0, 10);
+    memset(http_request->U, 0, HTTP_HEAD_CACHE_SIZE);
+    memset(http_request->V, 0, 10);
 
     m = strchr(head, ' ');
-    http_request->method_len = m - head;
+    http_request->M_len = strlen(head) - strlen(m);
-    memmove(http_request->method, head, http_request->method_len);
+    //http_request->M_len = m - head;
-
+    memcpy(http_request->M, head, http_request->M_len);
     u = strchr(m + 1, ' ');
-    memmove(http_request->U, m + 1, u - (m + 1));
+    http_request->U_len = strlen(m + 1) - strlen(u);
-    http_request->U_len = u - (m + 1);
+    //http_request->U_len = u - m -1;
-
+    memcpy(http_request->U, m + 1, http_request->U_len);
-    memmove(http_request->version, u + 1, 8);
+    memcpy(http_request->V, u + 1, 8);
-    http_request->version_len = 8;
+    http_request->V_len = 8;
+    http_request->U_len = (int)strlen(http_request->U);
     
     // 获取Host、Port长度
     get_http_host_port_len(http_request_line, &host_len, &port_len);
     
     // URI LENGTH
     char *_p0 = strstr(http_request->U, "http://");
-    if (_p0) {                  // 标准头
+    if (_p0) {                                      // 标准头
         char *_p1 = strchr(http_request->U + 7, '/');
-        char *_p2 = strchr(http_request->U + 7, '\0');
         if (_p1) {
-            uri_len = _p2 - _p1;
+            uri_len = (int)strlen(_p1);
         }
-    } else {                    // 非标准头
+    } else {                                        // 非标准头
         char *_p1 = strchr(http_request->U, '/');
-        char *_p2 = strchr(http_request->U, '\0');
         if (_p1) {
-            uri_len = _p2 - _p1;
+            uri_len = (int)strlen(_p1);
         } else {
-            uri_len = 1;        // 没有uri时
+            uri_len = 1;                            // 没有uri时
         }
     }
 
-    http_request->host = (char *)malloc(sizeof(char) * host_len + 1);
+    http_request->host = (char *)malloc(sizeof(char) * host_len+1);
     if (http_request->host == NULL)
         perror("malloc");
-    http_request->port = (char *)malloc(sizeof(char) * port_len + 1);
+    http_request->port = (char *)malloc(sizeof(char) * port_len+1);
     if (http_request->port == NULL)
         perror("malloc");
-    http_request->url = (char *)malloc(sizeof(char) * http_request->U_len + 1);
+    http_request->url = (char *)malloc(sizeof(char) * http_request->U_len+1);
     if (http_request->url == NULL)
         perror("malloc");
-    http_request->uri = (char *)malloc(sizeof(char) * uri_len + 1);
+    http_request->uri = (char *)malloc(sizeof(char) * uri_len+1);
     if (http_request->uri == NULL)
         perror("malloc");
     http_request->H = (char *)malloc(sizeof(char) * host_len + port_len + 1);
     if (http_request->H == NULL)
         perror("malloc");
 
-    memset(http_request->host, 0, host_len + 1);
+    memset(http_request->host, 0, host_len+1);
-    memset(http_request->port, 0, port_len + 1);
+    memset(http_request->port, 0, port_len+1);
-    memset(http_request->url, 0, http_request->U_len + 1);
+    memset(http_request->url, 0, http_request->U_len+1);
-    memset(http_request->uri, 0, uri_len + 1);
+    memset(http_request->uri, 0, uri_len+1);
     memset(http_request->H, 0, host_len + port_len + 1);
+
     if (extract_host(http_request_line, http_request->host, http_request->port) == -1)
         return;
     http_request->host_len = (int)strlen(http_request->host);
     http_request->port_len = (int)strlen(http_request->port);
     memcpy(http_request->H, http_request->host, http_request->host_len);
-    strncat(http_request->H, ":", 2);
+    strcat(http_request->H, ":");
-    strncat(http_request->H, http_request->port, http_request->port_len);
+    strcat(http_request->H, http_request->port);
     memcpy(http_request->url, http_request->U, http_request->U_len);
-    http_request->url_len = http_request->U_len;
+    get_http_path(http_request->url, http_request->uri);
-    if (get_http_path(http_request->url, http_request->url_len, http_request->uri) == NULL)
-        return;
 
-    http_request->uri_len = uri_len;
+    http_request->U_len = (int)strlen(http_request->U);
-    http_request->H_len = http_request->host_len + http_request->port_len + 1;
+    http_request->url_len = (int)strlen(http_request->url);
-
+    http_request->uri_len = (int)strlen(http_request->uri);
-/* 
+    http_request->H_len = (int)strlen(http_request->H);
-   // 调试
-   printf("%s %d\n", http_request->method, http_request->method_len);
-   printf("%s %d\n", http_request->U, http_request->U_len);
-   printf("%s %d\n", http_request->version, http_request->version_len);
-   printf("%s %d\n", http_request->host, http_request->host_len);
-   printf("%s %d\n", http_request->port, http_request->port_len);
-   printf("%s %d\n", http_request->H, http_request->H_len);
-   printf("%s %d\n", http_request->url, http_request->url_len);
-   printf("%s %d\n", http_request->uri, http_request->uri_len);
-*/
 
     free(head);
     return;
 }
 
-static char *splice_head(char *head, int *head_len, const char *needle, char *string, int string_len)
-{
-    char *tail_head;
-    char *_p0;
-    char *_p1;
-
-    _p1 = strstr(head, needle);
-    if (_p1 == NULL) {
-        return head;
-    }
-    _p1 = _p1 + 1;
-    _p0 = strchr(_p1, '\0');
-
-    tail_head = (char *)alloca((_p0 - _p1) + 1);
-    if (tail_head == NULL) {
-        perror("alloca");
-        return head;
-    }
-    memset(tail_head, 0, (_p0 - _p1) + 1);
-    memcpy(tail_head, _p1, (_p0 - _p1));
-
-    memset(head, 0, *head_len);
-    memcpy(head, string, string_len);
-    strncat(head, tail_head, (_p0 - _p1));
-    *head_len = string_len + (_p0 - _p1);
-    return head;
-}
-
-static char *delete_head(char *head, int *head_len, const char *needle, int string)
-{
-    char *temp_stack;
-    char *_p1, *_p2, *_p3;
-    _p1 = _p2 = _p3 = NULL;
-    int temp_stack_len;
-
-    _p1 = strstr(head, needle); // _p1指向head字符串中的"needle"字符处(needle字符串的第一个字符)
-    if (_p1 == NULL) {
-        //perror("_p1 HEAD NULL");
-        return head;
-    }
-    _p2 = strchr(_p1, string);  // _p2指向head字符串中"string"字符到末尾中的'\0'
-    if (_p2 == NULL) {
-        //perror("_p2 HEAD NULL");
-        return head;
-    }
-    _p3 = strchr(_p1, '\0');    // _p3指向head字符串末尾的'\0'
-    if (_p3 == NULL) {
-        //perror("_p3 HEAD NULL");
-        return head;
-    }
-    temp_stack_len = (_p1 - head) + (_p3 - _p2);
-    temp_stack = (char *)alloca(temp_stack_len + 1); // 分配临时栈内存，长度是去除needle到string处
-    if (temp_stack == NULL) {
-        perror("alloca");
-        return head;
-    }
-    memset(temp_stack, 0, temp_stack_len + 1);
-    memmove(temp_stack, head, (_p1 - head) - 1);
-    strncat(temp_stack, _p2, _p3 - _p2);
-
-    memset(head, 0, *head_len);
-    *head_len = temp_stack_len;
-    return memmove(head, temp_stack, temp_stack_len);
-}
-
-static char *conf_handle_strrep(char *str, int *str_len, tcp * temp)
-{
-    tcp *p = temp;
-
-    while (p) {
-        if (p->strrep) {
-            str = replace(str, str_len, p->strrep_s, p->strrep_s_len, p->strrep_t, p->strrep_t_len);
-        }
-
-        p = p->next;
-    }
-
-    return str;
-}
-
-static char *conf_handle_regrep(char *str, int *str_len, tcp * temp)
-{
-    tcp *p = temp;
-
-    while (p) {
-        if (p->regrep) {
-            str = regrep(str, str_len, p->regrep_s, p->regrep_t, p->regrep_t_len);
-        }
-
-        p = p->next;
-    }
-
-    return str;
-}
-
 char *request_head(conn_t * in, conf * configure)
 {
-    char *result = NULL;
-    char *delim = ",";
-    char *saveptr = NULL;
-    char *incomplete_head = NULL;
-    int incomplete_head_len = 0;
-    int return_val = 0;
     struct http_request *http_request;
     http_request = (struct http_request *)malloc(sizeof(struct http_request));
     memset(http_request, 0, sizeof(struct http_request));
 
     parse_request_head(in->incomplete_data, http_request);
 
-    if ((return_val = strncmp(in->incomplete_data, "CONNECT", 7)) == 0) {
+    if (strncmp(in->incomplete_data, "CONNECT", 7) == 0) {
-        sslEncodeCode = configure->https_encode;
+        char *incomplete_head;
-
+        int incomplete_head_len;
-        char https_del_copy[configure->https_del_len + 1];
+        char https_del_copy[configure->https_del_len * 2];
+        char *result = NULL;
 
         memset(remote_host, 0, CACHE_SIZE);
-        if (configure->https_port > 0) {
+        if (configure->https_port > 0)
             remote_port = configure->https_port;
-        }
+        if (configure->https_ip != NULL)
-        if (configure->https_ip != NULL) {
+            strcpy(remote_host, configure->https_ip);
-            memcpy(remote_host, configure->https_ip, configure->https_ip_len);
-        }
-
         incomplete_head = (char *)malloc(sizeof(char) * (BUFFER_SIZE));
         if (incomplete_head == NULL) {
             free(incomplete_head);
             perror("malloc");
         }
         memset(incomplete_head, 0, sizeof(char) * (BUFFER_SIZE));
-        memmove(incomplete_head, in->incomplete_data, in->incomplete_data_len);
+        memcpy(incomplete_head, in->incomplete_data, strlen(in->incomplete_data));
-        memmove(https_del_copy, configure->https_del, configure->https_del_len + 1);
+        memcpy(https_del_copy, configure->https_del, configure->https_del_len);
 
-        result = strtok_r(https_del_copy, delim, &saveptr);
+        result = strtok(https_del_copy, ",");
         while (result != NULL) {
-            delete_head(incomplete_head, &in->incomplete_data_len, result, '\n');
+            delete_head(incomplete_head, result, '\n');
-            result = strtok_r(NULL, delim, &saveptr);
+            result = strtok(NULL, ",");
         }
-
+        splice_head(incomplete_head, "\n", configure->https_first);
-        splice_head(incomplete_head, &in->incomplete_data_len, "\n", configure->https_first, configure->https_first_len);
+        incomplete_head_len = strlen(incomplete_head);
-
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "\\r", 2, "\r", 1);
-        incomplete_head_len = in->incomplete_data_len; // 更新HTTPS HEADER长度
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "\\n", 2, "\n", 1);
-        incomplete_head = conf_handle_strrep(incomplete_head, &incomplete_head_len, https_head_strrep);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "\\b", 2, "\b", 1);
-        incomplete_head = conf_handle_regrep(incomplete_head, &incomplete_head_len, https_head_regrep);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "\\v", 2, "\v", 1);
-
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "\\f", 2, "\f", 1);
-        incomplete_head = replace(incomplete_head, &incomplete_head_len, "[M]", 3, http_request->method, http_request->method_len);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "\\a", 2, "\a", 1);
-        incomplete_head = replace(incomplete_head, &incomplete_head_len, "[method]", 8, http_request->method, http_request->method_len);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "\\t", 2, "\t", 1);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "\\r", 2, "\r", 1);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "\\n", 2, "\n", 1);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "[M]", 3, http_request->M, http_request->M_len);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "[method]", 8, http_request->M, http_request->M_len);
         incomplete_head = replace(incomplete_head, &incomplete_head_len, "[U]", 3, http_request->U, http_request->U_len);
-        incomplete_head = replace(incomplete_head, &incomplete_head_len, "[V]", 3, http_request->version, http_request->version_len);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "[V]", 3, http_request->V, http_request->V_len);
-        incomplete_head = replace(incomplete_head, &incomplete_head_len, "[version]", 9, http_request->version, http_request->version_len);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "[version]", 9, http_request->V, http_request->V_len);
         incomplete_head = replace(incomplete_head, &incomplete_head_len, "[host]", 6, http_request->host, http_request->host_len);
         incomplete_head = replace(incomplete_head, &incomplete_head_len, "[port]", 6, http_request->port, http_request->port_len);
         incomplete_head = replace(incomplete_head, &incomplete_head_len, "[H]", 3, http_request->H, http_request->H_len);
+        if (configure->https_strrep)
+            incomplete_head = replace(incomplete_head, &incomplete_head_len, configure->https_strrep_aim, configure->https_strrep_aim_len, configure->https_strrep_obj, configure->https_strrep_obj_len);
+        if (configure->https_regrep)
+            incomplete_head = regrep(incomplete_head, &incomplete_head_len, configure->https_regrep_aim, configure->https_regrep_obj, configure->https_regrep_obj_len);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "[H]", 3, http_request->H, http_request->H_len);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "[host]", 6, http_request->host, http_request->host_len);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "[port]", 6, http_request->port, http_request->port_len);
+        incomplete_head_len = strlen(incomplete_head);      // 更新HTTPS HEADER长度
+        //printf("%s", incomplete_head);                      // 打印HTTPS HEADER
 
-        printf("%s", incomplete_head); // 打印HTTPS HEADER
 
         char *new_incomplete_data;
-        new_incomplete_data = (char *)realloc(in->incomplete_data, incomplete_head_len + 1);
+        new_incomplete_data = (char *)realloc(in->incomplete_data, incomplete_head_len + 1);        // 更新incomplete_data堆内存
-        if (new_incomplete_data == NULL) {
+        if (new_incomplete_data == NULL)    {
-            free(in->incomplete_data);
             perror("realloc");
-            return in->incomplete_data;
+            return NULL;
         }
         in->incomplete_data = new_incomplete_data;
-        memset(in->incomplete_data, 0, incomplete_head_len + 1);                // 清空incomplete_data数据
+        memset(in->incomplete_data, 0, incomplete_head_len + 1);                                    // 清空incomplete_data数据
-        memmove(in->incomplete_data, incomplete_head, incomplete_head_len);     // 更新incomplete_data数据
+        strcpy(in->incomplete_data, incomplete_head);                                               // 更新incomplete_data数据
-        in->incomplete_data_len = incomplete_head_len;                          // 更新incomplete_data长度
+        in->incomplete_data_len = strlen(in->incomplete_data);                                      // 更新incomplete_data长度
+        free(incomplete_head);                                                                      // 释放incomplete_head内存
 
-        free(incomplete_head);                                                  // 释放incomplete_head内存
     }
     
-    if (strncmp(in->incomplete_data, "GET", 3) == 0 || strncmp(in->incomplete_data, "POST", 4) == 0) {
+    if (strncmp(in->incomplete_data, "GET", 3) == 0 || strncmp(in->incomplete_data, "POST", 4) == 0)    {
-        sslEncodeCode = configure->http_encode;
+        char *incomplete_head;
-
+        int incomplete_head_len;
-        char http_del_copy[configure->http_del_len + 1];
+        char http_del_copy[configure->http_del_len];
+        char *result = NULL;
 
         memset(remote_host, 0, CACHE_SIZE);
-        if (configure->http_port > 0) {
+        if (configure->http_port > 0)
             remote_port = configure->http_port;
-        }
+        if (configure->http_ip != NULL)
-        if (configure->http_ip != NULL) {
+            strcpy(remote_host, configure->http_ip);
-            memcpy(remote_host, configure->http_ip, configure->http_ip_len);
-        }
-
         incomplete_head = (char *)malloc(sizeof(char) * (BUFFER_SIZE));
         if (incomplete_head == NULL) {
             perror("malloc");
@@ -667,46 +556,57 @@ char *request_head(conn_t * in, conf * configure)
         }
 
         memset(incomplete_head, 0, sizeof(char) * (BUFFER_SIZE));
-        memmove(incomplete_head, in->incomplete_data, in->incomplete_data_len);
+        memcpy(incomplete_head, in->incomplete_data, strlen(in->incomplete_data));
-        memmove(http_del_copy, configure->http_del, configure->http_del_len + 1);
+        memcpy(http_del_copy, configure->http_del, configure->http_del_len);
 
-        result = strtok_r(http_del_copy, delim, &saveptr);
+        result = strtok(http_del_copy, ",");
         while (result != NULL) {
-            delete_head(incomplete_head, &in->incomplete_data_len, result, '\n');
+            delete_head(incomplete_head, result, '\n');
-            result = strtok_r(NULL, delim, &saveptr);
+            result = strtok(NULL, ",");
         }
-
+        splice_head(incomplete_head, "\n", configure->http_first);
-        splice_head(incomplete_head, &in->incomplete_data_len, "\n", configure->http_first, configure->http_first_len);
+        incomplete_head_len = strlen(incomplete_head);
-        incomplete_head_len = in->incomplete_data_len; // 更新HTTP HEADER长度
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "\\r", 2, "\r", 1);
-        incomplete_head = conf_handle_strrep(incomplete_head, &incomplete_head_len, http_head_strrep);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "\\n", 2, "\n", 1);
-        incomplete_head = conf_handle_regrep(incomplete_head, &incomplete_head_len, http_head_regrep);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "\\b", 2, "\b", 1);
-
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "\\v", 2, "\v", 1);
-        incomplete_head = replace(incomplete_head, &incomplete_head_len, "[M]", 3, http_request->method, http_request->method_len);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "\\f", 2, "\f", 1);
-        incomplete_head = replace(incomplete_head, &incomplete_head_len, "[method]", 8, http_request->method, http_request->method_len);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "\\a", 2, "\a", 1);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "\\t", 2, "\t", 1);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "\\r", 2, "\r", 1);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "\\n", 2, "\n", 1);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "[M]", 3, http_request->M, http_request->M_len);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "[method]", 8, http_request->M, http_request->M_len);
         incomplete_head = replace(incomplete_head, &incomplete_head_len, "[U]", 3, http_request->U, http_request->U_len);
-        incomplete_head = replace(incomplete_head, &incomplete_head_len, "[V]", 3, http_request->version, http_request->version_len);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "[V]", 3, http_request->V, http_request->V_len);
-        incomplete_head = replace(incomplete_head, &incomplete_head_len, "[version]", 9, http_request->version, http_request->version_len);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "[version]", 9, http_request->V, http_request->V_len);
         incomplete_head = replace(incomplete_head, &incomplete_head_len, "[url]", 5, http_request->url, http_request->url_len);
         incomplete_head = replace(incomplete_head, &incomplete_head_len, "[uri]", 5, http_request->uri, http_request->uri_len);
         incomplete_head = replace(incomplete_head, &incomplete_head_len, "[host]", 6, http_request->host, http_request->host_len);
         incomplete_head = replace(incomplete_head, &incomplete_head_len, "[port]", 6, http_request->port, http_request->port_len);
         incomplete_head = replace(incomplete_head, &incomplete_head_len, "[H]", 3, http_request->H, http_request->H_len);
+        if (configure->http_strrep)
+            incomplete_head = replace(incomplete_head, &incomplete_head_len, configure->http_strrep_aim, configure->http_strrep_aim_len, configure->http_strrep_obj, configure->http_strrep_obj_len);
+        if (configure->http_regrep)
+            incomplete_head = regrep(incomplete_head, &incomplete_head_len, configure->http_regrep_aim, configure->http_regrep_obj, configure->http_regrep_obj_len);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "[host]", 6, http_request->host, http_request->host_len);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "[port]", 6, http_request->port, http_request->port_len);
+        incomplete_head = replace(incomplete_head, &incomplete_head_len, "[H]", 3, http_request->H, http_request->H_len);
+        incomplete_head_len = strlen(incomplete_head);      // 更新HTTP HEADER长度
+        //printf("%s", incomplete_head);                      // 打印HTTP HEADER
 
-        printf("%s", incomplete_head); // 打印HTTP HEADER
 
         char *new_incomplete_data;
-        new_incomplete_data = (char *)realloc(in->incomplete_data, incomplete_head_len + 1);
+        new_incomplete_data = (char *)realloc(in->incomplete_data, incomplete_head_len + 1);        // 更新incomplete_data堆内存
-        if (new_incomplete_data == NULL) {
+        if (new_incomplete_data == NULL)    {
-            free(in->incomplete_data);
             perror("realloc");
-            return in->incomplete_data;
+            return NULL;
         }
         in->incomplete_data = new_incomplete_data;
-        memset(in->incomplete_data, 0, incomplete_head_len + 1);                // 清空incomplete_data数据
+        memset(in->incomplete_data, 0, incomplete_head_len + 1);                                    // 清空incomplete_data数据
-        memmove(in->incomplete_data, incomplete_head, incomplete_head_len);     // 更新incomplete_data数据
+        memmove(in->incomplete_data, incomplete_head, incomplete_head_len + 1);                     // 更新incomplete_data数据
-        in->incomplete_data_len = incomplete_head_len;                          // 更新incomplete_data长度
+        in->incomplete_data_len = strlen(in->incomplete_data);                                      // 更新incomplete_data长度
-
+        free(incomplete_head);                                                                      // 释放incomplete_head内存
-        free(incomplete_head);                                                  // 释放incomplete_head内存
     }
 
     free_http_request(http_request);

http_request.h

@@ -8,22 +8,18 @@
 #include "http_proxy.h"
 #include "conf.h"
 
-#define HTTP_HEAD_HOST_CACHE_SIZE 1024
-
 struct http_request {
-    char *method, *U, *version;
+    char *M, *U, *V;
     char *host, *port, *H;
     char *url, *uri;
 
-    int method_len, U_len, version_len;
+    int M_len, U_len, V_len;
     int host_len, port_len, H_len;
     int url_len, uri_len;
 };
 
 void *memmem(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen);
-extern char *replace(char *replace_memory, int *replace_memory_len, const char *src, const int src_len, const char *dest, const int dest_len);
+char *replace(char *replace_memory, int *replace_memory_len, const char *src, const int src_len, const char *dest, const int dest_len);
 char *request_head(conn_t * in, conf * configure);
-extern int8_t copy_new_mem(char *src, int src_len, char **dest);
-extern void errors(const char *msg);
 
 #endif

httpdns.c

@@ -1,184 +1,130 @@
-#include <sys/wait.h>
-#include <sys/stat.h>
 #include "httpdns.h"
 #include "http_request.h"
 
-#define DNS_MAX_CONCURRENT 512
+char http_rsp[HTTP_RSP_SIZE + 1];
-#define DNS_REQUEST_MAX_SIZE 512+2 //2是TCPDNS头部用于指定dns的长度
+struct sockaddr_in dst_addr;
-#define HTTP_RSP_SIZE 2048
+char *host_value;
-/*
+int dnsListenFd = -1, dns_efd;
-    缓存结构: (dns查询请求长度-2)(2字节) + dns原查询请求(删除2字节的dnsID) + dns回应长度(2字节) + dns回应
+unsigned int host_value_len;
-*/
+static int8_t encodeCode = 0;
-struct dns_cache {
-    char *dns_cache;
-    struct dns_cache *next;
-};
-typedef struct dns_connection {
-    char dns_req[DNS_REQUEST_MAX_SIZE + 1];
-    struct sockaddr_in src_addr;
-    char *out_request;
-    char *host;
-    int out_request_len, fd, timer;
-    /*
-       sent_CONNECT_len:
-       在使用SSL代理的情况下，与httpDNS的CONNECT请求长度对比
-       小于表示需要发送CONNECT请求，并且还没有发送完成
-       等于表示已经完成CONNECT连接
-       大于表示已发送完成CONNECT连接，但是没有读取CONNECT的回应包
-     */
-    int sent_CONNECT_len;
-    uint16_t dns_req_len;
-    char query_type;
-    unsigned host_len:7;
-} dns_t;
-
-static dns_t dns_list[DNS_MAX_CONCURRENT];
-static struct epoll_event dns_evs[DNS_MAX_CONCURRENT + 1], dns_ev;
-struct httpdns httpdns;
-static int dns_efd;
 /* 缓存变量 */
 FILE *cfp = NULL;
-static struct dns_cache *cache = NULL;
+char *cachePath = NULL;
-static int cache_using;
+struct dns_cache *cache, *cache_temp;
-//子进程先写入缓存，再到父进程写入，否则可能导致缓存文件错乱
+socklen_t addr_len = sizeof(dst_addr);
-pid_t child_pid = 0;
+unsigned int cache_using, cacheLimit;
+dns_t dns_list[DNS_MAX_CONNECTION];
+struct epoll_event evs[DNS_MAX_CONNECTION + 1], event;
 
-/* 读取缓存文件 */
+int read_cache_file()
-int8_t read_cache_file()
 {
-    char *buff, *cache_ptr;
+    char *buff, *answer, *question;
-    struct dns_cache *cache_temp;
     long file_size;
-    int len, fl = 0;
+    int fn;
 
-    cache_temp = NULL;
+    fn = 0;
+    cache = cache_temp = NULL;
     cache_using = 0;
-    if ((cfp = fopen(httpdns.cachePath, "r+")) == NULL) {
+    if ((cfp = fopen(cachePath, "rb+")) == NULL) {
-        //创建文件并设置权限
+        //保持文件打开状态，防止切换uid后权限不足导致无法写入文件
-        if ((cfp = fopen(httpdns.cachePath, "w")) != NULL) {
+        cfp = fopen(cachePath, "wb");
-            chmod(httpdns.cachePath, S_IWOTH | S_IROTH | S_IWGRP | S_IRGRP | S_IWUSR | S_IRUSR);
+        return cfp == NULL ? 1 : 0;
-            fclose(cfp);
-            return 0;
-        }
-        return 1;
     }
-
     //读取文件内容
     fseek(cfp, 0, SEEK_END);
     file_size = ftell(cfp);
-    if ((buff = (char *)alloca(file_size)) == NULL)
+    if ((buff = (char *)alloca(file_size)) == NULL) {
+        fclose(cfp);
         return 1;
+    }
     rewind(cfp);
-    if ((fl = fread(buff, file_size, 1, cfp)) != 1) ;
+    if ((fn = fread(buff, file_size, 1, cfp)) < 0) {
-    fclose(cfp);
+        perror("fread");
+    }
 
-    for (cache_ptr = buff; cache_ptr - buff < file_size; cache_ptr += len) {
+    //读取缓存，一组缓存的内容为[ipDomain\0]，其中ip占5字节
-        cache_temp = (struct dns_cache *)malloc(sizeof(struct dns_cache));
+    for (answer = buff; answer - buff < file_size; answer = question + cache->question_len + 2) {
+        cache_temp = (struct dns_cache *)malloc(sizeof(*cache));
         if (cache_temp == NULL)
             return 1;
         cache_temp->next = cache;
         cache = cache_temp;
         cache_using++;
-        len = *(uint16_t *) cache_ptr + *(uint16_t *) (cache_ptr + *(uint16_t *) cache_ptr + 2) + 4;
+        cache->answer = strndup(answer, 5);
-        copy_new_mem(cache_ptr, len, &cache->dns_cache);
+        question = answer + 5;
-        if (cache->dns_cache == NULL)
+        cache->question = strdup(question);
+        if (cache->question == NULL || cache->answer == NULL)
             return 1;
+        cache->question_len = strlen(question) - 1;
     }
     /* 删除重复记录 */
     struct dns_cache *before, *after;
     for (; cache_temp; cache_temp = cache_temp->next) {
         for (before = cache_temp; before && (after = before->next) != NULL; before = before->next) {
-            if (*(uint16_t *) after->dns_cache == *(uint16_t *) cache_temp->dns_cache && memcmp(after->dns_cache + 2, cache_temp->dns_cache + 2, *(uint16_t *) after->dns_cache) == 0) {
+            if (strcmp(after->question, cache_temp->question) == 0) {
                 before->next = after->next;
-                free(after->dns_cache);
+                free(after->question);
+                free(after->answer);
                 free(after);
                 cache_using--;
             }
         }
     }
 
-    chmod(httpdns.cachePath, S_IWOTH | S_IROTH | S_IWGRP | S_IRGRP | S_IWUSR | S_IRUSR);
+    fclose(cfp);
+    cfp = fopen(cachePath, "wb");
     return 0;
 }
 
-/* 程序结束时将缓存写入文件 */
+void write_dns_cache()
-static void write_dns_cache(int sig)
 {
-    //子进程先写入缓存
-    if (child_pid) {
-        wait(NULL);
-        cfp = fopen(httpdns.cachePath, "a");
-    } else {
-        cfp = fopen(httpdns.cachePath, "w");
-    }
     while (cache) {
-        fwrite(cache->dns_cache, *(uint16_t *) cache->dns_cache + *(uint16_t *) (cache->dns_cache + *(uint16_t *) cache->dns_cache + 2) + 4, 1, cfp);
+        fputs(cache->answer, cfp);
+        fputs(cache->question, cfp);
+        fputc('\0', cfp);
         cache = cache->next;
     }
 
     exit(0);
 }
 
-static void dnsProxyStop(dns_t * dns)
+char *cache_lookup(char *question, dns_t * dns)
-{
-    epoll_ctl(dns_efd, EPOLL_CTL_DEL, dns->fd, NULL);
-    close(dns->fd);
-    if (httpdns.tcpDNS_mode == 0)
-        free(dns->out_request);
-    memset(((char *)dns) + DNS_REQUEST_MAX_SIZE + sizeof(struct sockaddr_in), 0, sizeof(dns_t) - DNS_REQUEST_MAX_SIZE + -sizeof(struct sockaddr_in));
-    dns->fd = -1;
-}
-
-/* 查询缓存 */
-static uint8_t cache_lookup(dns_t * dns)
 {
     struct dns_cache *c;
-    char *rsp;
 
     for (c = cache; c; c = c->next) {
-        //不匹配dnsID
+        if (strcmp(c->question, question) == 0) {
-        if (dns->dns_req_len - 2 == *(uint16_t *) c->dns_cache && memcmp(dns->dns_req + 2, c->dns_cache + 2, dns->dns_req_len - 2) == 0) {
+            dns->host_len = c->question_len;
-            rsp = c->dns_cache + *(uint16_t *) c->dns_cache + 2;
+            dns->query_type = 1;
-            *(uint16_t *) (rsp + 2) = *(uint16_t *) dns->dns_req; //设置dns id
+            return c->answer;
-            sendto(global.dns_listen_fd, rsp + 2, *(uint16_t *) rsp, 0, (struct sockaddr *)&dns->src_addr, sizeof(struct sockaddr_in));
-            return 0;
         }
     }
 
-    return 1;
+    return NULL;
 }
 
-/* 记录缓存 */
+void cache_record(dns_t * dns)
-static void cache_record(char *request, uint16_t request_len, char *response, uint16_t response_len)
 {
-    struct dns_cache *cache_temp;
+    cache_temp = (struct dns_cache *)malloc(sizeof(*cache));
-
-    cache_temp = (struct dns_cache *)malloc(sizeof(struct dns_cache));
     if (cache_temp == NULL)
         return;
-    cache_temp->dns_cache = (char *)malloc(request_len + response_len + 2);
+    cache_temp->question = strdup(dns->dns_req + 12);
-    if (cache_temp->dns_cache == NULL) {
+    if (cache_temp->question == NULL) {
         free(cache_temp);
         return;
     }
     cache_temp->next = cache;
     cache = cache_temp;
-    //不缓存dnsid
+    cache->question_len = dns->host_len;
-    request += 2;
+    cache->answer = dns->reply;
-    request_len -= 2;
+    if (cacheLimit) {
-    memcpy(cache_temp->dns_cache, &request_len, 2);
-    memcpy(cache_temp->dns_cache + 2, request, request_len);
-    memcpy(cache_temp->dns_cache + request_len + 2, &response_len, 2);
-    memcpy(cache_temp->dns_cache + request_len + 4, response, response_len);
-    if (httpdns.cacheLimit) {
         //到达缓存记录条目限制则释放前一半缓存
-        if (cache_using >= httpdns.cacheLimit) {
+        if (cache_using >= cacheLimit) {
             struct dns_cache *free_c;
             int i;
-            for (i = cache_using = httpdns.cacheLimit >> 1; i--; cache_temp = cache_temp->next) ;
+            for (i = cache_using = cacheLimit >> 1; i--; cache_temp = cache_temp->next) ;
             for (free_c = cache_temp->next, cache_temp->next = NULL; free_c; free_c = cache_temp) {
                 cache_temp = free_c->next;
-                free(free_c->dns_cache);
                 free(free_c);
             }
         }
@@ -186,69 +132,100 @@ static void cache_record(char *request, uint16_t request_len, char *response, ui
     }
 }
 
-/* 分析DNS请求 */
+int respond_client(dns_t * dns)
-static int8_t parse_dns_request(char *dns_req, dns_t * dns)
 {
-    int len;
+    int write_len = sendto(dnsListenFd, dns->dns_req, dns->dns_rsp_len, 0, (struct sockaddr *)&dns->src_addr, sizeof(struct sockaddr_in));
-
+    if (write_len == dns->dns_rsp_len) {
-    dns_req += 13;              //跳到域名部分
+        dns->query_type = 0;
-    dns->host_len = strlen(dns_req);
-    dns->query_type = *(dns_req + 2 + dns->host_len);
-    //tcpdns不需要解析域名
-    if (httpdns.tcpDNS_mode == 1)
         return 0;
-    //httpdns只支持域名查询ipv4
+    } else if (write_len == -1)
-    if (dns->query_type != 1 || (dns->host = strdup(dns_req)) == NULL)
+        return -1;
+    else {
+        dns->dns_rsp_len -= write_len;
+        memcpy(dns->dns_req, dns->dns_req + write_len, dns->dns_rsp_len);
         return 1;
-    for (len = *(--dns_req); dns_req[len + 1] != 0; len += dns_req[len]) {
-        //防止数组越界
-        if (len > dns->host_len) {
-            free(dns->host);
-            return 1;
-        }
-        dns->host[len++] = '.';
     }
-
-    return 0;
 }
 
-/* 回应dns客户端 */
+void respond_clients()
-static int8_t httpDNS_respond_client(dns_t * dns, char *rspIp)
 {
-    static char rsp[DNS_REQUEST_MAX_SIZE + 16];
+    int i;
-    char *p;
+    for (i = 0; i < DNS_MAX_CONNECTION; i++) {
-    int rsp_len;
+        if (dns_list[i].wait_response_client) {
+            if (respond_client(&dns_list[i]) == 1)
+                return;
+            else
+                dns_list[i].wait_response_client = 0;
+        }
+    }
+    event.events = EPOLLIN;
+    event.data.fd = dnsListenFd;
+    epoll_ctl(dns_efd, EPOLL_CTL_MOD, dnsListenFd, &event);
+}
 
-    //18: 查询资源的前(12字节)后(6字节)部分
+/* 分析DNS请求 */
-    rsp_len = 18 + dns->host_len + (rspIp ? 16 : 0);
+int parse_dns_request(char *dns_req, dns_t * dns)
-    //判断是否超出缓冲大小
+{
-    if (rsp_len > DNS_REQUEST_MAX_SIZE) {
+    dns_req += 13;              //跳到域名部分
-        dns->query_type = 0;
+    dns->host_len = strlen(dns_req);
+    //判断请求类型
+    switch ((dns->query_type = *(dns_req + 2 + dns->host_len))) {
+        //case 28:    //查询ipv6地址
+        //dns->query_type = 1; //httpDNS不支持查询ipv6，所以改成ipv4
+
+    case 1:                    //查询ipv4地址
+        dns->host = strdup(dns_req);
+        if (dns->host == NULL)
+            return 1;
+        int len;
+        for (len = *(--dns_req); dns_req[len + 1] != 0; len += dns_req[len]) {
+            //防止数组越界
+            if (len > dns->host_len) {
+                free(dns->host);
+                return 1;
+            }
+            dns->host[len++] = '.';
+        }
+        //printf("dns->host: %s\n", dns->host);
+        return 0;
+
+    default:
+        dns->host = NULL;
         return 1;
     }
-    /* dns ID */
+}
-    memcpy(rsp, dns->dns_req, 2);
+
+/* 建立DNS回应 */
+int build_dns_response(dns_t * dns)
+{
+    char *p;
+
+    //18: 查询资源的前(12字节)后(6字节)部分
+    dns->dns_rsp_len = 18 + dns->host_len + (dns->reply ? 16 : 0);
+    if (dns->dns_rsp_len > DATA_SIZE) {
+        dns->query_type = 0;
+        return 1;               //超出缓冲大小
+    }
     /* 问题数 */
-    rsp[4] = 0;
+    dns->dns_req[4] = 0;
-    rsp[5] = 1;
+    dns->dns_req[5] = 1;
     /* 资源记录数 */
-    rsp[6] = 0;
+    dns->dns_req[6] = 0;
-    rsp[7] = 0;
+    dns->dns_req[7] = 0;
     /* 授权资源记录数 */
-    rsp[8] = 0;
+    dns->dns_req[8] = 0;
-    rsp[9] = 0;
+    dns->dns_req[9] = 0;
     /* 额外资源记录数 */
-    rsp[10] = 0;
+    dns->dns_req[10] = 0;
-    rsp[11] = 0;
+    dns->dns_req[11] = 0;
-    memcpy(rsp + 12, dns->dns_req + 12, dns->host_len + 6);
     /* 如果有回应内容(资源记录) */
-    if (rspIp) {
+    if (dns->reply) {
-        p = rsp + 18 + dns->host_len;
+        p = dns->dns_req + 18 + dns->host_len;
         /* 资源记录数+1 */
-        rsp[7]++;
+        dns->dns_req[7]++;
         /* 成功标志 */
-        rsp[2] = (char)133;
+        dns->dns_req[2] = (char)133;
-        rsp[3] = (char)128;
+        dns->dns_req[3] = (char)128;
         /* 指向主机域名 */
         p[0] = (char)192;
         p[1] = 12;
@@ -265,341 +242,267 @@ static int8_t httpDNS_respond_client(dns_t * dns, char *rspIp)
         p[9] = 16;
         /* 回应长度 */
         p[10] = 0;
-        p[11] = 4;
+        p[11] = 4;              //reply中包含回应长度
-        memcpy(p + 12, rspIp, 4);
+        strcpy(p + 12, dns->reply);
     } else {
         /* 失败标志 */
-        rsp[2] = (char)129;
+        dns->dns_req[2] = (char)129;
-        rsp[3] = (char)130;
+        dns->dns_req[3] = (char)130;
+    }
+    if (respond_client(dns) == 1) {
+        dns->wait_response_client = 1;
+        event.events = EPOLLIN | EPOLLOUT;
+        event.data.fd = dnsListenFd;
+        epoll_ctl(dns_efd, EPOLL_CTL_MOD, dnsListenFd, &event);
     }
 
-    //因为UDP是无连接协议，所以不做返回值判断
-    sendto(global.dns_listen_fd, rsp, rsp_len, 0, (struct sockaddr *)&dns->src_addr, sizeof(struct sockaddr_in));
-    dns->query_type = 0;        //表示结构体空闲
-    if (cfp && rspIp)
-        cache_record(dns->dns_req, dns->dns_req_len, rsp, rsp_len);
     return 0;
 }
 
-void dns_timeout_check()
+void http_out(dns_t * out)
-{
-    int i;
-
-    for (i = 0; i < DNS_MAX_CONCURRENT; i++) {
-        if (dns_list[i].fd > -1) {
-            if (dns_list[i].timer >= global.timeout_m) {
-                dnsProxyStop(dns_list + i);
-            } else {
-                dns_list[i].timer++;
-            }
-        }
-    }
-}
-
-static void http_out(dns_t * out)
 {
     int write_len;
 
-    out->timer = 0;
+    //puts("writing");
-    if (httpdns.connect_request && out->sent_CONNECT_len < httpdns.connect_request_len) {
+    //printf("%s\n", out->http_request);
-        write_len = write(out->fd, httpdns.connect_request + out->sent_CONNECT_len, httpdns.connect_request_len - out->sent_CONNECT_len);
+    write_len = write(out->fd, out->http_request, out->http_request_len);
-        if (write_len == -1) {
+    if (write_len == out->http_request_len) {
-            dnsProxyStop(out);
+        //puts("write success");
-        } else {
+        free(out->http_request);
-            out->sent_CONNECT_len += write_len;
+        event.events = EPOLLIN | EPOLLET;
-            if (out->sent_CONNECT_len == httpdns.connect_request_len) {
+        event.data.ptr = out;
-                out->sent_CONNECT_len++; //表示已完全发送CONNECT请求，等待HTTP回应
+        epoll_ctl(dns_efd, EPOLL_CTL_MOD, out->fd, &event);
-                dns_ev.events = EPOLLIN | EPOLLET;
-                dns_ev.data.ptr = out;
-                epoll_ctl(dns_efd, EPOLL_CTL_MOD, out->fd, &dns_ev);
-            }
-        }
-        return;
-    }
-
-    write_len = write(out->fd, out->out_request, out->out_request_len);
-    if (write_len == out->out_request_len) {
-        dns_ev.events = EPOLLIN | EPOLLET;
-        dns_ev.data.ptr = out;
-        epoll_ctl(dns_efd, EPOLL_CTL_MOD, out->fd, &dns_ev);
     } else if (write_len > 0) {
-        out->out_request_len -= write_len;
+        //puts("write a little");
-        memmove(out->out_request, out->out_request + write_len, out->out_request_len);
+        out->http_request_len -= write_len;
+        memcpy(out->http_request, out->http_request + write_len, out->http_request_len);
     } else {
+        //puts("write error");
+        free(out->http_request);
         epoll_ctl(dns_efd, EPOLL_CTL_DEL, out->fd, NULL);
         close(out->fd);
         out->query_type = 0;
     }
 }
 
-static void handle_httpDNS_rsp(dns_t * dns, char *rsp, int rsp_len)
+void http_in(dns_t * in)
 {
-    char *ip_ptr, *p, ip[4];
+    char *ip_ptr, *p;
-    int i;
+    int len, i;
 
-    p = strstr(rsp, "\n\r");
-    if (p) {
-        p += 3;
-        rsp_len -= p - rsp;
-        //部分代理服务器使用长连接，第二次读取数据才读到域名的IP
-        if (rsp_len <= 0)
-            return;
-        rsp = p;
-    }
-    if (httpdns.encodeCode)
-        dataEncode(rsp, rsp_len, httpdns.encodeCode);
-    do {
-        if (*rsp == '\n')
-            rsp++;
-        /* 匹配IP */
-        while ((*rsp > 57 || *rsp < 49) && *rsp != '\0')
-            rsp++;
-        for (i = 0, ip_ptr = rsp, rsp = strchr(ip_ptr, '.');; ip_ptr = rsp + 1, rsp = strchr(ip_ptr, '.')) {
-            if (i < 3) {
-                if (rsp == NULL) {
-                    httpDNS_respond_client(dns, NULL);
-                    return;
-                }
-                //查找下一行
-                if (rsp - ip_ptr > 3)
-                    break;
-                ip[i++] = atoi(ip_ptr);
-            } else {
-                ip[3] = atoi(ip_ptr);
-                httpDNS_respond_client(dns, ip);
-                return;
-            }
-        }
-    } while ((rsp = strchr(rsp, '\n')) != NULL);
-}
-
-static void handle_tcpDNS_rsp(dns_t * dns, char *rsp, int rsp_len)
-{
-    /* 转换为UDPdns请求(为什么不做长度判断？因为懒) */
-    rsp += 2;
-    rsp_len -= 2;
-    //回应客户端
-    sendto(global.dns_listen_fd, rsp, rsp_len, 0, (struct sockaddr *)&dns->src_addr, sizeof(struct sockaddr_in));
-    if (cfp && (unsigned char)rsp[3] == 128) {
-        //如果使用编码，则需要还原dns请求
-        if (httpdns.httpsProxy_encodeCode)
-            dataEncode(dns->dns_req + 2 /* 换成TCPDNS请求时原本请求后移动了2字节 */ , dns->dns_req_len, httpdns.httpsProxy_encodeCode);
-        cache_record(dns->dns_req + 2, dns->dns_req_len, rsp, (uint16_t) rsp_len);
-    }
-}
-
-static void http_in(dns_t * in)
-{
-    static char http_rsp[HTTP_RSP_SIZE + 1];
-    int len;
-
-    in->timer = 0;
-    if (httpdns.connect_request && in->sent_CONNECT_len > httpdns.connect_request_len) {
-        in->sent_CONNECT_len--;
-        do {
-            len = read(in->fd, http_rsp, HTTP_RSP_SIZE);
-            //没有数据读取，CONNECT代理连接完成
-            if (len < 0 && errno == EAGAIN)
-                break;
-            if (len <= 0) {
-                dnsProxyStop(in);
-                return;
-            }
-        } while (len == HTTP_RSP_SIZE);
-        dns_ev.events = EPOLLIN | EPOLLOUT | EPOLLET;
-        dns_ev.data.ptr = in;
-        epoll_ctl(dns_efd, EPOLL_CTL_MOD, in->fd, &dns_ev);
-        return;
-    }
     len = read(in->fd, http_rsp, HTTP_RSP_SIZE);
     if (len <= 0) {
-        if (len == 0 || errno != EAGAIN)
+        in->query_type = 0;
-            dnsProxyStop(in);
+        epoll_ctl(dns_efd, EPOLL_CTL_DEL, in->fd, NULL);
+        close(in->fd);
         return;
     }
+    if (encodeCode)
+        dataEncode(http_rsp, len);
     http_rsp[len] = '\0';
-    if (httpdns.httpsProxy_encodeCode)
+    //printf("[%s]\n", http_rsp);
-        dataEncode(http_rsp, len, httpdns.httpsProxy_encodeCode);
+    p = strstr(http_rsp, "\n\r");
-    if (httpdns.tcpDNS_mode == 1) {
+    if (p) {
-        handle_tcpDNS_rsp(in, http_rsp, len);
+        //部分代理服务器使用长连接，第二次读取数据才读到域名的IP
-    } else {
+        if (p + 3 - http_rsp >= len)
-        handle_httpDNS_rsp(in, http_rsp, len);
+            return;
-    }
+        p += 3;
-    dnsProxyStop(in);
+    } else
+        p = http_rsp;
+    epoll_ctl(dns_efd, EPOLL_CTL_DEL, in->fd, NULL);
+    close(in->fd);
+    in->reply = (char *)malloc(5);
+    if (in->reply == NULL)
+        goto error;
+    do {
+        if (*p == '\n')
+            p++;
+        /* 匹配IP */
+        if (*p > 57 || *p < 49)
+            continue;
+        for (i = 0, ip_ptr = p, p = strchr(ip_ptr, '.');; ip_ptr = p + 1, p = strchr(ip_ptr, '.')) {
+            if (i < 3) {
+                if (p == NULL)
+                    goto error;
+                //查找下一行
+                if (p - ip_ptr > 3)
+                    break;
+                in->reply[i++] = atoi(ip_ptr);
+            } else {
+                in->reply[3] = atoi(ip_ptr);
+                in->reply[4] = 0;
+                build_dns_response(in);
+                cfp ? cache_record(in) : free(in->reply);
+                return;
+            }
+        }
+    } while ((p = strchr(p, '\n')) != NULL);
+
+error:
+    free(in->reply);
+    in->reply = NULL;
+    if (build_dns_response(in) == 1)
+        in->query_type = 0;
 }
 
-static int8_t create_outRequest(dns_t * dns)
+void new_client(conf * configure)
-{
-    if (parse_dns_request(dns->dns_req, dns) != 0) {
-        dns->out_request = NULL;
-        return 1;
-    }
-    if (httpdns.tcpDNS_mode == 1) {
-        memmove(dns->dns_req + 2, dns->dns_req, dns->dns_req_len);
-        dns->dns_req[0] = *((char *)(&dns->dns_req_len) + 1);
-        dns->dns_req[1] = *((char *)&dns->dns_req_len);
-        dns->out_request = dns->dns_req;
-        dns->out_request_len = dns->dns_req_len + 2;
-        dns->host = NULL;
-        /*
-           //调试用
-           int i;
-           printf("(");
-           for (i=0;i<dns->out_request_len;i++)
-           printf("%u ", dns->out_request[i]);
-           puts(")");
-         */
-    } else {
-        if (httpdns.encodeCode)
-            dataEncode(dns->host, dns->host_len, httpdns.encodeCode);
-        dns->out_request_len = httpdns.http_req_len;
-        copy_new_mem(httpdns.http_req, httpdns.http_req_len, &dns->out_request);
-        dns->out_request = replace(dns->out_request, &dns->out_request_len, "[D]", 3, dns->host, dns->host_len);
-        free(dns->host);
-        if (dns->out_request == NULL)
-            return 1;
-    }
-    if (httpdns.httpsProxy_encodeCode)
-        dataEncode(dns->out_request, dns->out_request_len, httpdns.httpsProxy_encodeCode);
-    dns->sent_CONNECT_len = 0;
-
-    return 0;
-}
-
-/* 连接到dns服务器 */
-static int connectToDnsServer(dns_t * dns)
-{
-    dns->fd = socket(AF_INET, SOCK_STREAM, 0);
-    if (dns->fd < 0)
-        return 1;
-    dns->timer = 0;             //超时计时器设为0
-    fcntl(dns->fd, F_SETFL, O_NONBLOCK);
-    dns_ev.events = EPOLLERR | EPOLLOUT | EPOLLET;
-    dns_ev.data.ptr = dns;
-    if (epoll_ctl(dns_efd, EPOLL_CTL_ADD, dns->fd, &dns_ev) != 0) {
-        close(dns->fd);
-        return 1;
-    }
-    if (connect(dns->fd, (struct sockaddr *)&httpdns.dst, sizeof(httpdns.dst)) != 0 && errno != EINPROGRESS) {
-        epoll_ctl(dns_efd, EPOLL_CTL_DEL, dns->fd, NULL);
-        close(dns->fd);
-        return 1;
-    }
-
-    return 0;
-}
-
-static void new_client()
 {
     dns_t *dns;
-    socklen_t addr_len = sizeof(struct sockaddr_in);
     int i, len;
 
-    for (i = 0; i < DNS_MAX_CONCURRENT; i++) {
+    for (i = 0; i < DNS_MAX_CONNECTION; i++)
-        if (dns_list[i].query_type == 0) {
+        if (dns_list[i].query_type == 0)
-            dns = &dns_list[i];
             break;
-        }
+    if (i == DNS_MAX_CONNECTION)
-    }
-    if (i == DNS_MAX_CONCURRENT)
         return;
-    len = recvfrom(global.dns_listen_fd, dns->dns_req, DNS_REQUEST_MAX_SIZE - 2, 0, (struct sockaddr *)&dns->src_addr, &addr_len);
+    dns = &dns_list[i];
+    len = recvfrom(dnsListenFd, &dns->dns_req, DATA_SIZE, 0, (struct sockaddr *)&dns->src_addr, &addr_len);
+    //printf("addr: [%s:%d]\n", inet_ntoa(dns->src_addr.sin_addr), ntohs(dns->src_addr.sin_port));
     //dns请求必须大于18
     if (len <= 18)
         return;
-    dns->dns_req_len = (uint16_t) len;
     /* 查询缓存 */
-    if (cfp && cache_lookup(dns) == 0)
+    if (cachePath) {
-        return;
+        dns->reply = cache_lookup(dns->dns_req + 12, dns);
-    if (create_outRequest(dns) != 0 || connectToDnsServer(dns) != 0) {
+        if (dns->reply != NULL) {
-        if (dns->out_request != dns->dns_req)
+            if (build_dns_response(dns) != 0)
-            free(dns->out_request);
+                dns->query_type = 0;
-        httpDNS_respond_client(dns, NULL);
+            return;
-    }
-}
-
-static void httpRequest_init()
-{
-    char dest[22];
-    uint16_t port;
-
-    port = ntohs(httpdns.dst.sin_port);
-    sprintf(dest, "%s:%u", inet_ntoa(httpdns.dst.sin_addr), port);
-
-    //如果设置http_req = "";则不创建请求头
-    if (httpdns.http_req_len > 0) {
-        httpdns.http_req_len = strlen(httpdns.http_req);
-        httpdns.http_req_len += 2;
-        httpdns.http_req = (char *)realloc(httpdns.http_req, httpdns.http_req_len + 1);
-        if (httpdns.http_req == NULL)
-            printf("out of memory.\n");
-        strcat(httpdns.http_req, "\r\n");
-        httpdns.http_req = replace(httpdns.http_req, &httpdns.http_req_len, "[V]", 3, "HTTP/1.1", 8);
-        httpdns.http_req = replace(httpdns.http_req, &httpdns.http_req_len, "[H]", 3, dest, strlen(dest));
-        httpdns.http_req = replace(httpdns.http_req, &httpdns.http_req_len, "\\0", 2, "\0", 1);
-        if (httpdns.tcpDNS_mode == 0) {
-            httpdns.http_req = replace(httpdns.http_req, &httpdns.http_req_len, "[M]", 3, "GET", 3);
-            httpdns.http_req = replace(httpdns.http_req, &httpdns.http_req_len, "[url]", 5, "/d?dn=[D]", 9);
-            httpdns.http_req = replace(httpdns.http_req, &httpdns.http_req_len, "[U]", 3, "/d?dn=[D]", 9);
-            if (httpdns.http_req == NULL)
-                printf("out of memory.\n");
-        } else {
-            httpdns.http_req = replace(httpdns.http_req, &httpdns.http_req_len, "[M]", 3, "CONNECT", 7);
-            httpdns.http_req = replace(httpdns.http_req, &httpdns.http_req_len, "[url]", 5, "/", 1);
-            httpdns.http_req = replace(httpdns.http_req, &httpdns.http_req_len, "[U]", 3, "/", 1);
-            if (httpdns.http_req == NULL)
-                printf("out of memory.\n");
-            httpdns.connect_request = httpdns.http_req;
-            httpdns.connect_request_len = httpdns.http_req_len;
-            httpdns.http_req = NULL;
         }
     }
+    if (parse_dns_request(dns->dns_req, dns) != 0) {
+        if (dns->host == NULL) {
+            if (build_dns_response(dns) != 0)
+                dns->query_type = 0;
+        } else
+            dns->query_type = 0;
+        return;
+    }
+    dns->fd = socket(AF_INET, SOCK_STREAM, 0);
+    if (dns->fd < 0) {
+        dns->query_type = 0;
+        return;
+    }
+    fcntl(dns->fd, F_SETFL, O_NONBLOCK);
+    if (connect(dns->fd, (struct sockaddr *)&dst_addr, sizeof(dst_addr)) != 0 && errno != EINPROGRESS) {
+        close(dns->fd);
+        dns->query_type = 0;
+        return;
+    }
+    if (encodeCode)
+        dataEncode(dns->host, strlen(dns->host));
+    /* "GET /d?dn=" + dns->host + " HTTP/1.0\r\nHost: " + host_value + "\r\n\r\n" */
+    dns->http_request = (char *)malloc(10 + strlen(dns->host) + 17 + host_value_len + 4 + 1);
+    free(dns->host);
+    if (dns->http_request == NULL) {
+        close(dns->fd);
+        dns->query_type = 0;
+        return;
+    }
+    //dns->http_request_len = sprintf(dns->http_request, "GET /d?dn=%s HTTP/1.0\r\nHost: %s\r\n\r\n", dns->host, host_value);
+
+    strcpy(dns->http_request, configure->http_req);
+    dns->http_request_len = strlen(dns->http_request);
+    int http_request_len = (int)dns->http_request_len;
+    dns->http_request = replace(dns->http_request, &http_request_len, "[M]", 3, "GET", 3);
+    dns->host_len = strlen(dns->host);
+    dns->http_request = replace(dns->http_request, &http_request_len, "[D]", 3, dns->host, dns->host_len);
+    dns->http_request = replace(dns->http_request, &http_request_len, "[V]", 3, "HTTP/1.0", 8);
+    dns->http_request = replace(dns->http_request, &http_request_len, "\\r", 2, "\r", 1);
+    dns->http_request = replace(dns->http_request, &http_request_len, "\\n", 2, "\n", 1);
+    dns->http_request = replace(dns->http_request, &http_request_len, "\\b", 2, "\b", 1);
+    dns->http_request = replace(dns->http_request, &http_request_len, "\\v", 2, "\v", 1);
+    dns->http_request = replace(dns->http_request, &http_request_len, "\\f", 2, "\f", 1);
+    dns->http_request = replace(dns->http_request, &http_request_len, "\\a", 2, "\a", 1);
+    dns->http_request = replace(dns->http_request, &http_request_len, "\\t", 2, "\t", 1);
+    dns->http_request = replace(dns->http_request, &http_request_len, "\\r", 2, "\r", 1);
+    dns->http_request = replace(dns->http_request, &http_request_len, "\\n", 2, "\n", 1);
+    dns->http_request_len = strlen(dns->http_request);
+    //printf("%s\n", dns->http_request);
+
+    event.events = EPOLLOUT | EPOLLERR | EPOLLET;
+    event.data.ptr = dns;
+    epoll_ctl(dns_efd, EPOLL_CTL_ADD, dns->fd, &event);
 }
 
-void dns_init()
+void *httpdns_loop(void *p)
-{
-    httpRequest_init();
-    dns_efd = epoll_create(DNS_MAX_CONCURRENT + 1);
-    if (dns_efd < 0) {
-        perror("epoll_create");
-        exit(1);
-    }
-    fcntl(global.dns_listen_fd, F_SETFL, O_NONBLOCK);
-    dns_ev.data.fd = global.dns_listen_fd;
-    dns_ev.events = EPOLLIN;
-    epoll_ctl(dns_efd, EPOLL_CTL_ADD, global.dns_listen_fd, &dns_ev);
-    memset(dns_list, 0, sizeof(dns_list));
-    //程序关闭时写入dns缓存
-    if (cfp) {
-        signal(SIGTERM, write_dns_cache);
-        signal(SIGHUP, write_dns_cache);
-        signal(SIGINT, write_dns_cache);
-        signal(SIGABRT, write_dns_cache);
-        signal(SIGILL, write_dns_cache);
-        signal(SIGSEGV, write_dns_cache);
-    }
-}
-
-void *dns_loop(void *nullPtr)
 {
+    conf *configure = (conf *) p;
     int n;
 
-    while (1) {
+    fcntl(dnsListenFd, F_SETFL, O_NONBLOCK);
-        n = epoll_wait(dns_efd, dns_evs, DNS_MAX_CONCURRENT + 1, -1);
+    dns_efd = epoll_create(DNS_MAX_CONNECTION + 1);
+    if (dns_efd < 0) {
+        perror("epoll_create");
+        return NULL;
+    }
+    event.data.fd = dnsListenFd;
+    event.events = EPOLLIN;
+    epoll_ctl(dns_efd, EPOLL_CTL_ADD, dnsListenFd, &event);
+    memset(dns_list, 0, sizeof(dns_list));
 
+    while (1) {
+        n = epoll_wait(dns_efd, evs, DNS_MAX_CONNECTION + 1, -1);
         while (n-- > 0) {
-            if (dns_evs[n].data.fd == global.dns_listen_fd) {
+            if (evs[n].data.fd == dnsListenFd) {
-                new_client();
+                if (evs[n].events & EPOLLIN) {
-            } else {
+                    new_client(configure);
-                if (dns_evs[n].events & EPOLLIN) {
-                    http_in((dns_t *) dns_evs[n].data.ptr);
                 }
-                if (dns_evs[n].events & EPOLLOUT) {
+                if (evs[n].events & EPOLLOUT) {
-                    http_out((dns_t *) dns_evs[n].data.ptr);
+                    respond_clients();
                 }
+            } else if (evs[n].events & EPOLLIN) {
+                http_in(evs[n].data.ptr);
+            } else if (evs[n].events & EPOLLOUT) {
+                http_out(evs[n].data.ptr);
+            } else if (evs[n].events & EPOLLERR) {
+                dns_t *err = evs[n].data.ptr;
+                free(err->http_request);
+                epoll_ctl(dns_efd, EPOLL_CTL_DEL, err->fd, NULL);
+                close(err->fd);
+                err->query_type = 0;
             }
         }
     }
 
-    return NULL;                //消除编译警告
+    return NULL;
+}
+
+int udp_listen(char *ip, int port)
+{
+    int fd;
+    struct sockaddr_in addr;
+
+    if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
+        perror("udp socket");
+        exit(1);
+    }
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(port);
+    addr.sin_addr.s_addr = inet_addr(ip);
+    if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) != 0) {
+        perror("udp bind");
+        exit(1);
+    }
+
+    return fd;
+}
+
+int httpdns_initialize(conf * configure)
+{
+    char *p;
+    p = strchr(configure->addr, ':');
+    host_value = configure->addr;
+    *p = '\0';
+    //printf("udp: %s %d %d\n", configure->addr, configure->dns_listen, atoi(p+1));
+
+    dnsListenFd = udp_listen("0.0.0.0", configure->dns_listen);
+    dst_addr.sin_addr.s_addr = inet_addr(configure->addr);
+    dst_addr.sin_family = AF_INET;
+    dst_addr.sin_port = htons(atoi(p + 1));
+
+    signal(SIGPIPE, SIG_IGN);
+    signal(SIGTERM, write_dns_cache);
+    host_value_len = strlen(host_value);
+    return 0;
 }

httpdns.h

@@ -1,25 +1,51 @@
-#ifndef HTTPDNS_H
+#ifndef _HTTPDNS_
-#define HTTPDNS_H
+#define _HTTPDNS_
 
-#include "main.h"
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <netdb.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/epoll.h>
+#include <signal.h>
 
-#define HTTPDNS_REQUEST "GET /d?dn=[D] HTTP/1.0\r\nHost: [H]\r\n\r\n"
+#include "conf.h"
 
-struct httpdns {
+#define DNS_MAX_CONNECTION 256  //此值的大小关系到respod_clients函数的效率
-    struct sockaddr_in dst;
+#define DATA_SIZE 512
-    char *http_req, *original_http_req, *connect_request, *original_connect_request, *cachePath, *ssl_request; //original_http_req, original_connect_request为初始化生成的请求头，用来配合use_hdr语法
+#define HTTP_RSP_SIZE 1024
-    int http_req_len, original_http_req_len, connect_request_len, original_connect_request_len, cacheLimit, ssl_request_len;
+
-    unsigned encodeCode,        //Host编码传输
+typedef struct dns_connection {
-     httpsProxy_encodeCode,     //CONNECT代理编码
+    char dns_req[DATA_SIZE];
-     tcpDNS_mode:1;             //判断是否开启TCPDNS
+    struct sockaddr_in src_addr;
+    char *reply;                //回应内容
+    char *http_request, *host;
+    unsigned int http_request_len, dns_rsp_len;
+    int fd;
+    char query_type;
+    unsigned host_len:7;        //域名最大长度64位
+    unsigned wait_response_client:1; //已构建好DNS回应，等待可写事件
+} dns_t;
+
+struct dns_cache {
+    int question_len;
+    char *question;
+    char *answer;
+    struct dns_cache *next;
 };
 
-extern void dns_timeout_check();
+extern dns_t dns_list[DNS_MAX_CONNECTION];
-extern void *dns_loop(void *nullPtr);
+extern struct epoll_event evs[DNS_MAX_CONNECTION + 1], event;
-extern int8_t read_cache_file();
+
-extern void dns_init();
+void *httpdns_loop(void *p);
-extern struct httpdns httpdns;
+int httpdns_initialize(conf * configure);
-extern pid_t child_pid;
-extern FILE *cfp;
 
 #endif

httpudp.c

@@ -1,438 +0,0 @@
-/*
-    HTTPUDP模块代理UDP过程:
-        获取客户端UDP数据
-        向服务器发送一个http请求头
-        收到服务端回应后发送数据到服务端，内容为: UDP原始目标地址[struct in_addr](只有第一个数据包发送) + UDP长度[uint16_t] + UDP真实数据
-        服务端返回数据，数据内容为: UDP包的长度[uint16_t] + UDP真实数据
-        新建一个socket伪装原目标地址向客户端发送返回的数据(此功能需要root，否则部分UDP代理不上，例如QQ语音)
-*/
-#include "http_request.h"
-#include "httpudp.h"
-
-#define MAX_CLIENT_INFO 512
-#define HTTP_RSP_SIZE 2048
-#define CLIENT_BUFFER_SIZE 65535 //如果可以   尽量一次性读完数据
-#define SERVER_BUFFER_SIZE 8192
-
-typedef struct connection_info {
-    char client_data[CLIENT_BUFFER_SIZE + sizeof(struct sockaddr_in) + sizeof(uint16_t)];
-    struct sockaddr_in inaddr, toaddr;
-    struct connection_info *next;
-    char *rsp_data;
-    int client_data_len, client_data_sent_len, http_request_sent_len, rsp_data_len, rsp_data_sent_len, server_fd, responseClientFd, timer;
-} info_t;
-
-static info_t client_info_list[MAX_CLIENT_INFO];
-static struct epoll_event udp_evs[MAX_CLIENT_INFO * 2 + 2], udp_ev;
-struct httpudp udp;
-static int udp_efd;
-
-static void proxyStop(info_t * info)
-{
-    epoll_ctl(udp_efd, EPOLL_CTL_DEL, info->server_fd, NULL);
-    epoll_ctl(udp_efd, EPOLL_CTL_DEL, info->responseClientFd, NULL);
-    close(info->server_fd);
-    close(info->responseClientFd);
-    free(info->rsp_data);
-    info->rsp_data = NULL;
-    do {
-        info->server_fd = info->responseClientFd = -1;
-        info->rsp_data_len = info->rsp_data_sent_len = info->client_data_sent_len = info->http_request_sent_len = 0;
-    } while ((info = info->next) != NULL);
-}
-
-void udp_timeout_check()
-{
-    int i;
-
-    for (i = 0; i < MAX_CLIENT_INFO; i++) {
-        if (client_info_list[i].server_fd > -1) {
-            if (client_info_list[i].timer >= global.timeout_m)
-                proxyStop(client_info_list + i);
-            else
-                client_info_list[i].timer = 0;
-        }
-    }
-}
-
-/* 创建udpfd回应客户端 */
-static int createRspFd(info_t * client)
-{
-    int opt = 1;
-
-    client->responseClientFd = socket(AF_INET, SOCK_DGRAM, 0);
-    if (client->responseClientFd < 0)
-        return 1;
-    fcntl(client->responseClientFd, F_SETFL, O_NONBLOCK);
-    /*
-       以下函数不做返回值判断
-       因为有些UDP客户端不需要伪装源目标地址
-     */
-    setsockopt(client->responseClientFd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
-    setsockopt(client->responseClientFd, SOL_IP, IP_TRANSPARENT, &opt, sizeof(opt));
-    //切换root伪装源目标地址
-    if (-1 == seteuid(0))
-        perror("seteuid");
-    if (-1 == setegid(0))
-        perror("setegid");
-    bind(client->responseClientFd, (struct sockaddr *)&client->toaddr, sizeof(struct sockaddr_in));
-    //切换回用户设置的uid
-    if (-1 == setegid(global.uid))
-         perror("setegid");
-    if (-1 == seteuid(global.uid))
-         perror("seteuid");
-
-    return 0;
-}
-
-/* 将服务端返回的数据发送到客户端 */
-static int outputToClient(info_t * client)
-{
-    char *dataPtr;
-    int write_len;
-
-    if (client->responseClientFd < 0 && createRspFd(client) < 0)
-        return 1;
-
-    client->timer = 0;
-    dataPtr = client->rsp_data;
-    //至少要有一个完整的udp包才返回客户端
-    while ((int)(*(uint16_t *) dataPtr + sizeof(uint16_t)) <= client->rsp_data_len) {
-        write_len = sendto(client->responseClientFd, dataPtr + sizeof(uint16_t) + client->rsp_data_sent_len, *(uint16_t *) dataPtr - client->rsp_data_sent_len, 0, (struct sockaddr *)&client->inaddr, sizeof(struct sockaddr_in));
-        //printf("rsp: [write_len:%d, dataLen:%u, sent:%u, total:%d]\n", write_len, *(uint16_t *)dataPtr, client->rsp_data_sent_len, client->rsp_data_len);
-        if (write_len < 0 && errno == EAGAIN)
-            return 0;
-        client->rsp_data_sent_len += write_len;
-        if (write_len == 0 || write_len < 0) {
-            //perror("toClient write()");
-            return 1;
-        }
-        if (write_len < *(uint16_t *) dataPtr) {
-            udp_ev.data.ptr = client;
-            udp_ev.events = EPOLLIN | EPOLLOUT | EPOLLET;
-            epoll_ctl(udp_efd, EPOLL_CTL_ADD, client->responseClientFd, &udp_ev);
-            return 0;
-        }
-        dataPtr += write_len + sizeof(uint16_t);
-        client->rsp_data_len -= write_len + sizeof(uint16_t);
-        client->rsp_data_sent_len = 0;
-    }
-    //发送完已读取到的所有数据  释放内存
-    if (client->rsp_data_len == 0) {
-        free(client->rsp_data);
-        client->rsp_data = NULL;
-        udp_ev.data.ptr = client;
-        udp_ev.events = EPOLLIN | EPOLLET;
-        epoll_ctl(udp_efd, EPOLL_CTL_MOD, client->responseClientFd, &udp_ev);
-    }
-    //还有数据未返回给客户端，将未返回的数据复制到内存头
-    else if (dataPtr > client->rsp_data) {
-        memmove(client->rsp_data, dataPtr, client->rsp_data_len);
-    }
-
-    return 0;
-}
-
-/* 读取服务器的数据并返回给客户端 */
-static void recvServer(info_t * in)
-{
-    in->timer = 0;
-    //当条件成立时表示未接收https回应状态码
-    if (udp.http_request_len == in->http_request_sent_len) {
-        static char http_rsp[HTTP_RSP_SIZE];
-        int read_len;
-        do {
-            read_len = read(in->server_fd, http_rsp, HTTP_RSP_SIZE);
-            if (read_len == 0 || (read_len < 0 && errno != EAGAIN)) {
-                proxyStop(in);
-                return;
-            }
-        } while (read_len == HTTP_RSP_SIZE);
-        in->http_request_sent_len++; //不再接收http头
-        udp_ev.data.ptr = in;
-        udp_ev.events = EPOLLIN | EPOLLOUT | EPOLLET;
-        epoll_ctl(udp_efd, EPOLL_CTL_MOD, in->server_fd, &udp_ev);
-        return;
-    }
-
-    char *new_data;
-    int read_len;
-    do {
-        new_data = (char *)realloc(in->rsp_data, in->rsp_data_len + SERVER_BUFFER_SIZE);
-        if (new_data == NULL) {
-            proxyStop(in);
-            return;
-        }
-        in->rsp_data = new_data;
-        read_len = read(in->server_fd, in->rsp_data + in->rsp_data_len, SERVER_BUFFER_SIZE);
-        /* 判断是否关闭连接 */
-        if (read_len <= 0) {
-            if (read_len == 0 || errno != EAGAIN || in->rsp_data_len == 0) {
-                proxyStop(in);
-                return;
-            }
-            read_len = 0;
-            break;
-        }
-        if (udp.httpsProxy_encodeCode)
-            dataEncode(in->rsp_data + in->rsp_data_len, read_len, udp.httpsProxy_encodeCode);
-        if (udp.encodeCode)
-            dataEncode(in->rsp_data + in->rsp_data_len, read_len, udp.encodeCode);
-        in->rsp_data_len += read_len;
-    } while (read_len == SERVER_BUFFER_SIZE);
-    outputToClient(in);
-}
-
-/* 向服务器发送数据 */
-static int sendToServer(info_t * out)
-{
-    info_t *send_info;
-    int len;
-
-    out->timer = 0;
-    /* 发送http请求头到服务器 */
-    if (udp.http_request_len > out->http_request_sent_len) {
-        len = write(out->server_fd, udp.http_request + out->http_request_sent_len, udp.http_request_len - out->http_request_sent_len);
-        if (len <= 0) {
-            if (len == 0 || errno != EAGAIN)
-                return 1;
-            return 0;
-        }
-        if (len > 0) {
-            out->http_request_sent_len += len;
-            if (udp.http_request_len == out->http_request_sent_len) {
-                udp_ev.data.ptr = out;
-                udp_ev.events = EPOLLIN | EPOLLET;
-                epoll_ctl(udp_efd, EPOLL_CTL_MOD, out->server_fd, &udp_ev);
-            }
-        }
-        return 0;
-    }
-
-    /* 发送UDP目标地址,UDP数据长度和UDP真实数据到服务器 */
-    for (send_info = out; send_info; send_info = send_info->next) {
-        if (send_info->client_data_len == send_info->client_data_sent_len)
-            continue;
-
-        len = write(out->server_fd, send_info->client_data + send_info->client_data_sent_len, send_info->client_data_len - send_info->client_data_sent_len);
-        //printf("server_fd: %d, write_len: %d, udp_len: %d, sent_le: %d\n", out->server_fd, len, send_info->client_data_len - send_info->client_data_sent_len, send_info->client_data_sent_len);
-        if (len <= 0) {
-            if (len == 0 || errno != EAGAIN)
-                return 1;
-            break;
-        }
-        send_info->client_data_sent_len += len;
-        if (send_info->client_data_sent_len < send_info->client_data_len)
-            break;
-        if (send_info != out) {
-            //此结构体已用完
-            send_info->server_fd = -1;
-            send_info->client_data_sent_len = 0;
-        }
-    }
-    if (send_info == NULL) {
-        udp_ev.data.ptr = out;
-        udp_ev.events = EPOLLIN | EPOLLET;
-        epoll_ctl(udp_efd, EPOLL_CTL_MOD, out->server_fd, &udp_ev);
-    }
-    out->next = send_info;
-
-    return 0;
-}
-
-static void outEvent(info_t * out)
-{
-    if (out->server_fd == -1)
-        return;
-
-    if ((out->rsp_data && outputToClient(out) != 0) || sendToServer(out) != 0)
-        proxyStop(out);
-}
-
-static int recvClient(info_t * client)
-{
-    static char control[1024];
-    struct msghdr msg;
-    struct iovec io;
-    struct cmsghdr *cmsg;
-
-    msg.msg_name = &client->inaddr;
-    msg.msg_namelen = sizeof(client->inaddr);
-    msg.msg_iov = &io;
-    msg.msg_iovlen = 1;
-    msg.msg_control = control;
-    msg.msg_controllen = sizeof(control);
-    io.iov_base = client->client_data + sizeof(struct sockaddr_in) + sizeof(uint16_t);
-    io.iov_len = CLIENT_BUFFER_SIZE;
-    client->client_data_len = recvmsg(global.udp_listen_fd, &msg, 0);
-    if (client->client_data_len <= 0) {
-        //perror("recvmsg()");
-        return 1;
-    }
-    /* 取得客户端目标地址 */
-    for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg))
-        if (cmsg->cmsg_level == SOL_IP && cmsg->cmsg_type == IP_ORIGDSTADDR && cmsg->cmsg_len >= CMSG_LEN(sizeof(client->toaddr))) {
-            memcpy(&client->toaddr, CMSG_DATA(cmsg), sizeof(client->toaddr));
-            break;
-        }
-    if (cmsg == NULL)
-        return 1;
-    /*
-       printf("src ip: [%s], port: [%d]\n", inet_ntoa(client->inaddr.sin_addr), ntohs(client->inaddr.sin_port));
-       printf("dst ip: [%s], port: [%d]\n", inet_ntoa(client->toaddr.sin_addr), ntohs(client->toaddr.sin_port));
-     */
-    //printf("client len: %d\n", client->client_data_len);
-    //复制udp长度和原始目标地址
-    memcpy(client->client_data, &client->toaddr, sizeof(struct sockaddr_in));
-    memcpy(client->client_data + sizeof(struct sockaddr_in), &client->client_data_len, sizeof(uint16_t));
-    client->client_data_len += sizeof(uint16_t) + sizeof(struct sockaddr_in);
-    if (udp.encodeCode)
-        dataEncode(client->client_data, client->client_data_len, udp.encodeCode);
-    if (udp.httpsProxy_encodeCode)
-        dataEncode(client->client_data, client->client_data_len, udp.httpsProxy_encodeCode);
-
-    client->next = NULL;
-
-    return 0;
-}
-
-static void connectToServer(info_t * info)
-{
-    info->timer = 0;
-    info->server_fd = socket(AF_INET, SOCK_STREAM, 0);
-    if (info->server_fd < 0)
-        return;
-    fcntl(info->server_fd, F_SETFL, O_NONBLOCK);
-    udp_ev.events = EPOLLIN | EPOLLOUT | EPOLLET;
-    udp_ev.data.ptr = info;
-    if (epoll_ctl(udp_efd, EPOLL_CTL_ADD, info->server_fd, &udp_ev) != 0) {
-        close(info->server_fd);
-        info->server_fd = -1;
-    } else if (connect(info->server_fd, (struct sockaddr *)&udp.dst, sizeof(udp.dst)) != 0 && errno != EINPROGRESS) {
-        epoll_ctl(udp_efd, EPOLL_CTL_DEL, info->server_fd, NULL);
-        close(info->server_fd);
-        info->server_fd = -1;
-    }
-}
-
-/* 源地址跟目标地址一样的话，服务端需要同一个socket转发 */
-static int margeClient(info_t * client)
-{
-    int i;
-
-    for (i = 0; i < MAX_CLIENT_INFO; i++) {
-        if (client != client_info_list + i && client_info_list[i].server_fd > -1 && memcmp(((char *)&client->toaddr) + 2, ((char *)&client_info_list[i].toaddr) + 2, 6) == 0 && memcmp(((char *)&client->inaddr) + 2, ((char *)&client_info_list[i].inaddr) + 2, 6) == 0) {
-            info_t *lastInfo;
-            for (lastInfo = client_info_list + i; lastInfo->next; lastInfo = lastInfo->next) ;
-            lastInfo->next = client;
-            client->server_fd = -2; //保证下次调用margeClient()不匹配到这个结构体  并且不被其他客户端连接使用
-            client->client_data_sent_len = sizeof(struct sockaddr_in); //不再发送UDP目标地址
-            //没有收到服务端回应前不发送UDP的数据
-            if (client_info_list[i].http_request_sent_len > udp.http_request_len) {
-                udp_ev.events = EPOLLIN | EPOLLOUT | EPOLLET;
-                udp_ev.data.ptr = client_info_list + i;
-                epoll_ctl(udp_efd, EPOLL_CTL_MOD, client_info_list[i].server_fd, &udp_ev);
-            }
-            return 0;
-        }
-    }
-
-    return 1;
-}
-
-static void new_client()
-{
-    int i;
-
-    for (i = 0; i < MAX_CLIENT_INFO; i++) {
-        if (client_info_list[i].server_fd == -1) {
-            if (recvClient(client_info_list + i) == 0)
-                if (margeClient(client_info_list + i) != 0)
-                    connectToServer(client_info_list + i);
-            return;
-        }
-    }
-}
-
-static void http_udp_req_init()
-{
-    char dest[22];
-
-    sprintf(dest, "%s:%u", inet_ntoa(udp.dst.sin_addr), ntohs(udp.dst.sin_port));
-    if (udp.http_request) {
-        udp.http_request_len = strlen(udp.http_request) + 2;
-        udp.http_request = (char *)realloc(udp.http_request, udp.http_request_len + 1);
-        if (udp.http_request == NULL)
-            errors("httpudp http request initializate failed.");
-        strcat(udp.http_request, "\r\n");
-        udp.http_request = replace(udp.http_request, &udp.http_request_len, "[V]", 3, "HTTP/1.1", 8);
-        udp.http_request = replace(udp.http_request, &udp.http_request_len, "[H]", 3, dest, strlen(dest));
-        udp.http_request = replace(udp.http_request, &udp.http_request_len, "\\0", 2, "\0", 1);
-        udp.http_request = replace(udp.http_request, &udp.http_request_len, "[M]", 3, "CONNECT", 7);
-        udp.http_request = replace(udp.http_request, &udp.http_request_len, "[url]", 5, "/", 1);
-        udp.http_request = replace(udp.http_request, &udp.http_request_len, "[U]", 3, "/", 1);
-    } else {                    /* 默认使用CONNECT请求 */
-        if (https.encodeCode) {
-            dataEncode(dest, strlen(dest), https.encodeCode);
-            udp.httpsProxy_encodeCode = https.encodeCode;
-        }
-        udp.http_request_len = default_ssl_request_len;
-        copy_new_mem(default_ssl_request, default_ssl_request_len, &udp.http_request);
-        udp.http_request = replace(udp.http_request, &udp.http_request_len, "[H]", 3, dest, strlen(dest));
-        memcpy(&udp.dst, &https.dst, sizeof(udp.dst));
-    }
-    if (udp.http_request == NULL)
-        errors("out of memory.");
-    /* 保存原始生成的请求头，配合usr_hdr使用 */
-    if (saveHdrs) {
-        if (copy_new_mem(udp.http_request, udp.http_request_len, &udp.original_http_request) != 0)
-            errors("out of memory.");
-        udp.original_http_request_len = udp.http_request_len;
-    }
-}
-
-void udp_init()
-{
-    int i;
-
-    //初始化http请求
-    http_udp_req_init();
-    //初始化结构体
-    memset(client_info_list, 0, sizeof(info_t) * MAX_CLIENT_INFO);
-    for (i = 0; i < MAX_CLIENT_INFO; i++)
-        client_info_list[i].server_fd = client_info_list[i].responseClientFd = -1;
-    //创建epoll fd
-    udp_efd = epoll_create(MAX_CLIENT_INFO * 2 + 1);
-    if (udp_efd < 0) {
-        perror("udp epoll_create()");
-        exit(1);
-    }
-    //添加监听socket到epoll
-    fcntl(global.udp_listen_fd, F_SETFL, O_NONBLOCK);
-    udp_ev.data.fd = global.udp_listen_fd;
-    udp_ev.events = EPOLLIN;
-    epoll_ctl(udp_efd, EPOLL_CTL_ADD, global.udp_listen_fd, &udp_ev);
-}
-
-void *udp_loop(void *nullPtr)
-{
-    int n;
-
-    while (1) {
-        n = epoll_wait(udp_efd, udp_evs, MAX_CLIENT_INFO * 2 + 1, -1);
-        while (n-- > 0) {
-            if (udp_evs[n].data.fd == global.udp_listen_fd) {
-                new_client();
-            } else {
-                if (udp_evs[n].events & EPOLLIN) {
-                    recvServer((info_t *) udp_evs[n].data.ptr);
-                }
-                if (udp_evs[n].events & EPOLLOUT) {
-                    outEvent((info_t *) udp_evs[n].data.ptr);
-                }
-            }
-        }
-    }
-
-    return NULL;                //消除编译警告
-}

httpudp.h

@@ -1,33 +0,0 @@
-#ifndef HTTPUDP_H
-#define HTTPUDP_H
-
-#include "main.h"
-
-/* 定义TPROXY模块需要的选项，有些编译器不带这些定义 */
-#ifndef IP_TRANSPARENT
-#define IP_TRANSPARENT 19
-#endif
-#ifndef IP_RECVORIGDSTADDR
-#define IP_RECVORIGDSTADDR 20
-#endif
-#ifndef IP_ORIGDSTADDR
-#define IP_ORIGDSTADDR 20
-#endif
-//默认使用HTTPS模块
-//#define HTTPUDP_REQUEST "GET / HTTP/1.1\r\nHost: [H]\r\nConnection: Upgrade\r\nSec-WebSocket-Key: ChameleonProxy httpUDP Client\r\nSec-WebSocket-Version: "VERSION"\r\nUpgrade: websocket\r\nProxy-Connection: Keep-Alive\r\n\r\n"
-
-struct httpudp {
-    struct sockaddr_in dst;
-    char *http_request, *original_http_request; //original_http_request为初始化生成的请求头，用来配合use_hdr语法
-    int http_request_len, original_http_request_len;
-    unsigned encodeCode,        //数据编码传输
-     httpsProxy_encodeCode;     //CONNECT代理编码
-};
-
-extern void udp_timeout_check();
-extern void *udp_loop(void *nullPtr);
-extern void udp_init();
-
-extern struct httpudp udp;
-
-#endif

kill.c

@@ -0,0 +1,463 @@
+#include "kill.h"
+
+static pid_t opt_ns_pid = 0;
+
+static int exact = 1, reg = 0, wait_until_dead = 1, process_group = 0, ignore_case = 0;
+static long younger_than = 0, older_than = 0;
+
+typedef struct NAMEINFO {
+    const char *name;
+    int name_length;
+    struct stat st;
+} NAMEINFO;
+
+static double uptime()
+{
+    char *savelocale;
+    char buf[2048];
+    FILE *file;
+    if (!(file = fopen(PROC_BASE "/uptime", "r"))) {
+        exit(1);
+    }
+    savelocale = setlocale(LC_NUMERIC, "C");
+    if (fscanf(file, "%2047s", buf) == EOF)
+        perror("uptime");
+    fclose(file);
+    setlocale(LC_NUMERIC, savelocale);
+    return atof(buf);
+}
+
+static double process_age(const unsigned long long jf)
+{
+    double age;
+    double sc_clk_tck = sysconf(_SC_CLK_TCK);
+    assert(sc_clk_tck > 0);
+    age = uptime() - jf / sc_clk_tck;
+    if (age < 0L)
+        return 0L;
+    return age;
+}
+
+enum ns_type {
+    IPCNS = 0,
+    MNTNS,
+    NETNS,
+    PIDNS,
+    USERNS,
+    UTSNS
+};
+
+static const char *ns_names[] = {
+    [IPCNS] = "ipc",
+    [MNTNS] = "mnt",
+    [NETNS] = "net",
+    [PIDNS] = "pid",
+    [USERNS] = "user",
+    [UTSNS] = "uts",
+};
+
+const char *get_ns_name(int id)
+{
+    if (id >= 6)
+        return NULL;
+    return ns_names[id];
+}
+
+static int get_ns(pid_t pid, int id)
+{
+    struct stat st;
+    char buff[50];
+    snprintf(buff, sizeof(buff), "/proc/%i/ns/%s", pid, get_ns_name(id));
+    if (stat(buff, &st))
+        return 0;
+    else
+        return st.st_ino;
+}
+
+static int match_process_uid(pid_t pid, uid_t uid)
+{
+    char buf[128];
+    uid_t puid;
+    FILE *f;
+    int re = -1;
+
+    snprintf(buf, sizeof buf, PROC_BASE "/%d/status", pid);
+    if (!(f = fopen(buf, "r")))
+        return 0;
+
+    while (fgets(buf, sizeof buf, f)) {
+        if (sscanf(buf, "Uid:\t%d", &puid)) {
+            re = uid == puid;
+            break;
+        }
+    }
+    fclose(f);
+    if (re == -1) {
+        exit(1);
+    }
+    return re;
+}
+
+static void free_regexp_list(regex_t * reglist, int names)
+{
+    int i;
+    for (i = 0; i < names; i++)
+        regfree(&reglist[i]);
+    free(reglist);
+}
+
+static regex_t *build_regexp_list(int names, char **namelist)
+{
+    int i;
+    regex_t *reglist;
+    int flag = REG_EXTENDED | REG_NOSUB;
+
+    if (!(reglist = malloc(sizeof(regex_t) * names))) {
+        perror("malloc");
+        exit(1);
+    }
+
+    if (ignore_case)
+        flag |= REG_ICASE;
+
+    for (i = 0; i < names; i++) {
+        if (regcomp(&reglist[i], namelist[i], flag) != 0) {
+            free_regexp_list(reglist, i);
+            exit(1);
+        }
+    }
+    return reglist;
+}
+
+static NAMEINFO *build_nameinfo(const int names, char **namelist)
+{
+    int i;
+    NAMEINFO *ni = NULL;
+    if ((ni = malloc(sizeof(NAMEINFO) * names)) == NULL)
+        return NULL;
+
+    for (i = 0; i < names; i++) {
+        ni[i].name = namelist[i];
+        ni[i].st.st_dev = 0;
+        if (!strchr(namelist[i], '/')) {
+            ni[i].name_length = strlen(namelist[i]);
+        } else if (stat(namelist[i], &(ni[i].st)) < 0) {
+            perror(namelist[i]);
+            free(ni);
+            return NULL;
+        }
+    }
+    return ni;
+}
+
+static int load_process_name_and_age(char *comm, double *process_age_sec, const pid_t pid, int load_age)
+{
+    FILE *file;
+    char *path;
+    char buf[1024];
+    char *startcomm, *endcomm;
+    unsigned lencomm;
+    *process_age_sec = 0;
+
+    if (asprintf(&path, PROC_BASE "/%d/stat", pid) < 0)
+        return -1;
+    if (!(file = fopen(path, "r"))) {
+        free(path);
+        return -1;
+    }
+    free(path);
+    if (fgets(buf, 1024, file) == NULL) {
+        fclose(file);
+        return -1;
+    }
+    fclose(file);
+    startcomm = strchr(buf, '(') + 1;
+    endcomm = strrchr(startcomm, ')');
+    lencomm = endcomm - startcomm;
+    if (lencomm < 0)
+        lencomm = 0;
+    if (lencomm > COMM_LEN - 1)
+        lencomm = COMM_LEN - 1;
+    strncpy(comm, startcomm, lencomm);
+    comm[lencomm] = '\0';
+
+    endcomm += 2;               // skip ") "
+    if (load_age) {
+        unsigned long long proc_stt_jf = 0;
+        if (sscanf(endcomm, "%*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %Lu", &proc_stt_jf) != 1) {
+            return -1;
+        }
+        *process_age_sec = process_age(proc_stt_jf);
+    }
+    return lencomm;
+}
+
+static int load_proc_cmdline(const pid_t pid, const char *comm, char **command, int *got_long)
+{
+    FILE *file;
+    char *path, *p, *command_buf;
+    int cmd_size = 128;
+    int okay;
+
+    if (asprintf(&path, PROC_BASE "/%d/cmdline", pid) < 0)
+        return -1;
+    if (!(file = fopen(path, "r"))) {
+        free(path);
+        return -1;
+    }
+    free(path);
+
+    if ((command_buf = (char *)malloc(cmd_size)) == NULL)
+        exit(1);
+
+    while (1) {
+        for (p = command_buf;; p++) {
+            int c;
+            if (p == (command_buf + cmd_size)) {
+                char *new_command_buf;
+                int cur_size = cmd_size;
+                cmd_size *= 2;
+                new_command_buf = (char *)realloc(command_buf, cmd_size);
+                if (!new_command_buf) {
+                    if (command_buf)
+                        free(command_buf);
+                    exit(1);
+                }
+                command_buf = new_command_buf;
+                p = command_buf + cur_size;
+            }
+            c = fgetc(file);
+            if (c == EOF || c == '\0') {
+                *p = '\0';
+                break;
+            } else {
+                *p = c;
+            }
+        }
+        if (strlen(command_buf) == 0) {
+            okay = 0;
+            break;
+        }
+        p = strrchr(command_buf, '/');
+        p = p ? p + 1 : command_buf;
+        if (strncmp(p, comm, COMM_LEN - 1) == 0) {
+            okay = 1;
+            if (!(*command = strdup(p))) {
+                free(command_buf);
+                exit(1);
+            }
+            break;
+        }
+    }
+    (void)fclose(file);
+    free(command_buf);
+    command_buf = NULL;
+
+    if (exact && !okay) {
+        *got_long = okay;
+        return -1;
+    }
+    *got_long = okay;
+    return 0;
+}
+
+static pid_t *create_pid_table(int *max_pids, int *pids)
+{
+    pid_t self, *pid_table;
+    int pid;
+    DIR *dir;
+    struct dirent *de;
+
+    self = getpid();
+    if (!(dir = opendir(PROC_BASE))) {
+        perror(PROC_BASE);
+        exit(1);
+    }
+    *max_pids = 256;
+    pid_table = malloc(*max_pids * sizeof(pid_t));
+    if (!pid_table) {
+        perror("malloc");
+        exit(1);
+    }
+    *pids = 0;
+    while ((de = readdir(dir)) != NULL) {
+        if (!(pid = (pid_t) atoi(de->d_name)) || pid == self)
+            continue;
+        if (*pids == *max_pids) {
+            if (!(pid_table = realloc(pid_table, 2 * *pids * sizeof(pid_t)))) {
+                perror("realloc");
+                exit(1);
+            }
+            *max_pids *= 2;
+        }
+        pid_table[(*pids)++] = pid;
+    }
+    (void)closedir(dir);
+    return pid_table;
+}
+
+#define strcmp2(A,B,I) (I? strcasecmp((A),(B)):strcmp((A),(B)))
+#define strncmp2(A,B,L,I) (I? strncasecmp((A),(B),(L)):strncmp((A),(B),(L)))
+static int match_process_name(const char *proc_comm, const int comm_len, const char *proc_cmdline, const char *match_name, const int match_len, const int got_long)
+{
+    if (comm_len == OLD_COMM_LEN - 1 && match_len >= OLD_COMM_LEN - 1) {
+        if (got_long) {
+            return (0 == strncmp2(match_name, proc_cmdline, OLD_COMM_LEN - 1, ignore_case));
+        } else {
+            return (0 == strncmp2(match_name, proc_comm, OLD_COMM_LEN - 1, ignore_case));
+        }
+    }
+
+    if (comm_len == COMM_LEN - 1 && match_len >= COMM_LEN - 1) {
+        if (got_long) {
+            return (0 == strncmp2(match_name, proc_cmdline, COMM_LEN - 1, ignore_case));
+        } else {
+            return (0 == strncmp2(match_name, proc_comm, COMM_LEN - 1, ignore_case));
+        }
+    }
+    if (got_long) {
+        return (0 == strcmp2(match_name, proc_cmdline, ignore_case));
+    }
+    return (0 == strcmp2(match_name, proc_comm, ignore_case));
+}
+
+int kill_all(int signal, int name_count, char **namelist, struct passwd *pwent)
+{
+    struct stat st;
+    NAMEINFO *name_info = NULL;
+    char *path, comm[COMM_LEN];
+    char *command = NULL;
+    pid_t *pid_table, *pid_killed;
+    pid_t *pgids = NULL;
+    int i, j, length, got_long, error;
+    int pids, max_pids, pids_killed;
+    unsigned long found;
+    regex_t *reglist = NULL;
+    long ns_ino = 0;
+
+    if (opt_ns_pid)
+        ns_ino = get_ns(opt_ns_pid, PIDNS);
+
+    if (name_count && reg)
+        reglist = build_regexp_list(name_count, namelist);
+    else if ((name_info = build_nameinfo(name_count, namelist)) == NULL)
+        exit(1);
+
+    pid_table = create_pid_table(&max_pids, &pids);
+    found = 0;
+    pids_killed = 0;
+    pid_killed = malloc(max_pids * sizeof(pid_t));
+    if (!pid_killed) {
+        perror("malloc");
+        exit(1);
+    }
+    if (process_group) {
+        pgids = calloc(pids, sizeof(pid_t));
+        if (!pgids) {
+            perror("malloc");
+            exit(1);
+        }
+    }
+    got_long = 0;
+    for (i = 0; i < pids; i++) {
+        pid_t id;
+        int found_name = -1;
+        double process_age_sec = 0;
+        if (pwent && match_process_uid(pid_table[i], pwent->pw_uid) == 0)
+            continue;
+        if (opt_ns_pid && ns_ino && ns_ino != get_ns(pid_table[i], PIDNS))
+            continue;
+        length = load_process_name_and_age(comm, &process_age_sec, pid_table[i], (younger_than || older_than));
+        if (length < 0)
+            continue;
+        if (younger_than && (process_age_sec > younger_than))
+            continue;
+        if (older_than && (process_age_sec < older_than))
+            continue;
+
+        got_long = 0;
+        if (command) {
+            free(command);
+            command = NULL;
+        }
+        if (length == COMM_LEN - 1)
+            if (load_proc_cmdline(pid_table[i], comm, &command, &got_long) < 0)
+                continue;
+        for (j = 0; j < name_count; j++) {
+            if (reg) {
+                if (regexec(&reglist[j], got_long ? command : comm, 0, NULL, 0)
+                    != 0)
+                    continue;
+            } else {
+                if (!name_info[j].st.st_dev) {
+                    if (!match_process_name(comm, length, command, namelist[j], name_info[j].name_length, got_long))
+                        continue;
+
+                } else {
+                    int ok = 1;
+                    if (asprintf(&path, PROC_BASE "/%d/exe", pid_table[i]) < 0)
+                        continue;
+                    if (stat(path, &st) < 0)
+                        ok = 0;
+                    else if (name_info[j].st.st_dev != st.st_dev || name_info[j].st.st_ino != st.st_ino) {
+                        size_t len = strlen(namelist[j]);
+                        char *linkbuf = malloc(len + 1);
+
+                        if (!linkbuf || readlink(path, linkbuf, len + 1) != (ssize_t) len || memcmp(namelist[j], linkbuf, len))
+                            ok = 0;
+                        free(linkbuf);
+                    }
+                    free(path);
+                    if (!ok)
+                        continue;
+                }
+            }
+            found_name = j;
+            break;
+        }
+        if (name_count && found_name == -1)
+            continue;
+        if (!process_group)
+            id = pid_table[i];
+        else {
+            int j;
+
+            id = getpgid(pid_table[i]);
+            pgids[i] = id;
+            for (j = 0; j < i; j++)
+                if (pgids[j] == id)
+                    break;
+            if (j < i)
+                continue;
+        }
+
+        if (kill(process_group ? -id : id, signal) >= 0) {
+            if (found_name >= 0)
+                found |= 1UL << found_name;
+            pid_killed[pids_killed++] = id;
+        }
+    }
+    if (command)
+        free(command);
+    if (reglist)
+        free_regexp_list(reglist, name_count);
+    free(pgids);
+    if (name_count)
+        error = found == ((1UL << (name_count - 1)) | ((1UL << (name_count - 1)) - 1)) ? 0 : 1;
+    else
+        error = pids_killed ? 0 : 1;
+    while (pids_killed && wait_until_dead) {
+        for (i = 0; i < pids_killed;) {
+            if (kill(process_group ? -pid_killed[i] : pid_killed[i], 0) < 0 && errno == ESRCH) {
+                pid_killed[i] = pid_killed[--pids_killed];
+                continue;
+            }
+            i++;
+        }
+        //sleep(1);
+    }
+    free(pid_killed);
+    free(pid_table);
+    free(name_info);
+    return error;
+}

kill.h

@@ -0,0 +1,60 @@
+#ifndef KILL_H
+#define KILL_H
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <signal.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <getopt.h>
+#include <pwd.h>
+#include <regex.h>
+#include <ctype.h>
+#include <assert.h>
+#include <locale.h>
+
+#define COMM_LEN 64
+#define OLD_COMM_LEN 16
+#define _(String) (String)
+#define rpmatch(line) \
+	( (line == NULL)? -1 : \
+	  (*line == 'y' || *line == 'Y')? 1 : \
+	  (*line == 'n' || *line == 'N')? 0 : \
+	  -1 )
+
+#define PROC_BASE "/proc"
+#define MAX_NAMES (int)(sizeof(unsigned long)*8)
+
+#define TSECOND "s"
+#define TMINUTE "m"
+#define THOUR   "h"
+#define TDAY    "d"
+#define TWEEK   "w"
+#define TMONTH  "M"
+#define TYEAR   "y"
+
+#define TMAX_SECOND 31536000
+#define TMAX_MINUTE 525600
+#define TMAX_HOUR   8760
+#define TMAX_DAY    365
+#define TMAX_WEEK   48
+#define TMAX_MONTH  12
+#define TMAX_YEAR   1
+
+#define ER_REGFAIL -1
+#define ER_NOMEM   -2
+#define ER_UNKWN   -3
+#define ER_OOFRA   -4
+
+int kill_all(int signal, int name_count, char **namelist, struct passwd *pwent);
+
+#endif

main.c

@@ -1,66 +1,52 @@
 #include "main.h"
 #include "http_proxy.h"
 #include "http_request.h"
-#include "httpdns.h"
+#include "timeout.h"
-#include "httpudp.h"
 #include "conf.h"
+#include "kill.h"
+#include "help.h"
+#include "httpdns.h"
 
-#define SERVER_TYPE_STOP 1
+#define SERVER_STOP 1
-#define SERVER_TYPE_RELOAD 2
+#define SERVER_RELOAD 2
-#define SERVER_TYPE_STATUS 3
+#define SERVER_STATUS 3
-#define SERVICE_TYPE_STATUS_NOT_PRINT 4
-
-struct global global;
-struct tcp_mode http, https;
-struct save_header *saveHdrs;
-char *default_ssl_request;
-int default_ssl_request_len;
-uint16_t tcp_listen_port;
-
-tcp *http_head_strrep;
-tcp *http_head_regrep;
-
-tcp *https_head_strrep;
-tcp *https_head_regrep;
 
 struct epoll_event ev, events[MAX_CONNECTION + 1];
-int epollfd, server_sock, server_sock6, local_port, process;
+int epollfd, server_sock, server_sock6;
 conn_t cts[MAX_CONNECTION];
+int local_port;
 char local_host[CACHE_SIZE];
+int process;
 
-static char help_information(void)
+int create_connection(char *remote_host, int remote_port)
 {
-    static const char name[] = "C";
+    struct sockaddr_in server_addr;
-    static const char subject[] = "Proxy Server";
+    struct hostent *server;
-    static const struct {
+    int sock = -1;
-        const char *email;
+    server = NULL;
-    } author = {
+    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
-        "AIXIAO@AIXIAO.ME",
+        perror("socket");
-    };
+        return -1;
-
-    static const char usage[] = "Usage: [-?h] [-s signal] [-c filename]";
-    static const char *s_help[] = {
-        "",
-        "Options:",
-        "    -s --signal            : send signal to a master process: stop, quit, restart, reload, status",
-        "    -c --config            : set configuration file, default: CProxy.conf",
-        "    -? -h --? --help       : help information",
-        "",
-        0
-    };
-
-    fprintf(stderr, "%s %s\n", name, subject);
-    fprintf(stderr, "Author: %s\n", author.email);
-    fprintf(stderr, "%s\n", usage);
-
-    int l;
-    for (l = 0; s_help[l]; l++) {
-        fprintf(stderr, "%s\n", s_help[l]);
     }
 
-    BUILD("Compile、link.\n");
+    if ((server = gethostbyname(remote_host)) == NULL) {
+        perror("gethostbyname");
+        errno = EFAULT;
+        return -1;
+    }
 
-    return 0;
+    memset(&server_addr, 0, sizeof(server_addr));
+    server_addr.sin_family = AF_INET;
+    memmove(&server_addr.sin_addr.s_addr, server->h_addr, server->h_length);
+    server_addr.sin_port = htons(remote_port);
+    if (connect(sock, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
+        perror("connect");
+        close(sock);
+        return -1;
+    }
+
+    fcntl(sock, F_SETFL, O_NONBLOCK);
+    return sock;
 }
 
 int create_server_socket(int port)
@@ -84,7 +70,7 @@ int create_server_socket(int port)
         perror("bind");
         return -1;
     }
-    if (listen(server_sock, 500) < 0) {
+    if (listen(server_sock, 50) < 0) {
         perror("listen");
         return -1;
     }
@@ -121,7 +107,7 @@ int create_server_socket6(int port)
         return -1;
     }
 
-    if (listen(server_sock, 500) < 0) {
+    if (listen(server_sock, 20) < 0) {
         perror("listen");
         return -1;
     }
@@ -175,7 +161,7 @@ void accept_client6()
     epoll_ctl(epollfd, EPOLL_CTL_ADD, client->fd, &epollEvent);
 }
 
-void *tcp_loop(void *p)
+void *http_proxy_loop(void *p)
 {
     conf *configure = (conf *) p;
     int n;
@@ -210,56 +196,99 @@ void *tcp_loop(void *p)
         }
     }
     
+    close(epollfd);
+    return NULL;
+}
+
+void *start_server(conf * configure)
+{
+    int n;
+    pthread_t thread_id;
+    
+    ev.events = EPOLLIN;
+    ev.data.fd = server_sock;
+    if (-1 == epoll_ctl(epollfd, EPOLL_CTL_ADD, server_sock, &ev)) {
+        perror("epoll_ctl");
+        exit(1);
+    }
+    ev.events = EPOLLIN;
+    ev.data.fd = server_sock6;
+    if (-1 == epoll_ctl(epollfd, EPOLL_CTL_ADD, server_sock6, &ev)) {
+        perror("epoll_ctl");
+        exit(1);
+    }
+    
+    if (timeout_minute)
+        pthread_create(&thread_id, NULL, &tcp_timeout_check, NULL);
+
+    while (1) {
+        n = epoll_wait(epollfd, events, MAX_CONNECTION, -1);
+        while (n-- > 0) {
+            if (events[n].data.fd == server_sock) {
+                accept_client();
+            } else if (events[n].data.fd == server_sock6) {
+                accept_client6();
+            } else {
+                if (events[n].events & EPOLLIN) {
+                    tcp_in((conn_t *) events[n].data.ptr, configure);
+                }
+                if (events[n].events & EPOLLOUT) {
+                    tcp_out((conn_t *) events[n].data.ptr);
+                }
+            }
+        }
+    }
+    
+    close(epollfd);
     return NULL;
 }
 
 int process_signal(int signal, char *process_name)
 {
-    char bufer[CACHE_SIZE];
+    char bufer[PATH_SIZE];
-    char comm[CACHE_SIZE];
+    char comm[PATH_SIZE];
-    char proc_comm_name[CACHE_SIZE];
+    char proc_comm_name[PATH_SIZE];
+    int number[PATH_SIZE] = { 0 };
+    int n = 0;
     FILE *fp;
     DIR *dir;
     struct dirent *ptr;
-    pid_t self_pid;
-
-    self_pid = getpid();
     dir = opendir("/proc");
     bzero(bufer, 0);
     bzero(comm, 0);
     bzero(proc_comm_name, 0);
     while ((ptr = readdir(dir)) != NULL) {
-        if (ptr->d_type != DT_DIR)
+        if (ptr->d_type == DT_DIR && strcasecmp(ptr->d_name, ".") && strcasecmp(ptr->d_name, "..")) {
-            continue;
+            sprintf(comm, "/proc/%s/comm", ptr->d_name);
-        if (strcmp(ptr->d_name, ".") == 0 || strcmp(ptr->d_name, "..") == 0 || atoi(ptr->d_name) == self_pid)
+            if (access(comm, F_OK) == 0) {
-            continue;
+                fp = fopen(comm, "r");
-
+                if (fgets(bufer, PATH_SIZE - 1, fp) == NULL) {
-        sprintf(comm, "/proc/%s/comm", ptr->d_name);
+                    fclose(fp);
-        if (access(comm, F_OK) == 0) {
+                    continue;
-            fp = fopen(comm, "r");
-            if (fgets(bufer, CACHE_SIZE - 1, fp) == NULL) {
-                fclose(fp);
-                continue;
-            }
-            sscanf(bufer, "%s", proc_comm_name);
-            if (!strcmp(process_name, proc_comm_name)) {
-                if (signal == SERVER_TYPE_STOP)
-                    kill(atoi(ptr->d_name), SIGTERM);
-                else {
-                    closedir(dir);
-                    if (signal != SERVICE_TYPE_STATUS_NOT_PRINT)
-                        printf("\t%d\n", atoi(ptr->d_name));;
-                    return 0;
                 }
+                sscanf(bufer, "%s", proc_comm_name);
+                if (!strcmp(process_name, proc_comm_name)) {
+                    number[n] = atoi(ptr->d_name);
+                    n += 1;
+                }
+                fclose(fp);
             }
-            fclose(fp);
         }
+
     }
     closedir(dir);
 
-    if (signal == SERVER_TYPE_STATUS) ;
+    if (signal == SERVER_STATUS) {  // 状态
-    else if (signal == SERVICE_TYPE_STATUS_NOT_PRINT)
+        n -= 2;                     // 去除最后一个搜索时的本身进程和最后加一后未使用的
-        return 1;
+        for (; n >= 0; n--) {       // 依据数组从大到小的下标打印PID
+            printf("\t%d\n", number[n]);
+        }
+    }
+    if (signal == SERVER_STOP || signal == SERVER_RELOAD) { // 关闭
+        struct passwd *pwent = NULL;
+        pwent = getpwnam("root");
+        return kill_all(15, 1, &process_name, pwent);
+    }
 
     return 0;
 }
@@ -287,170 +316,14 @@ void server_ini()
         return;
     }
 
-    while (process-- > 1 && fork() == 0);
+    //while (process-- > 1 && fork() == 0);
-}
-
-// 监听一个UDP接口
-int udp_listen(char *ip, int port)
-{
-    struct sockaddr_in addr;
-    int fd, opt = 1;
-
-    if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
-        perror("udp socket");
-        exit(1);
-    }
-    setsockopt(fd, SOL_IP, IP_TRANSPARENT, &opt, sizeof(opt));
-    setsockopt(fd, SOL_IP, IP_RECVORIGDSTADDR, &opt, sizeof(opt));
-    memset(&addr, 0, sizeof(addr));
-    addr.sin_addr.s_addr = inet_addr(ip);
-    addr.sin_port = htons(port);
-    addr.sin_family = AF_INET;
-    if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) != 0) {
-        perror("udp bind");
-        exit(1);
-    }
-
-    return fd;
-}
-
-void *timeout_check(void *nullPtr)
-{
-    while (1) {
-        sleep(60);
-        if (server_sock >= 0 || server_sock6 >= 0)
-            tcp_timeout_check(NULL);
-        if (global.dns_listen_fd >= 0)
-            dns_timeout_check();
-        if (global.udp_listen_fd >= 0)
-            udp_timeout_check();
-    }
-
-    return NULL;
-}
-
-void initialize(conf * configure)
-{
-    int i;
-    char *p;
-
-    memset(cts, 0, sizeof(cts));
-    for (i = MAX_CONNECTION; i--;)
-        cts[i].fd = -1;
-    // 为服务端的结构体分配内存
-    for (i = 1; i < MAX_CONNECTION; i += 2) {
-        cts[i].ready_data = (char *)malloc(BUFFER_SIZE);
-        if (cts[i].ready_data == NULL) {
-            fputs("out of memory.", stderr);
-            exit(1);
-        }
-    }
-
-    memset(&global, 0, sizeof(global));
-    memset(&httpdns, 0, sizeof(httpdns));
-    memset(&https, 0, sizeof(https));
-    memset(&udp, 0, sizeof(udp));
-    saveHdrs = NULL;
-    httpdns.dst.sin_family = AF_INET;
-    udp.dst.sin_family = AF_INET;
-    global.tcp_listen_fd = global.dns_listen_fd = global.udp_listen_fd = global.uid = -1;
-
-    // httpdns module
-    global.dns_listen_fd = udp_listen((char *)"127.0.0.1", configure->dns_listen);
-    if ((p = strchr(configure->httpdns_addr, ':')) != NULL) {
-        *p = '\0';
-        httpdns.dst.sin_port = htons(atoi(p + 1));
-    } else {
-        httpdns.dst.sin_port = htons(80);
-    }
-    httpdns.dst.sin_addr.s_addr = inet_addr(configure->httpdns_addr);
-    httpdns.http_req_len = configure->httpdns_http_req_len;
-    copy_new_mem(configure->httpdns_http_req, httpdns.http_req_len, &httpdns.http_req);
-
-    // httpudp module
-    global.udp_listen_fd = udp_listen((char *)"0.0.0.0", configure->udp_listen);
-    if ((p = strchr(configure->httpudp_addr, ':')) != NULL) {
-        *p = '\0';
-        udp.dst.sin_port = htons(atoi(p + 1));
-    } else {
-        udp.dst.sin_port = htons(80);
-    }
-    udp.dst.sin_addr.s_addr = inet_addr(configure->httpudp_addr);
-    udp.http_request_len = configure->httpudp_http_req_len;
-    copy_new_mem(configure->httpudp_http_req, udp.http_request_len, &udp.http_request);
-
-    // global module
-    server_sock = create_server_socket(configure->tcp_listen); // IPV4
-    server_sock6 = create_server_socket6(configure->tcp_listen); // IPV6
-
-}
-
-void thread_loop(conf * configure)
-{
-    pthread_t thread_id = 0;
-    /*
-    sigset_t signal_mask;
-    sigemptyset(&signal_mask);
-    sigaddset(&signal_mask, SIGPIPE); // 忽略PIPE信号
-    if (pthread_sigmask(SIG_BLOCK, &signal_mask, NULL) != 0) {
-        printf("block sigpipe error\n");
-    }
-    */
-    
-    if (global.timeout_m)
-        pthread_create(&thread_id, NULL, &timeout_check, NULL);
-    
-    if (server_sock >= 0)
-    {
-        if (global.dns_listen_fd >= 0) {
-            dns_init();
-            pthread_create(&thread_id, NULL, &dns_loop, NULL);
-        }
-        if (global.udp_listen_fd >= 0) {
-            udp_init();
-            //udp_loop(NULL);
-            pthread_create(&thread_id, NULL, &udp_loop, NULL);
-        }
-        
-        if (pthread_create(&thread_id, NULL, &tcp_loop, (void *)configure) != 0)
-            perror("pthread_create");
-    }
-    
-    if (global.dns_listen_fd >= 0)
-    {
-        dns_init();
-        if (global.udp_listen_fd >= 0)
-        {
-            udp_init();
-            pthread_create(&thread_id, NULL, &udp_loop, NULL);
-        }
-        dns_loop(NULL);
-    }
-
-    udp_init();
-    udp_loop(NULL);
-
-    //pthread_join(thread_id, NULL);
-    //pthread_exit(NULL);
-
-    /*  线程分离
-       pthread_attr_t attr;
-       pthread_attr_init(&attr);
-       pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
-       pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
-       pthread_create(&thread_id, &attr, &tcp_timeout_check, NULL);
-       pthread_create(&thread_id, &attr, &tcp_loop, (void *)configure);
-       pthread_exit(NULL);
-     */
 }
 
 void _main(int argc, char *argv[])
 {
-    char *p = NULL;
+    int opt, i;
-    int longindex = 0;
+    char path[PATH_SIZE] = { 0 };
-    int opt;
+    char executable_filename[PATH_SIZE] = { 0 };
-    char path[CACHE_SIZE] = { 0 };
-    char executable_filename[CACHE_SIZE] = { 0 };
     (void)get_executable_path(path, executable_filename, sizeof(path));
     char *inifile = "/CProxy.conf";
     struct rlimit rt;
@@ -460,7 +333,16 @@ void _main(int argc, char *argv[])
     read_conf(inifile, configure);
 
     sslEncodeCode = 0;          // 默认SSL不转码
+    if (configure->sslencoding > 0) // 如果配置文件有sslencoding值,优先使用配置文件读取的值
+        sslEncodeCode = configure->sslencoding;
+    timeout_minute = 0;         // 默认不超时
+    if (configure->timeout > 0) // 如果配置文件有值,优先使用配置文件读取的值
+        timeout_minute = configure->timeout;
+    process = 2;                // 默认开启2个进程
+    if (configure->process > 0) // 如果配置文件有值,优先使用配置文件读取的值
+        process = configure->process;
 
+    int longindex = 0;
     char optstring[] = ":l:f:t:p:c:e:s:h?";
     static struct option longopts[] = {
         { "local_address", required_argument, 0, 'l' },
@@ -474,6 +356,9 @@ void _main(int argc, char *argv[])
         { "?", no_argument, 0, '?' },
         { 0, 0, 0, 0 }
     };
+    char *p = NULL;
+    //char optstring[] = ":l:f:t:p:c:e:s:h?";
+    //while (-1 != (opt = getopt(argc, argv, optstring))) {
     while (-1 != (opt = getopt_long(argc, argv, optstring, longopts, &longindex))) {
         switch (opt) {
         case 'l':
@@ -501,12 +386,7 @@ void _main(int argc, char *argv[])
             process = atoi(optarg);
             break;
         case 'c':
-            free_tcp(&http_head_strrep);
-            free_tcp(&http_head_regrep);
-            free_tcp(&https_head_strrep);
-            free_tcp(&https_head_regrep);
             free_conf(configure);
-            memset(configure, 0, sizeof(struct CONF));
             read_conf(optarg, configure);
             break;
         case 'e':
@@ -515,14 +395,13 @@ void _main(int argc, char *argv[])
         case 's':
             if (strcasecmp(optarg, "stop") == 0 || strcasecmp(optarg, "quit") == 0) {
                 free_conf(configure);
-                exit(process_signal(SERVER_TYPE_STOP, executable_filename));
+                exit(process_signal(SERVER_STOP, executable_filename));
             }
             if (strcasecmp(optarg, "restart") == 0 || strcasecmp(optarg, "reload") == 0) {
-                process_signal(SERVER_TYPE_STOP, executable_filename);
+                process_signal(SERVER_RELOAD, executable_filename);
-                while (process_signal(SERVICE_TYPE_STATUS_NOT_PRINT, executable_filename) == 0) ;
             }
             if (strcasecmp(optarg, "status") == 0)
-                exit(process_signal(SERVER_TYPE_STATUS, executable_filename));
+                exit(process_signal(SERVER_STATUS, executable_filename));
             break;
         case 'h':
         case '?':
@@ -534,102 +413,73 @@ void _main(int argc, char *argv[])
         }
     }
     
-    
+    // 设置每个进程允许打开的最大文件数
-    signal(SIGPIPE, SIG_IGN);
+    rt.rlim_max = rt.rlim_cur = MAX_CONNECTION * 2;
-#if DAEMON
+    if (setrlimit(RLIMIT_NOFILE, &rt) == -1) {
-    // 守护进程
-    int nochdir = 1;
-    int noclose = 1;
-    int pid;
-    if ((pid = fork()) < 0) {
-        return;
-    } else if (0 != pid) {
-        free_tcp(&http_head_strrep);
-        free_tcp(&http_head_regrep);
-        free_tcp(&https_head_strrep);
-        free_tcp(&https_head_regrep);
-        free_conf(configure);
-        free(configure);
-        exit(0);
-    }
-
-    if (setsid() < 0) {
-        return;
-    }
-
-    signal(SIGHUP, SIG_IGN);
-    if ((pid = fork()) < 0) {
-        return;
-    } else if (0 != pid) {
-        free_tcp(&http_head_strrep);
-        free_tcp(&http_head_regrep);
-        free_tcp(&https_head_strrep);
-        free_tcp(&https_head_regrep);
-        free_conf(configure);
-        free(configure);
-        exit(0);
-    }
-
-    if (0 == nochdir) {
-        chdir("/");
-    }
-
-    if (0 == noclose) {
-        freopen("/dev/null", "r", stdin);
-        freopen("/dev/null", "w", stdout);
-        freopen("/dev/null", "w", stderr);
-    }
-#endif
-
-
-
-    // 反转链表，使读取的配置正序
-    http_head_strrep = local_reverse(http_head_strrep);
-    http_head_regrep = local_reverse(http_head_regrep);
-
-    https_head_strrep = local_reverse(https_head_strrep);
-    https_head_regrep = local_reverse(https_head_regrep);
-
-/*
-    print_tcp(https_head_strrep);
-    print_tcp(https_head_regrep);
-    free_tcp(&https_head_strrep);
-    free_tcp(&https_head_regrep);
-    
-    print_tcp(http_head_strrep);
-    print_tcp(http_head_regrep);
-    free_tcp(&http_head_strrep);
-    free_tcp(&http_head_regrep);
-    
-    free_conf(configure);
-    free(configure);
-    exit(0);
-*/
-
-    
-    rt.rlim_max = rt.rlim_cur = MAX_CONNECTION * 2; // 设置每个进程允许打开的最大文件数
-    if (setrlimit(RLIMIT_NOFILE, &rt) == -1)
         perror("setrlimit");
-    initialize(configure);
+    }
     
+    server_ini();                   // 守护进程
+    httpdns_initialize(configure);  // 初始化httpdns
+    memset(cts, 0, sizeof(cts));
+    for (i = MAX_CONNECTION; i--;)
+        cts[i].fd = -1;
+    // 为服务端的结构体分配内存
+    for (i = 1; i < MAX_CONNECTION; i += 2) {
+        cts[i].ready_data = (char *)malloc(BUFFER_SIZE);
+        if (cts[i].ready_data == NULL) {
+            fputs("out of memory.", stderr);
+            exit(1);
+        }
+    }
 
-    if (setegid(configure->uid) == -1 || seteuid(configure->uid) == -1) // 设置uid
+    server_sock = create_server_socket(configure->tcp_listen);      // IPV4
-        exit(1);
+    server_sock6 = create_server_socket6(configure->tcp6_listen);   // IPV6
-        
-    while (configure->process-- > 1 && (child_pid = fork()) == 0);
-    
     epollfd = epoll_create(MAX_CONNECTION);
     if (epollfd == -1) {
         perror("epoll_create");
         exit(1);
     }
 
-    thread_loop(configure);
+    if (setegid(configure->uid) == -1 || seteuid(configure->uid) == -1) // 设置uid
+        exit(1);
+/*
+    start_server(configure); // 单线程
+    httpdns_loop(configure);
+*/
 
+    pthread_t thread_id = 0;
+    sigset_t signal_mask;
+    sigemptyset(&signal_mask);
+    sigaddset(&signal_mask, SIGPIPE); // 忽略PIPE信号
+    if (pthread_sigmask(SIG_BLOCK, &signal_mask, NULL) != 0) {
+        printf("block sigpipe error\n");
+    }
+    
+    if (timeout_minute)
+        pthread_create(&thread_id, NULL, &tcp_timeout_check, NULL);
+    if (pthread_create(&thread_id, NULL, &http_proxy_loop, (void *)configure) != 0)
+        perror("pthread_create");
+    if (pthread_create(&thread_id, NULL, &httpdns_loop, (void *)configure) != 0)
+        perror("pthread_create");
+
+    pthread_join(thread_id, NULL);
+    pthread_exit(NULL);
+
+/*  线程分离
+    pthread_attr_t attr;
+    pthread_attr_init(&attr);
+    pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+    pthread_create(&thread_id, &attr, &tcp_timeout_check, NULL);
+    pthread_create(&thread_id, &attr, &http_proxy_loop, (void *)configure);
+    pthread_create(&thread_id, &attr, &httpdns_loop, (void *)configure);
+    pthread_exit(NULL);
+*/
     return;
 }
 
-int main(int argc, char *argv[], char **envp)
+int main(int argc, char *argv[], char **env)
 {
     _main(argc, argv);
     return 0;

main.h

@@ -24,50 +24,17 @@
 
 #define MAX_CONNECTION 1020
 #define BUFFER_SIZE 8192
+#define PATH_SIZE 270
 #define CACHE_SIZE 270
-#define BUILD(fmt...)  do { fprintf(stderr,"%s %s ",__DATE__,__TIME__); fprintf(stderr, ##fmt); } while(0)
+#define HTTP_HEAD_CACHE_SIZE 1024
-#define ERRDEBUG fprintf(stderr,"Error Occured at File: %s, Function: %s, Line: %d, Date: %s, Time: %s.\n", __FILE__, __FUNCTION__, __LINE__, __DATE__, __TIME__);
-
-#define DAEMON 1
-
-struct global {
-    int tcp_listen_fd, dns_listen_fd, udp_listen_fd, uid, procs, timeout_m;
-    unsigned mode:3, strict_modify:1;
-};
-
-struct save_header {
-    struct save_header *next;
-    char *key, *value, *replace_string;
-    int key_len, value_len, replace_string_len, updateTime, timer;
-    unsigned notUpdate:1;
-};
-
-struct modify {
-    char *first, *del_hdr, *src, *dest;
-    struct save_header *saveHdr;
-    struct modify *next;
-    int first_len, del_hdr_len, src_len, dest_len;
-    unsigned flag:3;            //判断修改请求头的操作
-};
-
-struct tcp_mode {
-    struct sockaddr_in dst;
-    struct modify *m;
-    unsigned encodeCode,        //wap_connect模式数据编码传输
-     uri_strict:1, http_only_get_post:1;
-};
-
-extern struct global global;
-extern struct tcp_mode https;
-extern struct save_header *saveHdrs;
-extern int default_ssl_request_len;
-extern char *default_ssl_request;
 
+extern int local_port;
 extern char local_host[CACHE_SIZE];
-extern int epollfd, local_port, process;
+extern int process;
+
+extern int epollfd;
 extern struct epoll_event ev, events[MAX_CONNECTION + 1];
 int create_connection(char *remote_host, int remote_port);
 int create_connection6(char *remote_host, int remote_port);
-extern uint16_t tcp_listen_port;
 
 #endif

timeout.c

@@ -0,0 +1,22 @@
+#include "timeout.h"
+#include "main.h"
+#include "http_proxy.h"
+
+int timeout_minute;
+
+void *tcp_timeout_check(void *nullPtr)
+{
+    int i;
+
+    while (1) {
+        sleep(60);
+        for (i = 0; i < MAX_CONNECTION; i += 2) {
+            if (cts[i].fd > -1) {
+                if (cts[i].timer >= timeout_minute) {
+                    close_connection(cts + i);
+                } else
+                    cts[i].timer++;
+            }
+        }
+    }
+}

timeout.h

@@ -0,0 +1,7 @@
+#ifndef TIME_H
+#define TIME_H
+
+extern int timeout_minute;
+void *tcp_timeout_check(void *nullPtr);
+
+#endif

udpServer/Makefile

@@ -1,13 +0,0 @@
-CROSS_COMPILE ?= 
-CC := $(CROSS_COMPILE)gcc
-STRIP := $(CROSS_COMPILE)strip
-CFLAGS := -O2 -pthread -Wall
-BIN := udpServer
-
-all : udpServer.o
-	$(CC) $(CFLAGS) -o $(BIN) $^
-	$(STRIP) $(BIN)
-	-chmod a+x $(BIN)
-
-clean : 
-	rm -f *.o $(BIN)

udpServer/udpServer.c

@@ -1,553 +0,0 @@
-/*
-    httpUDPServer代理UDP过程:
-        [接收客户端http请求并回应http请求]  这一步可有可无
-        接收客户端数据   格式为: UDP目标地址[steuct in_addr](只有第一个包有) + UDP数据长度[uint16_t] + UDP真实数据
-        发送UDP数据并接收UDP服务器回应的数据
-        将UDP服务器回应的UDP数据返回给客户端，格式: UDP数据长度[uint16_t] + UDP真实数据
-*/
-
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <signal.h>
-#include <errno.h>
-#include <pthread.h>
-#include <time.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <poll.h>
-#include <fcntl.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <linux/netfilter_ipv4.h>
-
-#define WEB_SOCKET_RSP "HTTP/1.1 101 Switching Protocols\r\nUpgrade:  websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: ChameleonProxy httpUDP Server\r\nVia: ChameleonProxy httpUDP Server\r\n\r\n"
-#define HTTP_RSP "HTTP/1.1 200 OK\r\nConnection: Keep-Alive\r\nContent-Length: 999999999\r\nServer: ChameleonProxy httpUDP Server\r\n\r\n"
-#define SSL_RSP "HTTP/1.1 200 Connection established\r\nConnection: Keep-Alive\r\nServer: ChameleonProxy httpUDP Server\r\n\r\n"
-#define BUFFER_SIZE 4096+65535
-#define DEFAULT_TIMEOUT_S 20
-#define DEFAULT_THEAD_POOL_SIZE 30
-#define HTTP_TYPE 0
-#define OTHER_TYPE 1
-
-struct clientData {
-    char buffer[BUFFER_SIZE+1], *client_data, *udpData;
-    struct sockaddr_in udpDst;
-    int client_data_len, clientfd, remote_udpfd;
-    uint16_t udpData_len;
-    unsigned sentRspHttpReq :1;
-};
-
-struct clientData publicConn;  //主线程设置该变量，子线程复制
-pthread_cond_t thCond = PTHREAD_COND_INITIALIZER;
-pthread_mutex_t thMutex = PTHREAD_MUTEX_INITIALIZER;
-pthread_t master_thId;  //主线程的线程id
-int listenfd = -1,
-    timeout_s = DEFAULT_TIMEOUT_S,
-    thread_pool_size = DEFAULT_THEAD_POOL_SIZE;
-uint8_t encodeCode = 0;
-
-void usage()
-{
-    printf("httpudp server(0.3):\n"
-    "Author: CuteBi\n"
-    "E-mail: 915445800@qq.com\n"
-    "    -l    \033[20G listen port\n"
-    "    -t    \033[20G timeout(s)  defaule is %d s\n"
-    "    -w   \033[20G worker proc\n"
-    "    -p    \033[20G thread pool size default is %d\n"
-    "    -e    \033[20G encode data code(128-255) default is 0\n"
-    "    -u    \033[20G set uid\n\n", DEFAULT_TIMEOUT_S, DEFAULT_THEAD_POOL_SIZE);
-    exit(0);
-}
-
-/* 对数据进行编码 */
-void dataEncode(char *data, int data_len)
-{
-    while (data_len-- > 0)
-        data[data_len] ^= encodeCode;
-}
-
-/* 判断请求类型 */
-uint8_t request_type(char *req)
-{
-    if (strncmp(req, "GET", 3) == 0 || 
-    strncmp(req, "POST", 4) == 0 ||
-    strncmp(req, "CONNECT", 7) == 0 ||
-    strncmp(req, "HEAD", 4) == 0 ||
-    strncmp(req, "PUT", 3) == 0 ||
-    strncmp(req, "OPTIONS", 7) == 0 ||
-    strncmp(req, "MOVE", 4) == 0 ||
-    strncmp(req, "COPY", 4) == 0 ||
-    strncmp(req, "TRACE", 5) == 0 ||
-    strncmp(req, "DELETE", 6) == 0 ||
-    strncmp(req, "LINK", 4) == 0 ||
-    strncmp(req, "UNLINK", 6) == 0 ||
-    strncmp(req, "PATCH", 5) == 0 ||
-    strncmp(req, "WRAPPED", 7) == 0)
-        return HTTP_TYPE;
-    else
-        return OTHER_TYPE;
-}
-
-/* 回应HTTP请求 */
-int rspHttpReq(struct clientData *client)
-{
-    /* 回应CONNECT请求 */
-    if (strncmp(client->client_data, "CON", 3) == 0)
-    {
-        if (write(client->clientfd, SSL_RSP, sizeof(SSL_RSP) - 1) <= 0)
-        {
-            perror("ssl rsp write()");
-            return 1;
-        }
-    }
-    /* 回应WebSocket请求 */
-    else if (strstr(client->client_data, "websocket"))
-    {
-        if (write(client->clientfd, WEB_SOCKET_RSP, sizeof(WEB_SOCKET_RSP) - 1) <= 0)
-        {
-            perror("websocket rsp write()");
-            return 1;
-        }
-    }
-    /* 回应HTTP请求 */
-    else
-    {
-        if (write(client->clientfd, HTTP_RSP, sizeof(HTTP_RSP) - 1) <= 0)
-        {
-            perror("http rsp write()");
-            return 1;
-        }
-    }
-
-    client->sentRspHttpReq = 1;
-    return 0;
-}
-
-/* 得到客户端数据中的udpDataLen dstAddr */
-int parse_request(struct clientData *client)
-{
-    char *headerEnd;
-
-    if (request_type(client->client_data) == OTHER_TYPE)
-    {
-        client->udpData = client->client_data;
-    }
-    else
-    {
-        headerEnd = strstr(client->client_data, "\n\r\n");
-        if (headerEnd == NULL)
-        {
-            //puts("headerEnd NULL.");
-            return 1;
-        }
-        *headerEnd = '\0';
-        if (client->sentRspHttpReq == 0 && rspHttpReq(client) != 0)
-            return 1;
-        *headerEnd = '\n';
-        client->udpData = headerEnd + 3;
-    }
-    if ((int)(client->client_data_len - (client->udpData - client->client_data) - sizeof(struct sockaddr_in) - sizeof(uint16_t)) <= 0)
-        return 1;
-    if (encodeCode)
-        dataEncode(client->udpData, (int)(client->client_data_len - (client->udpData - client->client_data)));
-
-    /* 复制UDP目标地址跟UDP长度 */
-    memcpy(&client->udpDst, client->udpData, sizeof(struct sockaddr_in));
-    memcpy(&(client->udpData_len), (uint16_t *)(client->udpData + sizeof(struct sockaddr_in)), sizeof(uint16_t));
-    client->udpData += sizeof(struct sockaddr_in);
-    //printf("len: [%u] dataLen: [%d], ip: [%s], port: [%d]\n", client->udpData_len, (int)(client->client_data_len - (client->udpData - client->client_data)), inet_ntoa(client->udpDst.sin_addr), ntohs(client->udpDst.sin_port));
-
-    return 0;
-}
-
-int recvServer(struct clientData *server)
-{
-    int read_len;
-
-    while ((read_len = recv(server->remote_udpfd, server->buffer + sizeof(uint16_t), BUFFER_SIZE - sizeof(uint16_t), MSG_DONTWAIT)) > 0)
-    {
-        //printf("%u: read remote: [%d]\n", pthread_self(), read_len);
-        memcpy(server->buffer, &read_len, sizeof(uint16_t));
-        //printf("server read_len: [%d], server->buffer: [%u]\n", read_len, *(uint16_t *)server->buffer);
-        read_len += sizeof(uint16_t);
-        if (encodeCode)
-            dataEncode(server->buffer, read_len);
-        if (write(server->clientfd, server->buffer, read_len) != read_len)
-        {
-            perror("write to client()");
-            return 1;
-        }
-    }
-    if (read_len == 0 || errno != EAGAIN)
-    {
-        perror("server recv()");
-        return 1;
-    }
-    return 0;
-}
-
-/*
-    发送客户端数据到服务器
-    发送失败或者发送完成返回null
-    未发送完成返回未发送的数据首地址
-*/
-char *sendServer(struct clientData *client)
-{
-    char *dataPtr;
-    int write_len;
-
-    dataPtr = client->client_data;
-    //client->client_data_len > 1才能满意uint16_t这个类型的储存空间
-    while (client->client_data_len > 1 && (int)(*(uint16_t *)dataPtr + sizeof(uint16_t)) <= client->client_data_len)
-    {
-        if ((write_len = write(client->remote_udpfd, dataPtr+sizeof(uint16_t), *(uint16_t *)dataPtr)) != *(uint16_t *)dataPtr)
-        {
-            perror("write to remote()");
-            return NULL;
-        }
-        //printf("%u, fd: %d, write_len: %d, client_data_len: %d\n", pthread_self(), client->remote_udpfd, write_len, client->client_data_len);
-        dataPtr += write_len + sizeof(uint16_t);
-        client->client_data_len -= write_len + sizeof(uint16_t);
-    }
-
-    return client->client_data_len > 0 ? dataPtr : NULL;
-}
-
-int recvClient(struct clientData *client)
-{
-    char *new_data, *dataPtr;
-    int read_len;
-
-    do {
-        new_data = (char *)realloc(client->client_data, client->client_data_len + BUFFER_SIZE);
-        if (new_data == NULL)
-            return 1;
-        client->client_data = new_data;
-        read_len = recv(client->clientfd, client->client_data + client->client_data_len, BUFFER_SIZE, MSG_DONTWAIT);
-        printf("%lu: get client len: [%d]\n", pthread_self(), read_len);
-        if (read_len <= 0)
-        {
-            if (read_len == 0 || errno != EAGAIN)
-            {
-                perror("client read()");
-                return 1;
-            }
-            return 0;
-        }
-        if (encodeCode)
-            dataEncode(client->client_data + client->client_data_len, read_len);
-        client->client_data_len += read_len;
-        dataPtr = sendServer(client);
-        //write()发生错误
-        if (dataPtr == NULL && client->client_data_len > 0)
-        {
-            return 1;
-        }
-        else if (client->client_data_len > 0)
-        {
-            memmove(client->client_data, dataPtr, client->client_data_len);
-        }
-        else
-        {
-            free(client->client_data);
-            client->client_data = NULL;
-            client->client_data_len = 0;
-        }
-    } while (read_len == BUFFER_SIZE);
-
-    return 0;
-}
-
-void forwardData(struct clientData *client)
-{
-    struct pollfd pfds[2];
-
-    pfds[0].fd = client->remote_udpfd;
-    pfds[1].fd = client->clientfd;
-    pfds[0].events = pfds[1].events = POLLIN;
-    while (poll(pfds, 2, timeout_s*1000) > 0)
-    {
-        printf("a event %lu\n", pthread_self());
-        if (pfds[0].revents & POLLIN)
-        {
-            printf("recvServer %lu\n", pthread_self());
-            if (recvServer(client) != 0)
-                return;
-        }
-        if (pfds[1].revents & POLLIN)
-        {
-            printf("recvServer %lu\n", pthread_self());
-            if (recvClient(client) != 0)
-                return;
-        }
-    }
-}
-
-int sendFirstData(struct clientData *client)
-{
-    char *dataPtr;
-
-    printf("%lu: sendFirstData\n", pthread_self());
-    client->remote_udpfd = socket(AF_INET, SOCK_DGRAM, 0);
-    if (client->remote_udpfd < 0)
-    {
-        perror("socket()");
-        return 1;
-    }
-    connect(client->remote_udpfd, (struct sockaddr *)&client->udpDst, sizeof(struct sockaddr_in));
-    client->client_data = client->udpData;
-    client->client_data_len = client->udpData_len + sizeof(uint16_t);
-    dataPtr = sendServer(client);
-    if (dataPtr == NULL)
-    {
-        if (client->client_data_len > 0)
-            return 1;
-        client->client_data = NULL;
-    }
-    else
-    {
-        client->client_data = (char *)malloc(client->client_data_len);
-        if (client->client_data == NULL)
-            return 1;
-        memcpy(client->client_data, dataPtr, client->client_data_len);
-    }
-
-    printf("%lu: sendFirstData end\n", pthread_self());
-    return 0;
-}
-
-int parseClient(struct clientData *client)
-{
-    int read_len, count;
-
-    printf("%lu: parseClient\n", pthread_self());
-    count = 0;
-    client->client_data = client->buffer;
-    do {
-        //printf("%u: start read\n", pthread_self());
-        read_len = read(client->clientfd, client->client_data + client->client_data_len, BUFFER_SIZE - client->client_data_len);
-        //printf("%u: read_len = %d\n", pthread_self(), read_len);
-        if (read_len <= 0)
-        {
-            perror("parseClient read()");
-            return 1;
-        }
-        client->client_data_len += read_len;
-        client->client_data[client->client_data_len]  = '\0';
-        count++;
-    } while (parse_request(client) != 0 && count < 5);
-
-    //printf("%u: parseClient end\n", pthread_self());
-    return count == 5 ? 1 : 0;
-}
-
-void *new_connection(void *nullPtr)
-{
-    #define NO_COPY_SIZE (BUFFER_SIZE + 1 + (sizeof(char *)<<1) + sizeof(struct sockaddr_in))  //struct clientData不需要全部复制
-    struct clientData client;
-
-    //printf("new_connection: %u\n", pthread_self())
-    memcpy((void *)(&client) + NO_COPY_SIZE, (void *)(&publicConn) + NO_COPY_SIZE, sizeof(struct clientData) - NO_COPY_SIZE);
-    pthread_kill(master_thId, SIGUSR1);
-    /* 读取客户端数据 */
-    if (parseClient(&client) == 0 && sendFirstData(&client) == 0)
-        forwardData(&client);
-    else
-        puts("parseClient() client error");
-
-    close(client.remote_udpfd);
-    close(client.clientfd);
-    if (client.client_data != client.buffer && client.client_data != client.udpData)
-        free(client.client_data);
-
-    //printf("new_connection end: %u\n", pthread_self());
-    return NULL;
-}
-
-int accept_client()
-{
-    struct sockaddr_in addr;
-    struct timeval tv = {timeout_s, 0};
-    socklen_t addr_len = sizeof(addr);
-
-    publicConn.clientfd = accept(listenfd, (struct sockaddr *)&addr, &addr_len);
-    if (publicConn.clientfd < 0)
-    {
-        perror("accept()");
-        return 1;
-    }
-    setsockopt(publicConn.clientfd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
-
-    return 0;
-}
-
-void *threadPool_waitTask(void *ptr)
-{
-    int *isBusy;
-
-    isBusy = (int *)ptr;
-    while (1)
-    {
-        pthread_cond_wait(&thCond, &thMutex);
-        pthread_mutex_unlock(&thMutex);  //解锁，让其他线程可以并发
-        *isBusy = 1;
-        new_connection(NULL);
-        *isBusy = 0;
-    }
-
-    return NULL;
-}
-
-void loop()
-{
-    pthread_t th_id;
-    pthread_attr_t attr;
-    sigset_t sig;
-    int *th_isBusy,  //线程执行繁忙值为1，空闲值为0
-        i, signum;
-
-    //初始化publicConn
-    memset(&publicConn, 0, sizeof(struct clientData));
-    publicConn.remote_udpfd = -1;
-    /* 创建线程池 */
-    pthread_attr_init(&attr);
-    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
-    th_isBusy = (int *)calloc(thread_pool_size, sizeof(int));
-    if (th_isBusy == NULL)
-    {
-        perror("calloc()");
-        return;
-    }
-    for (i = 0; i < thread_pool_size; i++)
-        pthread_create(&th_id, &attr, &threadPool_waitTask, (void *)(th_isBusy + i));
-    /* 初始化信号设置，用于子线程告诉主线程内存已经拷贝完毕 */
-    sigemptyset(&sig);
-    sigaddset(&sig, SIGUSR1);
-    pthread_sigmask(SIG_BLOCK, &sig, NULL);
-    master_thId = pthread_self();
-    while (1)
-    {
-        if (accept_client() != 0)
-        {
-            sleep(3);
-            continue;
-        }
-        /* 如果线程池有空闲线程则调用空闲线程处理 */
-        for (i = 0; i < thread_pool_size; i++)
-        {
-            if (th_isBusy[i] == 0)
-            {
-                pthread_cond_signal(&thCond);
-                break;
-            }
-        }
-        /* 线程池没有空闲线线程，创建新线程运行任务 */
-        if (i == thread_pool_size)
-        {
-            if (pthread_create(&th_id, &attr, &new_connection, NULL) != 0)
-            {
-                close(publicConn.clientfd);
-                continue;
-            }
-        }
-        sigwait(&sig, &signum);
-    }
-}
-
-int create_listen(char *ip, int port)
-{
-    int fd, optval = 1;
-    struct sockaddr_in addr;
-
-    if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
-    {
-        perror("socket()");
-        return -1;
-    }
-    addr.sin_family = AF_INET;
-    addr.sin_port = htons(port);
-    addr.sin_addr.s_addr = inet_addr(ip);
-    if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) < 0)
-    {
-        close(fd);
-        perror("setsockopt()");
-        return -1;
-    }
-    if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) != 0)
-    {
-        close(fd);
-        perror("bind()");
-        return -1;
-    }
-    if (listen(fd, 500) != 0)
-    {
-        close(fd);
-        perror("listen()");
-        return -1;
-    }
-
-    return fd;
-}
-
-void readCmd(int argc, char **argv)
-{
-    int opt, worker_proc;
-
-    while ((opt = getopt(argc, argv, "l:u:e:w:p:t:h")) != -1)
-    {
-        switch (opt)
-        {
-            case 't':
-                timeout_s = atoi(optarg);
-            break;
-
-            case 'e':
-                encodeCode = atoi(optarg);
-            break;
-
-            case 'l':
-                    listenfd = create_listen((char *)"0.0.0.0", atoi(optarg));
-            break;
-
-            case 'u':
-                if (setgid(atoi(optarg)) || setuid(atoi(optarg)))
-                    perror("setgid(or setuid)()");
-            break;
-
-            case 'w':
-                worker_proc = atoi(optarg);
-                while (worker_proc-- > 1 && fork());
-            break;
-
-            case 'p':
-                thread_pool_size = atoi(optarg);
-            break;
-
-            case 'h':
-                usage();
-            break;
-        }
-    }
-
-}
-int main(int argc, char **argv)
-{
-    readCmd(argc, argv);
-    if (listenfd < 0)
-    {
-        usage();
-        return 1;
-    }
-    if (daemon(1, 1) == -1)
-    {
-        perror("daemon()");
-        return 1;
-    }
-    signal(SIGPIPE, SIG_IGN);
-    loop();
-
-    return 0;
-}