wifidog原理分析

wifidog源码分析 - wifidog原理    

wifidog是一个用于配合认证服务器实现无线网页认证功能的程序，常见的情景就是使用于公共场合的无线wifi接入点，首先移动设备会连接公共wifi接入点，之后会弹出网页要求输入用户名密码，认证过后才能够连入外网。其主页是http://dev.wifidog.org/

1. 实现原理

　　其实wifidog原理很简单，主要是通过管控iptables，配合认证服务器进行客户端的放行操作。wifidog在启动后都会自动启动三个线程，分别为客户端检测线程、wdctrl交互线程、认证服务器心跳检测线程。每当新用户连接无线AP并浏览网页时，wifidog会获取新用户的此次操作，并返回一个重定向到认证服务器的http于用户，此后用户通过认证服务器认证后，再继续浏览网页时，wifidog会询问认证服务器此用户权限，若放行则修改iptables放行此用户IP。

 

　　主要流程如下

• 添加关键路径对应的回调函数
• 删除所有iptables路由表
• 建立新的iptables路由表
• 开启客户端检测线程（用于判断客户端是否在线，是否登出）
• 开启wdctrl交互线程
• 开启认证服务器心跳检测线程
• 循环等待客户端连接（使用socket绑定2060端口并监听，实际上在建立新的iptables路由表规则时会将网关的80端口重定向到2060端口）

 

　　回调函数

　　回调函数主要用于根据用户http报文执行不同的操作，其原理就是分析http报文请求中有没有关键路径，若有，则执行关键路径对应的回调函数，若没有，则返回一个重定向到认证服务器的包给用户。一次典型的流程为

• 用户连接无线AP，访问某网站（比如http://www.baidu.com）
• wifidog获取到此http报文，检查是否包含关键路径，没有则返回重定向包给用户，将其重定向到认证服务器
• 用户认证成功，认证服务器将用户重定向到无线AP网关，并包含关键路径"/wifidog/auth"和token
• wifidog接收到用户重定向后访问的报文，检测到关键路径"/wifidog/auth"，然后访问认证服务器进行token认证
• 认证成功，wifidog修改iptables放行此用户（根据mac和ip进行放行）

 

　　wifidog的iptables规则

　　这一部分我没有仔细认真看源码，但可以推论出wifidog是怎么修改iptables的规则的，了解iptables基本原理的同学都清楚iptables实际上有两条路进行数据包处理，一条路会通过应用程序，一条路不同过应用程序，直接到POSTOUTPUT，而我认为wifidog建立的规则是

• 只要是访问认证服务器的http请求都直接不通过wifidog发送出去
• 只要是通过认证的客户端wifidog都会修改iptables让其数据直接从FORWARD到POSTOUTPUT，而不经过wifidog
• 其他行为都必须进过wifidog处理

 

　　客户端检测线程

　　此线程每隔60s会遍历一次客户端列表，对每一个客户端列表统计流量，如果客户端在60s间隔内没有新产生的流量则不更新客户端的最新更新时间，当当前时间减去最新更新时间大于断线要求时间时，则会将此客户端从客户端列表删除，并修改iptables规则禁止其访问外部网络，然后发送此客户端登出包于认证服务器，认证服务器根据此登出包将此客户端做登出处理。如若没有超出断线要求时间，此线程还会发送客户端状态获取包于认证服务器，认证服务器返回此客户端在认证服务器上的信息，如若信息表示此客户端已在认证服务器上登出，wifidog则会执行此客户端下线操作。

 

　　wdctrl交互线程

　　其原理是使用unix socket进行进程间通信，具体实现在之后文章中体现

 

　　认证服务器心跳检测线程

　　原理也很简单，就是每隔60s将路由的一些系统信息发送给认证服务器，认证服务器接收到会返回一个回执

 

　　循环等待客户端连接

　　这里主要会接收到两种类型的客户端连接

• 未认证的客户端打开网页操作，wifidog会接收到此http请求，并返回一个重定向到认证服务器的包于客户端
• 经过认证服务器认证成功后，认证服务器自动将客户端重定向到无线AP的操作，wifidog接收到此类http请求后会检测关键路径"/tmp/wifidog"，并把http请求中携带的token与认证服务器进行认证，认证成功后则修改iptables放行客户端。

 

具体代码实现见之后章节

wifidog源码分析 - 初始化阶段 

Wifidog是一个linux下开源的认证网关软件，它主要用于配合认证服务器实现无线路由器的认证放行功能。

wifidog是一个后台的服务程序，可以通过wdctrl命令对wifidog主程序进行控制。

本文解释wifidog在启动阶段所做的初始化主要工作（代码片段1.1）

• 初始化配置（先将配置结构体初始化为默认值，在读取配置文件修改配置结构体）
• 初始化已连接客户端列表（如果是通过wdctrl重启wifidog，将会读取之前wifidog的已连接客户端列表 代码片段1.2 代码片段1.3）
• 如无特殊情况，分离进程，建立守护进程 （代码片段1.1）
• 添加多个http请求回调函数（包括404错误回调函数） （见之后章节）
• 摧毁删除现有的iptables路由表规则 （见之后章节）
• 建立新的iptables路由表规则 （见之后章节）
• 启动多个功能线程 （见之后章节）
• 循环等待客户端连接 （见之后章节）

代码片段1.1

点击(此处)折叠或打开

1. int main(int argc, char **argv) {
   
2. 
   
3.     s_config *config = config_get_config(); //就是返回全局变量config结构体的地址
   
4.     config_init(); //初始化全局变量config结构体为默认值
   
5. 
   
6.     parse_commandline(argc, argv); //根据传入参数执行操作（如果参数有-x则会设置restart_orig_pid为已运行的wifidog的pid）
   
7. 
   
8.     /* Initialize the config */
   
9.     config_read(config->configfile); //根据配置文件设置全局变量config结构体
   
10.     config_validate(); //判断GatewayInterface和AuthServer是否为空，空则无效退出程序。
    
11. 
    
12.     /* Initializes the linked list of connected clients */
    
13.     client_list_init(); //将已连接客户端链表置空。
    
14. 
    
15.     /* Init the signals to catch chld/quit/etc */
    
16.     init_signals(); //初始化一些信号
    
17. 
    
18.     if (restart_orig_pid) { //用于restart，如果有已运行的wifidog，先会kill它
    
19.         /*
    
20.          * We were restarted and our parent is waiting for us to talk to it over the socket
    
21.          */
    
22.         get_clients_from_parent(); //从已运行的wifidog中获取客户端列表，详见 代码片段1.2
    
23. 
    
24.         /*
    
25.          * At this point the parent will start destroying itself and the firewall. Let it finish it's job before we continue
    
26.          */
    
27. 
    
28.         while (kill(restart_orig_pid, 0) != -1) { //kill已运行的wifidog
    
29.             debug(LOG_INFO, "Waiting for parent PID %d to die before continuing loading", restart_orig_pid);
    
30.             sleep(1);
    
31.         }
    
32. 
    
33.         debug(LOG_INFO, "Parent PID %d seems to be dead. Continuing loading.");
    
34.     }
    
35. 
    
36.     if (config->daemon) { //创建为守护进程，config->daemon默认值为-1
    
37. 
    
38.         debug(LOG_INFO, "Forking into background");
    
39. 
    
40.         switch(safe_fork()) {
    
41.             case 0: /* child */
    
42.                 setsid(); //创建新会话，脱离此终端，实现守护进程
    
43.                 append_x_restartargv();
    
44.                 main_loop(); //进入主循环（核心代码在此）。
    
45.                 break;
    
46. 
    
47.             default: /* parent */
    
48.                 exit(0);
    
49.                 break;
    
50.         }
    
51.     }
    
52.     else {
    
53.         append_x_restartargv();
    
54.         main_loop();
    
55.     }
    
56. 
    
57.     return(0); /* never reached */
    
58. }

代码片段1.2（获取已启动的wifidog的客户端列表）：

此段代表描述了新启动的wifidog如何从已启动的wifidog程序中获取已连接的客户端列表。发送端见 代码片段1.3

点击(此处)折叠或打开

