fix indent with clang-format

main.cpp

@@ -12,107 +12,101 @@
 #include "git_version.h"
 using namespace std;
 
-static void print_help()
-{
-	char git_version_buf[100]={0};
-	strncpy(git_version_buf,gitversion,10);
-
-	printf("tinyFecVPN\n");
-	printf("git version: %s    ",git_version_buf);
-	printf("build date: %s %s\n",__DATE__,__TIME__);
-	printf("repository: https://github.com/wangyu-/tinyFecVPN/\n");
-	printf("\n");
-	printf("usage:\n");
-	printf("    run as client: ./this_program -c -r server_ip:server_port  [options]\n");
-	printf("    run as server: ./this_program -s -l server_listen_ip:server_port  [options]\n");
-	printf("\n");
-	printf("common options, must be same on both sides:\n");
-	printf("    -k,--key              <string>        key for simple xor encryption. if not set, xor is disabled\n");
-
-	printf("main options:\n");
-	printf("    --sub-net             <number>        specify sub-net, for example: 192.168.1.0 , default: 10.22.22.0\n");
-	printf("    --tun-dev             <number>        sepcify tun device name, for example: tun10, default: a random name such as tun987\n");
-	printf("    -f,--fec              x:y             forward error correction, send y redundant packets for every x packets\n");
-	printf("    --timeout             <number>        how long could a packet be held in queue before doing fec, unit: ms, default: 8ms\n");
-	printf("    --report              <number>        turn on send/recv report, and set a period for reporting, unit: s\n");
-	printf("    --keep-reconnect                      re-connect after lost connection,only for client. \n");
-
-
-	printf("advanced options:\n");
-	printf("    --mode                <number>        fec-mode,available values: 0,1; mode 0(default) costs less bandwidth,no mtu problem.\n");
-	printf("                                          mode 1 usually introduces less latency, but you have to care about mtu.\n");
-	printf("    --mtu                 <number>        mtu for fec. for mode 0, the program will split packet to segment smaller than mtu.\n");
-	printf("                                          for mode 1, no packet will be split, the program just check if the mtu is exceed.\n");
-	printf("                                          default value: 1250\n");
-	printf("    -j,--jitter           <number>        simulated jitter. randomly delay first packet for 0~<number> ms, default value: 0.\n");
-	printf("                                          do not use if you dont know what it means.\n");
-	printf("    -i,--interval         <number>        scatter each fec group to a interval of <number> ms, to defend burst packet loss.\n");
-	printf("                                          default value: 0. do not use if you dont know what it means.\n");
-	printf("    -f,--fec              x1:y1,x2:y2,..  similiar to -f/--fec above,fine-grained fec parameters,may help save bandwidth.\n");
-	printf("                                          example: \"-f 1:3,2:4,10:6,20:10\". check repo for details\n");
-	printf("    --random-drop         <number>        simulate packet loss, unit: 0.01%%. default value: 0\n");
-	printf("    --disable-obscure     <number>        disable obscure, to save a bit bandwidth and cpu\n");
-	printf("    --disable-checksum    <number>        disable checksum to save a bit bandwdith and cpu\n");
-	//printf("    --disable-xor         <number>        disable xor\n");
-	printf("    --persist-tun         <number>        make the tun device persistent, so that it wont be deleted after exited.\n");
-	printf("    --mssfix              <number>        do mssfix for tcp connection, use 0 to disable. default value: 1250\n");
-
-	printf("developer options:\n");
-	printf("    --tun-mtu             <number>        mtu of the tun interface,most time you shouldnt change this\n");
-	printf("    --manual-set-tun      <number>        tell tinyfecvpn to not setup the tun device automatically(e.g. assign ip address),\n");
-	printf("                                          so that you can do it manually later\n");
-	printf("    --fifo                <string>        use a fifo(named pipe) for sending commands to the running program, so that you\n");
-	printf("                                          can change fec encode parameters dynamically, check readme.md in repository for\n");
-	printf("                                          supported commands.\n");
-	printf("    -j ,--jitter          jmin:jmax       similiar to -j above, but create jitter randomly between jmin and jmax\n");
-	printf("    -i,--interval         imin:imax       similiar to -i above, but scatter randomly between imin and imax\n");
+static void print_help() {
+    char git_version_buf[100] = {0};
+    strncpy(git_version_buf, gitversion, 10);
+
+    printf("tinyFecVPN\n");
+    printf("git version: %s    ", git_version_buf);
+    printf("build date: %s %s\n", __DATE__, __TIME__);
+    printf("repository: https://github.com/wangyu-/tinyFecVPN/\n");
+    printf("\n");
+    printf("usage:\n");
+    printf("    run as client: ./this_program -c -r server_ip:server_port  [options]\n");
+    printf("    run as server: ./this_program -s -l server_listen_ip:server_port  [options]\n");
+    printf("\n");
+    printf("common options, must be same on both sides:\n");
+    printf("    -k,--key              <string>        key for simple xor encryption. if not set, xor is disabled\n");
+
+    printf("main options:\n");
+    printf("    --sub-net             <number>        specify sub-net, for example: 192.168.1.0 , default: 10.22.22.0\n");
+    printf("    --tun-dev             <number>        sepcify tun device name, for example: tun10, default: a random name such as tun987\n");
+    printf("    -f,--fec              x:y             forward error correction, send y redundant packets for every x packets\n");
+    printf("    --timeout             <number>        how long could a packet be held in queue before doing fec, unit: ms, default: 8ms\n");
+    printf("    --report              <number>        turn on send/recv report, and set a period for reporting, unit: s\n");
+    printf("    --keep-reconnect                      re-connect after lost connection,only for client. \n");
+
+    printf("advanced options:\n");
+    printf("    --mode                <number>        fec-mode,available values: 0,1; mode 0(default) costs less bandwidth,no mtu problem.\n");
+    printf("                                          mode 1 usually introduces less latency, but you have to care about mtu.\n");
+    printf("    --mtu                 <number>        mtu for fec. for mode 0, the program will split packet to segment smaller than mtu.\n");
+    printf("                                          for mode 1, no packet will be split, the program just check if the mtu is exceed.\n");
+    printf("                                          default value: 1250\n");
+    printf("    -j,--jitter           <number>        simulated jitter. randomly delay first packet for 0~<number> ms, default value: 0.\n");
+    printf("                                          do not use if you dont know what it means.\n");
+    printf("    -i,--interval         <number>        scatter each fec group to a interval of <number> ms, to defend burst packet loss.\n");
+    printf("                                          default value: 0. do not use if you dont know what it means.\n");
+    printf("    -f,--fec              x1:y1,x2:y2,..  similiar to -f/--fec above,fine-grained fec parameters,may help save bandwidth.\n");
+    printf("                                          example: \"-f 1:3,2:4,10:6,20:10\". check repo for details\n");
+    printf("    --random-drop         <number>        simulate packet loss, unit: 0.01%%. default value: 0\n");
+    printf("    --disable-obscure     <number>        disable obscure, to save a bit bandwidth and cpu\n");
+    printf("    --disable-checksum    <number>        disable checksum to save a bit bandwdith and cpu\n");
+    // printf("    --disable-xor         <number>        disable xor\n");
+    printf("    --persist-tun         <number>        make the tun device persistent, so that it wont be deleted after exited.\n");
+    printf("    --mssfix              <number>        do mssfix for tcp connection, use 0 to disable. default value: 1250\n");
+
+    printf("developer options:\n");
+    printf("    --tun-mtu             <number>        mtu of the tun interface,most time you shouldnt change this\n");
+    printf("    --manual-set-tun      <number>        tell tinyfecvpn to not setup the tun device automatically(e.g. assign ip address),\n");
+    printf("                                          so that you can do it manually later\n");
+    printf("    --fifo                <string>        use a fifo(named pipe) for sending commands to the running program, so that you\n");
+    printf("                                          can change fec encode parameters dynamically, check readme.md in repository for\n");
+    printf("                                          supported commands.\n");
+    printf("    -j ,--jitter          jmin:jmax       similiar to -j above, but create jitter randomly between jmin and jmax\n");
+    printf("    -i,--interval         imin:imax       similiar to -i above, but scatter randomly between imin and imax\n");
     printf("    -q,--queue-len        <number>        fec queue len, only for mode 0, fec will be performed immediately after queue is full.\n");
-	printf("                                          default value: 200. \n");
+    printf("                                          default value: 200. \n");
     printf("    --decode-buf          <number>        size of buffer of fec decoder,u nit: packet, default: 2000\n");
-//    printf("    --fix-latency         <number>        try to stabilize latency, only for mode 0\n");
+    //    printf("    --fix-latency         <number>        try to stabilize latency, only for mode 0\n");
     printf("    --delay-capacity      <number>        max number of delayed packets, 0 means unlimited, default: 0\n");
-	printf("    --disable-fec         <number>        completely disable fec, turn the program into a normal udp tunnel\n");
-	printf("    --sock-buf            <number>        buf size for socket, >=10 and <=10240, unit: kbyte, default: 1024\n");
-	printf("    --out-addr            ip:port         force all output packets of '-r' end to go through this address, port 0 for random port.\n");
-	printf("    --out-interface       <string>        force all output packets of '-r' end to go through this interface.\n");
-
-	printf("log and help options:\n");
-	printf("    --log-level           <number>        0: never    1: fatal   2: error   3: warn \n");
-	printf("                                          4: info (default)      5: debug   6: trace\n");
-	printf("    --log-position                        enable file name, function name, line number in log\n");
-	printf("    --disable-color                       disable log color\n");
-	printf("    -h,--help                             print this help message\n");
-
-	//printf("common options,these options must be same on both side\n");
+    printf("    --disable-fec         <number>        completely disable fec, turn the program into a normal udp tunnel\n");
+    printf("    --sock-buf            <number>        buf size for socket, >=10 and <=10240, unit: kbyte, default: 1024\n");
+    printf("    --out-addr            ip:port         force all output packets of '-r' end to go through this address, port 0 for random port.\n");
+    printf("    --out-interface       <string>        force all output packets of '-r' end to go through this interface.\n");
+
+    printf("log and help options:\n");
+    printf("    --log-level           <number>        0: never    1: fatal   2: error   3: warn \n");
+    printf("                                          4: info (default)      5: debug   6: trace\n");
+    printf("    --log-position                        enable file name, function name, line number in log\n");
+    printf("    --disable-color                       disable log color\n");
+    printf("    -h,--help                             print this help message\n");
+
+    // printf("common options,these options must be same on both side\n");
 }
 
-void sigpipe_cb(struct ev_loop *l, ev_signal *w, int revents)
-{
-	mylog(log_info, "got sigpipe, ignored");
+void sigpipe_cb(struct ev_loop *l, ev_signal *w, int revents) {
+    mylog(log_info, "got sigpipe, ignored");
 }
 
-void sigterm_cb(struct ev_loop *l, ev_signal *w, int revents)
-{
-	mylog(log_info, "got sigterm, exit");
-	myexit(0);
+void sigterm_cb(struct ev_loop *l, ev_signal *w, int revents) {
+    mylog(log_info, "got sigterm, exit");
+    myexit(0);
 }
 
-void sigint_cb(struct ev_loop *l, ev_signal *w, int revents)
-{
-	mylog(log_info, "got sigint, exit");
-	myexit(0);
+void sigint_cb(struct ev_loop *l, ev_signal *w, int revents) {
+    mylog(log_info, "got sigint, exit");
+    myexit(0);
 }
 
-int main(int argc, char *argv[])
-{
-	working_mode=tun_dev_mode;
-	struct ev_loop* loop=ev_default_loop(0);
+int main(int argc, char *argv[]) {
+    working_mode = tun_dev_mode;
+    struct ev_loop *loop = ev_default_loop(0);
 #if !defined(__MINGW32__)
     ev_signal signal_watcher_sigpipe;
     ev_signal_init(&signal_watcher_sigpipe, sigpipe_cb, SIGPIPE);
     ev_signal_start(loop, &signal_watcher_sigpipe);
 #else
-    enable_log_color=0;
+    enable_log_color = 0;
 #endif
 
     ev_signal signal_watcher_sigterm;
@@ -123,54 +117,47 @@ int main(int argc, char *argv[])
     ev_signal_init(&signal_watcher_sigint, sigint_cb, SIGINT);
     ev_signal_start(loop, &signal_watcher_sigint);
 
-	assert(sizeof(u64_t)==8);
-	assert(sizeof(i64_t)==8);
-	assert(sizeof(u32_t)==4);
-	assert(sizeof(i32_t)==4);
-	assert(sizeof(u16_t)==2);
-	assert(sizeof(i16_t)==2);
-	dup2(1, 2);		//redirect stderr to stdout
-	int i, j, k;
-	if (argc == 1)
-	{
-		print_help();
-		myexit( -1);
-	}
-	for (i = 0; i < argc; i++)
-	{
-		if(strcmp(argv[i],"-h")==0||strcmp(argv[i],"--help")==0)
-		{
-			print_help();
-			myexit(0);
-		}
-	}
-
-	//g_fec_mode=0;
-
-	process_arg(argc,argv);
-
-	delay_manager.set_capacity(delay_capacity);
-	//local_ip_uint32=inet_addr(local_ip);
-	//remote_ip_uint32=inet_addr(remote_ip);
-	sub_net_uint32=inet_addr(sub_net);
-
-	if(strlen(tun_dev)==0)
-	{
-		sprintf(tun_dev,"tun%u",get_fake_random_number()%1000);
-	}
-	mylog(log_info,"using interface %s\n",tun_dev);
-	/*if(tun_mtu==0)
-	{
-		tun_mtu=g_fec_mtu;
-	}*/
-	if(program_mode==client_mode)
-	{
-		tun_dev_client_event_loop();
-	}
-	else
-	{
-		tun_dev_server_event_loop();
-	}
-
-	return 0;
+    assert(sizeof(u64_t) == 8);
+    assert(sizeof(i64_t) == 8);
+    assert(sizeof(u32_t) == 4);
+    assert(sizeof(i32_t) == 4);
+    assert(sizeof(u16_t) == 2);
+    assert(sizeof(i16_t) == 2);
+    dup2(1, 2);  // redirect stderr to stdout
+    int i, j, k;
+    if (argc == 1) {
+        print_help();
+        myexit(-1);
+    }
+    for (i = 0; i < argc; i++) {
+        if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) {
+            print_help();
+            myexit(0);
+        }
+    }
+
+    // g_fec_mode=0;
+
+    process_arg(argc, argv);
+
+    delay_manager.set_capacity(delay_capacity);
+    // local_ip_uint32=inet_addr(local_ip);
+    // remote_ip_uint32=inet_addr(remote_ip);
+    sub_net_uint32 = inet_addr(sub_net);
+
+    if (strlen(tun_dev) == 0) {
+        sprintf(tun_dev, "tun%u", get_fake_random_number() % 1000);
+    }
+    mylog(log_info, "using interface %s\n", tun_dev);
+    /*if(tun_mtu==0)
+    {
+            tun_mtu=g_fec_mtu;
+    }*/
+    if (program_mode == client_mode) {
+        tun_dev_client_event_loop();
+    } else {
+        tun_dev_server_event_loop();
+    }
+
+    return 0;
 }

tun_dev.cpp

@@ -5,335 +5,293 @@
  *      Author: root
  */
 
-
 #include "tun_dev.h"
 
-my_time_t last_keep_alive_time=0;
+my_time_t last_keep_alive_time = 0;
 
-int get_tun_fd(char * dev_name)
-{
-	int tun_fd=open("/dev/net/tun",O_RDWR);
-
-	if(tun_fd <0)
-	{
-		mylog(log_fatal,"open /dev/net/tun failed");
-		myexit(-1);
-	}
-	struct ifreq ifr;
-	memset(&ifr, 0, sizeof(ifr));
-	ifr.ifr_flags = IFF_TUN|IFF_NO_PI;
-
-	strncpy(ifr.ifr_name, dev_name, IFNAMSIZ);
-
-	if(ioctl(tun_fd, TUNSETIFF, (void *)&ifr) != 0)
-	{
-		mylog(log_fatal,"open /dev/net/tun failed");
-		myexit(-1);
-	}
-
-	if (persist_tun == 1) {
-		if (ioctl(tun_fd, TUNSETPERSIST, 1) != 0) {
-			mylog(log_warn,"failed to set tun persistent");
-		}
-	}
-	return tun_fd;
+int get_tun_fd(char *dev_name) {
+    int tun_fd = open("/dev/net/tun", O_RDWR);
+
+    if (tun_fd < 0) {
+        mylog(log_fatal, "open /dev/net/tun failed");
+        myexit(-1);
+    }
+    struct ifreq ifr;
+    memset(&ifr, 0, sizeof(ifr));
+    ifr.ifr_flags = IFF_TUN | IFF_NO_PI;
+
+    strncpy(ifr.ifr_name, dev_name, IFNAMSIZ);
+
+    if (ioctl(tun_fd, TUNSETIFF, (void *)&ifr) != 0) {
+        mylog(log_fatal, "open /dev/net/tun failed");
+        myexit(-1);
+    }
+
+    if (persist_tun == 1) {
+        if (ioctl(tun_fd, TUNSETPERSIST, 1) != 0) {
+            mylog(log_warn, "failed to set tun persistent");
+        }
+    }
+    return tun_fd;
 }
 
-int set_tun(char *if_name,u32_t local_ip,u32_t remote_ip,int mtu)
-{
-	if(manual_set_tun) return 0;
+int set_tun(char *if_name, u32_t local_ip, u32_t remote_ip, int mtu) {
+    if (manual_set_tun) return 0;
 
-	//printf("i m here1\n");
-	struct ifreq ifr;
-	struct sockaddr_in sai;
-	memset(&ifr,0,sizeof(ifr));
-	memset(&sai, 0, sizeof(struct sockaddr));
+    // printf("i m here1\n");
+    struct ifreq ifr;
+    struct sockaddr_in sai;
+    memset(&ifr, 0, sizeof(ifr));
+    memset(&sai, 0, sizeof(struct sockaddr));
 
-	int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
-	strncpy(ifr.ifr_name, if_name, IFNAMSIZ);
+    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
+    strncpy(ifr.ifr_name, if_name, IFNAMSIZ);
 
     sai.sin_family = AF_INET;
     sai.sin_port = 0;
 
     sai.sin_addr.s_addr = local_ip;
-    memcpy(&ifr.ifr_addr,&sai, sizeof(struct sockaddr));
-    assert(ioctl(sockfd, SIOCSIFADDR, &ifr)==0); //set source ip
+    memcpy(&ifr.ifr_addr, &sai, sizeof(struct sockaddr));
+    assert(ioctl(sockfd, SIOCSIFADDR, &ifr) == 0);  // set source ip
 
     sai.sin_addr.s_addr = remote_ip;
-    memcpy(&ifr.ifr_addr,&sai, sizeof(struct sockaddr));
-    assert(ioctl(sockfd, SIOCSIFDSTADDR, &ifr)==0);//set dest ip
+    memcpy(&ifr.ifr_addr, &sai, sizeof(struct sockaddr));
+    assert(ioctl(sockfd, SIOCSIFDSTADDR, &ifr) == 0);  // set dest ip
 
-    ifr.ifr_mtu=mtu;
-    assert(ioctl(sockfd, SIOCSIFMTU, &ifr)==0);//set mtu
+    ifr.ifr_mtu = mtu;
+    assert(ioctl(sockfd, SIOCSIFMTU, &ifr) == 0);  // set mtu
 
-    assert(ioctl(sockfd, SIOCGIFFLAGS, &ifr)==0);
-   // ifr.ifr_flags |= ( IFF_UP|IFF_POINTOPOINT|IFF_RUNNING|IFF_NOARP|IFF_MULTICAST );
-    ifr.ifr_flags = ( IFF_UP|IFF_POINTOPOINT|IFF_RUNNING|IFF_NOARP|IFF_MULTICAST );//set interface flags
-    assert(ioctl(sockfd, SIOCSIFFLAGS, &ifr)==0);
+    assert(ioctl(sockfd, SIOCGIFFLAGS, &ifr) == 0);
+    // ifr.ifr_flags |= ( IFF_UP|IFF_POINTOPOINT|IFF_RUNNING|IFF_NOARP|IFF_MULTICAST );
+    ifr.ifr_flags = (IFF_UP | IFF_POINTOPOINT | IFF_RUNNING | IFF_NOARP | IFF_MULTICAST);  // set interface flags
+    assert(ioctl(sockfd, SIOCSIFFLAGS, &ifr) == 0);
 
-    //printf("i m here2\n");
-	return 0;
+    // printf("i m here2\n");
+    return 0;
 }
 
-
-int put_header(char header,char * data,int &len)
-{
-	assert(len>=0);
-	data[len]=header;
-	len+=1;
-	return 0;
+int put_header(char header, char *data, int &len) {
+    assert(len >= 0);
+    data[len] = header;
+    len += 1;
+    return 0;
 }
-int get_header(char &header,char * data,int &len)
-{
-	assert(len>=0);
-	if(len<1) return -1;
-	len-=1;
-	header=data[len];
+int get_header(char &header, char *data, int &len) {
+    assert(len >= 0);
+    if (len < 1) return -1;
+    len -= 1;
+    header = data[len];
 
-	return 0;
+    return 0;
+}
+int from_normal_to_fec2(conn_info_t &conn_info, dest_t &dest, char *data, int len, char header) {
+    int out_n;
+    char **out_arr;
+    int *out_len;
+    my_time_t *out_delay;
+
+    from_normal_to_fec(conn_info, data, len, out_n, out_arr, out_len, out_delay);
+
+    for (int i = 0; i < out_n; i++) {
+        char tmp_buf[buf_len];
+        int tmp_len = out_len[i];
+        memcpy(tmp_buf, out_arr[i], out_len[i]);
+        put_header(header, tmp_buf, tmp_len);
+        delay_send(out_delay[i], dest, tmp_buf, tmp_len);  // this is slow but safer.just use this one
+
+        // put_header(header,out_arr[i],out_len[i]);//modify in place
+        // delay_send(out_delay[i],dest,out_arr[i],out_len[i]);//warning this is currently okay,but if you modified fec encoder,you  may have to use the above code
+    }
+    return 0;
 }
-int from_normal_to_fec2(conn_info_t & conn_info,dest_t &dest,char * data,int len,char header)
-{
-	int  out_n;char **out_arr;int *out_len;my_time_t *out_delay;
 
-	from_normal_to_fec(conn_info,data,len,out_n,out_arr,out_len,out_delay);
+int from_fec_to_normal2(conn_info_t &conn_info, dest_t &dest, char *data, int len) {
+    int out_n;
+    char **out_arr;
+    int *out_len;
+    my_time_t *out_delay;
 
-	for(int i=0;i<out_n;i++)
-	{
+    from_fec_to_normal(conn_info, data, len, out_n, out_arr, out_len, out_delay);
 
-		char tmp_buf[buf_len];
-		int tmp_len=out_len[i];
-		memcpy(tmp_buf,out_arr[i],out_len[i]);
-		put_header(header,tmp_buf,tmp_len);
-		delay_send(out_delay[i],dest,tmp_buf,tmp_len);//this is slow but safer.just use this one
+    for (int i = 0; i < out_n; i++) {
+#ifndef NOLIMIT
+        if (program_mode == server_mode) {
+            char *tmp_data = out_arr[i];
+            int tmp_len = out_len[i];
+            iphdr *iph;
+            iph = (struct iphdr *)tmp_data;
+            if (tmp_len >= int(sizeof(iphdr)) && iph->version == 4) {
+                u32_t dest_ip = iph->daddr;
+                // printf("%s\n",my_ntoa(dest_ip));
+                if ((ntohl(sub_net_uint32) & 0xFFFFFF00) != (ntohl(dest_ip) & 0xFFFFFF00)) {
+                    string sub = my_ntoa(dest_ip);
+                    string dst = my_ntoa(htonl(ntohl(sub_net_uint32) & 0xFFFFFF00));
+                    mylog(log_warn, "[restriction]packet's dest ip [%s] not in subnet [%s],dropped, maybe you need to compile an un-restricted server\n", sub.c_str(), dst.c_str());
+                    continue;
+                }
+            }
+        }
+#endif
+        delay_send(out_delay[i], dest, out_arr[i], out_len[i]);
+    }
 
-		//put_header(header,out_arr[i],out_len[i]);//modify in place
-		//delay_send(out_delay[i],dest,out_arr[i],out_len[i]);//warning this is currently okay,but if you modified fec encoder,you  may have to use the above code
-	}
-	return 0;
+    return 0;
 }
-
-int from_fec_to_normal2(conn_info_t & conn_info,dest_t &dest,char * data,int len)
+int do_mssfix(char *s, int len)  // currently only for ipv4
 {
-	int  out_n;char **out_arr;int *out_len;my_time_t *out_delay;
-
-	from_fec_to_normal(conn_info,data,len,out_n,out_arr,out_len,out_delay);
+    if (mssfix == 0) {
+        return 0;
+    }
 
-	for(int i=0;i<out_n;i++)
-	{
+    if (len < int(sizeof(iphdr))) {
+        mylog(log_debug, "packet from tun len=%d <20\n", len);
+        return -1;
+    }
+    iphdr *iph;
+    iph = (struct iphdr *)s;
+    if (iph->version != 4) {
+        // mylog(log_trace,"not ipv4");
+        return 0;
+    }
 
-#ifndef NOLIMIT
-		if(program_mode==server_mode)
-		{
-			char * tmp_data=out_arr[i];
-			int tmp_len=out_len[i];
-			iphdr *  iph;
-			iph = (struct iphdr *) tmp_data;
-			if(tmp_len>=int(sizeof(iphdr))&&iph->version==4)
-			{
-				u32_t dest_ip=iph->daddr;
-				//printf("%s\n",my_ntoa(dest_ip));
-				if(  ( ntohl(sub_net_uint32)&0xFFFFFF00 ) !=  ( ntohl (dest_ip) &0xFFFFFF00) )
-				{
-					string sub=my_ntoa(dest_ip);
-					string dst=my_ntoa( htonl( ntohl (sub_net_uint32) &0xFFFFFF00)   );
-					mylog(log_warn,"[restriction]packet's dest ip [%s] not in subnet [%s],dropped, maybe you need to compile an un-restricted server\n", sub.c_str(), dst.c_str());
-					continue;
-				}
-			}
-		}
-#endif
-		delay_send(out_delay[i],dest,out_arr[i],out_len[i]);
+    if (iph->protocol != IPPROTO_TCP) {
+        // mylog(log_trace,"not tcp");
+        return 0;
+    }
 
-	}
+    int ip_len = ntohs(iph->tot_len);
+    int ip_hdr_len = iph->ihl * 4;
 
-	return 0;
-}
-int do_mssfix(char * s,int len)//currently only for ipv4
-{
-	if(mssfix==0)
-	{
-		return 0;
-	}
-
-	if(len<int(sizeof(iphdr)))
-	{
-		mylog(log_debug,"packet from tun len=%d <20\n",len);
-		return -1;
-	}
-	iphdr *  iph;
-	iph = (struct iphdr *) s;
-	if(iph->version!=4)
-	{
-		//mylog(log_trace,"not ipv4");
-		return 0;
-	}
-
-	if(iph->protocol!=IPPROTO_TCP)
-	{
-		//mylog(log_trace,"not tcp");
-		return 0;
-	}
-
-    int ip_len=ntohs(iph->tot_len);
-    int ip_hdr_len=iph->ihl*4;
-
-    if(len<ip_hdr_len)
-    {
-    	mylog(log_debug,"len<ip_hdr_len,%d %d\n",len,ip_hdr_len);
-    	return -1;
+    if (len < ip_hdr_len) {
+        mylog(log_debug, "len<ip_hdr_len,%d %d\n", len, ip_hdr_len);
+        return -1;
     }
-    if(len<ip_len)
-    {
-    	mylog(log_debug,"len<ip_len,%d %d\n",len,ip_len);
-    	return -1;
+    if (len < ip_len) {
+        mylog(log_debug, "len<ip_len,%d %d\n", len, ip_len);
+        return -1;
     }
-    if(ip_hdr_len>ip_len)
-    {
-    	mylog(log_debug,"ip_hdr_len<ip_len,%d %d\n",ip_hdr_len,ip_len);
-    	return -1;
+    if (ip_hdr_len > ip_len) {
+        mylog(log_debug, "ip_hdr_len<ip_len,%d %d\n", ip_hdr_len, ip_len);
+        return -1;
     }
 
-    if( ( ntohs(iph->frag_off) &(short)(0x1FFF) ) !=0 )
-    {
-    	//not first segment
+    if ((ntohs(iph->frag_off) & (short)(0x1FFF)) != 0) {
+        // not first segment
 
-    	//printf("line=%d %x  %x \n",__LINE__,(u32_t)ntohs(iph->frag_off),u32_t( ntohs(iph->frag_off) &0xFFF8));
-    	return 0;
+        // printf("line=%d %x  %x \n",__LINE__,(u32_t)ntohs(iph->frag_off),u32_t( ntohs(iph->frag_off) &0xFFF8));
+        return 0;
     }
-    if( ( ntohs(iph->frag_off) &(short)(0x80FF) )  !=0 )
-    {
-    	//not whole segment
-      	//printf("line=%d   \n",__LINE__);
-    	return 0;
+    if ((ntohs(iph->frag_off) & (short)(0x80FF)) != 0) {
+        // not whole segment
+        // printf("line=%d   \n",__LINE__);
+        return 0;
     }
 
-    char * tcp_begin=s+ip_hdr_len;
-    int tcp_len=ip_len-ip_hdr_len;
+    char *tcp_begin = s + ip_hdr_len;
+    int tcp_len = ip_len - ip_hdr_len;
 
-    if(tcp_len<20)
-    {
-    	mylog(log_debug,"tcp_len<20,%d\n",tcp_len);
-    	return -1;
+    if (tcp_len < 20) {
+        mylog(log_debug, "tcp_len<20,%d\n", tcp_len);
+        return -1;
     }
 
-    tcphdr * tcph=(struct tcphdr*)tcp_begin;
+    tcphdr *tcph = (struct tcphdr *)tcp_begin;
 
-    if(int(tcph->syn)==0)  //fast fail
+    if (int(tcph->syn) == 0)  // fast fail
     {
-    	mylog(log_trace,"tcph->syn==0\n");
-    	return 0;
+        mylog(log_trace, "tcph->syn==0\n");
+        return 0;
     }
 
-    int tcp_hdr_len = tcph->doff*4;
+    int tcp_hdr_len = tcph->doff * 4;
 
-    if(tcp_len<tcp_hdr_len)
-    {
-    	mylog(log_debug,"tcp_len <tcp_hdr_len, %d %d\n",tcp_len,tcp_hdr_len);
-    	return -1;
+    if (tcp_len < tcp_hdr_len) {
+        mylog(log_debug, "tcp_len <tcp_hdr_len, %d %d\n", tcp_len, tcp_hdr_len);
+        return -1;
     }
 
     /*
     if(tcp_hdr_len==20)
     {
-    	//printf("line=%d\n",__LINE__);
-    	mylog(log_trace,"no tcp option\n");
-    	return 0;
+        //printf("line=%d\n",__LINE__);
+        mylog(log_trace,"no tcp option\n");
+        return 0;
     }*/
 
-    char *ptr=tcp_begin+20;
-    char *option_end=tcp_begin+tcp_hdr_len;
-    while(ptr<option_end)
-    {
-    	if(*ptr==0)
-    	{
-    		return  0;
-    	}
-    	else if(*ptr==1)
-    	{
-    		ptr++;
-    	}
-    	else if(*ptr==2)
-    	{
-    		if(ptr+1>=option_end)
-    		{
-    			mylog(log_debug,"invaild option ptr+1==option_end,for mss\n");
-    			return -1;
-    		}
-    		if(*(ptr+1)!=4)
-    		{
-    			mylog(log_debug,"invaild mss len\n");
-    			return -1;
-    		}
-    		if(ptr+3>=option_end)
-    		{
-    			mylog(log_debug,"ptr+4>option_end for mss\n");
-    			return -1;
-    		}
-    		int mss= read_u16(ptr+2);//uint8_t(ptr[2])*256+uint8_t(ptr[3]);
-    		int new_mss=mss;
-    		if(new_mss>::mssfix-40-10) //minus extra 10 for safe
-    		{
-    			new_mss=::mssfix-40-10;
-    		}
-    		write_u16(ptr+2,(unsigned short)new_mss);
-
-    	    pseudo_header psh;
-
-    	    psh.source_address =iph->saddr;
-    	    psh.dest_address = iph->daddr;
-    	    psh.placeholder = 0;
-    	    psh.protocol = iph->protocol;
-    	    psh.tcp_length = htons(tcp_len);
-
-
-    	    tcph->check=0;
-    	    tcph->check=tcp_csum(psh,(unsigned short *)tcph,tcp_len);
-
-    		mylog(log_trace,"mss=%d  syn=%d ack=%d, changed mss to %d \n",mss,(int)tcph->syn,(int)tcph->ack,new_mss);
-
-    		//printf("test=%x\n",u32_t(1));
-    		//printf("frag=%x\n",u32_t( ntohs(iph->frag_off) ));
-
-    		return 0;
-    	}
-    	else
-    	{
-
-    		if(ptr+1>=option_end)
-    		{
-    			mylog(log_debug,"invaild option ptr+1==option_end\n");
-    			return -1;
-    		}
-    		else
-    		{
-    			int len=(unsigned char)*(ptr+1);
-    			if(len<=1)
-    			{
-    				mylog(log_debug,"invaild option len %d\n",len);
-    				return -1;
-    			}
-    			ptr+=len;
-    		}
-    	}
+    char *ptr = tcp_begin + 20;
+    char *option_end = tcp_begin + tcp_hdr_len;
+    while (ptr < option_end) {
+        if (*ptr == 0) {
+            return 0;
+        } else if (*ptr == 1) {
+            ptr++;
+        } else if (*ptr == 2) {
+            if (ptr + 1 >= option_end) {
+                mylog(log_debug, "invaild option ptr+1==option_end,for mss\n");
+                return -1;
+            }
+            if (*(ptr + 1) != 4) {
+                mylog(log_debug, "invaild mss len\n");
+                return -1;
+            }
+            if (ptr + 3 >= option_end) {
+                mylog(log_debug, "ptr+4>option_end for mss\n");
+                return -1;
+            }
+            int mss = read_u16(ptr + 2);  // uint8_t(ptr[2])*256+uint8_t(ptr[3]);
+            int new_mss = mss;
+            if (new_mss > ::mssfix - 40 - 10)  // minus extra 10 for safe
+            {
+                new_mss = ::mssfix - 40 - 10;
+            }
+            write_u16(ptr + 2, (unsigned short)new_mss);
+
+            pseudo_header psh;
+
+            psh.source_address = iph->saddr;
+            psh.dest_address = iph->daddr;
+            psh.placeholder = 0;
+            psh.protocol = iph->protocol;
+            psh.tcp_length = htons(tcp_len);
+
+            tcph->check = 0;
+            tcph->check = tcp_csum(psh, (unsigned short *)tcph, tcp_len);
+
+            mylog(log_trace, "mss=%d  syn=%d ack=%d, changed mss to %d \n", mss, (int)tcph->syn, (int)tcph->ack, new_mss);
+
+            // printf("test=%x\n",u32_t(1));
+            // printf("frag=%x\n",u32_t( ntohs(iph->frag_off) ));
+
+            return 0;
+        } else {
+            if (ptr + 1 >= option_end) {
+                mylog(log_debug, "invaild option ptr+1==option_end\n");
+                return -1;
+            } else {
+                int len = (unsigned char)*(ptr + 1);
+                if (len <= 1) {
+                    mylog(log_debug, "invaild option len %d\n", len);
+                    return -1;
+                }
+                ptr += len;
+            }
+        }
     }
 
-	return 0;
+    return 0;
 }
-int do_keep_alive(dest_t & dest)
-{
-	if(get_current_time()-last_keep_alive_time>u64_t(keep_alive_interval))
-	{
-		last_keep_alive_time=get_current_time();
-		char data[buf_len];int len;
-		data[0]=header_keep_alive;
-		len=1;
-
-		assert(dest.cook==1);
-		//do_cook(data,len);
-
-		delay_send(0,dest,data,len);
-	}
-	return 0;
+int do_keep_alive(dest_t &dest) {
+    if (get_current_time() - last_keep_alive_time > u64_t(keep_alive_interval)) {
+        last_keep_alive_time = get_current_time();
+        char data[buf_len];
+        int len;
+        data[0] = header_keep_alive;
+        len = 1;
+
+        assert(dest.cook == 1);
+        // do_cook(data,len);
+
+        delay_send(0, dest, data, len);
+    }
+    return 0;
 }
-

tun_dev.h

@@ -5,7 +5,6 @@
  *      Author: root
  */
 
-
 #ifndef TUN_DEV_H_
 #define TUN_DEV_H_
 
@@ -13,9 +12,9 @@
 #include "log.h"
 #include "misc.h"
 
-#include <netinet/tcp.h>   //Provides declarations for tcp header
+#include <netinet/tcp.h>  //Provides declarations for tcp header
 #include <netinet/udp.h>
-#include <netinet/ip.h>    //Provides declarations for ip header
+#include <netinet/ip.h>  //Provides declarations for ip header
 #include <netinet/if_ether.h>
 
 #include <linux/if.h>
@@ -23,26 +22,25 @@
 
 extern my_time_t last_keep_alive_time;
 
-const int keep_alive_interval=3000;//3000ms
-
-const char header_normal=1;
-const char header_new_connect=2;
-const char header_reject=3;
-const char header_keep_alive=4;
+const int keep_alive_interval = 3000;  // 3000ms
 
-int set_tun(char *if_name,u32_t local_ip,u32_t remote_ip,int mtu);
+const char header_normal = 1;
+const char header_new_connect = 2;
+const char header_reject = 3;
+const char header_keep_alive = 4;
 
-int get_tun_fd(char * dev_name);
+int set_tun(char *if_name, u32_t local_ip, u32_t remote_ip, int mtu);
 
-int put_header(char header,char * data,int &len);
+int get_tun_fd(char *dev_name);
 
-int get_header(char &header,char * data,int &len);
-int from_normal_to_fec2(conn_info_t & conn_info,dest_t &dest,char * data,int len,char header);
+int put_header(char header, char *data, int &len);
 
-int from_fec_to_normal2(conn_info_t & conn_info,dest_t &dest,char * data,int len);
-int do_mssfix(char * s,int len);
-int do_keep_alive(dest_t & dest);
+int get_header(char &header, char *data, int &len);
+int from_normal_to_fec2(conn_info_t &conn_info, dest_t &dest, char *data, int len, char header);
 
+int from_fec_to_normal2(conn_info_t &conn_info, dest_t &dest, char *data, int len);
+int do_mssfix(char *s, int len);
+int do_keep_alive(dest_t &dest);
 
 int tun_dev_client_event_loop();
 

tun_dev_client.cpp

@@ -1,346 +1,307 @@
 #include "tun_dev.h"
 
-static int got_feed_back=0;
+static int got_feed_back = 0;
 
 static dest_t udp_dest;
 static dest_t tun_dest;
 
-
-static void remote_cb(struct ev_loop *loop, struct ev_io *watcher, int revents)
-{
-	assert(!(revents&EV_ERROR));
-
-	conn_info_t & conn_info= *((conn_info_t*)watcher->data);
-
-	char data[buf_len];
-	int len;
-
-	fd64_t fd64=watcher->u64;
-	int fd=fd_manager.to_fd(fd64);
-
-	len=recv(fd,data,max_data_len+1,0);
-
-	if(len==max_data_len+1)
-	{
-		mylog(log_warn,"huge packet, data_len > %d,dropped\n",max_data_len);
-		return;
-	}
-
-	if(len<0)
-	{
-		mylog(log_warn,"recv return %d,errno=%s\n",len,strerror(errno));
-		return;
-	}
-
-	if(de_cook(data,len)<0)
-	{
-		mylog(log_warn,"de_cook(data,len)failed \n");
-		return;
-
-	}
-
-	char header=0;
-	if(get_header(header,data,len)!=0)
-	{
-		mylog(log_warn,"get_header failed\n");
-		return;
-	}
-
-	if(header==header_keep_alive)
-	{
-		mylog(log_trace,"got keep_alive packet\n");
-		return;
-	}
-
-	if(header==header_reject)
-	{
-		if(keep_reconnect==0)
-		{
-			mylog(log_fatal,"server restarted or switched to handle another client,exited. maybe you need --keep-reconnect\n");
-			myexit(-1);
-		}
-		else
-		{
-			if(got_feed_back==1)
-				mylog(log_warn,"server restarted or switched to handle another client,but keep-reconnect enabled,trying to reconnect\n");
-			got_feed_back=0;
-		}
-		return;
-	}
-	else if(header==header_normal)
-	{
-		if(got_feed_back==0)
-			mylog(log_info,"connection accepted by server\n");
-		got_feed_back=1;
-	}
-	else
-	{
-		mylog(log_warn,"invalid header %d %d\n",int(header),len);
-		return;
-	}
-
-	mylog(log_trace,"Received packet from udp,len: %d\n",len);
-
-	from_fec_to_normal2(conn_info,tun_dest,data,len);
-
-
+static void remote_cb(struct ev_loop *loop, struct ev_io *watcher, int revents) {
+    assert(!(revents & EV_ERROR));
+
+    conn_info_t &conn_info = *((conn_info_t *)watcher->data);
+
+    char data[buf_len];
+    int len;
+
+    fd64_t fd64 = watcher->u64;
+    int fd = fd_manager.to_fd(fd64);
+
+    len = recv(fd, data, max_data_len + 1, 0);
+
+    if (len == max_data_len + 1) {
+        mylog(log_warn, "huge packet, data_len > %d,dropped\n", max_data_len);
+        return;
+    }
+
+    if (len < 0) {
+        mylog(log_warn, "recv return %d,errno=%s\n", len, strerror(errno));
+        return;
+    }
+
+    if (de_cook(data, len) < 0) {
+        mylog(log_warn, "de_cook(data,len)failed \n");
+        return;
+    }
+
+    char header = 0;
+    if (get_header(header, data, len) != 0) {
+        mylog(log_warn, "get_header failed\n");
+        return;
+    }
+
+    if (header == header_keep_alive) {
+        mylog(log_trace, "got keep_alive packet\n");
+        return;
+    }
+
+    if (header == header_reject) {
+        if (keep_reconnect == 0) {
+            mylog(log_fatal, "server restarted or switched to handle another client,exited. maybe you need --keep-reconnect\n");
+            myexit(-1);
+        } else {
+            if (got_feed_back == 1)
+                mylog(log_warn, "server restarted or switched to handle another client,but keep-reconnect enabled,trying to reconnect\n");
+            got_feed_back = 0;
+        }
+        return;
+    } else if (header == header_normal) {
+        if (got_feed_back == 0)
+            mylog(log_info, "connection accepted by server\n");
+        got_feed_back = 1;
+    } else {
+        mylog(log_warn, "invalid header %d %d\n", int(header), len);
+        return;
+    }
+
+    mylog(log_trace, "Received packet from udp,len: %d\n", len);
+
+    from_fec_to_normal2(conn_info, tun_dest, data, len);
 }
 
-static void tun_fd_cb(struct ev_loop *loop, struct ev_io *watcher, int revents)
-{
-	assert(!(revents&EV_ERROR));
+static void tun_fd_cb(struct ev_loop *loop, struct ev_io *watcher, int revents) {
+    assert(!(revents & EV_ERROR));
 
-	conn_info_t & conn_info= *((conn_info_t*)watcher->data);
+    conn_info_t &conn_info = *((conn_info_t *)watcher->data);
 
-	char data[buf_len];
-	int len;
-	int tun_fd=watcher->fd;
+    char data[buf_len];
+    int len;
+    int tun_fd = watcher->fd;
 
-	len=read(tun_fd,data,max_data_len+1);
+    len = read(tun_fd, data, max_data_len + 1);
 
-	if(len==max_data_len+1)
-	{
-		mylog(log_warn,"huge packet, data_len > %d,dropped\n",max_data_len);
-		return;
-	}
+    if (len == max_data_len + 1) {
+        mylog(log_warn, "huge packet, data_len > %d,dropped\n", max_data_len);
+        return;
+    }
 
-	if(len<0)
-	{
-		mylog(log_warn,"read from tun_fd return %d,errno=%s\n",len,strerror(errno));
-		return;
-	}
+    if (len < 0) {
+        mylog(log_warn, "read from tun_fd return %d,errno=%s\n", len, strerror(errno));
+        return;
+    }
 
-	do_mssfix(data,len);
+    do_mssfix(data, len);
 
-	mylog(log_trace,"Received packet from tun,len: %d\n",len);
+    mylog(log_trace, "Received packet from tun,len: %d\n", len);
 
-	char header=(got_feed_back==0?header_new_connect:header_normal);
-	from_normal_to_fec2(conn_info,udp_dest,data,len,header);
+    char header = (got_feed_back == 0 ? header_new_connect : header_normal);
+    from_normal_to_fec2(conn_info, udp_dest, data, len, header);
 }
 
-static void delay_manager_cb(struct ev_loop *loop, struct ev_timer *watcher, int revents)
-{
-	assert(!(revents&EV_ERROR));
+static void delay_manager_cb(struct ev_loop *loop, struct ev_timer *watcher, int revents) {
+    assert(!(revents & EV_ERROR));
 
-	//do nothing
+    // do nothing
 }
 
-static void fec_encode_cb(struct ev_loop *loop, struct ev_timer *watcher, int revents)
-{
-	assert(!(revents&EV_ERROR));
-
-	mylog(log_trace,"fec_encode_cb() called\n");
-
-	conn_info_t & conn_info= *((conn_info_t*)watcher->data);
-
-	///int ret;
-	///fd64_t fd64=watcher->u64;
-	///mylog(log_trace,"events[idx].data.u64 == conn_info.fec_encode_manager.get_timer_fd64()\n");
-
-	///uint64_t value;
-	///if(!fd_manager.exist(fd64))   //fd64 has been closed
-	///{
-	///	mylog(log_trace,"!fd_manager.exist(fd64)");
-	///	return;
-	///}
-	///if((ret=read(fd_manager.to_fd(fd64), &value, 8))!=8)
-	///{
-	///	mylog(log_trace,"(ret=read(fd_manager.to_fd(fd64), &value, 8))!=8,ret=%d\n",ret);
-	///	return;
-	///}
-	///if(value==0)
-	///{
-	///	mylog(log_debug,"value==0\n");
-	///	return;
-	///}
-	///assert(value==1);
-
-	char header=(got_feed_back==0?header_new_connect:header_normal);
-	from_normal_to_fec2(conn_info,udp_dest,0,0,header);
+static void fec_encode_cb(struct ev_loop *loop, struct ev_timer *watcher, int revents) {
+    assert(!(revents & EV_ERROR));
+
+    mylog(log_trace, "fec_encode_cb() called\n");
+
+    conn_info_t &conn_info = *((conn_info_t *)watcher->data);
+
+    /// int ret;
+    /// fd64_t fd64=watcher->u64;
+    /// mylog(log_trace,"events[idx].data.u64 == conn_info.fec_encode_manager.get_timer_fd64()\n");
+
+    /// uint64_t value;
+    /// if(!fd_manager.exist(fd64))   //fd64 has been closed
+    ///{
+    ///	mylog(log_trace,"!fd_manager.exist(fd64)");
+    ///	return;
+    /// }
+    /// if((ret=read(fd_manager.to_fd(fd64), &value, 8))!=8)
+    ///{
+    ///	mylog(log_trace,"(ret=read(fd_manager.to_fd(fd64), &value, 8))!=8,ret=%d\n",ret);
+    ///	return;
+    /// }
+    /// if(value==0)
+    ///{
+    ///	mylog(log_debug,"value==0\n");
+    ///	return;
+    /// }
+    /// assert(value==1);
+
+    char header = (got_feed_back == 0 ? header_new_connect : header_normal);
+    from_normal_to_fec2(conn_info, udp_dest, 0, 0, header);
 }
 
-static void conn_timer_cb(struct ev_loop *loop, struct ev_timer *watcher, int revents)
-{
-	assert(!(revents&EV_ERROR));
+static void conn_timer_cb(struct ev_loop *loop, struct ev_timer *watcher, int revents) {
+    assert(!(revents & EV_ERROR));
 
-	conn_info_t & conn_info= *((conn_info_t*)watcher->data);
+    conn_info_t &conn_info = *((conn_info_t *)watcher->data);
 
-	///uint64_t value;
-	///read(conn_info.timer.get_timer_fd(), &value, 8);
-	///mylog(log_trace,"events[idx].data.u64==(u64_t)conn_info.timer.get_timer_fd()\n");
+    /// uint64_t value;
+    /// read(conn_info.timer.get_timer_fd(), &value, 8);
+    /// mylog(log_trace,"events[idx].data.u64==(u64_t)conn_info.timer.get_timer_fd()\n");
 
-	mylog(log_trace,"conn_timer_cb() called\n");
-	conn_info.stat.report_as_client();
-	if(got_feed_back) do_keep_alive(udp_dest);
+    mylog(log_trace, "conn_timer_cb() called\n");
+    conn_info.stat.report_as_client();
+    if (got_feed_back) do_keep_alive(udp_dest);
 }
 
-static void fifo_cb(struct ev_loop *loop, struct ev_io *watcher, int revents)
-{
-	assert(!(revents&EV_ERROR));
-	int fifo_fd=watcher->fd;
-
-	char buf[buf_len];
-	int len=read (fifo_fd, buf, sizeof (buf));
-	if(len<0)
-	{
-		mylog(log_warn,"fifo read failed len=%d,errno=%s\n",len,strerror(errno));
-		return;
-	}
-	buf[len]=0;
-	handle_command(buf);
+static void fifo_cb(struct ev_loop *loop, struct ev_io *watcher, int revents) {
+    assert(!(revents & EV_ERROR));
+    int fifo_fd = watcher->fd;
+
+    char buf[buf_len];
+    int len = read(fifo_fd, buf, sizeof(buf));
+    if (len < 0) {
+        mylog(log_warn, "fifo read failed len=%d,errno=%s\n", len, strerror(errno));
+        return;
+    }
+    buf[len] = 0;
+    handle_command(buf);
 }
 
-static void prepare_cb(struct ev_loop *loop, struct ev_prepare *watcher, int revents)
-{
-	assert(!(revents&EV_ERROR));
+static void prepare_cb(struct ev_loop *loop, struct ev_prepare *watcher, int revents) {
+    assert(!(revents & EV_ERROR));
 
-	delay_manager.check();
+    delay_manager.check();
 }
 
-int tun_dev_client_event_loop()
-{
-	//char data[buf_len];
-	//int len;
-	int i,j,k,ret;
-	int tun_fd;
-
-	int remote_fd;
-	fd64_t remote_fd64;
-
-    conn_info_t *conn_info_p=new conn_info_t;
-    conn_info_t &conn_info=*conn_info_p;  //huge size of conn_info,do not allocate on stack
-
-	tun_fd=get_tun_fd(tun_dev);
-	assert(tun_fd>0);
-
-	assert(new_connected_socket2(remote_fd,remote_addr,out_addr,out_interface)==0);
-	remote_fd64=fd_manager.create(remote_fd);
+int tun_dev_client_event_loop() {
+    // char data[buf_len];
+    // int len;
+    int i, j, k, ret;
+    int tun_fd;
 
-	assert(set_tun(tun_dev,htonl((ntohl(sub_net_uint32)&0xFFFFFF00)|2),htonl((ntohl(sub_net_uint32)&0xFFFFFF00 )|1),tun_mtu)==0);
+    int remote_fd;
+    fd64_t remote_fd64;
 
-	tun_dest.type=type_write_fd;
-	tun_dest.inner.fd=tun_fd;
+    conn_info_t *conn_info_p = new conn_info_t;
+    conn_info_t &conn_info = *conn_info_p;  // huge size of conn_info,do not allocate on stack
 
-	udp_dest.cook=1;
-	udp_dest.type=type_fd64;
-	udp_dest.inner.fd64=remote_fd64;
+    tun_fd = get_tun_fd(tun_dev);
+    assert(tun_fd > 0);
 
-	///epoll_fd = epoll_create1(0);
-	///assert(epoll_fd>0);
+    assert(new_connected_socket2(remote_fd, remote_addr, out_addr, out_interface) == 0);
+    remote_fd64 = fd_manager.create(remote_fd);
 
-	///const int max_events = 4096;
-	///struct epoll_event ev, events[max_events];
-	///if (epoll_fd < 0) {
-	///	mylog(log_fatal,"epoll return %d\n", epoll_fd);
-	///	myexit(-1);
-	///}
+    assert(set_tun(tun_dev, htonl((ntohl(sub_net_uint32) & 0xFFFFFF00) | 2), htonl((ntohl(sub_net_uint32) & 0xFFFFFF00) | 1), tun_mtu) == 0);
 
+    tun_dest.type = type_write_fd;
+    tun_dest.inner.fd = tun_fd;
 
-	struct ev_loop * loop= ev_default_loop(0);
-	assert(loop != NULL);
-    conn_info.loop=loop;
+    udp_dest.cook = 1;
+    udp_dest.type = type_fd64;
+    udp_dest.inner.fd64 = remote_fd64;
 
+    /// epoll_fd = epoll_create1(0);
+    /// assert(epoll_fd>0);
 
-	///ev.events = EPOLLIN;
-	///ev.data.u64 = remote_fd64;
-	///ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, remote_fd, &ev);
-	///if (ret!=0) {
-	///	mylog(log_fatal,"add  remote_fd64 error\n");
-	///	myexit(-1);
-	///}
+    /// const int max_events = 4096;
+    /// struct epoll_event ev, events[max_events];
+    /// if (epoll_fd < 0) {
+    ///	mylog(log_fatal,"epoll return %d\n", epoll_fd);
+    ///	myexit(-1);
+    /// }
 
-	struct ev_io remote_watcher;
-	remote_watcher.data=&conn_info;
-	remote_watcher.u64=remote_fd64;
+    struct ev_loop *loop = ev_default_loop(0);
+    assert(loop != NULL);
+    conn_info.loop = loop;
 
-	ev_io_init(&remote_watcher, remote_cb, remote_fd, EV_READ);
-	ev_io_start(loop, &remote_watcher);
+    /// ev.events = EPOLLIN;
+    /// ev.data.u64 = remote_fd64;
+    /// ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, remote_fd, &ev);
+    /// if (ret!=0) {
+    ///	mylog(log_fatal,"add  remote_fd64 error\n");
+    ///	myexit(-1);
+    /// }
 
+    struct ev_io remote_watcher;
+    remote_watcher.data = &conn_info;
+    remote_watcher.u64 = remote_fd64;
 
-	///ev.events = EPOLLIN;
-	///ev.data.u64 = tun_fd;
-	///ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, tun_fd, &ev);
-	///if (ret!=0) {
-	///	mylog(log_fatal,"add  tun_fd error\n");
-	///	myexit(-1);
-	///}
+    ev_io_init(&remote_watcher, remote_cb, remote_fd, EV_READ);
+    ev_io_start(loop, &remote_watcher);
 
-	struct ev_io tun_fd_watcher;
-	tun_fd_watcher.data=&conn_info;
+    /// ev.events = EPOLLIN;
+    /// ev.data.u64 = tun_fd;
+    /// ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, tun_fd, &ev);
+    /// if (ret!=0) {
+    ///	mylog(log_fatal,"add  tun_fd error\n");
+    ///	myexit(-1);
+    /// }
 
-	ev_io_init(&tun_fd_watcher, tun_fd_cb, tun_fd, EV_READ);
-	ev_io_start(loop, &tun_fd_watcher);
+    struct ev_io tun_fd_watcher;
+    tun_fd_watcher.data = &conn_info;
 
+    ev_io_init(&tun_fd_watcher, tun_fd_cb, tun_fd, EV_READ);
+    ev_io_start(loop, &tun_fd_watcher);
 
-	///ev.events = EPOLLIN;
-	///ev.data.u64 = delay_manager.get_timer_fd();
+    /// ev.events = EPOLLIN;
+    /// ev.data.u64 = delay_manager.get_timer_fd();
 
-	///mylog(log_debug,"delay_manager.get_timer_fd()=%d\n",delay_manager.get_timer_fd());
-	///ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, delay_manager.get_timer_fd(), &ev);
-	///if (ret!= 0) {
-	///	mylog(log_fatal,"add delay_manager.get_timer_fd() error\n");
-	///	myexit(-1);
-	///}
+    /// mylog(log_debug,"delay_manager.get_timer_fd()=%d\n",delay_manager.get_timer_fd());
+    /// ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, delay_manager.get_timer_fd(), &ev);
+    /// if (ret!= 0) {
+    ///	mylog(log_fatal,"add delay_manager.get_timer_fd() error\n");
+    ///	myexit(-1);
+    /// }
 
-    delay_manager.set_loop_and_cb(loop,delay_manager_cb);
+    delay_manager.set_loop_and_cb(loop, delay_manager_cb);
 
+    /// u64_t tmp_timer_fd64=conn_info.fec_encode_manager.get_timer_fd64();
+    /// ev.events = EPOLLIN;
+    /// ev.data.u64 = tmp_timer_fd64;
 
-	///u64_t tmp_timer_fd64=conn_info.fec_encode_manager.get_timer_fd64();
-	///ev.events = EPOLLIN;
-	///ev.data.u64 = tmp_timer_fd64;
-
-	///mylog(log_debug,"conn_info.fec_encode_manager.get_timer_fd64()=%llu\n",conn_info.fec_encode_manager.get_timer_fd64());
-	///ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd_manager.to_fd(tmp_timer_fd64), &ev);
-	///if (ret!= 0) {
-	///	mylog(log_fatal,"add fec_encode_manager.get_timer_fd64() error\n");
-	///	myexit(-1);
-	///}
+    /// mylog(log_debug,"conn_info.fec_encode_manager.get_timer_fd64()=%llu\n",conn_info.fec_encode_manager.get_timer_fd64());
+    /// ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd_manager.to_fd(tmp_timer_fd64), &ev);
+    /// if (ret!= 0) {
+    ///	mylog(log_fatal,"add fec_encode_manager.get_timer_fd64() error\n");
+    ///	myexit(-1);
+    /// }
 
     conn_info.fec_encode_manager.set_data(&conn_info);
-    conn_info.fec_encode_manager.set_loop_and_cb(loop,fec_encode_cb);
-
-
-	//conn_info.timer.add_fd_to_epoll(epoll_fd);
-	// conn_info.timer.data=&conn_info;
+    conn_info.fec_encode_manager.set_loop_and_cb(loop, fec_encode_cb);
 
-    conn_info.timer.data=&conn_info;
-    ev_init(&conn_info.timer,conn_timer_cb);
-    ev_timer_set(&conn_info.timer, 0, timer_interval/1000.0 );
-    ev_timer_start(loop,&conn_info.timer);
+    // conn_info.timer.add_fd_to_epoll(epoll_fd);
+    //  conn_info.timer.data=&conn_info;
 
+    conn_info.timer.data = &conn_info;
+    ev_init(&conn_info.timer, conn_timer_cb);
+    ev_timer_set(&conn_info.timer, 0, timer_interval / 1000.0);
+    ev_timer_start(loop, &conn_info.timer);
 
     struct ev_io fifo_watcher;
 
-	int fifo_fd=-1;
-
-	if(fifo_file[0]!=0)
-	{
-		fifo_fd=create_fifo(fifo_file);
-		///ev.events = EPOLLIN;
-		///ev.data.u64 = fifo_fd;
-
-		///ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fifo_fd, &ev);
-		///if (ret!= 0) {
-		///	mylog(log_fatal,"add fifo_fd to epoll error %s\n",strerror(errno));
-		///	myexit(-1);
-		///}
-	    ev_io_init(&fifo_watcher, fifo_cb, fifo_fd, EV_READ);
-	    ev_io_start(loop, &fifo_watcher);
-
-		mylog(log_info,"fifo_file=%s\n",fifo_file);
-	}
+    int fifo_fd = -1;
 
+    if (fifo_file[0] != 0) {
+        fifo_fd = create_fifo(fifo_file);
+        /// ev.events = EPOLLIN;
+        /// ev.data.u64 = fifo_fd;
 
-	ev_prepare prepare_watcher;
-	ev_init(&prepare_watcher,prepare_cb);
-	ev_prepare_start(loop,&prepare_watcher);
+        /// ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fifo_fd, &ev);
+        /// if (ret!= 0) {
+        ///	mylog(log_fatal,"add fifo_fd to epoll error %s\n",strerror(errno));
+        ///	myexit(-1);
+        /// }
+        ev_io_init(&fifo_watcher, fifo_cb, fifo_fd, EV_READ);
+        ev_io_start(loop, &fifo_watcher);
 
+        mylog(log_info, "fifo_file=%s\n", fifo_file);
+    }
 
-	ev_run(loop, 0);
+    ev_prepare prepare_watcher;
+    ev_init(&prepare_watcher, prepare_cb);
+    ev_prepare_start(loop, &prepare_watcher);
 
-	mylog(log_warn,"ev_run returned\n");
-	myexit(0);
+    ev_run(loop, 0);
 
+    mylog(log_warn, "ev_run returned\n");
+    myexit(0);
 
-	return 0;
+    return 0;
 }

tun_dev_server.cpp

@@ -3,360 +3,324 @@
 static dest_t udp_dest;
 static dest_t tun_dest;
 
-static void local_listen_cb(struct ev_loop *loop, struct ev_io *watcher, int revents)
-{
-	char data[buf_len];
-	int len;
-
-	assert(!(revents&EV_ERROR));
-
-	conn_info_t & conn_info= *((conn_info_t*)watcher->data);
-
-	int local_listen_fd=watcher->fd;
-
-	//struct sockaddr_in udp_new_addr_in={0};
-	//socklen_t udp_new_addr_len = sizeof(sockaddr_in);
-	address_t::storage_t udp_new_addr_in={0};
-	socklen_t udp_new_addr_len = sizeof(address_t::storage_t);
-
-	if ((len = recvfrom(local_listen_fd, data, max_data_len+1, 0,
-			(struct sockaddr *) &udp_new_addr_in, &udp_new_addr_len)) < 0) {
-		mylog(log_error,"recv_from error,this shouldnt happen,err=%s,but we can try to continue\n",strerror(errno));
-		return;
-		//myexit(1);
-	};
-
-	address_t new_addr;
-	new_addr.from_sockaddr((struct sockaddr *) &udp_new_addr_in,udp_new_addr_len);
-
-	if(len==max_data_len+1)
-	{
-		mylog(log_warn,"huge packet, data_len > %d,dropped\n",max_data_len);
-		return;
-	}
-
-	if(de_cook(data,len)<0)
-	{
-		mylog(log_warn,"de_cook(data,len)failed \n");
-		return;
-
-	}
-
-	char header=0;
-	if(get_header(header,data,len)!=0)
-	{
-		mylog(log_warn,"get_header() failed\n");
-		return;
-	}
-
-	if(udp_dest.inner.fd_addr.addr==new_addr)
-	{
-		if(header==header_keep_alive)
-		{
-			mylog(log_trace,"got keep_alive packet\n");
-			return;
-		}
-
-		if(header!=header_new_connect&& header!=header_normal)
-		{
-			mylog(log_warn,"invalid header\n");
-			return;
-		}
-	}
-	else
-	{
-		if(header==header_keep_alive)
-		{
-			mylog(log_debug,"got keep_alive packet from unexpected client\n");
-			return;
-		}
-
-		if(header==header_new_connect)
-		{
-			mylog(log_info,"new connection from %s\n", new_addr.get_str());
-			udp_dest.inner.fd_addr.addr=new_addr;
-			//udp_dest.inner.fd_ip_port.ip_port.ip=udp_new_addr_in.sin_addr.s_addr;
-			//udp_dest.inner.fd_ip_port.ip_port.port=ntohs(udp_new_addr_in.sin_port);
-			conn_info.fec_decode_manager.clear();
-			conn_info.fec_encode_manager.clear_data();
-			memset(&conn_info.stat,0,sizeof(conn_info.stat));
-
-		}
-		else if(header==header_normal)
-		{
-			mylog(log_debug,"rejected connection from %s\n", new_addr.get_str());
-
-
-			len=1;
-			data[0]=header_reject;
-			do_cook(data,len);
-
-
-			dest_t tmp_dest;
-			tmp_dest.type=type_fd_addr;
-
-			tmp_dest.inner.fd_addr.fd=local_listen_fd;
-			tmp_dest.inner.fd_addr.addr=new_addr;
-
-			delay_manager.add(0,tmp_dest,data,len);;
-			return;
-		}
-		else
-		{
-			mylog(log_warn,"invalid header\n");
-		}
-	}
-
-	mylog(log_trace,"Received packet from %s,len: %d\n", new_addr.get_str(),len);
-
-	from_fec_to_normal2(conn_info,tun_dest,data,len);
-
+static void local_listen_cb(struct ev_loop *loop, struct ev_io *watcher, int revents) {
+    char data[buf_len];
+    int len;
+
+    assert(!(revents & EV_ERROR));
+
+    conn_info_t &conn_info = *((conn_info_t *)watcher->data);
+
+    int local_listen_fd = watcher->fd;
+
+    // struct sockaddr_in udp_new_addr_in={0};
+    // socklen_t udp_new_addr_len = sizeof(sockaddr_in);
+    address_t::storage_t udp_new_addr_in = {0};
+    socklen_t udp_new_addr_len = sizeof(address_t::storage_t);
+
+    if ((len = recvfrom(local_listen_fd, data, max_data_len + 1, 0,
+                        (struct sockaddr *)&udp_new_addr_in, &udp_new_addr_len)) < 0) {
+        mylog(log_error, "recv_from error,this shouldnt happen,err=%s,but we can try to continue\n", strerror(errno));
+        return;
+        // myexit(1);
+    };
+
+    address_t new_addr;
+    new_addr.from_sockaddr((struct sockaddr *)&udp_new_addr_in, udp_new_addr_len);
+
+    if (len == max_data_len + 1) {
+        mylog(log_warn, "huge packet, data_len > %d,dropped\n", max_data_len);
+        return;
+    }
+
+    if (de_cook(data, len) < 0) {
+        mylog(log_warn, "de_cook(data,len)failed \n");
+        return;
+    }
+
+    char header = 0;
+    if (get_header(header, data, len) != 0) {
+        mylog(log_warn, "get_header() failed\n");
+        return;
+    }
+
+    if (udp_dest.inner.fd_addr.addr == new_addr) {
+        if (header == header_keep_alive) {
+            mylog(log_trace, "got keep_alive packet\n");
+            return;
+        }
+
+        if (header != header_new_connect && header != header_normal) {
+            mylog(log_warn, "invalid header\n");
+            return;
+        }
+    } else {
+        if (header == header_keep_alive) {
+            mylog(log_debug, "got keep_alive packet from unexpected client\n");
+            return;
+        }
+
+        if (header == header_new_connect) {
+            mylog(log_info, "new connection from %s\n", new_addr.get_str());
+            udp_dest.inner.fd_addr.addr = new_addr;
+            // udp_dest.inner.fd_ip_port.ip_port.ip=udp_new_addr_in.sin_addr.s_addr;
+            // udp_dest.inner.fd_ip_port.ip_port.port=ntohs(udp_new_addr_in.sin_port);
+            conn_info.fec_decode_manager.clear();
+            conn_info.fec_encode_manager.clear_data();
+            memset(&conn_info.stat, 0, sizeof(conn_info.stat));
+
+        } else if (header == header_normal) {
+            mylog(log_debug, "rejected connection from %s\n", new_addr.get_str());
+
+            len = 1;
+            data[0] = header_reject;
+            do_cook(data, len);
+
+            dest_t tmp_dest;
+            tmp_dest.type = type_fd_addr;
+
+            tmp_dest.inner.fd_addr.fd = local_listen_fd;
+            tmp_dest.inner.fd_addr.addr = new_addr;
+
+            delay_manager.add(0, tmp_dest, data, len);
+            ;
+            return;
+        } else {
+            mylog(log_warn, "invalid header\n");
+        }
+    }
+
+    mylog(log_trace, "Received packet from %s,len: %d\n", new_addr.get_str(), len);
+
+    from_fec_to_normal2(conn_info, tun_dest, data, len);
 }
-static void tun_fd_cb(struct ev_loop *loop, struct ev_io *watcher, int revents)
-{
-	char data[buf_len];
-	int len;
+static void tun_fd_cb(struct ev_loop *loop, struct ev_io *watcher, int revents) {
+    char data[buf_len];
+    int len;
 
-	assert(!(revents&EV_ERROR));
+    assert(!(revents & EV_ERROR));
 
-	conn_info_t & conn_info= *((conn_info_t*)watcher->data);
-	int tun_fd=watcher->fd;
+    conn_info_t &conn_info = *((conn_info_t *)watcher->data);
+    int tun_fd = watcher->fd;
 
-	len=read(tun_fd,data,max_data_len+1);
+    len = read(tun_fd, data, max_data_len + 1);
 
-	if(len==max_data_len+1)
-	{
-		mylog(log_warn,"huge packet, data_len > %d,dropped\n",max_data_len);
-		return;
-	}
+    if (len == max_data_len + 1) {
+        mylog(log_warn, "huge packet, data_len > %d,dropped\n", max_data_len);
+        return;
+    }
 
-	if(len<0)
-	{
-		mylog(log_warn,"read from tun_fd return %d,errno=%s\n",len,strerror(errno));
-		return;
-	}
+    if (len < 0) {
+        mylog(log_warn, "read from tun_fd return %d,errno=%s\n", len, strerror(errno));
+        return;
+    }
 
-	do_mssfix(data,len);
+    do_mssfix(data, len);
 
-	mylog(log_trace,"Received packet from tun,len: %d\n",len);
+    mylog(log_trace, "Received packet from tun,len: %d\n", len);
 
-	if(udp_dest.inner.fd_addr.addr.is_vaild()==0)
-	{
-		mylog(log_debug,"received packet from tun,but there is no client yet,dropped packet\n");
-		return;
-	}
+    if (udp_dest.inner.fd_addr.addr.is_vaild() == 0) {
+        mylog(log_debug, "received packet from tun,but there is no client yet,dropped packet\n");
+        return;
+    }
 
-	from_normal_to_fec2(conn_info,udp_dest,data,len,header_normal);
+    from_normal_to_fec2(conn_info, udp_dest, data, len, header_normal);
 }
 
-static void delay_manager_cb(struct ev_loop *loop, struct ev_timer *watcher, int revents)
-{
-	assert(!(revents&EV_ERROR));
+static void delay_manager_cb(struct ev_loop *loop, struct ev_timer *watcher, int revents) {
+    assert(!(revents & EV_ERROR));
 
-	//do nothing
+    // do nothing
 }
 
-static void fec_encode_cb(struct ev_loop *loop, struct ev_timer *watcher, int revents)
-{
-	assert(!(revents&EV_ERROR));
-
-	mylog(log_trace,"fec_encode_cb() called\n");
-
-	conn_info_t & conn_info= *((conn_info_t*)watcher->data);
-
-	assert(udp_dest.inner.fd_addr.addr.is_vaild()!=0);
-	///mylog(log_trace,"events[idx].data.u64 == conn_info.fec_encode_manager.get_timer_fd64()\n");
-	///uint64_t fd64=events[idx].data.u64;
-	///uint64_t value;
-	///if(!fd_manager.exist(fd64))   //fd64 has been closed
-	///{
-	///	mylog(log_trace,"!fd_manager.exist(fd64)");
-	///	continue;
-	///}
-	///if((ret=read(fd_manager.to_fd(fd64), &value, 8))!=8)
-	///{
-	///	mylog(log_trace,"(ret=read(fd_manager.to_fd(fd64), &value, 8))!=8,ret=%d\n",ret);
-	///	continue;
-	///}
-	///if(value==0)
-	///{
-	///	mylog(log_debug,"value==0\n");
-	///	continue;
-	///}
-	///assert(value==1);
-
-	from_normal_to_fec2(conn_info,udp_dest,0,0,header_normal);
+static void fec_encode_cb(struct ev_loop *loop, struct ev_timer *watcher, int revents) {
+    assert(!(revents & EV_ERROR));
+
+    mylog(log_trace, "fec_encode_cb() called\n");
+
+    conn_info_t &conn_info = *((conn_info_t *)watcher->data);
+
+    assert(udp_dest.inner.fd_addr.addr.is_vaild() != 0);
+    /// mylog(log_trace,"events[idx].data.u64 == conn_info.fec_encode_manager.get_timer_fd64()\n");
+    /// uint64_t fd64=events[idx].data.u64;
+    /// uint64_t value;
+    /// if(!fd_manager.exist(fd64))   //fd64 has been closed
+    ///{
+    ///	mylog(log_trace,"!fd_manager.exist(fd64)");
+    ///	continue;
+    /// }
+    /// if((ret=read(fd_manager.to_fd(fd64), &value, 8))!=8)
+    ///{
+    ///	mylog(log_trace,"(ret=read(fd_manager.to_fd(fd64), &value, 8))!=8,ret=%d\n",ret);
+    ///	continue;
+    /// }
+    /// if(value==0)
+    ///{
+    ///	mylog(log_debug,"value==0\n");
+    ///	continue;
+    /// }
+    /// assert(value==1);
+
+    from_normal_to_fec2(conn_info, udp_dest, 0, 0, header_normal);
 }
 
-static void fifo_cb(struct ev_loop *loop, struct ev_io *watcher, int revents)
-{
-	assert(!(revents&EV_ERROR));
-	int fifo_fd=watcher->fd;
-
-	char buf[buf_len];
-	int len=read (fifo_fd, buf, sizeof (buf));
-	if(len<0)
-	{
-		mylog(log_warn,"fifo read failed len=%d,errno=%s\n",len,strerror(errno));
-		return;
-	}
-	buf[len]=0;
-	handle_command(buf);
+static void fifo_cb(struct ev_loop *loop, struct ev_io *watcher, int revents) {
+    assert(!(revents & EV_ERROR));
+    int fifo_fd = watcher->fd;
+
+    char buf[buf_len];
+    int len = read(fifo_fd, buf, sizeof(buf));
+    if (len < 0) {
+        mylog(log_warn, "fifo read failed len=%d,errno=%s\n", len, strerror(errno));
+        return;
+    }
+    buf[len] = 0;
+    handle_command(buf);
 }
 
-static void conn_timer_cb(struct ev_loop *loop, struct ev_timer *watcher, int revents)
-{
-	assert(!(revents&EV_ERROR));
-
-	conn_info_t & conn_info= *((conn_info_t*)watcher->data);
+static void conn_timer_cb(struct ev_loop *loop, struct ev_timer *watcher, int revents) {
+    assert(!(revents & EV_ERROR));
 
-	mylog(log_trace,"conn_timer_cb() called\n");
+    conn_info_t &conn_info = *((conn_info_t *)watcher->data);
 
-	//uint64_t value;
-	//read(conn_info.timer.get_timer_fd(), &value, 8);
+    mylog(log_trace, "conn_timer_cb() called\n");
 
-	if(udp_dest.inner.fd_addr.addr.is_vaild()==0)
-	{
-		return;
-	}
-	conn_info.stat.report_as_server(udp_dest.inner.fd_addr.addr);
-	do_keep_alive(udp_dest);
+    // uint64_t value;
+    // read(conn_info.timer.get_timer_fd(), &value, 8);
 
+    if (udp_dest.inner.fd_addr.addr.is_vaild() == 0) {
+        return;
+    }
+    conn_info.stat.report_as_server(udp_dest.inner.fd_addr.addr);
+    do_keep_alive(udp_dest);
 }
 
-static void prepare_cb(struct ev_loop *loop, struct ev_prepare *watcher, int revents)
-{
-	assert(!(revents&EV_ERROR));
+static void prepare_cb(struct ev_loop *loop, struct ev_prepare *watcher, int revents) {
+    assert(!(revents & EV_ERROR));
 
-	delay_manager.check();
+    delay_manager.check();
 }
 
-int tun_dev_server_event_loop()
-{
-	int i,j,k,ret;
-	int tun_fd;
-	int local_listen_fd;
-
-    conn_info_t *conn_info_p=new conn_info_t;
-    conn_info_t &conn_info=*conn_info_p;  //huge size of conn_info,do not allocate on stack
+int tun_dev_server_event_loop() {
+    int i, j, k, ret;
+    int tun_fd;
+    int local_listen_fd;
 
-	tun_fd=get_tun_fd(tun_dev);
-	assert(tun_fd>0);
+    conn_info_t *conn_info_p = new conn_info_t;
+    conn_info_t &conn_info = *conn_info_p;  // huge size of conn_info,do not allocate on stack
 
-	assert(new_listen_socket2(local_listen_fd,local_addr)==0);
-	assert(set_tun(tun_dev,htonl((ntohl(sub_net_uint32)&0xFFFFFF00)|1),htonl((ntohl(sub_net_uint32)&0xFFFFFF00 )|2),tun_mtu)==0);
+    tun_fd = get_tun_fd(tun_dev);
+    assert(tun_fd > 0);
 
-	udp_dest.cook=1;
-	udp_dest.type=type_fd_addr;
+    assert(new_listen_socket2(local_listen_fd, local_addr) == 0);
+    assert(set_tun(tun_dev, htonl((ntohl(sub_net_uint32) & 0xFFFFFF00) | 1), htonl((ntohl(sub_net_uint32) & 0xFFFFFF00) | 2), tun_mtu) == 0);
 
-	udp_dest.inner.fd_addr.fd=local_listen_fd;
-	udp_dest.inner.fd_addr.addr.clear();
+    udp_dest.cook = 1;
+    udp_dest.type = type_fd_addr;
 
+    udp_dest.inner.fd_addr.fd = local_listen_fd;
+    udp_dest.inner.fd_addr.addr.clear();
 
-	tun_dest.type=type_write_fd;
-	tun_dest.inner.fd=tun_fd;
+    tun_dest.type = type_write_fd;
+    tun_dest.inner.fd = tun_fd;
 
-	///epoll_fd = epoll_create1(0);
-	///assert(epoll_fd>0);
+    /// epoll_fd = epoll_create1(0);
+    /// assert(epoll_fd>0);
 
-	///const int max_events = 4096;
-	///struct epoll_event ev, events[max_events];
-	///if (epoll_fd < 0) {
-	///	mylog(log_fatal,"epoll return %d\n", epoll_fd);
-	///	myexit(-1);
-	///}
+    /// const int max_events = 4096;
+    /// struct epoll_event ev, events[max_events];
+    /// if (epoll_fd < 0) {
+    ///	mylog(log_fatal,"epoll return %d\n", epoll_fd);
+    ///	myexit(-1);
+    /// }
 
-	struct ev_loop * loop= ev_default_loop(0);
-	assert(loop != NULL);
-    conn_info.loop=loop;
+    struct ev_loop *loop = ev_default_loop(0);
+    assert(loop != NULL);
+    conn_info.loop = loop;
 
-	///ev.events = EPOLLIN;
-	///ev.data.u64 = local_listen_fd;
-	///ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, local_listen_fd, &ev);
-	///if (ret!=0) {
-	///	mylog(log_fatal,"add  udp_listen_fd error\n");
-	///	myexit(-1);
-	///}
+    /// ev.events = EPOLLIN;
+    /// ev.data.u64 = local_listen_fd;
+    /// ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, local_listen_fd, &ev);
+    /// if (ret!=0) {
+    ///	mylog(log_fatal,"add  udp_listen_fd error\n");
+    ///	myexit(-1);
+    /// }
 
-	struct ev_io local_listen_watcher;
-	local_listen_watcher.data=&conn_info;
+    struct ev_io local_listen_watcher;
+    local_listen_watcher.data = &conn_info;
     ev_io_init(&local_listen_watcher, local_listen_cb, local_listen_fd, EV_READ);
     ev_io_start(loop, &local_listen_watcher);
 
-	///ev.events = EPOLLIN;
-	///ev.data.u64 = tun_fd;
-	///ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, tun_fd, &ev);
-	///if (ret!=0) {
-	///	mylog(log_fatal,"add  tun_fd error\n");
-	///	myexit(-1);
-	///}
+    /// ev.events = EPOLLIN;
+    /// ev.data.u64 = tun_fd;
+    /// ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, tun_fd, &ev);
+    /// if (ret!=0) {
+    ///	mylog(log_fatal,"add  tun_fd error\n");
+    ///	myexit(-1);
+    /// }
 
-	struct ev_io tun_fd_watcher;
-	tun_fd_watcher.data=&conn_info;
+    struct ev_io tun_fd_watcher;
+    tun_fd_watcher.data = &conn_info;
 
-	ev_io_init(&tun_fd_watcher, tun_fd_cb, tun_fd, EV_READ);
-	ev_io_start(loop, &tun_fd_watcher);
+    ev_io_init(&tun_fd_watcher, tun_fd_cb, tun_fd, EV_READ);
+    ev_io_start(loop, &tun_fd_watcher);
 
+    /// ev.events = EPOLLIN;
+    /// ev.data.u64 = delay_manager.get_timer_fd();
 
-	///ev.events = EPOLLIN;
-	///ev.data.u64 = delay_manager.get_timer_fd();
+    /// mylog(log_debug,"delay_manager.get_timer_fd()=%d\n",delay_manager.get_timer_fd());
+    /// ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, delay_manager.get_timer_fd(), &ev);
+    /// if (ret!= 0) {
+    ///	mylog(log_fatal,"add delay_manager.get_timer_fd() error\n");
+    ///	myexit(-1);
+    /// }
 
-	///mylog(log_debug,"delay_manager.get_timer_fd()=%d\n",delay_manager.get_timer_fd());
-	///ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, delay_manager.get_timer_fd(), &ev);
-	///if (ret!= 0) {
-	///	mylog(log_fatal,"add delay_manager.get_timer_fd() error\n");
-	///	myexit(-1);
-	///}
+    delay_manager.set_loop_and_cb(loop, delay_manager_cb);
 
-    delay_manager.set_loop_and_cb(loop,delay_manager_cb);
+    /// u64_t tmp_timer_fd64=conn_info.fec_encode_manager.get_timer_fd64();
+    /// ev.events = EPOLLIN;
+    /// ev.data.u64 = tmp_timer_fd64;
 
-
-	///u64_t tmp_timer_fd64=conn_info.fec_encode_manager.get_timer_fd64();
-	///ev.events = EPOLLIN;
-	///ev.data.u64 = tmp_timer_fd64;
-
-	///mylog(log_debug,"conn_info.fec_encode_manager.get_timer_fd64()=%llu\n",conn_info.fec_encode_manager.get_timer_fd64());
-	///ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd_manager.to_fd(tmp_timer_fd64), &ev);
-	///if (ret!= 0) {
-	///	mylog(log_fatal,"add fec_encode_manager.get_timer_fd64() error\n");
-	///	myexit(-1);
-	///}
+    /// mylog(log_debug,"conn_info.fec_encode_manager.get_timer_fd64()=%llu\n",conn_info.fec_encode_manager.get_timer_fd64());
+    /// ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd_manager.to_fd(tmp_timer_fd64), &ev);
+    /// if (ret!= 0) {
+    ///	mylog(log_fatal,"add fec_encode_manager.get_timer_fd64() error\n");
+    ///	myexit(-1);
+    /// }
 
     conn_info.fec_encode_manager.set_data(&conn_info);
-    conn_info.fec_encode_manager.set_loop_and_cb(loop,fec_encode_cb);
-
-	///conn_info.timer.add_fd_to_epoll(epoll_fd);
-	///conn_info.timer.set_timer_repeat_us(timer_interval*1000);
+    conn_info.fec_encode_manager.set_loop_and_cb(loop, fec_encode_cb);
 
-    conn_info.timer.data=&conn_info;
-    ev_init(&conn_info.timer,conn_timer_cb);
-    ev_timer_set(&conn_info.timer, 0, timer_interval/1000.0 );
-    ev_timer_start(loop,&conn_info.timer);
+    /// conn_info.timer.add_fd_to_epoll(epoll_fd);
+    /// conn_info.timer.set_timer_repeat_us(timer_interval*1000);
 
+    conn_info.timer.data = &conn_info;
+    ev_init(&conn_info.timer, conn_timer_cb);
+    ev_timer_set(&conn_info.timer, 0, timer_interval / 1000.0);
+    ev_timer_start(loop, &conn_info.timer);
 
     struct ev_io fifo_watcher;
-	int fifo_fd=-1;
+    int fifo_fd = -1;
 
-	if(fifo_file[0]!=0)
-	{
-		fifo_fd=create_fifo(fifo_file);
+    if (fifo_file[0] != 0) {
+        fifo_fd = create_fifo(fifo_file);
 
-	    ev_io_init(&fifo_watcher, fifo_cb, fifo_fd, EV_READ);
-	    ev_io_start(loop, &fifo_watcher);
+        ev_io_init(&fifo_watcher, fifo_cb, fifo_fd, EV_READ);
+        ev_io_start(loop, &fifo_watcher);
 
-		mylog(log_info,"fifo_file=%s\n",fifo_file);
-	}
+        mylog(log_info, "fifo_file=%s\n", fifo_file);
+    }
 
-	ev_prepare prepare_watcher;
-	ev_init(&prepare_watcher,prepare_cb);
-	ev_prepare_start(loop,&prepare_watcher);
+    ev_prepare prepare_watcher;
+    ev_init(&prepare_watcher, prepare_cb);
+    ev_prepare_start(loop, &prepare_watcher);
 
-	mylog(log_info,"now listening at %s\n",local_addr.get_str());
+    mylog(log_info, "now listening at %s\n", local_addr.get_str());
 
-	ev_run(loop, 0);
+    ev_run(loop, 0);
 
-	mylog(log_warn,"ev_run returned\n");
-	myexit(0);
+    mylog(log_warn, "ev_run returned\n");
+    myexit(0);
 
-	return 0;
+    return 0;
 }