🌴 Sync 2026-03-05 23:51:42

openwrt-mproxy/Makefile

@@ -0,0 +1,49 @@
+include $(TOPDIR)/rules.mk
+
+PKG_NAME:=mproxy
+PKG_VERSION=1.0.1
+PKG_RELEASE:=1
+
+PKG_MAINTAINER:=lean
+PKG_LICENSE:=MIT
+PKG_LICENSE_FILES:=LICENSE
+
+PKG_SOURCE_PROTO:=git
+#PKG_SOURCE_URL:=https://github.com/openwrt-develop/mproxy.git
+#PKG_SOURCE_VERSION:=ea3abaa40c901da6bb8e655cde63d3cac28b83ec
+PKG_SOURCE_URL:=https://github.com/lonsx/mproxy-mod.git
+PKG_SOURCE_VERSION:=ea3abaa40c901da6bb8e655cde63d3cac28b83ec
+
+PKG_SOURCE_SUBDIR:=$(PKG_NAME)
+#PKG_SOURCE:=$(PKG_SOURCE_SUBDIR).tar.gz
+PKG_SOURCE:=$(PKG_NAME).$(PKG_VERSION).$(PKG_RELEASE).tar.gz
+PKG_BUILD_DIR:=$(BUILD_DIR)/$(PKG_SOURCE_SUBDIR)
+PKG_BUILD_PARALLEL:=1
+
+include $(INCLUDE_DIR)/package.mk
+
+define Package/mproxy
+	SECTION:=net
+	CATEGORY:=Network
+	TITLE:=mproxy for OpenWRT
+	DEPENDS:=
+endef
+
+define Package/mproxy/description
+	mproxy is a Tiny Proxy in C.
+endef
+
+
+define Package/mproxy/Prepare
+  mkdir -p $(PKG_BUILD_DIR)
+  $(CP) ./src/* $(PKG_BUILD_DIR)/
+endef
+
+
+define Package/mproxy/install
+	$(INSTALL_DIR) $(1)/usr/bin
+	$(INSTALL_BIN) $(PKG_BUILD_DIR)/mproxy $(1)/usr/bin/mproxy
+endef
+
+$(eval $(call BuildPackage,mproxy))
+

openwrt-mproxy/README.md

@@ -0,0 +1,9 @@
+# luci-app-mproxy
+luci-app-mproxy | mproxy
+
+
+luci-app-mproxy  应用于openwrt上的mproxy
+# 使用：
+  将这个文件放入package里面，
+  make的时候选择“Network”>>“mproxy”
+# 暂时没有luci界面

openwrt-mproxy/files/etc/init.d/mproxy

@@ -0,0 +1,23 @@
+#!/bin/sh /etc/rc.common
+# Copyright (c) 2011-2015 OpenWrt.org
+
+START=95
+mproxy_port=8080
+
+start() {
+	service_start /usr/bin/mproxy -T -l $mproxy_port -h 127.0.0.1:1194 -d
+	#iptables -A INPUT -p tcp --dport $mproxy_port -j ACCEPT
+	echo "mproxy has started."
+}
+
+stop() {
+	service_stop /usr/bin/mproxy
+	#iptables -D INPUT -p tcp --dport $mproxy_port -j ACCEPT
+	echo "mproxy has stopped."
+}
+
+restart() {
+	stop
+	sleep 1
+	start
+}

openwrt-mproxy/src/Makefile

@@ -0,0 +1,14 @@
+CC ?= gcc
+CFLAGS = -g -Wall -Werror -DDBUG
+
+all: mproxy
+
+mproxy: mproxy.o
+	$(CC) $(CFLAGS) mproxy.o -o mproxy
+
+mproxy.o: mproxy.c
+	$(CC) $(CFLAGS) -c mproxy.c
+
+clean:
+	rm -rf *.o
+	rm -rf mproxy

openwrt-mproxy/src/mproxy.c

@@ -0,0 +1,862 @@
+#include <arpa/inet.h>
+#include <errno.h>
+#include <libgen.h>
+#include <netdb.h>
+#include <resolv.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <sys/wait.h>
+#include <netinet/in.h> 
+
+
+#include <string.h>
+
+#define BUF_SIZE 8192
+
+#define READ  0
+#define WRITE 1
+
+#define DEFAULT_LOCAL_PORT    8080  
+#define DEFAULT_REMOTE_PORT   8081 
+#define DEFAULT_R_P   1024		/* 定义-r 时默认的转发CONNECT流的端口 */
+#define DEFAULT_M_S   Lbxx: 	/* 定义-m 时默认的ML关键字符串(经判断无用，可舍弃) */
+#define SERVER_SOCKET_ERROR -1
+#define SERVER_SETSOCKOPT_ERROR -2
+#define SERVER_BIND_ERROR -3
+#define SERVER_LISTEN_ERROR -4
+#define CLIENT_SOCKET_ERROR -5
+#define CLIENT_RESOLVE_ERROR -6
+#define CLIENT_CONNECT_ERROR -7
+#define CREATE_PIPE_ERROR -8
+#define BROKEN_PIPE_ERROR -9
+#define HEADER_BUFFER_FULL -10
+#define BAD_HTTP_PROTOCOL -11
+
+#define MAX_HEADER_SIZE 8192
+
+
+#if defined(OS_ANDROID)
+#include <android/log.h>
+ 
+#define LOG(fmt...) __android_log_print(ANDROID_LOG_DEBUG,__FILE__,##fmt)
+ 
+#else
+#define LOG(fmt...)  do { fprintf(stderr,"%s %s ",__DATE__,__TIME__); fprintf(stderr, ##fmt); } while(0)
+#endif
+
+
+char remote_host[128]; 
+int remote_port; 
+int local_port;
+char r_h[128]; 
+int r_p; 
+char m_s[128];
+
+int server_sock; 
+int client_sock;
+int remote_sock;
+
+
+
+
+char * header_buffer ;
+
+
+enum 
+{
+    FLG_NONE = 0,       /* 正常数据流不进行编解码 */
+    R_C_DEC = 1,        /* 读取客户端数据仅进行解码 */
+    W_S_ENC = 2         /* 发送到服务端进行编码 */
+};
+
+static int io_flag; /* 网络io的一些标志位 */
+static int r_flag; /* 是否启用-r 匹配免流host直接转发CONNECT流量模式 */
+static int m_flag; /* 是否启用-m 关键字头匹配免流模式 */
+static int m_pid; /* 保存主进程id */
+
+
+
+void server_loop();
+void stop_server();
+void handle_client(int client_sock, struct sockaddr_in client_addr);
+void forward_header(int destination_sock);
+void forward_data(int source_sock, int destination_sock);
+void rewrite_header();
+int send_data(int socket,char * buffer,int len );
+int receive_data(int socket, char * buffer, int len);
+void hand_mproxy_info_req(int sock,char * header_buffer) ;
+void get_info(char * output);
+const char * get_work_mode() ;
+int create_connection() ;
+int _main(int argc, char *argv[]) ;
+
+
+
+
+ssize_t readLine(int fd, void *buffer, size_t n)
+{
+    ssize_t numRead;                    
+    size_t totRead;                     
+    char *buf;
+    char ch;
+
+    if (n <= 0 || buffer == NULL) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    buf = buffer;                       
+
+    totRead = 0;
+    for (;;) {
+        numRead = receive_data(fd, &ch, 1);
+
+        if (numRead == -1) {
+            if (errno == EINTR)         
+                continue;
+            else
+                return -1;              /* 未知错误 */
+
+        } else if (numRead == 0) {      /* EOF */
+            if (totRead == 0)           /* No bytes read; return 0 */
+                return 0;
+            else                        /* Some bytes read; add '\0' */
+                break;
+
+        } else {     
+                                      
+            if (totRead < n - 1) {      /* Discard > (n - 1) bytes */
+                totRead++;
+                *buf++ = ch;
+            }
+
+            if (ch == '\n')
+                break;
+        }
+    }
+
+    *buf = '\0';
+    return totRead;
+}
+
+int read_header(int fd, void * buffer)
+{
+    // bzero(header_buffer,sizeof(MAX_HEADER_SIZE));
+    memset(header_buffer,0,MAX_HEADER_SIZE);
+    char line_buffer[2048];
+    char * base_ptr = header_buffer;
+
+    for(;;)
+    {
+        memset(line_buffer,0,2048);
+
+        int total_read = readLine(fd,line_buffer,2048);
+        if(total_read <= 0)
+        {
+            return CLIENT_SOCKET_ERROR;
+        }
+        //防止header缓冲区蛮越界
+        if(base_ptr + total_read - header_buffer <= MAX_HEADER_SIZE)
+        {
+           strncpy(base_ptr,line_buffer,total_read); 
+           base_ptr += total_read;
+        } else 
+        {
+            return HEADER_BUFFER_FULL;
+        }
+
+        //读到了空行，http头结束
+        if(strcmp(line_buffer,"\r\n") == 0 || strcmp(line_buffer,"\n") == 0)
+        {
+            break;
+        }
+
+    }
+    return 0;
+
+}
+
+void extract_server_path(const char * header,char * output)
+{
+    char * p = strstr(header,"GET /");
+    if(p) {
+        char * p1 = strchr(p+4,' ');
+        strncpy(output,p+4,(int)(p1  - p - 4) );
+    }
+    
+}
+
+int extract_host(const char * header)
+{
+	if(!m_flag)
+	{
+		if(!r_flag)
+		{
+			char * _p = strstr(header,"CONNECT");  /* 在 CONNECT 方法中解析 隧道主机名称及端口号 */
+    		if(_p)
+    		{
+    		    char * _p1 = strchr(_p,' ');
+
+    		    char * _p2 = strchr(_p1 + 1,':');
+    		    char * _p3 = strchr(_p1 + 1,' ');
+
+    		    if(_p2)
+    		    {
+    		        char s_port[10];
+    		        bzero(s_port,10);
+
+    		        strncpy(remote_host,_p1+1,(int)(_p2  - _p1) - 1);
+    		        strncpy(s_port,_p2+1,(int) (_p3 - _p2) -1);
+    		        remote_port = atoi(s_port);
+
+    		    } else 
+    		    {
+    		        strncpy(remote_host,_p1+1,(int)(_p3  - _p1) -1);
+    		        remote_port = 80;
+    		    }
+    		    
+    		    
+    		    return 0;
+    		}
+
+
+    		char * p = strstr(header,"Host:");
+    		if(!p) 
+    		{
+    		    return BAD_HTTP_PROTOCOL;
+    		}
+    		char * p1 = strchr(p,'\n');
+    		if(!p1) 
+    		{
+    		    return BAD_HTTP_PROTOCOL; 
+    		}
+
+    		char * p2 = strchr(p + 5,':'); /* 5是指'Host:'的长度 */
+
+    		if(p2 && p2 < p1) 
+    		{
+    		    
+    		    int p_len = (int)(p1 - p2 -1);
+    		    char s_port[p_len];
+    		    strncpy(s_port,p2+1,p_len);
+    		    s_port[p_len] = '\0';
+    		    remote_port = atoi(s_port);
+
+    		    int h_len = (int)(p2 - p -5 -1 );
+    		    strncpy(remote_host,p + 5 + 1  ,h_len); //Host:
+    		    //assert h_len < 128;
+    		    remote_host[h_len] = '\0';
+    		} else 
+    		{   
+    		    int h_len = (int)(p1 - p - 5 -1 -1); 
+    		    strncpy(remote_host,p + 5 + 1,h_len);
+    		    //assert h_len < 128;
+    		    remote_host[h_len] = '\0';
+    		    remote_port = 80;
+    		}
+		} else
+		{
+			strncpy(remote_host, r_h, strlen(r_h));
+            remote_port = r_p;
+		}
+	} else
+	{
+    	char * __p = strstr(header,"CONNECT");  /* 在 CONNECT 方法中解析 隧道主机名称及端口号 */
+    	char * _p = strstr(header,m_s);
+    	//printf("Show: %s\n",_p);
+    	if(_p && __p)
+    	{
+    	    char * _p1 = strchr(_p,' ');
+
+    	    char * _p2 = strchr(_p1 + 1,':');
+    	    char * _p3 = strchr(_p1 + 1,'\r');
+
+    	    if(_p2)
+    	    {
+    	        char s_port[10];
+    	        bzero(s_port,10);
+
+    	        strncpy(remote_host,_p1+1,(int)(_p2  - _p1) - 1);
+    	        strncpy(s_port,_p2+1,(int) (_p3 - _p2) -1);
+    	        remote_port = atoi(s_port);
+
+    	    } else 
+    	    {
+    	        strncpy(remote_host,_p1+1,(int)(_p3  - _p1) -1);
+    	        remote_port = 80;
+    	    }
+    	    
+    	    
+    	    return 0;
+    	}
+
+
+    	char * p = strstr(header,m_s);
+    	if(!p) 
+    	{
+	    	if(r_flag)
+	    	{
+		    	strncpy(remote_host, r_h, strlen(r_h));
+		    	remote_port = r_p;
+		    	return 0;
+	    	}else 
+	    	{
+		    	return BAD_HTTP_PROTOCOL;
+	    	}
+    	}
+    	char * p1 = strchr(p,'\n');
+    	if(!p1) 
+    	{
+    	    return BAD_HTTP_PROTOCOL; 
+    	}
+    	
+		int m_l = strlen(m_s);
+    	char * p2 = strchr(p + m_l,':'); /* m_l是指类似自定义'Lbxx:'的长度 */
+
+    	if(p2 && p2 < p1) 
+    	{
+    	    
+    	    int p_len = (int)(p1 - p2 -1);
+    	    char s_port[p_len];
+    	    strncpy(s_port,p2+1,p_len);
+    	    s_port[p_len] = '\0';
+    	    remote_port = atoi(s_port);
+
+    	    int h_len = (int)(p2 - p - m_l -1 );
+    	    strncpy(remote_host,p + m_l + 1  ,h_len); //Host:
+    	    //assert h_len < 128;
+    	    remote_host[h_len] = '\0';
+    	} else 
+    	{   
+    	    int h_len = (int)(p1 - p - m_l -1 -1); 
+    	    strncpy(remote_host,p + m_l + 1,h_len);
+    	    //assert h_len < 128;
+    	    remote_host[h_len] = '\0';
+    	    remote_port = 80;
+    	}
+    }
+    return 0;
+}
+
+/* 响应隧道连接请求  */
+int send_tunnel_ok(int client_sock)
+{
+    char * resp = "HTTP/1.1 200 Connection Established\r\n\r\n";
+    int len = strlen(resp);
+    char buffer[len+1];
+    strcpy(buffer,resp);
+    if(send_data(client_sock,buffer,len) < 0)
+    {
+        perror("Send http tunnel response  failed\n");
+        return -1;
+    }
+    return 0;
+}
+
+
+//返回mproxy的运行基本信息
+void hand_mproxy_info_req(int sock, char * header) {
+    char server_path[255] ;
+    char response[8192];
+    extract_server_path(header,server_path);
+    
+    LOG("server path:%s\n",server_path);
+    char info_buf[1024];
+    get_info(info_buf);
+    sprintf(response,"HTTP/1.0 200 OK\nServer: MProxy/0.1\n\
+                    Content-type: text/html; charset=utf-8\n\n\
+                     <html><body>\
+                     <pre>%s</pre>\
+                     </body></html>\n",info_buf);
+
+
+    write(sock,response,strlen(response));
+
+}
+
+/* 获取运行的基本信息输出到指定的缓冲区 */
+void get_info(char * output)
+{
+    int pos = 0;
+    char line_buffer[512];
+    sprintf(line_buffer,"======= mproxy (v0.1) ========\n");
+    int len = strlen(line_buffer);
+    memcpy(output,line_buffer,len);
+    pos += len ;
+
+    sprintf(line_buffer,"%s\n",get_work_mode());
+    len = strlen(line_buffer);
+    memcpy(output + pos,line_buffer,len);
+    pos += len;
+
+    if(strlen(remote_host) > 0) 
+    {
+        sprintf(line_buffer,"start server on %d and next hop is %s:%d\n",local_port,remote_host,remote_port);
+
+    } else 
+    {
+        sprintf(line_buffer,"start server on %d\n",local_port);
+    }
+    
+    len = strlen(line_buffer);
+    memcpy(output+ pos,line_buffer,len);
+    pos += len ;
+    
+    output[pos] = '\0';
+
+}
+
+
+const char * get_work_mode() 
+{
+	
+    	if(strlen(remote_host) == 0) 
+    	{
+	    	if(!r_flag && !m_flag)
+			{
+    	    	if(io_flag == FLG_NONE) 
+    	    	{
+    	    	    return "start as normal http proxy";
+    	    	} else if(io_flag == R_C_DEC)
+    	    	{
+    	    	   return "start as remote forward proxy and do decode data when recevie data" ;
+    	    	}
+    	    } else
+    		{
+	    		return "start as -r or -m mode";
+    		}
+    	    
+    	} else 
+    	{
+    	    if(io_flag == FLG_NONE) 
+    	    {
+    	        return "start as remote forward proxy";
+    	    } else if(io_flag == W_S_ENC) 
+    	    {
+    	        return "start as forward proxy and do encode data when send data";
+    	    }
+    	}
+    	return "unknow";
+    
+
+}
+
+/* 处理客户端的连接 */
+void handle_client(int client_sock, struct sockaddr_in client_addr)
+{
+    int is_http_tunnel = 0; 
+    if(strlen(remote_host) == 0) /* 未指定远端主机名称从http 请求 HOST 字段中获取 */
+    {
+        
+        #ifdef DEBUG
+        LOG(" ============ handle new client ============\n");
+        LOG(">>>Header:%s\n",header_buffer);
+        #endif
+        
+        if(read_header(client_sock,header_buffer) < 0)
+        {
+            LOG("Read Http header failed\n");
+            return;
+        } else 
+        {
+            char * p = strstr(header_buffer,"CONNECT"); /* 判断是否是http 隧道请求 */
+            if(p) 
+            {
+                LOG("receive CONNECT request\n");
+                is_http_tunnel = 1;
+            }
+
+            if(strstr(header_buffer,"GET /mproxy") >0 ) 
+            {
+                LOG("====== hand mproxy info request ====");
+                //返回mproxy的运行基本信息
+                hand_mproxy_info_req(client_sock,header_buffer);
+
+                return; 
+            }
+
+            if(extract_host(header_buffer) < 0) 
+            {
+                LOG("Cannot extract host field,bad http protrotol");
+                return;
+            }
+            LOG("Host:%s port: %d io_flag:%d\n",remote_host,remote_port,io_flag);
+
+        }
+    }
+
+    if ((remote_sock = create_connection()) < 0) {
+        LOG("Cannot connect to host [%s:%d]\n",remote_host,remote_port);
+        return;
+    }
+
+    if (fork() == 0) { // 创建子进程用于从客户端转发数据到远端socket接口
+
+        if(strlen(header_buffer) > 0 && !is_http_tunnel) 
+        {
+            forward_header(remote_sock); //普通的http请求先转发header
+        } 
+        
+        forward_data(client_sock, remote_sock);
+        exit(0);
+    }
+
+    if (fork() == 0) { // 创建子进程用于转发从远端socket接口过来的数据到客户端
+
+        if(io_flag == W_S_ENC)
+        {
+            io_flag = R_C_DEC; //发送请求给服务端进行编码，读取服务端的响应则进行解码
+        } else if (io_flag == R_C_DEC)
+        {
+             io_flag = W_S_ENC; //接收客户端请求进行解码，那么响应客户端请求需要编码
+        }
+
+        if(is_http_tunnel)
+        {
+            send_tunnel_ok(client_sock);
+        } 
+
+        forward_data(remote_sock, client_sock);
+        exit(0);
+    }
+
+    close(remote_sock);
+    close(client_sock);
+}
+
+void forward_header(int destination_sock)
+{
+    rewrite_header();
+    #ifdef DEBUG
+        LOG("================ The Forward HEAD =================");
+        LOG("%s\n",header_buffer);
+    #endif
+   
+    int len = strlen(header_buffer);
+    send_data(destination_sock,header_buffer,len) ;
+}
+
+int send_data(int socket,char * buffer,int len)
+{
+
+    if(io_flag == W_S_ENC)
+    {
+        int i;
+        for(i = 0; i < len ; i++)
+        {
+            buffer[i] ^= 1;
+           
+        }
+    }
+
+    return send(socket,buffer,len,0);
+}
+
+int receive_data(int socket, char * buffer, int len)
+{
+    int n = recv(socket, buffer, len, 0);
+    if(io_flag == R_C_DEC && n > 0)
+    {
+        int i; 
+        for(i = 0; i< n; i++ )
+        {
+            buffer[i] ^= 1;
+            // printf("%d => %d\n",c,buffer[i]);
+        }
+    }
+
+    return n;
+}
+
+
+
+/* 代理中的完整URL转发前需改成 path 的形式 */
+void rewrite_header()
+{
+    char * p = strstr(header_buffer,"http://");
+    char * p0 = strchr(p,'\0');
+    char * p5 = strstr(header_buffer,"HTTP/"); /* "HTTP/" 是协议标识 如 "HTTP/1.1" */
+    int len = strlen(header_buffer);
+    if(p)
+    {
+        char * p1 = strchr(p + 7,'/');
+        if(p1 && (p5 > p1)) 
+        {
+            //转换url到 path
+            memcpy(p,p1,(int)(p0 -p1));
+            int l = len - (p1 - p) ;
+            header_buffer[l] = '\0';
+
+
+        } else 
+        {
+            char * p2 = strchr(p,' ');  //GET http://3g.sina.com.cn HTTP/1.1
+
+            // printf("%s\n",p2);
+            memcpy(p + 1,p2,(int)(p0-p2));
+            *p = '/';  //url 没有路径使用根
+            int l  = len - (p2  - p ) + 1;
+            header_buffer[l] = '\0';
+
+        }
+    }
+    
+    
+    if(m_flag)
+    {
+    	char * p6 = strstr(header_buffer,"Host:");   //...\r\nHost: miguvod.lovev.com:8080\r\nLbxx: tiny.cc\r\n....
+    	char * p00 = strchr(p6,'\0');					//	  p6	p7						  p8	p9				p00
+    	char * p7 = strchr(p6,' ');	
+    	char * p8 = strstr(header_buffer,m_s);				
+    	char * p9 = strchr(p8,' ');
+		if(p6)
+		{
+    		if(p8 && (p8 > p6))
+    		{
+		    	memcpy(p7,p9,(int)(p00 -p9));  //以Lbxx的值覆盖Host的值，这要求Lbxx在模式中要紧跟在Host后面(仅对http)
+    	    	int l = len - (p9 - p7) ;
+    	    	header_buffer[l] = '\0';
+    		}
+		}
+	}
+}
+
+
+void forward_data(int source_sock, int destination_sock) {
+    char buffer[BUF_SIZE];
+    int n;
+
+    while ((n = receive_data(source_sock, buffer, BUF_SIZE)) > 0) 
+    { 
+
+        send_data(destination_sock, buffer, n); 
+    }
+
+    shutdown(destination_sock, SHUT_RDWR); 
+
+    shutdown(source_sock, SHUT_RDWR); 
+}
+
+
+
+int create_connection() {
+    struct sockaddr_in server_addr;
+    struct hostent *server;
+    int sock;
+
+    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
+        return CLIENT_SOCKET_ERROR;
+    }
+
+    if ((server = gethostbyname(remote_host)) == NULL) {
+        errno = EFAULT;
+        return CLIENT_RESOLVE_ERROR;
+    }
+    LOG("======= forward request to remote host:%s port:%d ======= \n",remote_host,remote_port);
+    memset(&server_addr, 0, sizeof(server_addr));
+    server_addr.sin_family = AF_INET;
+    memcpy(&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) {
+        return CLIENT_CONNECT_ERROR;
+    }
+
+    return sock;
+}
+
+
+int create_server_socket(int port) {
+    int server_sock, optval;
+    struct sockaddr_in server_addr;
+
+    if ((server_sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
+        return SERVER_SOCKET_ERROR;
+    }
+
+    if (setsockopt(server_sock, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) < 0) {
+        return SERVER_SETSOCKOPT_ERROR;
+    }
+
+    memset(&server_addr, 0, sizeof(server_addr));
+    server_addr.sin_family = AF_INET;
+    server_addr.sin_port = htons(port);
+    server_addr.sin_addr.s_addr = INADDR_ANY;
+
+    if (bind(server_sock, (struct sockaddr*)&server_addr, sizeof(server_addr)) != 0) {
+        return SERVER_BIND_ERROR;
+    }
+
+    if (listen(server_sock, 20) < 0) {
+        return SERVER_LISTEN_ERROR;
+    }
+
+    return server_sock;
+}
+
+/* 处理僵尸进程 */
+void sigchld_handler(int signal) {
+    while (waitpid(-1, NULL, WNOHANG) > 0);
+}
+
+void server_loop() {
+    struct sockaddr_in client_addr;
+    socklen_t addrlen = sizeof(client_addr);
+
+    while (1) {
+        client_sock = accept(server_sock, (struct sockaddr*)&client_addr, &addrlen);
+        
+        if (fork() == 0) { // 创建子进程处理客户端连接请求
+            close(server_sock);
+            handle_client(client_sock, client_addr);
+            exit(0);
+        }
+        close(client_sock);
+    }
+
+}
+
+void stop_server()
+{
+    kill(m_pid, SIGKILL);        
+}
+
+void usage(void)
+{
+    printf("Usage:\n");
+    printf(" -l <port number>  specifyed local listen port \n");
+    printf(" -h <remote server and port> specifyed next hop server name to forward all trafic unhandled, prior to -m & -r\n");
+    printf(" -r <server and port> specifyed server name to forward 'HTTP'&'CONNECT' to, no matter what host is\n");
+    printf(" -m <ml key words>  specifyed key words replaced & recognized as 'Host:' function, prior to -r\n");
+    printf(" -d <remote server and port> run as daemon\n");
+    printf(" -E encode data when forwarding data\n");
+    printf(" -D decode data when receiving data\n");
+    printf(" Notice:-h -r -m can not be used together.\n");
+    exit (8);
+}
+
+void start_server(int daemon)
+{
+    //初始化全局变量
+    header_buffer = (char *) malloc(MAX_HEADER_SIZE);
+
+    signal(SIGCHLD, sigchld_handler); // 防止子进程变成僵尸进程
+
+    if ((server_sock = create_server_socket(local_port)) < 0) 
+    { // start server
+        LOG("Cannot run server on %d\n",local_port);
+        exit(server_sock);
+    }
+   
+    if(daemon)
+    {
+        pid_t pid;
+        if((pid = fork()) == 0)
+        {
+            server_loop();
+        } else if (pid > 0 ) 
+        {
+            m_pid = pid;
+            LOG("mporxy pid is: [%d]\n",pid);
+            close(server_sock);
+        } else 
+        {
+            LOG("Cannot daemonize\n");
+            exit(pid);
+        }
+
+    } else 
+    {
+        server_loop();
+    }
+
+}
+
+int main(int argc, char *argv[])
+{
+    return _main(argc,argv);
+}
+
+int _main(int argc, char *argv[]) 
+{
+    local_port = DEFAULT_LOCAL_PORT;
+    io_flag = FLG_NONE;
+    r_flag = 0;
+    m_flag = 0;
+    //m_s = "DEFAULT_M_S";
+    int daemon = 0; 
+
+    char info_buf[2048];
+	
+	int opt;
+	char optstrs[] = ":l:h:r:m:dED";
+	char *p = NULL;
+	while(-1 != (opt = getopt(argc, argv, optstrs)))
+	{
+		switch(opt)
+		{
+			case 'l':
+				local_port = atoi(optarg);
+				break;
+			case 'h':
+				p = strchr(optarg, ':');
+				if(p)
+				{
+					strncpy(remote_host, optarg, p - optarg);
+					remote_port = atoi(p+1);
+				}
+				else
+				{
+					strncpy(remote_host, optarg, strlen(optarg));
+					remote_port = DEFAULT_REMOTE_PORT;
+				}
+				break;
+			case 'r':
+				p = strchr(optarg, ':');
+				if(p)
+				{
+					strncpy(r_h, optarg, p - optarg);
+					r_p = atoi(p+1);
+				}
+				else
+				{
+					strncpy(r_h, optarg, strlen(optarg));
+					r_p = DEFAULT_R_P;
+				}
+				printf("Your forward server is: %s:%d\n",r_h,r_p);
+				r_flag = 1;
+				break;
+			case 'm':
+				strncpy(m_s, optarg, strlen(optarg));
+				printf("Your sting is: %s\n",m_s);
+				m_flag = 1;
+				break;
+			case 'd':
+				daemon = 1;
+				break;
+			case 'E':
+				io_flag = W_S_ENC;
+				break;
+			case 'D':
+				io_flag = R_C_DEC;
+				break;
+			case ':':
+				printf("\nMissing argument after: -%c\n", optopt);
+				usage();
+			case '?':
+				printf("\nInvalid argument: %c\n", optopt);
+			default:
+				usage();
+		}
+    }
+
+    get_info(info_buf);
+    LOG("%s\n",info_buf);
+    start_server(daemon);
+    return 0;
+
+}