1. void get_clients_from_parent(void) {
   
2.     int sock;
   
3.     struct sockaddr_un sa_un;
   
4.     s_config * config = NULL;
   
5.     char linebuffer[MAX_BUF];
   
6.     int len = 0;
   
7.     char *running1 = NULL;
   
8.     char *running2 = NULL;
   
9.     char *token1 = NULL;
   
10.     char *token2 = NULL;
    
11.     char onechar;
    
12.     char *command = NULL;
    
13.     char *key = NULL;
    
14.     char *value = NULL;
    
15.     t_client * client = NULL;
    
16.     t_client * lastclient = NULL;
    
17. 
    
18.     config = config_get_config();
    
19.     
    
20.     debug(LOG_INFO, "Connecting to parent to download clients");
    
21. 
    
22.     /* 连接socket */
    
23.     sock = socket(AF_UNIX, SOCK_STREAM, 0);
    
24.     memset(&sa_un, 0, sizeof(sa_un));
    
25.     sa_un.sun_family = AF_UNIX;
    
26.     strncpy(sa_un.sun_path, config->internal_sock, (sizeof(sa_un.sun_path) - 1)); //config->internal_sock的值为"/tmp/wifidog.sock"
    
27. 
    
28.     /* 连接已启动的wifidog */
    
29.     if (connect(sock, (struct sockaddr *)&sa_un, strlen(sa_un.sun_path) + sizeof(sa_un.sun_family))) {
    
30.         debug(LOG_ERR, "Failed to connect to parent (%s) - client list not downloaded", strerror(errno));
    
31.         return;
    
32.     }
    
33. 
    
34.     debug(LOG_INFO, "Connected to parent. Downloading clients");
    
35. 
    
36.     LOCK_CLIENT_LIST();
    
37. 
    
38.     command = NULL;
    
39.     memset(linebuffer, 0, sizeof(linebuffer));
    
40.     len = 0;
    
41.     client = NULL;
    
42.     /* 接收数据，逐个字符接收 */
    
43.     /* 数据包格式为 CLIENT|ip=%s|mac=%s|token=%s|fw_connection_state=%u|fd=%d|counters_incoming=%llu|counters_outgoing=%llu|counters_last_updated=%lu\n */
    
44.     while (read(sock, &onechar, 1) == 1) {
    
45.         if (onechar == '\n') {
    
46.             /* 如果接收到末尾（'\n'），则转为'\0' */
    
47.             onechar = '\0';
    
48.         }
    
49.         linebuffer[len++] = onechar;
    
50.         
    
51.         if (!onechar) {
    
52.             /* 以下将数据转化为t_client结构体添加到客户端列表 */
    
53.             debug(LOG_DEBUG, "Received from parent: [%s]", linebuffer);
    
54.             running1 = linebuffer;
    
55.             while ((token1 = strsep(&running1, "|")) != NULL) {
    
56.                 if (!command) {
    
57.                     /* The first token is the command */
    
58.                     command = token1;
    
59.                 }
    
60.                 else {
    
61.                 /* Token1 has something like "foo=bar" */
    
62.                     running2 = token1;
    
63.                     key = value = NULL;
    
64.                     while ((token2 = strsep(&running2, "=")) != NULL) {
    
65.                         if (!key) {
    
66.                             key = token2;
    
67.                         }
    
68.                         else if (!value) {
    
69.                             value = token2;
    
70.                         }
    
71.                     }
    
72.                 }
    
73. 
    
74.                 if (strcmp(command, "CLIENT") == 0) {
    
75.                     /* This line has info about a client in the client list */
    
76.                     if (!client) {
    
77.                         /* Create a new client struct */
    
78.                         client = safe_malloc(sizeof(t_client));
    
79.                         memset(client, 0, sizeof(t_client));
    
80.                     }
    
81.                 }
    
82. 
    
83.                 if (key && value) {
    
84.                     if (strcmp(command, "CLIENT") == 0) {
    
85.                         /* Assign the key into the appropriate slot in the connection structure */
    
86.                         if (strcmp(key, "ip") == 0) {
    
87.                             client->ip = safe_strdup(value);
    
88.                         }
    
89.                         else if (strcmp(key, "mac") == 0) {
    
90.                             client->mac = safe_strdup(value);
    
91.                         }
    
92.                         else if (strcmp(key, "token") == 0) {
    
93.                             client->token = safe_strdup(value);
    
94.                         }
    
95.                         else if (strcmp(key, "fw_connection_state") == 0) {
    
96.                             client->fw_connection_state = atoi(value);
    
97.                         }
    
98.                         else if (strcmp(key, "fd") == 0) {
    
99.                             client->fd = atoi(value);
    
100.                         }
     
101.                         else if (strcmp(key, "counters_incoming") == 0) {
     
102.                             client->counters.incoming_history = atoll(value);
     
103.                             client->counters.incoming = client->counters.incoming_history;
     
104.                         }
     
105.                         else if (strcmp(key, "counters_outgoing") == 0) {
     
106.                             client->counters.outgoing_history = atoll(value);
     
107.                             client->counters.outgoing = client->counters.outgoing_history;
     
108.                         }
     
109.                         else if (strcmp(key, "counters_last_updated") == 0) {
     
110.                             client->counters.last_updated = atol(value);
     
111.                         }
     
112.                         else {
     
113.                             debug(LOG_NOTICE, "I don't know how to inherit key [%s] value [%s] from parent", key, value);
     
114.                         }
     
115.                     }
     
116.                 }
     
117.             }
     
118. 
     
119.             /* End of parsing this command */
     
120.             if (client) {
     
121.                 /* Add this client to the client list */
     
122.                 if (!firstclient) {
     
123.                     firstclient = client;
     
124.                     lastclient = firstclient;
     
125.                 }
     
126.                 else {
     
127.                     lastclient->next = client;
     
128.                     lastclient = client;
     
129.                 }
     
130.             }
     
131. 
     
132.             /* Clean up */
     
133.             command = NULL;
     
134.             memset(linebuffer, 0, sizeof(linebuffer));
     
135.             len = 0;
     
136.             client = NULL;
     
137.         }
     
138.     }
     
139. 
     
140.     UNLOCK_CLIENT_LIST();
     
141.     debug(LOG_INFO, "Client list downloaded successfully from parent");
     
142. 
     
143.     close(sock);
     
144. }

代码片段1.3（已启动的wifidog发送客户端列表到新启动的wifidog）：

点击(此处)折叠或打开

1. //thread_wdctl_handler(void *arg)函数是wifidog启动后自动创建的控制线程，主要用于与wdctrl进行socket通信，根据wdctrl命令执行不同的操作。这里我们着重讲解的是wdctrl发送restart后wifidog的执行逻辑。
   
2. static void *
   
3. thread_wdctl_handler(void *arg)
   
4. {
   
5.     int fd,
   
6.         done,
   
7.         i;
   
8.     char request[MAX_BUF];
   
9.     ssize_t read_bytes,
   
10.         len;
    
11. 
    
12.     debug(LOG_DEBUG, "Entering thread_wdctl_handler....");
    
13. 
    
14.     fd = (int)arg;
    
15.     
    
16.     debug(LOG_DEBUG, "Read bytes and stuff from %d", fd);
    
17. 
    
18.     /* 初始化变量 */
    
19.     read_bytes = 0;
    
20.     done = 0;
    
21.     memset(request, 0, sizeof(request));
    
22.     
    
23.     /* 读取命令 */
    
24.     while (!done && read_bytes < (sizeof(request) - 1)) {
    
25.         len = read(fd, request + read_bytes,
    
26.                 sizeof(request) - read_bytes); //读取wdctrl发送的命令
    
27. 
    
28.         /* 判断命令正确性 */
    
29.         for (i = read_bytes; i < (read_bytes + len); i++) {
    
30.             if (request[i] == '\r' || request[i] == '\n') {
    
31.                 request[i] = '\0';
    
32.                 done = 1;
    
33.             }
    
34.         }
    
35.         
    
36.         /* Increment position */
    
37.         read_bytes += len;
    
38.     }
    
39. 
    
40.         //判断命令
    
41.     if (strncmp(request, "status", 6) == 0) {
    
42.         wdctl_status(fd);
    
43.     } else if (strncmp(request, "stop", 4) == 0) {
    
44.         wdctl_stop(fd);
    
45.     } else if (strncmp(request, "reset", 5) == 0) {
    
46.         wdctl_reset(fd, (request + 6));
    
47.     } else if (strncmp(request, "restart", 7) == 0) {
    
48.         wdctl_restart(fd); //执行wdctl_restart(int afd)函数
    
49.     }
    
50. 
    
51.     if (!done) {
    
52.         debug(LOG_ERR, "Invalid wdctl request.");
    
53.                 //关闭套接字
    
54.         shutdown(fd, 2);
    
55.         close(fd);
    
56.         pthread_exit(NULL);
    
57.     }
    
58. 
    
59.     debug(LOG_DEBUG, "Request received: [%s]", request);
    
60.     
    
61.         //关闭套接字
    
62.     shutdown(fd, 2);
    
63.     close(fd);
    
64.     debug(LOG_DEBUG, "Exiting thread_wdctl_handler....");
    
65. 
    
66.     return NULL;
    
67. }
    
68. 
    
69. 
    
70. //wdctl_restart(int afd)函数详解
    
71. static void
    
72. wdctl_restart(int afd)
    
