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] = '';
    
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=%lun", 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

（编辑：常州站长网）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!