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 }
130

 

代码片段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 recursion! */
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 }