73. {
    
74.     int sock,
    
75.         fd;
    
76.     char *sock_name;
    
77.     struct sockaddr_un sa_un;
    
78.     s_config * conf = NULL;
    
79.     t_client * client = NULL;
    
80.     char * tempstring = NULL;
    
81.     pid_t pid;
    
82.     ssize_t written;
    
83.     socklen_t len;
    
84. 
    
85.     conf = config_get_config();
    
86. 
    
87.     debug(LOG_NOTICE, "Will restart myself");
    
88. 
    
89.     /*
    
90.      * 准备内部连接socket
    
91.      */
    
92.     memset(&sa_un, 0, sizeof(sa_un));
    
93.     sock_name = conf->internal_sock; //conf->internal_sock值为"/tmp/wifidog.sock"
    
94.     debug(LOG_DEBUG, "Socket name: %s", sock_name);
    
95. 
    
96.     if (strlen(sock_name) > (sizeof(sa_un.sun_path) - 1)) {
    
97.        
    
98.         debug(LOG_ERR, "INTERNAL socket name too long");
    
99.         return;
    
100.     }
     
101. 
     
102.     debug(LOG_DEBUG, "Creating socket");
     
103.     sock = socket(PF_UNIX, SOCK_STREAM, 0); //建立内部socket套接字
     
104. 
     
105.     debug(LOG_DEBUG, "Got internal socket %d", sock);
     
106. 
     
107.     /* 如果sock_name文件存在，则删除*/
     
108.     unlink(sock_name);
     
109. 
     
110.     debug(LOG_DEBUG, "Filling sockaddr_un");
     
111.     strcpy(sa_un.sun_path, sock_name); 
     
112.     sa_un.sun_family = AF_UNIX;
     
113.     
     
114.     debug(LOG_DEBUG, "Binding socket (%s) (%d)", sa_un.sun_path, strlen(sock_name));
     
115.     
     
116.    
     
117.     if (bind(sock, (struct sockaddr *)&sa_un, strlen(sock_name) + sizeof(sa_un.sun_family))) {
     
118.         debug(LOG_ERR, "Could not bind internal socket: %s", strerror(errno));
     
119.         return;
     
120.     }
     
121. 
     
122.     if (listen(sock, 5)) {
     
123.         debug(LOG_ERR, "Could not listen on internal socket: %s", strerror(errno));
     
124.         return;
     
125.     }
     
126.     
     
127.     /*
     
128.      * socket建立完成，创建子进程
     
129.      */
     
130.     debug(LOG_DEBUG, "Forking in preparation for exec()...");
     
131.     pid = safe_fork();
     
132.     if (pid > 0) {
     
133.         /* 父进程 */
     
134. 
     
135.         /* 等待子进程连接此socket :*/
     
136.         debug(LOG_DEBUG, "Waiting for child to connect on internal socket");
     
137.         len = sizeof(sa_un);
     
138.         if ((fd = accept(sock, (struct sockaddr *)&sa_un, &len)) == -1){ //接受连接
     
139.             debug(LOG_ERR, "Accept failed on internal socket: %s", strerror(errno));
     
140.             close(sock);
     
141.             return;
     
142.         }
     
143. 
     
144.         close(sock);
     
145. 
     
146.         debug(LOG_DEBUG, "Received connection from child. Sending them all existing clients");
     
147. 
     
148.         /*子进程已经完成连接，发送客户端列表 */
     
149.         LOCK_CLIENT_LIST();
     
150.         client = client_get_first_client(); //获取第一个客户端
     
151.         while (client) {
     
152.             /* Send this client */
     
153.             safe_asprintf(&tempstring, "CLIENT|ip=%s|mac=%s|token=%s|fw_connection_state=%u|fd=%d|counters_incoming=%llu|counters_outgoing=%llu|counters_last_updated=%lu\n",client->ip, client->mac, client->token, client->fw_connection_state, client->fd, client->counters.incoming, client->counters.outgoing, client->counters.last_updated);
     
154.             debug(LOG_DEBUG, "Sending to child client data: %s", tempstring);
     
155.             len = 0;
     
156.             while (len != strlen(tempstring)) {
     
157.                 written = write(fd, (tempstring + len), strlen(tempstring) - len); //发送给子进程
     
158.                 if (written == -1) {
     
159.                     debug(LOG_ERR, "Failed to write client data to child: %s", strerror(errno));
     
160.                     free(tempstring);
     
161.                     break;
     
162.                 }
     
163.                 else {
     
164.                     len += written;
     
165.                 }
     
166.             }
     
167.             free(tempstring);
     
168.             client = client->next;
     
169.         }
     
170.         UNLOCK_CLIENT_LIST();
     
171. 
     
172.         close(fd);
     
173. 
     
174.         debug(LOG_INFO, "Sent all existing clients to child. Committing suicide!");
     
175. 
     
176.         shutdown(afd, 2);
     
177.         close(afd);
     
178. 
     
179.         
     
180.         wdctl_stop(afd);
     
181.     }
     
182.     else {
     
183.         /* 子进程，先关闭资源 */
     
184.         close(wdctl_socket_server);
     
185.         close(icmp_fd);
     
186.         close(sock);
     
187.         shutdown(afd, 2);
     
188.         close(afd);
     
189.         debug(LOG_NOTICE, "Re-executing myself (%s)", restartargv[0]);
     
190. 
     
191.         setsid();
     
192.         execvp(restartargv[0], restartargv); //执行外部命令，这里重新启动wifidog
     
193.         
     
194.         debug(LOG_ERR, "I failed to re-execute myself: %s", strerror(errno));
     
195.         debug(LOG_ERR, "Exiting without cleanup");
     
196.         exit(1);
     
197.     }
     
198. }

小结

　　客户端列表只有在restart命令中才会执行，实际上流程就是

• 父wifidog准备socket
• 父wifidog启动子wifidog
• 子wifidog连接父wifidog
• 客户端列表传递

• 子wifidog终止父wifidog

wifidog源码分析 - 用户连接过程 

main_loop

　　此函数几乎相当于我们写程序的main函数，主要功能都是在这里面实现的，函数主要实现了主循环，并启动了三个线程，这三个线程的功能具体见wifidog源码分析 - wifidog原理，在此函数最后主循环中会等待用户连接，新用户只要通过浏览器打开非认证服务器网页时主循环就会监听到，监听到后会启动一个处理线程。其流程为

• 设置程序启动时间
• 获取网关信息
• 绑定http端口（80重定向到了2060）
• 设置关键路径和404错误的回调函数
• 重新建立iptables规则
• 启动客户端检测线程 （稍后文章分析）
• 启动wdctrl交互线程 （稍后文章分析）
• 认证服务器心跳检测线程 （稍后文章分析）
• 循环等待用户http请求，为每个请求启动一个处理线程。（代码片段1.2 代码片段1.3 代码片段1.4）

代码片段1.1

1. static void
   
2. main_loop(void)
   
3. {
   
4.     int result;
   
5.     pthread_t tid;
   
6.     s_config *config = config_get_config();
   
7.     request *r;
   
8.     void **params;
   
9. 
   
10.     /* 设置启动时间 */
    
11.     if (!started_time) {
    
12.         debug(LOG_INFO, "Setting started_time");
    
13.         started_time = time(NULL);
    
14.     }
    
15.     else if (started_time < MINIMUM_STARTED_TIME) {
    
16.         debug(LOG_WARNING, "Detected possible clock skew - re-setting started_time");
    
17.         started_time = time(NULL);
    
18.     }
    
19. 
    
20.     /* 获取网关IP，失败退出程序 */
    
21.     if (!config->gw_address) {
    
22.         debug(LOG_DEBUG, "Finding IP address of %s", config->gw_interface);
    
23.         if ((config->gw_address = get_iface_ip(config->gw_interface)) == NULL) {
    
24.             debug(LOG_ERR, "Could not get IP address information of %s, exiting...", config->gw_interface);
    
25.             exit(1);
    
26.         }
    
27.         debug(LOG_DEBUG, "%s = %s", config->gw_interface, config->gw_address);
    
28.     }
    
29. 
    
30.     /* 获取网关ID，失败退出程序 */
    
31.     if (!config->gw_id) {
    
32.         debug(LOG_DEBUG, "Finding MAC address of %s", config->gw_interface);
    
33.         if ((config->gw_id = get_iface_mac(config->gw_interface)) == NULL) {
    
34.             debug(LOG_ERR, "Could not get MAC address information of %s, exiting...", config->gw_interface);
    
35.             exit(1);
    
36.         }
    
37.         debug(LOG_DEBUG, "%s = %s", config->gw_interface, config->gw_id);
    
38.     }
    
39. 
    
40.     /* 初始化监听网关2060端口的socket */
    
41.     debug(LOG_NOTICE, "Creating web server on %s:%d", config->gw_address, config->gw_port);
    
42.     
    
43.     if ((webserver = httpdCreate(config->gw_address, config->gw_port)) == NULL) {
    
44.         debug(LOG_ERR, "Could not create web server: %s", strerror(errno));
    
45.         exit(1);
    
46.     }
    
47. 
    
48.     debug(LOG_DEBUG, "Assigning callbacks to web server");
    
49.     /* 设置关键路径及其回调函数，在代码片段1.2中会使用到 */
    
50.     httpdAddCContent(webserver, "/", "wifidog", 0, NULL, http_callback_wifidog);
    
51.     httpdAddCContent(webserver, "/wifidog", "", 0, NULL, http_callback_wifidog);
    
52.     httpdAddCContent(webserver, "/wifidog", "about", 0, NULL, http_callback_about);
    
53.     httpdAddCContent(webserver, "/wifidog", "status", 0, NULL, http_callback_status);
    
54.     httpdAddCContent(webserver, "/wifidog", "auth", 0, NULL, http_callback_auth);
    
55.     /* 设置404错误回调函数，在里面实现了重定向至认证服务器 */
    
56.     httpdAddC404Content(webserver, http_callback_404);
    
57. 
    
58.     /* 清除iptables规则 */
    
59.     fw_destroy();
    
60.     /* 重新设置iptables规则 */
    
61.     if (!fw_init()) {
    
62.         debug(LOG_ERR, "FATAL: Failed to initialize firewall");
    
63.         exit(1);
    
64.     }
    
65. 
    
66.     /* 客户端检测线程 */
    
67.     result = pthread_create(&tid_fw_counter, NULL, (void *)thread_client_timeout_check, NULL);
    
68.     if (result != 0) {
    
69.         debug(LOG_ERR, "FATAL: Failed to create a new thread (fw_counter) - exiting");
    
70.         termination_handler(0);
    
71.     }
    
72.     pthread_detach(tid_fw_counter);
    
73. 
    
74.     /* wdctrl交互线程 */
    
75.     result = pthread_create(&tid, NULL, (void *)thread_wdctl, (void *)safe_strdup(config->wdctl_sock));
    
76.     if (result != 0) {
    
77.         debug(LOG_ERR, "FATAL: Failed to create a new thread (wdctl) - exiting");
    
78.         termination_handler(0);
    
79.     }
    
80.     pthread_detach(tid);
    
81.     
    
82.     /* 认证服务器心跳检测线程 */
    
83.     result = pthread_create(&tid_ping, NULL, (void *)thread_ping, NULL);
    
84.     if (result != 0) {
    
85.         debug(LOG_ERR, "FATAL: Failed to create a new thread (ping) - exiting");
    
86.         termination_handler(0);
    
87.     }
    
88.     pthread_detach(tid_ping);
    
89.     
    
90.     debug(LOG_NOTICE, "Waiting for connections");
    
91.     while(1) {
    
92.         /* 监听2060端口等待用户http请求 */
    
93.         r = httpdGetConnection(webserver, NULL);
    
94. 
    
95.         /* 错误处理 */
    
96.         if (webserver->lastError == -1) {
    
97.             /* Interrupted system call */
    
98.             continue; /* restart loop */
    
99.         }
    
100.         else if (webserver->lastError < -1) {
     
101.             debug(LOG_ERR, "FATAL: httpdGetConnection returned unexpected value %d, exiting.", webserver->lastError);
     
102.             termination_handler(0);
     
103.         }
     
104.         else if (r != NULL) {
     
105.             /* 用户http请求接收成功 */
     
106.             debug(LOG_INFO, "Received connection from %s, spawning worker thread", r->clientAddr);
     
107.             params = safe_malloc(2 * sizeof(void *));
     
108.             *params = webserver;
     
109.             *(params + 1) = r;
     
110. 
     
111.             /* 开启http请求处理线程 */
     
112.             result = pthread_create(&tid, NULL, (void *)thread_httpd, (void *)params);
     
113.             if (result != 0) {
     
114.                 debug(LOG_ERR, "FATAL: Failed to create a new thread (httpd) - exiting");
     
115.                 termination_handler(0);
     
116.             }
     
117.             pthread_detach(tid);
     
118.         }
     
119.         else {
     
120.             ;
     
121.         }
     
122.     }
     
123. 
     
124.     /* never reached */
     
125. }

