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 }