1 /*
2 * WPA Supplicant / UDP socket -based control interface
3 * Copyright (c) 2004-2005, Jouni Malinen <j@w1.fi>
4 *
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
7 */
8
9 #include "includes.h"
10
11 #include "common.h"
12 #include "eloop.h"
13 #include "config.h"
14 #include "eapol_supp/eapol_supp_sm.h"
15 #include "wpa_supplicant_i.h"
16 #include "ctrl_iface.h"
17 #include "common/wpa_ctrl.h"
18
19
20 #define COOKIE_LEN 8
21
22 /* Per-interface ctrl_iface */
23
24 /**
25 * struct wpa_ctrl_dst - Internal data structure of control interface monitors
26 *
27 * This structure is used to store information about registered control
28 * interface monitors into struct wpa_supplicant. This data is private to
29 * ctrl_iface_udp.c and should not be touched directly from other files.
30 */
31 struct wpa_ctrl_dst {
32 struct wpa_ctrl_dst *next;
33 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6
34 struct sockaddr_in6 addr;
35 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */
36 struct sockaddr_in addr;
37 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */
38 socklen_t addrlen;
39 int debug_level;
40 int errors;
41 };
42
43
44 struct ctrl_iface_priv {
45 struct wpa_supplicant *wpa_s;
46 int sock;
47 struct wpa_ctrl_dst *ctrl_dst;
48 u8 cookie[COOKIE_LEN];
49 };
50
51
52 static void wpa_supplicant_ctrl_iface_send(struct ctrl_iface_priv *priv,
53 int level, const char *buf,
54 size_t len);
55
56
wpa_supplicant_ctrl_iface_attach(struct ctrl_iface_priv * priv,struct sockaddr_in6 * from,socklen_t fromlen)57 static int wpa_supplicant_ctrl_iface_attach(struct ctrl_iface_priv *priv,
58 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6
59 struct sockaddr_in6 *from,
60 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */
61 struct sockaddr_in *from,
62 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */
63 socklen_t fromlen)
64 {
65 struct wpa_ctrl_dst *dst;
66 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6
67 char addr[INET6_ADDRSTRLEN];
68 #endif /* CONFIG_UDP_IPV6 */
69
70 dst = os_zalloc(sizeof(*dst));
71 if (dst == NULL)
72 return -1;
73 os_memcpy(&dst->addr, from, sizeof(*from));
74 dst->addrlen = fromlen;
75 dst->debug_level = MSG_INFO;
76 dst->next = priv->ctrl_dst;
77 priv->ctrl_dst = dst;
78 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6
79 wpa_printf(MSG_DEBUG, "CTRL_IFACE monitor attached %s:%d",
80 inet_ntop(AF_INET6, &from->sin6_addr, addr, sizeof(*from)),
81 ntohs(from->sin6_port));
82 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */
83 wpa_printf(MSG_DEBUG, "CTRL_IFACE monitor attached %s:%d",
84 inet_ntoa(from->sin_addr), ntohs(from->sin_port));
85 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */
86 return 0;
87 }
88
89
wpa_supplicant_ctrl_iface_detach(struct ctrl_iface_priv * priv,struct sockaddr_in6 * from,socklen_t fromlen)90 static int wpa_supplicant_ctrl_iface_detach(struct ctrl_iface_priv *priv,
91 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6
92 struct sockaddr_in6 *from,
93 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */
94 struct sockaddr_in *from,
95 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */
96 socklen_t fromlen)
97 {
98 struct wpa_ctrl_dst *dst, *prev = NULL;
99 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6
100 char addr[INET6_ADDRSTRLEN];
101 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */
102
103 dst = priv->ctrl_dst;
104 while (dst) {
105 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6
106 if (from->sin6_port == dst->addr.sin6_port &&
107 !os_memcmp(&from->sin6_addr, &dst->addr.sin6_addr,
108 sizeof(from->sin6_addr))) {
109 wpa_printf(MSG_DEBUG, "CTRL_IFACE monitor detached %s:%d",
110 inet_ntop(AF_INET6, &from->sin6_addr, addr,
111 sizeof(*from)),
112 ntohs(from->sin6_port));
113 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */
114 if (from->sin_addr.s_addr == dst->addr.sin_addr.s_addr &&
115 from->sin_port == dst->addr.sin_port) {
116 wpa_printf(MSG_DEBUG, "CTRL_IFACE monitor detached "
117 "%s:%d", inet_ntoa(from->sin_addr),
118 ntohs(from->sin_port));
119 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */
120 if (prev == NULL)
121 priv->ctrl_dst = dst->next;
122 else
123 prev->next = dst->next;
124 os_free(dst);
125 return 0;
126 }
127 prev = dst;
128 dst = dst->next;
129 }
130 return -1;
131 }
132
133
134 static int wpa_supplicant_ctrl_iface_level(struct ctrl_iface_priv *priv,
135 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6
136 struct sockaddr_in6 *from,
137 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */
138 struct sockaddr_in *from,
139 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */
140 socklen_t fromlen,
141 char *level)
142 {
143 struct wpa_ctrl_dst *dst;
144 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6
145 char addr[INET6_ADDRSTRLEN];
146 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */
147
148 wpa_printf(MSG_DEBUG, "CTRL_IFACE LEVEL %s", level);
149
150 dst = priv->ctrl_dst;
151 while (dst) {
152 #if CONFIG_CTRL_IFACE_UDP_IPV6
153 if (from->sin6_port == dst->addr.sin6_port &&
154 !os_memcmp(&from->sin6_addr, &dst->addr.sin6_addr,
155 sizeof(from->sin6_addr))) {
156 wpa_printf(MSG_DEBUG, "CTRL_IFACE changed monitor level %s:%d",
157 inet_ntop(AF_INET6, &from->sin6_addr, addr,
158 sizeof(*from)),
159 ntohs(from->sin6_port));
160 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */
161 if (from->sin_addr.s_addr == dst->addr.sin_addr.s_addr &&
162 from->sin_port == dst->addr.sin_port) {
163 wpa_printf(MSG_DEBUG, "CTRL_IFACE changed monitor "
164 "level %s:%d", inet_ntoa(from->sin_addr),
165 ntohs(from->sin_port));
166 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */
167 dst->debug_level = atoi(level);
168 return 0;
169 }
170 dst = dst->next;
171 }
172
173 return -1;
174 }
175
176
177 static char *
178 wpa_supplicant_ctrl_iface_get_cookie(struct ctrl_iface_priv *priv,
179 size_t *reply_len)
180 {
181 char *reply;
182 reply = os_malloc(7 + 2 * COOKIE_LEN + 1);
183 if (reply == NULL) {
184 *reply_len = 1;
185 return NULL;
186 }
187
188 os_memcpy(reply, "COOKIE=", 7);
189 wpa_snprintf_hex(reply + 7, 2 * COOKIE_LEN + 1,
190 priv->cookie, COOKIE_LEN);
191
192 *reply_len = 7 + 2 * COOKIE_LEN;
193 return reply;
194 }
195
196
197 static void wpa_supplicant_ctrl_iface_receive(int sock, void *eloop_ctx,
198 void *sock_ctx)
199 {
200 struct wpa_supplicant *wpa_s = eloop_ctx;
201 struct ctrl_iface_priv *priv = sock_ctx;
202 char buf[256], *pos;
203 int res;
204 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6
205 struct sockaddr_in6 from;
206 #ifndef CONFIG_CTRL_IFACE_UDP_REMOTE
207 char addr[INET6_ADDRSTRLEN];
208 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
209 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */
210 struct sockaddr_in from;
211 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */
212 socklen_t fromlen = sizeof(from);
213 char *reply = NULL;
214 size_t reply_len = 0;
215 int new_attached = 0;
216 u8 cookie[COOKIE_LEN];
217
218 res = recvfrom(sock, buf, sizeof(buf) - 1, 0,
219 (struct sockaddr *) &from, &fromlen);
220 if (res < 0) {
221 perror("recvfrom(ctrl_iface)");
222 return;
223 }
224
225 #ifndef CONFIG_CTRL_IFACE_UDP_REMOTE
226 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6
227 inet_ntop(AF_INET6, &from.sin6_addr, addr, sizeof(from));
228 if (os_strcmp(addr, "::1")) {
229 wpa_printf(MSG_DEBUG, "CTRL: Drop packet from unexpected source %s",
230 addr);
231 }
232 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */
233 if (from.sin_addr.s_addr != htonl((127 << 24) | 1)) {
234 /*
235 * The OS networking stack is expected to drop this kind of
236 * frames since the socket is bound to only localhost address.
237 * Just in case, drop the frame if it is coming from any other
238 * address.
239 */
240 wpa_printf(MSG_DEBUG, "CTRL: Drop packet from unexpected "
241 "source %s", inet_ntoa(from.sin_addr));
242 return;
243 }
244 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */
245 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
246
247 buf[res] = '\0';
248
249 if (os_strcmp(buf, "GET_COOKIE") == 0) {
250 reply = wpa_supplicant_ctrl_iface_get_cookie(priv, &reply_len);
251 goto done;
252 }
253
254 /*
255 * Require that the client includes a prefix with the 'cookie' value
256 * fetched with GET_COOKIE command. This is used to verify that the
257 * client has access to a bidirectional link over UDP in order to
258 * avoid attacks using forged localhost IP address even if the OS does
259 * not block such frames from remote destinations.
260 */
261 if (os_strncmp(buf, "COOKIE=", 7) != 0) {
262 wpa_printf(MSG_DEBUG, "CTLR: No cookie in the request - "
263 "drop request");
264 return;
265 }
266
267 if (hexstr2bin(buf + 7, cookie, COOKIE_LEN) < 0) {
268 wpa_printf(MSG_DEBUG, "CTLR: Invalid cookie format in the "
269 "request - drop request");
270 return;
271 }
272
273 if (os_memcmp(cookie, priv->cookie, COOKIE_LEN) != 0) {
274 wpa_printf(MSG_DEBUG, "CTLR: Invalid cookie in the request - "
275 "drop request");
276 return;
277 }
278
279 pos = buf + 7 + 2 * COOKIE_LEN;
280 while (*pos == ' ')
281 pos++;
282
283 if (os_strcmp(pos, "ATTACH") == 0) {
284 if (wpa_supplicant_ctrl_iface_attach(priv, &from, fromlen))
285 reply_len = 1;
286 else {
287 new_attached = 1;
288 reply_len = 2;
289 }
290 } else if (os_strcmp(pos, "DETACH") == 0) {
291 if (wpa_supplicant_ctrl_iface_detach(priv, &from, fromlen))
292 reply_len = 1;
293 else
294 reply_len = 2;
295 } else if (os_strncmp(pos, "LEVEL ", 6) == 0) {
296 if (wpa_supplicant_ctrl_iface_level(priv, &from, fromlen,
297 pos + 6))
298 reply_len = 1;
299 else
300 reply_len = 2;
301 } else {
302 reply = wpa_supplicant_ctrl_iface_process(wpa_s, pos,
303 &reply_len);
304 }
305
306 done:
307 if (reply) {
308 sendto(sock, reply, reply_len, 0, (struct sockaddr *) &from,
309 fromlen);
310 os_free(reply);
311 } else if (reply_len == 1) {
312 sendto(sock, "FAIL\n", 5, 0, (struct sockaddr *) &from,
313 fromlen);
314 } else if (reply_len == 2) {
315 sendto(sock, "OK\n", 3, 0, (struct sockaddr *) &from,
316 fromlen);
317 }
318
319 if (new_attached)
320 eapol_sm_notify_ctrl_attached(wpa_s->eapol);
321 }
322
323
324 static void wpa_supplicant_ctrl_iface_msg_cb(void *ctx, int level, int global,
325 const char *txt, size_t len)
326 {
327 struct wpa_supplicant *wpa_s = ctx;
328 if (wpa_s == NULL || wpa_s->ctrl_iface == NULL)
329 return;
330 wpa_supplicant_ctrl_iface_send(wpa_s->ctrl_iface, level, txt, len);
331 }
332
333
334 struct ctrl_iface_priv *
335 wpa_supplicant_ctrl_iface_init(struct wpa_supplicant *wpa_s)
336 {
337 struct ctrl_iface_priv *priv;
338 int port = WPA_CTRL_IFACE_PORT;
339 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6
340 struct sockaddr_in6 addr;
341 int domain = PF_INET6;
342 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */
343 struct sockaddr_in addr;
344 int domain = PF_INET;
345 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */
346
347 priv = os_zalloc(sizeof(*priv));
348 if (priv == NULL)
349 return NULL;
350 priv->wpa_s = wpa_s;
351 priv->sock = -1;
352 os_get_random(priv->cookie, COOKIE_LEN);
353
354 if (wpa_s->conf->ctrl_interface == NULL)
355 return priv;
356
357 priv->sock = socket(domain, SOCK_DGRAM, 0);
358 if (priv->sock < 0) {
359 perror("socket(PF_INET)");
360 goto fail;
361 }
362
363 os_memset(&addr, 0, sizeof(addr));
364 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6
365 addr.sin6_family = AF_INET6;
366 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE
367 addr.sin6_addr = in6addr_any;
368 #else /* CONFIG_CTRL_IFACE_UDP_REMOTE */
369 inet_pton(AF_INET6, "::1", &addr.sin6_addr);
370 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
371 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */
372 addr.sin_family = AF_INET;
373 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE
374 addr.sin_addr.s_addr = INADDR_ANY;
375 #else /* CONFIG_CTRL_IFACE_UDP_REMOTE */
376 addr.sin_addr.s_addr = htonl((127 << 24) | 1);
377 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
378 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */
379 try_again:
380 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6
381 addr.sin6_port = htons(port);
382 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */
383 addr.sin_port = htons(port);
384 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */
385 if (bind(priv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
386 port--;
387 if ((WPA_CTRL_IFACE_PORT - port) < WPA_CTRL_IFACE_PORT_LIMIT)
388 goto try_again;
389 perror("bind(AF_INET)");
390 goto fail;
391 }
392
393 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE
394 wpa_msg(wpa_s, MSG_DEBUG, "ctrl_iface_init UDP port: %d", port);
395 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
396
397 eloop_register_read_sock(priv->sock, wpa_supplicant_ctrl_iface_receive,
398 wpa_s, priv);
399 wpa_msg_register_cb(wpa_supplicant_ctrl_iface_msg_cb);
400
401 return priv;
402
403 fail:
404 if (priv->sock >= 0)
405 close(priv->sock);
406 os_free(priv);
407 return NULL;
408 }
409
410
411 void wpa_supplicant_ctrl_iface_deinit(struct ctrl_iface_priv *priv)
412 {
413 struct wpa_ctrl_dst *dst, *prev;
414
415 if (priv->sock > -1) {
416 eloop_unregister_read_sock(priv->sock);
417 if (priv->ctrl_dst) {
418 /*
419 * Wait before closing the control socket if
420 * there are any attached monitors in order to allow
421 * them to receive any pending messages.
422 */
423 wpa_printf(MSG_DEBUG, "CTRL_IFACE wait for attached "
424 "monitors to receive messages");
425 os_sleep(0, 100000);
426 }
427 close(priv->sock);
428 priv->sock = -1;
429 }
430
431 dst = priv->ctrl_dst;
432 while (dst) {
433 prev = dst;
434 dst = dst->next;
435 os_free(prev);
436 }
437 os_free(priv);
438 }
439
440
441 static void wpa_supplicant_ctrl_iface_send(struct ctrl_iface_priv *priv,
442 int level, const char *buf,
443 size_t len)
444 {
445 struct wpa_ctrl_dst *dst, *next;
446 char levelstr[10];
447 int idx;
448 char *sbuf;
449 int llen;
450 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6
451 char addr[INET6_ADDRSTRLEN];
452 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */
453
454 dst = priv->ctrl_dst;
455 if (priv->sock < 0 || dst == NULL)
456 return;
457
458 os_snprintf(levelstr, sizeof(levelstr), "<%d>", level);
459
460 llen = os_strlen(levelstr);
461 sbuf = os_malloc(llen + len);
462 if (sbuf == NULL)
463 return;
464
465 os_memcpy(sbuf, levelstr, llen);
466 os_memcpy(sbuf + llen, buf, len);
467
468 idx = 0;
469 while (dst) {
470 next = dst->next;
471 if (level >= dst->debug_level) {
472 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6
473 wpa_printf(MSG_DEBUG, "CTRL_IFACE monitor send %s:%d",
474 inet_ntop(AF_INET6, &dst->addr.sin6_addr,
475 addr, sizeof(dst->addr)),
476 ntohs(dst->addr.sin6_port));
477 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */
478 wpa_printf(MSG_DEBUG, "CTRL_IFACE monitor send %s:%d",
479 inet_ntoa(dst->addr.sin_addr),
480 ntohs(dst->addr.sin_port));
481 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */
482 if (sendto(priv->sock, sbuf, llen + len, 0,
483 (struct sockaddr *) &dst->addr,
484 sizeof(dst->addr)) < 0) {
485 perror("sendto(CTRL_IFACE monitor)");
486 dst->errors++;
487 if (dst->errors > 10) {
488 wpa_supplicant_ctrl_iface_detach(
489 priv, &dst->addr,
490 dst->addrlen);
491 }
492 } else
493 dst->errors = 0;
494 }
495 idx++;
496 dst = next;
497 }
498 os_free(sbuf);
499 }
500
501
502 void wpa_supplicant_ctrl_iface_wait(struct ctrl_iface_priv *priv)
503 {
504 wpa_printf(MSG_DEBUG, "CTRL_IFACE - %s - wait for monitor",
505 priv->wpa_s->ifname);
506 eloop_wait_for_read_sock(priv->sock);
507 }
508
509
510 /* Global ctrl_iface */
511
512 struct ctrl_iface_global_priv {
513 int sock;
514 u8 cookie[COOKIE_LEN];
515 };
516
517
518 static char *
519 wpa_supplicant_global_get_cookie(struct ctrl_iface_global_priv *priv,
520 size_t *reply_len)
521 {
522 char *reply;
523 reply = os_malloc(7 + 2 * COOKIE_LEN + 1);
524 if (reply == NULL) {
525 *reply_len = 1;
526 return NULL;
527 }
528
529 os_memcpy(reply, "COOKIE=", 7);
530 wpa_snprintf_hex(reply + 7, 2 * COOKIE_LEN + 1,
531 priv->cookie, COOKIE_LEN);
532
533 *reply_len = 7 + 2 * COOKIE_LEN;
534 return reply;
535 }
536
537
538 static void wpa_supplicant_global_ctrl_iface_receive(int sock, void *eloop_ctx,
539 void *sock_ctx)
540 {
541 struct wpa_global *global = eloop_ctx;
542 struct ctrl_iface_global_priv *priv = sock_ctx;
543 char buf[256], *pos;
544 int res;
545 struct sockaddr_in from;
546 socklen_t fromlen = sizeof(from);
547 char *reply;
548 size_t reply_len;
549 u8 cookie[COOKIE_LEN];
550
551 res = recvfrom(sock, buf, sizeof(buf) - 1, 0,
552 (struct sockaddr *) &from, &fromlen);
553 if (res < 0) {
554 perror("recvfrom(ctrl_iface)");
555 return;
556 }
557
558 #ifndef CONFIG_CTRL_IFACE_UDP_REMOTE
559 if (from.sin_addr.s_addr != htonl((127 << 24) | 1)) {
560 /*
561 * The OS networking stack is expected to drop this kind of
562 * frames since the socket is bound to only localhost address.
563 * Just in case, drop the frame if it is coming from any other
564 * address.
565 */
566 wpa_printf(MSG_DEBUG, "CTRL: Drop packet from unexpected "
567 "source %s", inet_ntoa(from.sin_addr));
568 return;
569 }
570 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
571
572 buf[res] = '\0';
573
574 if (os_strcmp(buf, "GET_COOKIE") == 0) {
575 reply = wpa_supplicant_global_get_cookie(priv, &reply_len);
576 goto done;
577 }
578
579 if (os_strncmp(buf, "COOKIE=", 7) != 0) {
580 wpa_printf(MSG_DEBUG, "CTLR: No cookie in the request - "
581 "drop request");
582 return;
583 }
584
585 if (hexstr2bin(buf + 7, cookie, COOKIE_LEN) < 0) {
586 wpa_printf(MSG_DEBUG, "CTLR: Invalid cookie format in the "
587 "request - drop request");
588 return;
589 }
590
591 if (os_memcmp(cookie, priv->cookie, COOKIE_LEN) != 0) {
592 wpa_printf(MSG_DEBUG, "CTLR: Invalid cookie in the request - "
593 "drop request");
594 return;
595 }
596
597 pos = buf + 7 + 2 * COOKIE_LEN;
598 while (*pos == ' ')
599 pos++;
600
601 reply = wpa_supplicant_global_ctrl_iface_process(global, pos,
602 &reply_len);
603
604 done:
605 if (reply) {
606 sendto(sock, reply, reply_len, 0, (struct sockaddr *) &from,
607 fromlen);
608 os_free(reply);
609 } else if (reply_len) {
610 sendto(sock, "FAIL\n", 5, 0, (struct sockaddr *) &from,
611 fromlen);
612 }
613 }
614
615
616 struct ctrl_iface_global_priv *
617 wpa_supplicant_global_ctrl_iface_init(struct wpa_global *global)
618 {
619 struct ctrl_iface_global_priv *priv;
620 struct sockaddr_in addr;
621 int port = WPA_GLOBAL_CTRL_IFACE_PORT;
622
623 priv = os_zalloc(sizeof(*priv));
624 if (priv == NULL)
625 return NULL;
626 priv->sock = -1;
627 os_get_random(priv->cookie, COOKIE_LEN);
628
629 if (global->params.ctrl_interface == NULL)
630 return priv;
631
632 wpa_printf(MSG_DEBUG, "Global control interface '%s'",
633 global->params.ctrl_interface);
634
635 priv->sock = socket(PF_INET, SOCK_DGRAM, 0);
636 if (priv->sock < 0) {
637 perror("socket(PF_INET)");
638 goto fail;
639 }
640
641 os_memset(&addr, 0, sizeof(addr));
642 addr.sin_family = AF_INET;
643 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE
644 addr.sin_addr.s_addr = INADDR_ANY;
645 #else /* CONFIG_CTRL_IFACE_UDP_REMOTE */
646 addr.sin_addr.s_addr = htonl((127 << 24) | 1);
647 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
648 try_again:
649 addr.sin_port = htons(port);
650 if (bind(priv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
651 port++;
652 if ((port - WPA_GLOBAL_CTRL_IFACE_PORT) <
653 WPA_GLOBAL_CTRL_IFACE_PORT_LIMIT)
654 goto try_again;
655 perror("bind(AF_INET)");
656 goto fail;
657 }
658
659 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE
660 wpa_printf(MSG_DEBUG, "global_ctrl_iface_init UDP port: %d", port);
661 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
662
663 eloop_register_read_sock(priv->sock,
664 wpa_supplicant_global_ctrl_iface_receive,
665 global, priv);
666
667 return priv;
668
669 fail:
670 if (priv->sock >= 0)
671 close(priv->sock);
672 os_free(priv);
673 return NULL;
674 }
675
676
677 void
678 wpa_supplicant_global_ctrl_iface_deinit(struct ctrl_iface_global_priv *priv)
679 {
680 if (priv->sock >= 0) {
681 eloop_unregister_read_sock(priv->sock);
682 close(priv->sock);
683 }
684 os_free(priv);
685 }
686