用户连接启动线程（void thread_httpd(void * args)）

代码片段1.2

此段代码是当有新用户（未认证的用户 代码片段1.3，已在认证服务器上认证但没有在wifidog认证的用户 代码片段1.4）连接时创建的线程，其主要功能为

• 获取用户浏览器发送过来的http报头
• 分析http报头，分析是否包含关键路径
• 不包含关键路径则调用404回调函数
• 包含关键路径则执行关键路径回调函数（这里主要讲解"/wifidog/auth"路径）

1. void
   
2. thread_httpd(void *args)
   
3. {
   
4.     void **params;
   
5.     httpd *webserver;
   
6.     request *r;
   
7.     
   
8.     params = (void **)args;
   
9.     webserver = *params;
   
10.     r = *(params + 1);
    
11.     free(params);
    
12.     
    
13.     /* 获取http报文 */
    
14.     if (httpdReadRequest(webserver, r) == 0) {
    
15.         debug(LOG_DEBUG, "Processing request from %s", r->clientAddr);
    
16.         debug(LOG_DEBUG, "Calling httpdProcessRequest() for %s", r->clientAddr);
    
17.         /* 分析http报文 */
    
18.         httpdProcessRequest(webserver, r);
    
19.         debug(LOG_DEBUG, "Returned from httpdProcessRequest() for %s", r->clientAddr);
    
20.     }
    
21.     else {
    
22.         debug(LOG_DEBUG, "No valid request received from %s", r->clientAddr);
    
23.     }
    
24.     debug(LOG_DEBUG, "Closing connection with %s", r->clientAddr);
    
25.     httpdEndRequest(r);
    
26. }
    
27. 
    
28. 
    
29. 
    
30. /* 被thread_httpd调用 */
    
31. void httpdProcessRequest(httpd *server, request *r)
    
32. {
    
33.     char dirName[HTTP_MAX_URL],
    
34.         entryName[HTTP_MAX_URL],
    
35.         *cp;
    
36.     httpDir *dir;
    
37.     httpContent *entry;
    
38. 
    
39.     r->response.responseLength = 0;
    
40.     strncpy(dirName, httpdRequestPath(r), HTTP_MAX_URL);
    
41.     dirName[HTTP_MAX_URL-1]=0;
    
42.     cp = rindex(dirName, '/');
    
43.     if (cp == NULL)
    
44.     {
    
45.         printf("Invalid request path '%s'\n",dirName);
    
46.         return;
    
47.     }
    
48.     strncpy(entryName, cp + 1, HTTP_MAX_URL);
    
49.     entryName[HTTP_MAX_URL-1]=0;
    
50.     if (cp != dirName)
    
51.         *cp = 0;
    
52.     else
    
53.         *(cp+1) = 0;
    
54. 
    
55.      /* 获取http报文中的关键路径，在main_loop中已经设置 */
    
56.     dir = _httpd_findContentDir(server, dirName, HTTP_FALSE);
    
57.     if (dir == NULL)
    
58.     {
    
59.         /* http报文中未包含关键路径，执行404回调函数（在404回调函数中新用户被重定向到认证服务器），见代码片段1.3 */
    
60.         _httpd_send404(server, r);
    
61.         _httpd_writeAccessLog(server, r);
    
62.         return;
    
63.     }
    
64.     /* 获取关键路径内容描述符 */
    
65.     entry = _httpd_findContentEntry(r, dir, entryName);
    
66.     if (entry == NULL)
    
67.     {
    
68.         _httpd_send404(server, r);
    
69.         _httpd_writeAccessLog(server, r);
    
70.         return;
    
71.     }
    
72.     if (entry->preload)
    
73.     {
    
74.         if ((entry->preload)(server) < 0)
    
75.         {
    
76.             _httpd_writeAccessLog(server, r);
    
77.             return;
    
78.         }
    
79.     }
    
80.     switch(entry->type)
    
81.     {
    
82.         case HTTP_C_FUNCT:
    
83.         case HTTP_C_WILDCARD:
    
84.             /* 如果是被认证服务器重定向到网关的用户，此处的关键路径为"/wifidog/auth"，并执行回调函数 */
    
85.             (entry->function)(server, r);
    
86.             break;
    
87. 
    
88.         case HTTP_STATIC:
    
89.             _httpd_sendStatic(server, r, entry->data);
    
90.             break;
    
91. 
    
92.         case HTTP_FILE:
    
93.             _httpd_sendFile(server, r, entry->path);
    
94.             break;
    
95. 
    
96.         case HTTP_WILDCARD:
    
97.             if (_httpd_sendDirectoryEntry(server, r, entry,
    
98.                         entryName)<0)
    
99.             {
    
100.                 _httpd_send404(server, r);
     
101.             }
     
102.             break;
     
103.     }
     
104.     _httpd_writeAccessLog(server, r);
     
105. }

代码片段1.3

此段代码表示wifidog是如何通过http 404回调函数实现客户端重定向了，实际上就是在404回调函数中封装了一个307状态的http报头，http的307状态在http协议中就是用于重定向的，封装完成后通过已经与客户端连接的socket返回给客户端。步骤流程为

• 判断本机是否处于离线状态
• 判断认证服务器是否在线
• 封装http 307报文
• 发送于目标客户端

1. void
   
2. http_callback_404(httpd *webserver, request *r)
   
3. {
   
4.     char tmp_url[MAX_BUF],
   
5.             *url;
   
6.     s_config *config = config_get_config();
   
7.     t_auth_serv *auth_server = get_auth_server();
   
8. 
   
9.     memset(tmp_url, 0, sizeof(tmp_url));
   
10. 
    
11.         snprintf(tmp_url, (sizeof(tmp_url) - 1), "http://%s%s%s%s",
    
12.                         r->request.host,
    
13.                         r->request.path,
    
14.                         r->request.query[0] ? "?" : "",
    
15.                         r->request.query);
    
16.     url = httpdUrlEncode(tmp_url);
    
17. 
    
18.     if (!is_online()) {
    
19.         /* 本机处于离线状态，此函数调用结果由认证服务器检测线程设置 */
    
20.         char * buf;
    
21.         safe_asprintf(&buf, 
    
22.             "

    We apologize, but it seems that the internet connection that powers this hotspot is temporarily unavailable.

    
    

    "
    
23.             "

    If at all possible, please notify the owners of this hotspot that the internet connection is out of service.

    
    

    "
    
24.             "

    The maintainers of this network are aware of this disruption. We hope that this situation will be resolved soon.

    
    

    "
    
25.             "

    In a while please click here to try your request again.

    
    

    ", tmp_url);
    
26. 
    
27.                 send_http_page(r, "Uh oh! Internet access unavailable!", buf);
    
28.         free(buf);
    
29.         debug(LOG_INFO, "Sent %s an apology since I am not online - no point sending them to auth server", r->clientAddr);
    
30.     }
    
31.     else if (!is_auth_online()) {
    
32.         /* 认证服务器处于离线状态 */
    
33.         char * buf;
    
34.         safe_asprintf(&buf, 
    
35.             "

    We apologize, but it seems that we are currently unable to re-direct you to the login screen.

    
    

    "
    
36.             "

    The maintainers of this network are aware of this disruption. We hope that this situation will be resolved soon.

    
    

    "
    
37.             "

    In a couple of minutes please click here to try your request again.

    
    

    ", tmp_url);
    
38. 
    
39.                 send_http_page(r, "Uh oh! Login screen unavailable!", buf);
    
40.         free(buf);
    
41.         debug(LOG_INFO, "Sent %s an apology since auth server not online - no point sending them to auth server", r->clientAddr);
    
42.     }
    
43.     else {
    
44.         /* 本机与认证服务器都在线，返回重定向包于客户端 */
    
45.         char *urlFragment;
    
46.         safe_asprintf(&urlFragment, "%sgw_address=%s&gw_port=%d&gw_id=%s&url=%s",
    
47.             auth_server->authserv_login_script_path_fragment,
    
48.             config->gw_address,
    
49.             config->gw_port, 
    
50.             config->gw_id,
    
51.             url);
    
52.         debug(LOG_INFO, "Captured %s requesting [%s] and re-directing them to login page", r->clientAddr, url);
    
53.         http_send_redirect_to_auth(r, urlFragment, "Redirect to login page"); /* 实际上此函数中通过socket返回一个307状态的http报头给客户端，里面包含有认证服务器地址 */
    
54.         free(urlFragment);
    
55.     }
    
56.     free(url);
    
57. }

代码片段1.4

此段表明当客户端已经在认证服务器确认登陆，认证服务器将客户端重新重定向回网关，并在重定向包中包含关键路径"/wifidog/auth"和token，认证服务器所执行的操作。

1. void 
   
2. http_callback_auth(httpd *webserver, request *r)
   
3. {
   
4.     t_client *client;
   
5.     httpVar * token;
   
6.     char *mac;
   
7.     /* 判断http报文是否包含登出logout */
   
8.     httpVar *logout = httpdGetVariableByName(r, "logout");
   
9.     if ((token = httpdGetVariableByName(r, "token"))) {
   
10.         /* 获取http报文中的token */
    
11.         if (!(mac = arp_get(r->clientAddr))) {
    
12.             /* 获取客户端mac地址失败 */
    
13.             debug(LOG_ERR, "Failed to retrieve MAC address for ip %s", r->clientAddr);
    
14.             send_http_page(r, "WiFiDog Error", "Failed to retrieve your MAC address");
    
15.         } else {
    
16.             LOCK_CLIENT_LIST();
    
17.             /* 判断客户端是否存在于列表中 */
    
18.             if ((client = client_list_find(r->clientAddr, mac)) == NULL) {
    
19.                 debug(LOG_DEBUG, "New client for %s", r->clientAddr);
    
20.                 /* 将此客户端添加到客户端列表 */
    
21.                 client_list_append(r->clientAddr, mac, token->value);
    
22.             } else if (logout) {
    
23.                 /* http报文为登出 */
    
24.                 t_authresponse authresponse;
    
25.                 s_config *config = config_get_config();
    
26.                 unsigned long long incoming = client->counters.incoming;
    
27.                 unsigned long long outgoing = client->counters.outgoing;
    
28.                 char *ip = safe_strdup(client->ip);
    
29.                 char *urlFragment = NULL;
    
30.                 t_auth_serv *auth_server = get_auth_server();
    
31.                 /* 修改iptables禁止客户端访问外网 */ 
    
32.                 fw_deny(client->ip, client->mac, client->fw_connection_state);
    
33.                 /* 从客户端列表中删除此客户端 */
    
34.                 client_list_delete(client);
    
35.                 debug(LOG_DEBUG, "Got logout from %s", client->ip);
    
36.                 
    
37.                 if (config->auth_servers != NULL) {
    
38.                     UNLOCK_CLIENT_LIST();
    
39.                     /* 发送登出认证包给认证服务器 */
    
40.                     auth_server_request(&authresponse, REQUEST_TYPE_LOGOUT, ip, mac, token->value, 
    
41.                                         incoming, outgoing);
    
42.                     LOCK_CLIENT_LIST();
    
43.                     
    
44.                     /* 将客户端重定向到认证服务器 */
    
45.                     debug(LOG_INFO, "Got manual logout from client ip %s, mac %s, token %s"
    
46.                     "- redirecting them to logout message", client->ip, client->mac, client->token);
    
47.                     safe_asprintf(&urlFragment, "%smessage=%s",
    
48.                         auth_server->authserv_msg_script_path_fragment,
    
49.                         GATEWAY_MESSAGE_ACCOUNT_LOGGED_OUT
    
50.                     );
    
51.                     http_send_redirect_to_auth(r, urlFragment, "Redirect to logout message");
    
52.                     free(urlFragment);
    
53.                 }
    
54.                 free(ip);
    
55.              } 
    
56.              else {
    
57.                 debug(LOG_DEBUG, "Client for %s is already in the client list", client->ip);
    
58.             }
    
59.             UNLOCK_CLIENT_LIST();
    
60.             if (!logout) {
    
61.                 /* 通过认证服务器认证此客户端token */
    
62.                 authenticate_client(r);
    
63.             }
    
64.             free(mac);
    
65.         }
    
66.     } else {
    
67.         send_http_page(r, "WiFiDog error", "Invalid token");
    
68.     }
    
69. }
    
70. 
    
71. /* 此函数用于提交token到认证服务器进行认证 */
    
72. void
    
73. authenticate_client(request *r)
    
74. {
    
75.     t_client *client;
    
76.     t_authresponse auth_response;
    
77.     char *mac,
    
78.         *token;
    
79.     char *urlFragment = NULL;
    
80.     s_config *config = NULL;
    
81.     t_auth_serv *auth_server = NULL;
    
82. 
    
83.     LOCK_CLIENT_LIST();
    
84. 
    
85.     client = client_list_find_by_ip(r->clientAddr);
    
86.     /* 判断此客户端是否在列表中 */
    
87.     if (client == NULL) {
    
88.         debug(LOG_ERR, "Could not find client for %s", r->clientAddr);
    
89.         UNLOCK_CLIENT_LIST();
    
90.         return;
    
91.     }
    
92.     
    
93.     mac = safe_strdup(client->mac);
    
94.     token = safe_strdup(client->token);
    
95.     
    
96.     UNLOCK_CLIENT_LIST();
    
97.     
    
98.     /* 提交token、客户端ip、客户端mac至认证服务器 */
    
99.     auth_server_request(&auth_response, REQUEST_TYPE_LOGIN, r->clientAddr, mac, token, 0, 0);
    
100.     
     
101.     LOCK_CLIENT_LIST();
     
102.     
     
103.     /*再次判断客户端是否存在于列表中，保险起见，因为有可能在于认证服务器认证过程中，客户端检测线程把此客户端下线 */
     
104.     client = client_list_find(r->clientAddr, mac);
     
105.     
     
106.     if (client == NULL) {
     
107.         debug(LOG_ERR, "Could not find client node for %s (%s)", r->clientAddr, mac);
     
108.         UNLOCK_CLIENT_LIST();
     
109.         free(token);
     
110.         free(mac);
     
111.         return;
     
112.     }
     
113.     
     
114.     free(token);
     
115.     free(mac);
     
116. 
     
117.     config = config_get_config();
     
118.     auth_server = get_auth_server();
     
119. 
     
120.         /* 判断认证服务器认证结果 */
     
121.     switch(auth_response.authcode) {
     
122. 
     
123.     case AUTH_ERROR:
     
124.         /* 认证错误 */
     
125.         debug(LOG_ERR, "Got %d from central server authenticating token %s from %s at %s", auth_response, client->token, client->ip, client->mac);
     
126.         send_http_page(r, "Error!", "Error: We did not get a valid answer from the central server");
     
127.         break;
     
128. 
     
129.     case AUTH_DENIED:
     
130.         /* 认证服务器拒绝此客户端 */
     
131.         debug(LOG_INFO, "Got DENIED from central server authenticating token %s from %s at %s - redirecting them to denied message", client->token, client->ip, client->mac);
     
132.         safe_asprintf(&urlFragment, "%smessage=%s",
     
133.             auth_server->authserv_msg_script_path_fragment,
     
134.             GATEWAY_MESSAGE_DENIED
     
135.         );
     
136.         http_send_redirect_to_auth(r, urlFragment, "Redirect to denied message");
     
137.         free(urlFragment);
     
138.         break;
     
139. 
     
140.     case AUTH_VALIDATION:
     
141.         /* 认证服务器处于等待此客户端电子邮件确认回执状态 */
     
142.         debug(LOG_INFO, "Got VALIDATION from central server authenticating token %s from %s at %s"
     
143.                 "- adding to firewall and redirecting them to activate message", client->token,
     
144.                 client->ip, client->mac);
     
145.         client->fw_connection_state = FW_MARK_PROBATION;
     
146.         fw_allow(client->ip, client->mac, FW_MARK_PROBATION);
     
147.         safe_asprintf(&urlFragment, "%smessage=%s",
     
148.             auth_server->authserv_msg_script_path_fragment,
     
149.             GATEWAY_MESSAGE_ACTIVATE_ACCOUNT
     
150.         );
     
151.         http_send_redirect_to_auth(r, urlFragment, "Redirect to activate message");
     
152.         free(urlFragment);
     
153.         break;
     
154. 
     
155.     case AUTH_ALLOWED:
     
156.         /* 认证通过 */
     
157.         debug(LOG_INFO, "Got ALLOWED from central server authenticating token %s from %s at %s - "
     
158.                 "adding to firewall and redirecting them to portal", client->token, client->ip, client->mac);
     
159.         client->fw_connection_state = FW_MARK_KNOWN;
     
160.         fw_allow(client->ip, client->mac, FW_MARK_KNOWN);
     
161.         served_this_session++;
     
162.         safe_asprintf(&urlFragment, "%sgw_id=%s",
     
163.             auth_server->authserv_portal_script_path_fragment,
     
164.             config->gw_id
     
165.         );
     
166.         http_send_redirect_to_auth(r, urlFragment, "Redirect to portal");
     
167.         free(urlFragment);
     
168.         break;
     
169. 
     
170.     case AUTH_VALIDATION_FAILED:
     
171.          /* 电子邮件确认回执超时 */
     
172.         debug(LOG_INFO, "Got VALIDATION_FAILED from central server authenticating token %s from %s at %s "
     
173.                 "- redirecting them to failed_validation message", client->token, client->ip, client->mac);
     
174.         safe_asprintf(&urlFragment, "%smessage=%s",
     
175.             auth_server->authserv_msg_script_path_fragment,
     
176.             GATEWAY_MESSAGE_ACCOUNT_VALIDATION_FAILED
     
177.         );
     
178.         http_send_redirect_to_auth(r, urlFragment, "Redirect to failed validation message");
     
179.         free(urlFragment);
     
180.         break;
     
181. 
     
182.     default:
     
183.         debug(LOG_WARNING, "I don't know what the validation code %d means for token %s from %s at %s - sending error message", auth_response.authcode, client->token, client->ip, client->mac);
     
184.         send_http_page(r, "Internal Error", "We can not validate your request at this time");
     
185.         break;
     
186. 
     
187.     }
     
188. 
     
189.     UNLOCK_CLIENT_LIST();
     
190.     return;
     
191. }

wifidog源码分析 - 客户端检测线程 

引言

　　当wifidog启动时，会启动一个线程(thread_client_timeout_check)维护客户端列表，具体就是wifidog必须定时检测客户端列表中的每个客户端是否在线，而wifidog是通过两种方式进行检测客户端在线情况，一种是定时通过iptables获取客户端出入总流量更新客户端时间，通过最近更新时间进行判断（有新的出入流量则更新客户端时间，之后使用最新客户端时间与当前时间判断），一种是查询认证服务器，通过认证服务器的返回信息进行判断（将客户端IP和状态请求发送给认证服务器，认证服务器会返回客户端是否在线，这种情况是用于客户端是在认证服务器上正常登出）。

 

thread_client_timeout_check

　　此线程执行函数用于维护客户端列表，此线程是一个while （1）循环，每隔一个配置文件中的checkinterval时间间隔执行一次fw_sync_with_authserver函数，核心代码处于fw_sync_with_authserver函数中，我们先具体代码
代码片段1.1

1. void
   
2. thread_client_timeout_check(const void *arg)
   
3. {
   
4.     pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
   
5.     pthread_mutex_t cond_mutex = PTHREAD_MUTEX_INITIALIZER;
   
6.     struct timespec timeout;
   
7.     
   
8.     while (1) {
   
9.         /* 设置超时时间 */
   
10.         timeout.tv_sec = time(NULL) + config_get_config()->checkinterval;
    
11.         timeout.tv_nsec = 0;
    
12. 
    
13.         /* 使用pthread_cond_timedwait必须先上锁 */
    
14.         pthread_mutex_lock(&cond_mutex);
    
15.         
    
16.         /* 等待超时 */
    
17.         pthread_cond_timedwait(&cond, &cond_mutex, &timeout);
    
18. 
    
19.         /* 解锁 */
    
20.         pthread_mutex_unlock(&cond_mutex);
    
21.     
    
22.         debug(LOG_DEBUG, "Running fw_counter()");
    
23.     
    
24.         /* 执行核心代码 */ 
    
25.         fw_sync_with_authserver();
    
26.     }
    
27. }

fw_sync_with_authserver

　　此函数是此线程的核心函数，维护客户端列表就在此中，其首先会遍历客户端列表，通过iptables获取每个客户端列表的出入流量，之后根据出口流量(入口流量不做判断，详见 代码片段1.3)更新客户端最近更新时间（last_updated），之后使用每个客户端最近更新时间与当前时间比较，如果超过超时间隔则判断为下线，而如果未超时，则还会从认证服务器中获取此客户端状态，确定其是否在线。具体流程如下

• 更新客户端出入口流量，根据出口流量更新每个客户端的最近更新时间
• 客户端超时则从客户端列表中移除并通过iptables禁止其访问网络，并告知认证服务器此客户端下线
• 客户端未超时则从认证服务器获取此客户端信息，判断其是否通过认证服务器下线

代码片段1.2

1. void
   
2. fw_sync_with_authserver(void)
   
3. {
   
4.     t_authresponse authresponse;
   
5.     char *token, *ip, *mac;
   
6.     t_client *p1, *p2;
   
7.     unsigned long long incoming, outgoing;
   
8.     s_config *config = config_get_config();
   
9. 
   
10.     /* 根据iptables流量更新最近更新时间，具体代码见 代码片段1.3 */
    
11.     if (-1 == iptables_fw_counters_update()) {
    
12.         debug(LOG_ERR, "Could not get counters from firewall!");
    
13.         return;
    
14.     }
    
15. 
    
16.     LOCK_CLIENT_LIST();
    
17. 
    
18.     /* 遍历客户端列表 */
    
19.     for (p1 = p2 = client_get_first_client(); NULL != p1; p1 = p2) {
    
20.         p2 = p1->next;
    
21. 
    
22.         ip = safe_strdup(p1->ip);
    
23.         token = safe_strdup(p1->token);
    
24.         mac = safe_strdup(p1->mac);
    
25.         outgoing = p1->counters.outgoing;
    
26.         incoming = p1->counters.incoming;
    
27. 
    
28.         UNLOCK_CLIENT_LIST();
    
29.         /* ping一下此客户端，不清楚作用 */
    
30.         icmp_ping(ip);
    
31.         /* 将客户端的出入流量上传至认证服务器，此时如果此客户端在认证服务器上下线会返回告知wifidog */
    
32.         if (config->auth_servers != NULL) {
    
33.             auth_server_request(&authresponse, REQUEST_TYPE_COUNTERS, ip, mac, token, incoming, outgoing);
    
34.         }
    
35.         LOCK_CLIENT_LIST();
    
36. 
    
37.         /* 从客户端列表获取IP,MAC对应客户端 */
    
38.         if (!(p1 = client_list_find(ip, mac))) {
    
39.             debug(LOG_ERR, "Node %s was freed while being re-validated!", ip);
    
40.         } else {
    
41.             time_t current_time=time(NULL);
    
42.             debug(LOG_INFO, "Checking client %s for timeout: Last updated %ld (%ld seconds ago), timeout delay %ld seconds, current time %ld, ",
    
43.                         p1->ip, p1->counters.last_updated, current_time-p1->counters.last_updated, config->checkinterval * config->clienttimeout, current_time);
    
44.             /* 判断是否超时，(最近更新时间 + 超时时间 <= 当前时间) 表明以超过超时时间，下线 */
    
45.             if (p1->counters.last_updated +
    
46.                 (config->checkinterval * config->clienttimeout)
    
47.                 <= current_time) {
    
48.                 debug(LOG_INFO, "%s - Inactive for more than %ld seconds, removing client and denying in firewall",
    
49.                         p1->ip, config->checkinterval * config->clienttimeout);
    
50.                 /* 修改iptables禁止此客户端访问外网 */
    
51.                 fw_deny(p1->ip, p1->mac, p1->fw_connection_state);
    
52.                 /* 从客户端列表中删除此客户端 */
    
53.                 client_list_delete(p1);
    
54. 
    
55.                 /* 通知认证服务器此客户端下线 */
    
56.                 if (config->auth_servers != NULL) {
    
57.                     UNLOCK_CLIENT_LIST();
    
58.                     auth_server_request(&authresponse, REQUEST_TYPE_LOGOUT, ip, mac, token, 0, 0);
    
59.                     LOCK_CLIENT_LIST();
    
60.                 }
    
61.             } else {
    
62.                 /* 未超时处理 */
    
63.                 if (config->auth_servers != NULL) {
    
64.                     /* 判断认证服务器返回信息 */
    
65.                     switch (authresponse.authcode) {
    
66.                         /* 认证服务器禁止其访问网络(下线或遭拒绝) */
    
67.                         case AUTH_DENIED:
    
68.                             debug(LOG_NOTICE, "%s - Denied. Removing client and firewall rules", p1->ip);
    
69.                             fw_deny(p1->ip, p1->mac, p1->fw_connection_state);
    
70.                             client_list_delete(p1);
    
71.                             break;
    
72. 
    
73.                         case AUTH_VALIDATION_FAILED:
    
74.                             debug(LOG_NOTICE, "%s - Validation timeout, now denied. Removing client and firewall rules", p1->ip);
    
75.                             fw_deny(p1->ip, p1->mac, p1->fw_connection_state);
    
76.                             client_list_delete(p1);
    
77.                             break;
    
78. 
    
79.                         /* 认证服务器允许其访问网络(在线) */
    
80.                         case AUTH_ALLOWED:
    
81.                             if (p1->fw_connection_state != FW_MARK_KNOWN) {
    
82.                                 debug(LOG_INFO, "%s - Access has changed to allowed, refreshing firewall and clearing counters", p1->ip);
    
83.                                 if (p1->fw_connection_state != FW_MARK_PROBATION) {
    
84.                                     p1->counters.incoming = p1->counters.outgoing = 0;
    
85.                                 }
    
86.                                 else {
    
87.                            
    
88.                                     debug(LOG_INFO, "%s - Skipped clearing counters after all, the user was previously in validation", p1->ip);
    
89.                                 }
    
90.                                 p1->fw_connection_state = FW_MARK_KNOWN;
    
91.                                 fw_allow(p1->ip, p1->mac, p1->fw_connection_state);
    
92.                             }
    
93.                             break;
    
94. 
    
95.                         case AUTH_VALIDATION:
    
96.                             debug(LOG_INFO, "%s - User in validation period", p1->ip);
    
97.                             break;
    
98. 
    
99.                             case AUTH_ERROR:
    
100.                                     debug(LOG_WARNING, "Error communicating with auth server - leaving %s as-is for now", p1->ip);
     
101.                                     break;
     
102. 
     
103.                         default:
     
104.                             debug(LOG_ERR, "I do not know about authentication code %d", authresponse.authcode);
     
105.                             break;
     
106.                     }
     
107.                 }
     
108.             }
     
109.         }
     
110. 
     
111.         free(token);
     
112.         free(ip);
     
113.         free(mac);
     
114.     }
     
115.     UNLOCK_CLIENT_LIST();
     
116. }

代码片段1.3

1. int
   
2. iptables_fw_counters_update(void)
   
3. {
   
4.     FILE *output;
   
5.     char *script,
   
6.          ip[16],
   
7.          rc;
   
8.     unsigned long long int counter;
   
9.     t_client *p1;
   
10.     struct in_addr tempaddr;
    
11. 
    
12.     /* 通过iptables获取其出口流量 */
    
13.     safe_asprintf(&script, "%s %s", "iptables", "-v -n -x -t mangle -L " TABLE_WIFIDOG_OUTGOING);
    
14.     iptables_insert_gateway_id(&script);
    
15.     output = popen(script, "r");
    
16.     free(script);
    
17.     if (!output) {
    
18.         debug(LOG_ERR, "popen(): %s", strerror(errno));
    
19.         return -1;
    
20.     }
    
21. 
    
22.     /* iptables返回信息处理 */
    
23.     while (('\n' != fgetc(output)) && !feof(output))
    
24.         ;
    
25.     while (('\n' != fgetc(output)) && !feof(output))
    
26.         ;
    
27.     while (output && !(feof(output))) {
    
28.         rc = fscanf(output, "%*s %llu %*s %*s %*s %*s %*s %15[0-9.] %*s %*s %*s %*s %*s %*s", &counter, ip);
    
29.         //rc = fscanf(output, "%*s %llu %*s %*s %*s %*s %*s %15[0-9.] %*s %*s %*s %*s %*s 0x%*u", &counter, ip);
    
30.         if (2 == rc && EOF != rc) {
    
31.             if (!inet_aton(ip, &tempaddr)) {
    
32.                 debug(LOG_WARNING, "I was supposed to read an IP address but instead got [%s] - ignoring it", ip);
    
33.                 continue;
    
34.             }
    
35.             debug(LOG_DEBUG, "Read outgoing traffic for %s: Bytes=%llu", ip, counter);
    
36.             LOCK_CLIENT_LIST();
    
37.             /* 通过ip获取客户端信息结构 */
    
38.             if ((p1 = client_list_find_by_ip(ip))) {
    
39.                 /* (上一次出口总流量(outgoing) + wifidog启动时的出口总流量(outgoing_history) < iptables返回的出口总流量) 表示此客户端有新的出口流量 */
    
40.                 if ((p1->counters.outgoing - p1->counters.outgoing_history) < counter) {
    
41.                     /* 更新上一次出口总流量(outgoing)为wifidog启动时的出口总流量(outgoing_history) + iptables返回总流量(counter) */
    
42.                     p1->counters.outgoing = p1->counters.outgoing_history + counter;
    
43.                     /* 更新最近更新时间为当前时间 */
    
44.                     p1->counters.last_updated = time(NULL);
    
45.                     debug(LOG_DEBUG, "%s - Updated counter.outgoing to %llu bytes. Updated last_updated to %d", ip, counter, p1->counters.last_updated);
    
46.                 }
    
47.             } else {
    
48.                 debug(LOG_ERR, "Could not find %s in client list", ip);
    
49.             }
    
50.             UNLOCK_CLIENT_LIST();
    
51.         }
    
52.     }
    
53.     pclose(output);
    
54. 
    
55.     /* 通过iptables获取其入口流量，入口流量不做更新最近更新时间参考，只用于更新后上传至认证服务器，其原理同上，后面的代码不做详细分析 */
    
56.     safe_asprintf(&script, "%s %s", "iptables", "-v -n -x -t mangle -L " TABLE_WIFIDOG_INCOMING);
    
57.     iptables_insert_gateway_id(&script);
    
58.     output = popen(script, "r");
    
59.     free(script);
    
60.     if (!output) {
    
61.         debug(LOG_ERR, "popen(): %s", strerror(errno));
    
62.         return -1;
    
63.     }
    
64. 
    
65.  
    
66.     while (('\n' != fgetc(output)) && !feof(output))
    
67.         ;
    
68.     while (('\n' != fgetc(output)) && !feof(output))
    
69.         ;
    
70.     while (output && !(feof(output))) {
    
71.         rc = fscanf(output, "%*s %llu %*s %*s %*s %*s %*s %*s %15[0-9.]", &counter, ip);
    
72.         if (2 == rc && EOF != rc) {
    
73.  
    
74.             if (!inet_aton(ip, &tempaddr)) {
    
75.                 debug(LOG_WARNING, "I was supposed to read an IP address but instead got [%s] - ignoring it", ip);
    
76.                 continue;
    
77.             }
    
78.             debug(LOG_DEBUG, "Read incoming traffic for %s: Bytes=%llu", ip, counter);
    
79.             LOCK_CLIENT_LIST();
    
80.             if ((p1 = client_list_find_by_ip(ip))) {
    
81.                 if ((p1->counters.incoming - p1->counters.incoming_history) < counter) {
    
82.                     p1->counters.incoming = p1->counters.incoming_history + counter;
    
83.                     debug(LOG_DEBUG, "%s - Updated counter.incoming to %llu bytes", ip, counter);
    
84.                 }
    
85.             } else {
    
86.                 debug(LOG_ERR, "Could not find %s in client list", ip);
    
87.             }
    
88.             UNLOCK_CLIENT_LIST();
    
89.         }
    
90.     }
    
91.     pclose(output);
    
92. 
    
93.     return 1;
    
94. }

wifidog源码分析 - 认证服务器心跳检测线程 

引言

　　但wifidog启动时，会自动启动认证服务器心跳检测线程，此线程默认每隔60s与认证服务器交互一次，会将路由器的信息（系统启动时长，内存使用情况和系统平均负载）告知认证服务器，并通过一个"ping"字符串作为信号，而当认证服务器接收到此数据包后，会返回一个"pong"给路由器，具体我们看看代码。

 

代码片段1.1

此段代码很简单，就是调用ping函数，然后等待60s

点击(此处)折叠或打开

1. void
   
2. thread_ping(void *arg)
   
3. {
   
4.     pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
   
5.     pthread_mutex_t cond_mutex = PTHREAD_MUTEX_INITIALIZER;
   
6.     struct timespec timeout;
   
7.     
   
8.     while (1) {
   
9.         /* 调用ping，具体代码看 代码片段1.2 */
   
10.         debug(LOG_DEBUG, "Running ping()");
    
11.         ping();
    
12.         
    
13.         /* 睡眠一个checkinterval，默认为60s */
    
14.         timeout.tv_sec = time(NULL) + config_get_config()->checkinterval;
    
15.         timeout.tv_nsec = 0;
    
16. 
    
17. 
    
18.         pthread_mutex_lock(&cond_mutex);
    
19.         
    
20.         pthread_cond_timedwait(&cond, &cond_mutex, &timeout);
    
21. 
    
22.         pthread_mutex_unlock(&cond_mutex);
    
23.     }

代码片段1.2

点击(此处)折叠或打开

1. static void
   
2. ping(void)
   
3. {
   
4.     ssize_t numbytes;
   
5.     size_t totalbytes;
   
6.     int sockfd, nfds, done;
   
7.     char request[MAX_BUF];
   
8.     fd_set readfds;
   
9.     struct timeval timeout;
   
10.     FILE * fh;
    
11.     unsigned long int sys_uptime = 0;
    
12.     unsigned int sys_memfree = 0;
    
13.     float sys_load = 0;
    
14.     t_auth_serv *auth_server = NULL;
    
15.     auth_server = get_auth_server();
    
16.     
    
17.     debug(LOG_DEBUG, "Entering ping()");
    
18.     
    
19.     /* 其实认证服务器就是一个web服务器，路由器跟他做通信行为就是通过发送http请求进行通信，首先先连接认证服务器的http端口，获取其socket */
    
20.     sockfd = connect_auth_server();
    
21.     if (sockfd == -1) {
    
22.         /* 无法连接认证服务器，connect_auth_server分析见 代码片段1.3 */
    
23.         return;
    
24.     }
    
25. 
    
26.     /*
    
27.      * 从/proc文件系统获取路由器信息
    
28.      */
    
29.     if ((fh = fopen("/proc/uptime", "r"))) {
    
30.         fscanf(fh, "%lu", &sys_uptime);
    
31.         fclose(fh);
    
32.     }
    
33.     if ((fh = fopen("/proc/meminfo", "r"))) {
    
34.         while (!feof(fh)) {
    
35.             if (fscanf(fh, "MemFree: %u", &sys_memfree) == 0) {
    
36.                 while (!feof(fh) && fgetc(fh) != '\n');
    
37.             }
    
38.             else {
    
39.                 break;
    
40.             }
    
41.         }
    
42.         fclose(fh);
    
43.     }
    
44.     if ((fh = fopen("/proc/loadavg", "r"))) {
    
45.         fscanf(fh, "%f", &sys_load);
    
46.         fclose(fh);
    
47.     }
    
48. 
    
49.     /*
    
50.      * 准备http请求包
    
51.      */
    
52.     snprintf(request, sizeof(request) - 1,
    
53.             "GET %s%sgw_id=%s&sys_uptime=%lu&sys_memfree=%u&sys_load=%.2f&wifidog_uptime=%lu HTTP/1.0\r\n"
    
54.             "User-Agent: WiFiDog %s\r\n"
    
55.             "Host: %s\r\n"
    
56.             "\r\n",
    
57.             auth_server->authserv_path,
    
58.             auth_server->authserv_ping_script_path_fragment,
    
59.             config_get_config()->gw_id,
    
60.             sys_uptime,
    
61.             sys_memfree,
    
62.             sys_load,
    
63.             (long unsigned int)((long unsigned int)time(NULL) - (long unsigned int)started_time),
    
64.             VERSION,
    
65.             auth_server->authserv_hostname);
    
66. 
    
67.     debug(LOG_DEBUG, "HTTP Request to Server: [%s]", request);
    
68.     /* 发送 */
    
69.     send(sockfd, request, strlen(request), 0);
    
70. 
    
71.     debug(LOG_DEBUG, "Reading response");
    
72.     
    
73.     numbytes = totalbytes = 0;
    
74.     done = 0;
    
75.     do {
    
76.         FD_ZERO(&readfds);
    
77.         FD_SET(sockfd, &readfds);
    
78.         /* 设置超时30s */
    
79.         timeout.tv_sec = 30;
    
80.         timeout.tv_usec = 0;
    
81.         nfds = sockfd + 1;
    
82. 
    
83.         nfds = select(nfds, &readfds, NULL, NULL, &timeout);
    
84. 
    
85.         if (nfds > 0) {
    
86.             /* 多路复用 */
    
87.             numbytes = read(sockfd, request + totalbytes, MAX_BUF - (totalbytes + 1));
    
88.             if (numbytes < 0) {
    
89.                 debug(LOG_ERR, "An error occurred while reading from auth server: %s", strerror(errno));
    
90.                 close(sockfd);
    
91.                 return;
    
92.             }
    
93.             else if (numbytes == 0) {
    
94.                 done = 1;
    
95.             }
    
96.             else {
    
97.                 totalbytes += numbytes;
    
98.                 debug(LOG_DEBUG, "Read %d bytes, total now %d", numbytes, totalbytes);
    
99.             }
    
100.         }
     
101.         else if (nfds == 0) {
     
102.             debug(LOG_ERR, "Timed out reading data via select() from auth server");
     
103.             close(sockfd);
     
104.             return;
     
105.         }
     
106.         else if (nfds < 0) {
     
107.             debug(LOG_ERR, "Error reading data via select() from auth server: %s", strerror(errno));
     
108.             close(sockfd);
     
109.             return;
     
110.         }
     
111.     } while (!done);
     
112.     close(sockfd);
     
113. 
     
114.     debug(LOG_DEBUG, "Done reading reply, total %d bytes", totalbytes);
     
115. 
     
116.     request[totalbytes] = '\0';
     
117. 
     
118.     debug(LOG_DEBUG, "HTTP Response from Server: [%s]", request);
     
119.     /* 判断认证服务器返回包中有没有"Pong"字符串 */
     
120.     if (strstr(request, "Pong") == 0) {
     
121.         debug(LOG_WARNING, "Auth server did NOT say pong!");
     
122.        
     
123.     }
     
124.     else {
     
125.         debug(LOG_DEBUG, "Auth Server Says: Pong");
     
126.     }
     
127. 
     
128.     return; 
     
129. }

代码片段1.3

connect_auth_server函数用于连接认证服务器并返回socket套接字，其具体实现是通过_connect_auth_server实现的，而在_connect_auth_server中，递归认证服务器列表，每次递归中首先会根据认证服务器域名获取ip，如果失败，会通过公共网站判断是否为DNS问题，再判断是否为认证服务器问题，如果都失败，继续递归，否则返回认证服务器socket。

1. int connect_auth_server() {
   
2.     int sockfd;
   
3. 
   
4.     LOCK_CONFIG();
   
5.     /* 连接认证服务器 */
   
6.     sockfd = _connect_auth_server(0);
   
7.     UNLOCK_CONFIG();
   
8. 
   
9.     if (sockfd == -1) {
   
10.         debug(LOG_ERR, "Failed to connect to any of the auth servers");
    
11.         /* 标记认证服务器离线 */
    
12.         mark_auth_offline();
    
13.     }
    
14.     else {
    
15.         debug(LOG_DEBUG, "Connected to auth server");
    
16.         /* 标记认证服务器在线 */
    
17.         mark_auth_online();
    
18.     }
    
19.     return (sockfd);
    
20. }
    
21. 
    
22. 
    
23. 
    
24. int _connect_auth_server(int level) {
    
25.     s_config *config = config_get_config();
    
26.     t_auth_serv *auth_server = NULL;
    
27.     struct in_addr *h_addr;
    
28.     int num_servers = 0;
    
29.     char * hostname = NULL;
    
30.     /* 公共网站，用于判断DNS问题 */
    
31.     char * popular_servers[] = {
    
32.           "www.google.com",
    
33.           "www.yahoo.com",
    
34.           NULL
    
35.     };
    
36.     char ** popularserver;
    
37.     char * ip;
    
38.     struct sockaddr_in their_addr;
    
39.     int sockfd;
    
40. 
    
41.     /* 用于递归，因为可能会有多个认证服务器，如果第一个认证服务器无法连接，会递归尝试连接后面的认证服务器，此参数用于递归判断的，当成功连接任意一个认证服务器后停止 */
    
42.     level++;
    
43. 
    
44.     /*
    
45.      * 获取认证服务器数量
    
46.      */
    
47.     for (auth_server = config->auth_servers; auth_server; auth_server = auth_server->next) {
    
48.         num_servers++;
    
49.     }
    
50.     debug(LOG_DEBUG, "Level %d: Calculated %d auth servers in list", level, num_servers);
    
51.         /* 已经尝试递归连接所有认证服务器，都不能连接 */
    
52.     if (level > num_servers) {
    
53.         return (-1);
    
54.     }
    
55. 
    
56.     /*
    
57.      * 获取认证服务器列表中的第一个认证服务器
    
58.      */
    
59.     auth_server = config->auth_servers;
    
60.     hostname = auth_server->authserv_hostname;
    
61.     debug(LOG_DEBUG, "Level %d: Resolving auth server [%s]", level, hostname);
    
62.     h_addr = wd_gethostbyname(hostname);
    
63.     if (!h_addr) {
    
64.         /*
    
65.          * DNS解析错误，尝试解析公共网站判断是否为DNS错误
    
66.          */
    
67.         debug(LOG_DEBUG, "Level %d: Resolving auth server [%s] failed", level, hostname);
    
68. 
    
69.         for (popularserver = popular_servers; *popularserver; popularserver++) {
    
70.             debug(LOG_DEBUG, "Level %d: Resolving popular server [%s]", level, *popularserver);
    
71.             h_addr = wd_gethostbyname(*popularserver);
    
72.             /* 公共网站DNS解析正确 */
    
73.             if (h_addr) {
    
74.                 debug(LOG_DEBUG, "Level %d: Resolving popular server [%s] succeeded = [%s]", level, *popularserver, inet_ntoa(*h_addr));
    
75.                 break;
    
76.             }
    
77.             else {
    
78.                 debug(LOG_DEBUG, "Level %d: Resolving popular server [%s] failed", level, *popularserver);
    
79.             }
    
80.         }
    
81. 
    
82.         if (h_addr) {
    
83.             /* DNS正确，尝试递归下一个认证服务器 */
    
84.             free (h_addr);
    
85. 
    
86.             debug(LOG_DEBUG, "Level %d: Marking auth server [%s] as bad and trying next if possible", level, hostname);
    
87.             if (auth_server->last_ip) {
    
88.                 free(auth_server->last_ip);
    
89.                 auth_server->last_ip = NULL;
    
90.             }
    
91.             /* 将此认证服务器放入bad_server链表，并将config->auth_server指向认证服务器的下一个节点 */
    
92.             mark_auth_server_bad(auth_server);
    
93.             /* 递归 */
    
94.             return _connect_auth_server(level);
    
95.         }
    
96.         else {
    
97.             /* DNS问题，标记路由器离线 */
    
98.             mark_offline();
    
99.             debug(LOG_DEBUG, "Level %d: Failed to resolve auth server and all popular servers. "
    
100.                     "The internet connection is probably down", level);
     
101.             return(-1);
     
102.         }
     
103.     }
     
104.     else {
     
105.         /* DNS解析成功 */
     
106.         ip = safe_strdup(inet_ntoa(*h_addr));
     
107.         debug(LOG_DEBUG, "Level %d: Resolving auth server [%s] succeeded = [%s]", level, hostname, ip);
     
108. 
     
109.         if (!auth_server->last_ip || strcmp(auth_server->last_ip, ip) != 0) {
     
110.             /* DNS解析到的IP与我们上一次连接的IP不同，更新上一次连接的IP */
     
111.             debug(LOG_DEBUG, "Level %d: Updating last_ip IP of server [%s] to [%s]", level, hostname, ip);
     
112.             if (auth_server->last_ip) free(auth_server->last_ip);
     
113.             auth_server->last_ip = ip;
     
114. 
     
115.             /* 将此新的认证服务器IP添加到iptables中的可访问外网地址中 */
     
116.             fw_clear_authservers();
     
117.             fw_set_authservers();
     
118.         }
     
119.         else {
     
120.             /*
     
121.              * DNS解析到的IP与我们上一次连接的IP相同
     
122.              */
     
123.             free(ip);
     
124.         }
     
125. 
     
126.         /*
     
127.          * 连接
     
128.          */
     
129.         debug(LOG_DEBUG, "Level %d: Connecting to auth server %s:%d", level, hostname, auth_server->authserv_http_port);
     
130.         their_addr.sin_family = AF_INET;
     
131.         their_addr.sin_port = htons(auth_server->authserv_http_port);
     
132.         their_addr.sin_addr = *h_addr;
     
133.         memset(&(their_addr.sin_zero), '\0', sizeof(their_addr.sin_zero));
     
134.         free (h_addr);
     
135. 
     
136.         if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
     
137.             debug(LOG_ERR, "Level %d: Failed to create a new SOCK_STREAM socket: %s", strerror(errno));
     
138.             return(-1);
     
139.         }
     
140. 
     
141.         if (connect(sockfd, (struct sockaddr *)&their_addr, sizeof(struct sockaddr)) == -1) {
     
142.             /*
     
143.              * 连接失败
     
144.              * 将此认证服务器放入bad_server链表，并将config->auth_server指向认证服务器的下一个节点
     
145.              */
     
146.             debug(LOG_DEBUG, "Level %d: Failed to connect to auth server %s:%d (%s). Marking it as bad and trying next if possible", level, hostname, auth_server->authserv_http_port, strerror(errno));
     
147.             close(sockfd);
     
148.             mark_auth_server_bad(auth_server);
     
149.             return _connect_auth_server(level); /* Yay */
     
150.         }
     
151.         else {
     
152.             /*
     
153.              * 连接成功
     
154.              */
     
155.             debug(LOG_DEBUG, "Level %d: Successfully connected to auth server %s:%d", level, hostname, auth_server->authserv_http_port);
     
156.             return sockfd;
     
157.         }
     
158.     }
     
159. }