]> git.ipfire.org Git - thirdparty/hostap.git/blob - hostapd/ctrl_iface.c
projects / thirdparty / hostap.git / blob
? search:


62feaa407f8fd273944f6cb279a126f21b03726b
[thirdparty/hostap.git] / hostapd / ctrl_iface.c
1 /*
2 * hostapd / UNIX domain socket -based control interface
3 * Copyright (c) 2004-2015, 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 "utils/includes.h"
10
11 #ifndef CONFIG_NATIVE_WINDOWS
12
13 #ifdef CONFIG_TESTING_OPTIONS
14 #include <net/ethernet.h>
15 #include <netinet/ip.h>
16 #endif /* CONFIG_TESTING_OPTIONS */
17
18 #include <sys/un.h>
19 #include <sys/stat.h>
20 #include <stddef.h>
21
22 #ifdef CONFIG_CTRL_IFACE_UDP
23 #include <netdb.h>
24 #endif /* CONFIG_CTRL_IFACE_UDP */
25
26 #include "utils/common.h"
27 #include "utils/eloop.h"
28 #include "utils/module_tests.h"
29 #include "common/version.h"
30 #include "common/ieee802_11_defs.h"
31 #include "common/ctrl_iface_common.h"
32 #include "crypto/tls.h"
33 #include "drivers/driver.h"
34 #include "eapol_auth/eapol_auth_sm.h"
35 #include "radius/radius_client.h"
36 #include "radius/radius_server.h"
37 #include "l2_packet/l2_packet.h"
38 #include "ap/hostapd.h"
39 #include "ap/ap_config.h"
40 #include "ap/ieee802_1x.h"
41 #include "ap/wpa_auth.h"
42 #include "ap/ieee802_11.h"
43 #include "ap/sta_info.h"
44 #include "ap/wps_hostapd.h"
45 #include "ap/ctrl_iface_ap.h"
46 #include "ap/ap_drv_ops.h"
47 #include "ap/hs20.h"
48 #include "ap/wnm_ap.h"
49 #include "ap/wpa_auth.h"
50 #include "ap/beacon.h"
51 #include "ap/neighbor_db.h"
52 #include "ap/rrm.h"
53 #include "wps/wps_defs.h"
54 #include "wps/wps.h"
55 #include "fst/fst_ctrl_iface.h"
56 #include "config_file.h"
57 #include "ctrl_iface.h"
58
59
60 #define HOSTAPD_CLI_DUP_VALUE_MAX_LEN 256
61
62 #ifdef CONFIG_CTRL_IFACE_UDP
63 #define COOKIE_LEN 8
64 static unsigned char cookie[COOKIE_LEN];
65 static unsigned char gcookie[COOKIE_LEN];
66 #define HOSTAPD_CTRL_IFACE_PORT 8877
67 #define HOSTAPD_CTRL_IFACE_PORT_LIMIT 50
68 #define HOSTAPD_GLOBAL_CTRL_IFACE_PORT 8878
69 #define HOSTAPD_GLOBAL_CTRL_IFACE_PORT_LIMIT 50
70 #endif /* CONFIG_CTRL_IFACE_UDP */
71
72 static void hostapd_ctrl_iface_send(struct hostapd_data *hapd, int level,
73 enum wpa_msg_type type,
74 const char *buf, size_t len);
75
76
77 static int hostapd_ctrl_iface_attach(struct hostapd_data *hapd,
78 struct sockaddr_storage *from,
79 socklen_t fromlen)
80 {
81 return ctrl_iface_attach(&hapd->ctrl_dst, from, fromlen);
82 }
83
84
85 static int hostapd_ctrl_iface_detach(struct hostapd_data *hapd,
86 struct sockaddr_storage *from,
87 socklen_t fromlen)
88 {
89 return ctrl_iface_detach(&hapd->ctrl_dst, from, fromlen);
90 }
91
92
93 static int hostapd_ctrl_iface_level(struct hostapd_data *hapd,
94 struct sockaddr_storage *from,
95 socklen_t fromlen,
96 char *level)
97 {
98 return ctrl_iface_level(&hapd->ctrl_dst, from, fromlen, level);
99 }
100
101
102 static int hostapd_ctrl_iface_new_sta(struct hostapd_data *hapd,
103 const char *txtaddr)
104 {
105 u8 addr[ETH_ALEN];
106 struct sta_info *sta;
107
108 wpa_printf(MSG_DEBUG, "CTRL_IFACE NEW_STA %s", txtaddr);
109
110 if (hwaddr_aton(txtaddr, addr))
111 return -1;
112
113 sta = ap_get_sta(hapd, addr);
114 if (sta)
115 return 0;
116
117 wpa_printf(MSG_DEBUG, "Add new STA " MACSTR " based on ctrl_iface "
118 "notification", MAC2STR(addr));
119 sta = ap_sta_add(hapd, addr);
120 if (sta == NULL)
121 return -1;
122
123 hostapd_new_assoc_sta(hapd, sta, 0);
124 return 0;
125 }
126
127
128 #ifdef CONFIG_IEEE80211W
129 #ifdef NEED_AP_MLME
130 static int hostapd_ctrl_iface_sa_query(struct hostapd_data *hapd,
131 const char *txtaddr)
132 {
133 u8 addr[ETH_ALEN];
134 u8 trans_id[WLAN_SA_QUERY_TR_ID_LEN];
135
136 wpa_printf(MSG_DEBUG, "CTRL_IFACE SA_QUERY %s", txtaddr);
137
138 if (hwaddr_aton(txtaddr, addr) ||
139 os_get_random(trans_id, WLAN_SA_QUERY_TR_ID_LEN) < 0)
140 return -1;
141
142 ieee802_11_send_sa_query_req(hapd, addr, trans_id);
143
144 return 0;
145 }
146 #endif /* NEED_AP_MLME */
147 #endif /* CONFIG_IEEE80211W */
148
149
150 #ifdef CONFIG_WPS
151 static int hostapd_ctrl_iface_wps_pin(struct hostapd_data *hapd, char *txt)
152 {
153 char *pin = os_strchr(txt, ' ');
154 char *timeout_txt;
155 int timeout;
156 u8 addr_buf[ETH_ALEN], *addr = NULL;
157 char *pos;
158
159 if (pin == NULL)
160 return -1;
161 *pin++ = '\0';
162
163 timeout_txt = os_strchr(pin, ' ');
164 if (timeout_txt) {
165 *timeout_txt++ = '\0';
166 timeout = atoi(timeout_txt);
167 pos = os_strchr(timeout_txt, ' ');
168 if (pos) {
169 *pos++ = '\0';
170 if (hwaddr_aton(pos, addr_buf) == 0)
171 addr = addr_buf;
172 }
173 } else
174 timeout = 0;
175
176 return hostapd_wps_add_pin(hapd, addr, txt, pin, timeout);
177 }
178
179
180 static int hostapd_ctrl_iface_wps_check_pin(
181 struct hostapd_data *hapd, char *cmd, char *buf, size_t buflen)
182 {
183 char pin[9];
184 size_t len;
185 char *pos;
186 int ret;
187
188 wpa_hexdump_ascii_key(MSG_DEBUG, "WPS_CHECK_PIN",
189 (u8 *) cmd, os_strlen(cmd));
190 for (pos = cmd, len = 0; *pos != '\0'; pos++) {
191 if (*pos < '0' || *pos > '9')
192 continue;
193 pin[len++] = *pos;
194 if (len == 9) {
195 wpa_printf(MSG_DEBUG, "WPS: Too long PIN");
196 return -1;
197 }
198 }
199 if (len != 4 && len != 8) {
200 wpa_printf(MSG_DEBUG, "WPS: Invalid PIN length %d", (int) len);
201 return -1;
202 }
203 pin[len] = '\0';
204
205 if (len == 8) {
206 unsigned int pin_val;
207 pin_val = atoi(pin);
208 if (!wps_pin_valid(pin_val)) {
209 wpa_printf(MSG_DEBUG, "WPS: Invalid checksum digit");
210 ret = os_snprintf(buf, buflen, "FAIL-CHECKSUM\n");
211 if (os_snprintf_error(buflen, ret))
212 return -1;
213 return ret;
214 }
215 }
216
217 ret = os_snprintf(buf, buflen, "%s", pin);
218 if (os_snprintf_error(buflen, ret))
219 return -1;
220
221 return ret;
222 }
223
224
225 #ifdef CONFIG_WPS_NFC
226 static int hostapd_ctrl_iface_wps_nfc_tag_read(struct hostapd_data *hapd,
227 char *pos)
228 {
229 size_t len;
230 struct wpabuf *buf;
231 int ret;
232
233 len = os_strlen(pos);
234 if (len & 0x01)
235 return -1;
236 len /= 2;
237
238 buf = wpabuf_alloc(len);
239 if (buf == NULL)
240 return -1;
241 if (hexstr2bin(pos, wpabuf_put(buf, len), len) < 0) {
242 wpabuf_free(buf);
243 return -1;
244 }
245
246 ret = hostapd_wps_nfc_tag_read(hapd, buf);
247 wpabuf_free(buf);
248
249 return ret;
250 }
251
252
253 static int hostapd_ctrl_iface_wps_nfc_config_token(struct hostapd_data *hapd,
254 char *cmd, char *reply,
255 size_t max_len)
256 {
257 int ndef;
258 struct wpabuf *buf;
259 int res;
260
261 if (os_strcmp(cmd, "WPS") == 0)
262 ndef = 0;
263 else if (os_strcmp(cmd, "NDEF") == 0)
264 ndef = 1;
265 else
266 return -1;
267
268 buf = hostapd_wps_nfc_config_token(hapd, ndef);
269 if (buf == NULL)
270 return -1;
271
272 res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf),
273 wpabuf_len(buf));
274 reply[res++] = '\n';
275 reply[res] = '\0';
276
277 wpabuf_free(buf);
278
279 return res;
280 }
281
282
283 static int hostapd_ctrl_iface_wps_nfc_token_gen(struct hostapd_data *hapd,
284 char *reply, size_t max_len,
285 int ndef)
286 {
287 struct wpabuf *buf;
288 int res;
289
290 buf = hostapd_wps_nfc_token_gen(hapd, ndef);
291 if (buf == NULL)
292 return -1;
293
294 res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf),
295 wpabuf_len(buf));
296 reply[res++] = '\n';
297 reply[res] = '\0';
298
299 wpabuf_free(buf);
300
301 return res;
302 }
303
304
305 static int hostapd_ctrl_iface_wps_nfc_token(struct hostapd_data *hapd,
306 char *cmd, char *reply,
307 size_t max_len)
308 {
309 if (os_strcmp(cmd, "WPS") == 0)
310 return hostapd_ctrl_iface_wps_nfc_token_gen(hapd, reply,
311 max_len, 0);
312
313 if (os_strcmp(cmd, "NDEF") == 0)
314 return hostapd_ctrl_iface_wps_nfc_token_gen(hapd, reply,
315 max_len, 1);
316
317 if (os_strcmp(cmd, "enable") == 0)
318 return hostapd_wps_nfc_token_enable(hapd);
319
320 if (os_strcmp(cmd, "disable") == 0) {
321 hostapd_wps_nfc_token_disable(hapd);
322 return 0;
323 }
324
325 return -1;
326 }
327
328
329 static int hostapd_ctrl_iface_nfc_get_handover_sel(struct hostapd_data *hapd,
330 char *cmd, char *reply,
331 size_t max_len)
332 {
333 struct wpabuf *buf;
334 int res;
335 char *pos;
336 int ndef;
337
338 pos = os_strchr(cmd, ' ');
339 if (pos == NULL)
340 return -1;
341 *pos++ = '\0';
342
343 if (os_strcmp(cmd, "WPS") == 0)
344 ndef = 0;
345 else if (os_strcmp(cmd, "NDEF") == 0)
346 ndef = 1;
347 else
348 return -1;
349
350 if (os_strcmp(pos, "WPS-CR") == 0)
351 buf = hostapd_wps_nfc_hs_cr(hapd, ndef);
352 else
353 buf = NULL;
354 if (buf == NULL)
355 return -1;
356
357 res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf),
358 wpabuf_len(buf));
359 reply[res++] = '\n';
360 reply[res] = '\0';
361
362 wpabuf_free(buf);
363
364 return res;
365 }
366
367
368 static int hostapd_ctrl_iface_nfc_report_handover(struct hostapd_data *hapd,
369 char *cmd)
370 {
371 size_t len;
372 struct wpabuf *req, *sel;
373 int ret;
374 char *pos, *role, *type, *pos2;
375
376 role = cmd;
377 pos = os_strchr(role, ' ');
378 if (pos == NULL)
379 return -1;
380 *pos++ = '\0';
381
382 type = pos;
383 pos = os_strchr(type, ' ');
384 if (pos == NULL)
385 return -1;
386 *pos++ = '\0';
387
388 pos2 = os_strchr(pos, ' ');
389 if (pos2 == NULL)
390 return -1;
391 *pos2++ = '\0';
392
393 len = os_strlen(pos);
394 if (len & 0x01)
395 return -1;
396 len /= 2;
397
398 req = wpabuf_alloc(len);
399 if (req == NULL)
400 return -1;
401 if (hexstr2bin(pos, wpabuf_put(req, len), len) < 0) {
402 wpabuf_free(req);
403 return -1;
404 }
405
406 len = os_strlen(pos2);
407 if (len & 0x01) {
408 wpabuf_free(req);
409 return -1;
410 }
411 len /= 2;
412
413 sel = wpabuf_alloc(len);
414 if (sel == NULL) {
415 wpabuf_free(req);
416 return -1;
417 }
418 if (hexstr2bin(pos2, wpabuf_put(sel, len), len) < 0) {
419 wpabuf_free(req);
420 wpabuf_free(sel);
421 return -1;
422 }
423
424 if (os_strcmp(role, "RESP") == 0 && os_strcmp(type, "WPS") == 0) {
425 ret = hostapd_wps_nfc_report_handover(hapd, req, sel);
426 } else {
427 wpa_printf(MSG_DEBUG, "NFC: Unsupported connection handover "
428 "reported: role=%s type=%s", role, type);
429 ret = -1;
430 }
431 wpabuf_free(req);
432 wpabuf_free(sel);
433
434 return ret;
435 }
436
437 #endif /* CONFIG_WPS_NFC */
438
439
440 static int hostapd_ctrl_iface_wps_ap_pin(struct hostapd_data *hapd, char *txt,
441 char *buf, size_t buflen)
442 {
443 int timeout = 300;
444 char *pos;
445 const char *pin_txt;
446
447 pos = os_strchr(txt, ' ');
448 if (pos)
449 *pos++ = '\0';
450
451 if (os_strcmp(txt, "disable") == 0) {
452 hostapd_wps_ap_pin_disable(hapd);
453 return os_snprintf(buf, buflen, "OK\n");
454 }
455
456 if (os_strcmp(txt, "random") == 0) {
457 if (pos)
458 timeout = atoi(pos);
459 pin_txt = hostapd_wps_ap_pin_random(hapd, timeout);
460 if (pin_txt == NULL)
461 return -1;
462 return os_snprintf(buf, buflen, "%s", pin_txt);
463 }
464
465 if (os_strcmp(txt, "get") == 0) {
466 pin_txt = hostapd_wps_ap_pin_get(hapd);
467 if (pin_txt == NULL)
468 return -1;
469 return os_snprintf(buf, buflen, "%s", pin_txt);
470 }
471
472 if (os_strcmp(txt, "set") == 0) {
473 char *pin;
474 if (pos == NULL)
475 return -1;
476 pin = pos;
477 pos = os_strchr(pos, ' ');
478 if (pos) {
479 *pos++ = '\0';
480 timeout = atoi(pos);
481 }
482 if (os_strlen(pin) > buflen)
483 return -1;
484 if (hostapd_wps_ap_pin_set(hapd, pin, timeout) < 0)
485 return -1;
486 return os_snprintf(buf, buflen, "%s", pin);
487 }
488
489 return -1;
490 }
491
492
493 static int hostapd_ctrl_iface_wps_config(struct hostapd_data *hapd, char *txt)
494 {
495 char *pos;
496 char *ssid, *auth, *encr = NULL, *key = NULL;
497
498 ssid = txt;
499 pos = os_strchr(txt, ' ');
500 if (!pos)
501 return -1;
502 *pos++ = '\0';
503
504 auth = pos;
505 pos = os_strchr(pos, ' ');
506 if (pos) {
507 *pos++ = '\0';
508 encr = pos;
509 pos = os_strchr(pos, ' ');
510 if (pos) {
511 *pos++ = '\0';
512 key = pos;
513 }
514 }
515
516 return hostapd_wps_config_ap(hapd, ssid, auth, encr, key);
517 }
518
519
520 static const char * pbc_status_str(enum pbc_status status)
521 {
522 switch (status) {
523 case WPS_PBC_STATUS_DISABLE:
524 return "Disabled";
525 case WPS_PBC_STATUS_ACTIVE:
526 return "Active";
527 case WPS_PBC_STATUS_TIMEOUT:
528 return "Timed-out";
529 case WPS_PBC_STATUS_OVERLAP:
530 return "Overlap";
531 default:
532 return "Unknown";
533 }
534 }
535
536
537 static int hostapd_ctrl_iface_wps_get_status(struct hostapd_data *hapd,
538 char *buf, size_t buflen)
539 {
540 int ret;
541 char *pos, *end;
542
543 pos = buf;
544 end = buf + buflen;
545
546 ret = os_snprintf(pos, end - pos, "PBC Status: %s\n",
547 pbc_status_str(hapd->wps_stats.pbc_status));
548
549 if (os_snprintf_error(end - pos, ret))
550 return pos - buf;
551 pos += ret;
552
553 ret = os_snprintf(pos, end - pos, "Last WPS result: %s\n",
554 (hapd->wps_stats.status == WPS_STATUS_SUCCESS ?
555 "Success":
556 (hapd->wps_stats.status == WPS_STATUS_FAILURE ?
557 "Failed" : "None")));
558
559 if (os_snprintf_error(end - pos, ret))
560 return pos - buf;
561 pos += ret;
562
563 /* If status == Failure - Add possible Reasons */
564 if(hapd->wps_stats.status == WPS_STATUS_FAILURE &&
565 hapd->wps_stats.failure_reason > 0) {
566 ret = os_snprintf(pos, end - pos,
567 "Failure Reason: %s\n",
568 wps_ei_str(hapd->wps_stats.failure_reason));
569
570 if (os_snprintf_error(end - pos, ret))
571 return pos - buf;
572 pos += ret;
573 }
574
575 if (hapd->wps_stats.status) {
576 ret = os_snprintf(pos, end - pos, "Peer Address: " MACSTR "\n",
577 MAC2STR(hapd->wps_stats.peer_addr));
578
579 if (os_snprintf_error(end - pos, ret))
580 return pos - buf;
581 pos += ret;
582 }
583
584 return pos - buf;
585 }
586
587 #endif /* CONFIG_WPS */
588
589 #ifdef CONFIG_HS20
590
591 static int hostapd_ctrl_iface_hs20_wnm_notif(struct hostapd_data *hapd,
592 const char *cmd)
593 {
594 u8 addr[ETH_ALEN];
595 const char *url;
596
597 if (hwaddr_aton(cmd, addr))
598 return -1;
599 url = cmd + 17;
600 if (*url == '\0') {
601 url = NULL;
602 } else {
603 if (*url != ' ')
604 return -1;
605 url++;
606 if (*url == '\0')
607 url = NULL;
608 }
609
610 return hs20_send_wnm_notification(hapd, addr, 1, url);
611 }
612
613
614 static int hostapd_ctrl_iface_hs20_deauth_req(struct hostapd_data *hapd,
615 const char *cmd)
616 {
617 u8 addr[ETH_ALEN];
618 int code, reauth_delay, ret;
619 const char *pos;
620 size_t url_len;
621 struct wpabuf *req;
622
623 /* <STA MAC Addr> <Code(0/1)> <Re-auth-Delay(sec)> [URL] */
624 if (hwaddr_aton(cmd, addr))
625 return -1;
626
627 pos = os_strchr(cmd, ' ');
628 if (pos == NULL)
629 return -1;
630 pos++;
631 code = atoi(pos);
632
633 pos = os_strchr(pos, ' ');
634 if (pos == NULL)
635 return -1;
636 pos++;
637 reauth_delay = atoi(pos);
638
639 url_len = 0;
640 pos = os_strchr(pos, ' ');
641 if (pos) {
642 pos++;
643 url_len = os_strlen(pos);
644 }
645
646 req = wpabuf_alloc(4 + url_len);
647 if (req == NULL)
648 return -1;
649 wpabuf_put_u8(req, code);
650 wpabuf_put_le16(req, reauth_delay);
651 wpabuf_put_u8(req, url_len);
652 if (pos)
653 wpabuf_put_data(req, pos, url_len);
654
655 wpa_printf(MSG_DEBUG, "HS 2.0: Send WNM-Notification to " MACSTR
656 " to indicate imminent deauthentication (code=%d "
657 "reauth_delay=%d)", MAC2STR(addr), code, reauth_delay);
658 ret = hs20_send_wnm_notification_deauth_req(hapd, addr, req);
659 wpabuf_free(req);
660 return ret;
661 }
662
663 #endif /* CONFIG_HS20 */
664
665
666 #ifdef CONFIG_INTERWORKING
667
668 static int hostapd_ctrl_iface_set_qos_map_set(struct hostapd_data *hapd,
669 const char *cmd)
670 {
671 u8 qos_map_set[16 + 2 * 21], count = 0;
672 const char *pos = cmd;
673 int val, ret;
674
675 for (;;) {
676 if (count == sizeof(qos_map_set)) {
677 wpa_printf(MSG_ERROR, "Too many qos_map_set parameters");
678 return -1;
679 }
680
681 val = atoi(pos);
682 if (val < 0 || val > 255) {
683 wpa_printf(MSG_INFO, "Invalid QoS Map Set");
684 return -1;
685 }
686
687 qos_map_set[count++] = val;
688 pos = os_strchr(pos, ',');
689 if (!pos)
690 break;
691 pos++;
692 }
693
694 if (count < 16 || count & 1) {
695 wpa_printf(MSG_INFO, "Invalid QoS Map Set");
696 return -1;
697 }
698
699 ret = hostapd_drv_set_qos_map(hapd, qos_map_set, count);
700 if (ret) {
701 wpa_printf(MSG_INFO, "Failed to set QoS Map Set");
702 return -1;
703 }
704
705 os_memcpy(hapd->conf->qos_map_set, qos_map_set, count);
706 hapd->conf->qos_map_set_len = count;
707
708 return 0;
709 }
710
711
712 static int hostapd_ctrl_iface_send_qos_map_conf(struct hostapd_data *hapd,
713 const char *cmd)
714 {
715 u8 addr[ETH_ALEN];
716 struct sta_info *sta;
717 struct wpabuf *buf;
718 u8 *qos_map_set = hapd->conf->qos_map_set;
719 u8 qos_map_set_len = hapd->conf->qos_map_set_len;
720 int ret;
721
722 if (!qos_map_set_len) {
723 wpa_printf(MSG_INFO, "QoS Map Set is not set");
724 return -1;
725 }
726
727 if (hwaddr_aton(cmd, addr))
728 return -1;
729
730 sta = ap_get_sta(hapd, addr);
731 if (sta == NULL) {
732 wpa_printf(MSG_DEBUG, "Station " MACSTR " not found "
733 "for QoS Map Configuration message",
734 MAC2STR(addr));
735 return -1;
736 }
737
738 if (!sta->qos_map_enabled) {
739 wpa_printf(MSG_DEBUG, "Station " MACSTR " did not indicate "
740 "support for QoS Map", MAC2STR(addr));
741 return -1;
742 }
743
744 buf = wpabuf_alloc(2 + 2 + qos_map_set_len);
745 if (buf == NULL)
746 return -1;
747
748 wpabuf_put_u8(buf, WLAN_ACTION_QOS);
749 wpabuf_put_u8(buf, QOS_QOS_MAP_CONFIG);
750
751 /* QoS Map Set Element */
752 wpabuf_put_u8(buf, WLAN_EID_QOS_MAP_SET);
753 wpabuf_put_u8(buf, qos_map_set_len);
754 wpabuf_put_data(buf, qos_map_set, qos_map_set_len);
755
756 ret = hostapd_drv_send_action(hapd, hapd->iface->freq, 0, addr,
757 wpabuf_head(buf), wpabuf_len(buf));
758 wpabuf_free(buf);
759
760 return ret;
761 }
762
763 #endif /* CONFIG_INTERWORKING */
764
765
766 #ifdef CONFIG_WNM
767
768 static int hostapd_ctrl_iface_disassoc_imminent(struct hostapd_data *hapd,
769 const char *cmd)
770 {
771 u8 addr[ETH_ALEN];
772 int disassoc_timer;
773 struct sta_info *sta;
774
775 if (hwaddr_aton(cmd, addr))
776 return -1;
777 if (cmd[17] != ' ')
778 return -1;
779 disassoc_timer = atoi(cmd + 17);
780
781 sta = ap_get_sta(hapd, addr);
782 if (sta == NULL) {
783 wpa_printf(MSG_DEBUG, "Station " MACSTR
784 " not found for disassociation imminent message",
785 MAC2STR(addr));
786 return -1;
787 }
788
789 return wnm_send_disassoc_imminent(hapd, sta, disassoc_timer);
790 }
791
792
793 static int hostapd_ctrl_iface_ess_disassoc(struct hostapd_data *hapd,
794 const char *cmd)
795 {
796 u8 addr[ETH_ALEN];
797 const char *url, *timerstr;
798 int disassoc_timer;
799 struct sta_info *sta;
800
801 if (hwaddr_aton(cmd, addr))
802 return -1;
803
804 sta = ap_get_sta(hapd, addr);
805 if (sta == NULL) {
806 wpa_printf(MSG_DEBUG, "Station " MACSTR
807 " not found for ESS disassociation imminent message",
808 MAC2STR(addr));
809 return -1;
810 }
811
812 timerstr = cmd + 17;
813 if (*timerstr != ' ')
814 return -1;
815 timerstr++;
816 disassoc_timer = atoi(timerstr);
817 if (disassoc_timer < 0 || disassoc_timer > 65535)
818 return -1;
819
820 url = os_strchr(timerstr, ' ');
821 if (url == NULL)
822 return -1;
823 url++;
824
825 return wnm_send_ess_disassoc_imminent(hapd, sta, url, disassoc_timer);
826 }
827
828
829 static int hostapd_ctrl_iface_bss_tm_req(struct hostapd_data *hapd,
830 const char *cmd)
831 {
832 u8 addr[ETH_ALEN];
833 const char *pos, *end;
834 int disassoc_timer = 0;
835 struct sta_info *sta;
836 u8 req_mode = 0, valid_int = 0x01;
837 u8 bss_term_dur[12];
838 char *url = NULL;
839 int ret;
840 u8 nei_rep[1000];
841 u8 *nei_pos = nei_rep;
842 u8 mbo[10];
843 size_t mbo_len = 0;
844
845 if (hwaddr_aton(cmd, addr)) {
846 wpa_printf(MSG_DEBUG, "Invalid STA MAC address");
847 return -1;
848 }
849
850 sta = ap_get_sta(hapd, addr);
851 if (sta == NULL) {
852 wpa_printf(MSG_DEBUG, "Station " MACSTR
853 " not found for BSS TM Request message",
854 MAC2STR(addr));
855 return -1;
856 }
857
858 pos = os_strstr(cmd, " disassoc_timer=");
859 if (pos) {
860 pos += 16;
861 disassoc_timer = atoi(pos);
862 if (disassoc_timer < 0 || disassoc_timer > 65535) {
863 wpa_printf(MSG_DEBUG, "Invalid disassoc_timer");
864 return -1;
865 }
866 }
867
868 pos = os_strstr(cmd, " valid_int=");
869 if (pos) {
870 pos += 11;
871 valid_int = atoi(pos);
872 }
873
874 pos = os_strstr(cmd, " bss_term=");
875 if (pos) {
876 pos += 10;
877 req_mode |= WNM_BSS_TM_REQ_BSS_TERMINATION_INCLUDED;
878 /* TODO: TSF configurable/learnable */
879 bss_term_dur[0] = 4; /* Subelement ID */
880 bss_term_dur[1] = 10; /* Length */
881 os_memset(bss_term_dur, 2, 8);
882 end = os_strchr(pos, ',');
883 if (end == NULL) {
884 wpa_printf(MSG_DEBUG, "Invalid bss_term data");
885 return -1;
886 }
887 end++;
888 WPA_PUT_LE16(&bss_term_dur[10], atoi(end));
889 }
890
891
892 /*
893 * BSS Transition Candidate List Entries - Neighbor Report elements
894 * neighbor=<BSSID>,<BSSID Information>,<Operating Class>,
895 * <Channel Number>,<PHY Type>[,<hexdump of Optional Subelements>]
896 */
897 pos = cmd;
898 while (pos) {
899 u8 *nei_start;
900 long int val;
901 char *endptr, *tmp;
902
903 pos = os_strstr(pos, " neighbor=");
904 if (!pos)
905 break;
906 if (nei_pos + 15 > nei_rep + sizeof(nei_rep)) {
907 wpa_printf(MSG_DEBUG,
908 "Not enough room for additional neighbor");
909 return -1;
910 }
911 pos += 10;
912
913 nei_start = nei_pos;
914 *nei_pos++ = WLAN_EID_NEIGHBOR_REPORT;
915 nei_pos++; /* length to be filled in */
916
917 if (hwaddr_aton(pos, nei_pos)) {
918 wpa_printf(MSG_DEBUG, "Invalid BSSID");
919 return -1;
920 }
921 nei_pos += ETH_ALEN;
922 pos += 17;
923 if (*pos != ',') {
924 wpa_printf(MSG_DEBUG, "Missing BSSID Information");
925 return -1;
926 }
927 pos++;
928
929 val = strtol(pos, &endptr, 0);
930 WPA_PUT_LE32(nei_pos, val);
931 nei_pos += 4;
932 if (*endptr != ',') {
933 wpa_printf(MSG_DEBUG, "Missing Operating Class");
934 return -1;
935 }
936 pos = endptr + 1;
937
938 *nei_pos++ = atoi(pos); /* Operating Class */
939 pos = os_strchr(pos, ',');
940 if (pos == NULL) {
941 wpa_printf(MSG_DEBUG, "Missing Channel Number");
942 return -1;
943 }
944 pos++;
945
946 *nei_pos++ = atoi(pos); /* Channel Number */
947 pos = os_strchr(pos, ',');
948 if (pos == NULL) {
949 wpa_printf(MSG_DEBUG, "Missing PHY Type");
950 return -1;
951 }
952 pos++;
953
954 *nei_pos++ = atoi(pos); /* PHY Type */
955 end = os_strchr(pos, ' ');
956 tmp = os_strchr(pos, ',');
957 if (tmp && (!end || tmp < end)) {
958 /* Optional Subelements (hexdump) */
959 size_t len;
960
961 pos = tmp + 1;
962 end = os_strchr(pos, ' ');
963 if (end)
964 len = end - pos;
965 else
966 len = os_strlen(pos);
967 if (nei_pos + len / 2 > nei_rep + sizeof(nei_rep)) {
968 wpa_printf(MSG_DEBUG,
969 "Not enough room for neighbor subelements");
970 return -1;
971 }
972 if (len & 0x01 ||
973 hexstr2bin(pos, nei_pos, len / 2) < 0) {
974 wpa_printf(MSG_DEBUG,
975 "Invalid neighbor subelement info");
976 return -1;
977 }
978 nei_pos += len / 2;
979 pos = end;
980 }
981
982 nei_start[1] = nei_pos - nei_start - 2;
983 }
984
985 pos = os_strstr(cmd, " url=");
986 if (pos) {
987 size_t len;
988 pos += 5;
989 end = os_strchr(pos, ' ');
990 if (end)
991 len = end - pos;
992 else
993 len = os_strlen(pos);
994 url = os_malloc(len + 1);
995 if (url == NULL)
996 return -1;
997 os_memcpy(url, pos, len);
998 url[len] = '\0';
999 req_mode |= WNM_BSS_TM_REQ_ESS_DISASSOC_IMMINENT;
1000 }
1001
1002 if (os_strstr(cmd, " pref=1"))
1003 req_mode |= WNM_BSS_TM_REQ_PREF_CAND_LIST_INCLUDED;
1004 if (os_strstr(cmd, " abridged=1"))
1005 req_mode |= WNM_BSS_TM_REQ_ABRIDGED;
1006 if (os_strstr(cmd, " disassoc_imminent=1"))
1007 req_mode |= WNM_BSS_TM_REQ_DISASSOC_IMMINENT;
1008
1009 #ifdef CONFIG_MBO
1010 pos = os_strstr(cmd, "mbo=");
1011 if (pos) {
1012 unsigned int mbo_reason, cell_pref, reassoc_delay;
1013 u8 *mbo_pos = mbo;
1014
1015 ret = sscanf(pos, "mbo=%u:%u:%u", &mbo_reason,
1016 &reassoc_delay, &cell_pref);
1017 if (ret != 3) {
1018 wpa_printf(MSG_DEBUG,
1019 "MBO requires three arguments: mbo=<reason>:<reassoc_delay>:<cell_pref>");
1020 ret = -1;
1021 goto fail;
1022 }
1023
1024 if (mbo_reason > MBO_TRANSITION_REASON_PREMIUM_AP) {
1025 wpa_printf(MSG_DEBUG,
1026 "Invalid MBO transition reason code %u",
1027 mbo_reason);
1028 ret = -1;
1029 goto fail;
1030 }
1031
1032 /* Valid values for Cellular preference are: 0, 1, 255 */
1033 if (cell_pref != 0 && cell_pref != 1 && cell_pref != 255) {
1034 wpa_printf(MSG_DEBUG,
1035 "Invalid MBO cellular capability %u",
1036 cell_pref);
1037 ret = -1;
1038 goto fail;
1039 }
1040
1041 if (reassoc_delay > 65535 ||
1042 (reassoc_delay &&
1043 !(req_mode & WNM_BSS_TM_REQ_DISASSOC_IMMINENT))) {
1044 wpa_printf(MSG_DEBUG,
1045 "MBO: Assoc retry delay is only valid in disassoc imminent mode");
1046 ret = -1;
1047 goto fail;
1048 }
1049
1050 *mbo_pos++ = MBO_ATTR_ID_TRANSITION_REASON;
1051 *mbo_pos++ = 1;
1052 *mbo_pos++ = mbo_reason;
1053 *mbo_pos++ = MBO_ATTR_ID_CELL_DATA_PREF;
1054 *mbo_pos++ = 1;
1055 *mbo_pos++ = cell_pref;
1056
1057 if (reassoc_delay) {
1058 *mbo_pos++ = MBO_ATTR_ID_ASSOC_RETRY_DELAY;
1059 *mbo_pos++ = 2;
1060 WPA_PUT_LE16(mbo_pos, reassoc_delay);
1061 mbo_pos += 2;
1062 }
1063
1064 mbo_len = mbo_pos - mbo;
1065 }
1066 #endif /* CONFIG_MBO */
1067
1068 ret = wnm_send_bss_tm_req(hapd, sta, req_mode, disassoc_timer,
1069 valid_int, bss_term_dur, url,
1070 nei_pos > nei_rep ? nei_rep : NULL,
1071 nei_pos - nei_rep, mbo_len ? mbo : NULL,
1072 mbo_len);
1073 #ifdef CONFIG_MBO
1074 fail:
1075 #endif /* CONFIG_MBO */
1076 os_free(url);
1077 return ret;
1078 }
1079
1080 #endif /* CONFIG_WNM */
1081
1082
1083 static int hostapd_ctrl_iface_get_key_mgmt(struct hostapd_data *hapd,
1084 char *buf, size_t buflen)
1085 {
1086 int ret = 0;
1087 char *pos, *end;
1088
1089 pos = buf;
1090 end = buf + buflen;
1091
1092 WPA_ASSERT(hapd->conf->wpa_key_mgmt);
1093
1094 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_PSK) {
1095 ret = os_snprintf(pos, end - pos, "WPA-PSK ");
1096 if (os_snprintf_error(end - pos, ret))
1097 return pos - buf;
1098 pos += ret;
1099 }
1100 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X) {
1101 ret = os_snprintf(pos, end - pos, "WPA-EAP ");
1102 if (os_snprintf_error(end - pos, ret))
1103 return pos - buf;
1104 pos += ret;
1105 }
1106 #ifdef CONFIG_IEEE80211R_AP
1107 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_PSK) {
1108 ret = os_snprintf(pos, end - pos, "FT-PSK ");
1109 if (os_snprintf_error(end - pos, ret))
1110 return pos - buf;
1111 pos += ret;
1112 }
1113 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X) {
1114 ret = os_snprintf(pos, end - pos, "FT-EAP ");
1115 if (os_snprintf_error(end - pos, ret))
1116 return pos - buf;
1117 pos += ret;
1118 }
1119 #ifdef CONFIG_SAE
1120 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_SAE) {
1121 ret = os_snprintf(pos, end - pos, "FT-SAE ");
1122 if (os_snprintf_error(end - pos, ret))
1123 return pos - buf;
1124 pos += ret;
1125 }
1126 #endif /* CONFIG_SAE */
1127 #ifdef CONFIG_FILS
1128 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_FILS_SHA256) {
1129 ret = os_snprintf(pos, end - pos, "FT-FILS-SHA256 ");
1130 if (os_snprintf_error(end - pos, ret))
1131 return pos - buf;
1132 pos += ret;
1133 }
1134 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_FILS_SHA384) {
1135 ret = os_snprintf(pos, end - pos, "FT-FILS-SHA384 ");
1136 if (os_snprintf_error(end - pos, ret))
1137 return pos - buf;
1138 pos += ret;
1139 }
1140 #endif /* CONFIG_FILS */
1141 #endif /* CONFIG_IEEE80211R_AP */
1142 #ifdef CONFIG_IEEE80211W
1143 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_PSK_SHA256) {
1144 ret = os_snprintf(pos, end - pos, "WPA-PSK-SHA256 ");
1145 if (os_snprintf_error(end - pos, ret))
1146 return pos - buf;
1147 pos += ret;
1148 }
1149 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA256) {
1150 ret = os_snprintf(pos, end - pos, "WPA-EAP-SHA256 ");
1151 if (os_snprintf_error(end - pos, ret))
1152 return pos - buf;
1153 pos += ret;
1154 }
1155 #endif /* CONFIG_IEEE80211W */
1156 #ifdef CONFIG_SAE
1157 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_SAE) {
1158 ret = os_snprintf(pos, end - pos, "SAE ");
1159 if (os_snprintf_error(end - pos, ret))
1160 return pos - buf;
1161 pos += ret;
1162 }
1163 #endif /* CONFIG_SAE */
1164 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X_SUITE_B) {
1165 ret = os_snprintf(pos, end - pos, "WPA-EAP-SUITE-B ");
1166 if (os_snprintf_error(end - pos, ret))
1167 return pos - buf;
1168 pos += ret;
1169 }
1170 if (hapd->conf->wpa_key_mgmt &
1171 WPA_KEY_MGMT_IEEE8021X_SUITE_B_192) {
1172 ret = os_snprintf(pos, end - pos,
1173 "WPA-EAP-SUITE-B-192 ");
1174 if (os_snprintf_error(end - pos, ret))
1175 return pos - buf;
1176 pos += ret;
1177 }
1178 #ifdef CONFIG_FILS
1179 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_FILS_SHA256) {
1180 ret = os_snprintf(pos, end - pos, "FILS-SHA256 ");
1181 if (os_snprintf_error(end - pos, ret))
1182 return pos - buf;
1183 pos += ret;
1184 }
1185 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_FILS_SHA384) {
1186 ret = os_snprintf(pos, end - pos, "FILS-SHA384 ");
1187 if (os_snprintf_error(end - pos, ret))
1188 return pos - buf;
1189 pos += ret;
1190 }
1191 #endif /* CONFIG_FILS */
1192
1193 if (pos > buf && *(pos - 1) == ' ') {
1194 *(pos - 1) = '\0';
1195 pos--;
1196 }
1197
1198 return pos - buf;
1199 }
1200
1201
1202 static int hostapd_ctrl_iface_get_config(struct hostapd_data *hapd,
1203 char *buf, size_t buflen)
1204 {
1205 int ret;
1206 char *pos, *end;
1207
1208 pos = buf;
1209 end = buf + buflen;
1210
1211 ret = os_snprintf(pos, end - pos, "bssid=" MACSTR "\n"
1212 "ssid=%s\n",
1213 MAC2STR(hapd->own_addr),
1214 wpa_ssid_txt(hapd->conf->ssid.ssid,
1215 hapd->conf->ssid.ssid_len));
1216 if (os_snprintf_error(end - pos, ret))
1217 return pos - buf;
1218 pos += ret;
1219
1220 #ifdef CONFIG_WPS
1221 ret = os_snprintf(pos, end - pos, "wps_state=%s\n",
1222 hapd->conf->wps_state == 0 ? "disabled" :
1223 (hapd->conf->wps_state == 1 ? "not configured" :
1224 "configured"));
1225 if (os_snprintf_error(end - pos, ret))
1226 return pos - buf;
1227 pos += ret;
1228
1229 if (hapd->conf->wps_state && hapd->conf->wpa &&
1230 hapd->conf->ssid.wpa_passphrase) {
1231 ret = os_snprintf(pos, end - pos, "passphrase=%s\n",
1232 hapd->conf->ssid.wpa_passphrase);
1233 if (os_snprintf_error(end - pos, ret))
1234 return pos - buf;
1235 pos += ret;
1236 }
1237
1238 if (hapd->conf->wps_state && hapd->conf->wpa &&
1239 hapd->conf->ssid.wpa_psk &&
1240 hapd->conf->ssid.wpa_psk->group) {
1241 char hex[PMK_LEN * 2 + 1];
1242 wpa_snprintf_hex(hex, sizeof(hex),
1243 hapd->conf->ssid.wpa_psk->psk, PMK_LEN);
1244 ret = os_snprintf(pos, end - pos, "psk=%s\n", hex);
1245 if (os_snprintf_error(end - pos, ret))
1246 return pos - buf;
1247 pos += ret;
1248 }
1249 #endif /* CONFIG_WPS */
1250
1251 if (hapd->conf->wpa) {
1252 ret = os_snprintf(pos, end - pos, "wpa=%d\n", hapd->conf->wpa);
1253 if (os_snprintf_error(end - pos, ret))
1254 return pos - buf;
1255 pos += ret;
1256 }
1257
1258 if (hapd->conf->wpa && hapd->conf->wpa_key_mgmt) {
1259 ret = os_snprintf(pos, end - pos, "key_mgmt=");
1260 if (os_snprintf_error(end - pos, ret))
1261 return pos - buf;
1262 pos += ret;
1263
1264 pos += hostapd_ctrl_iface_get_key_mgmt(hapd, pos, end - pos);
1265
1266 ret = os_snprintf(pos, end - pos, "\n");
1267 if (os_snprintf_error(end - pos, ret))
1268 return pos - buf;
1269 pos += ret;
1270 }
1271
1272 if (hapd->conf->wpa) {
1273 ret = os_snprintf(pos, end - pos, "group_cipher=%s\n",
1274 wpa_cipher_txt(hapd->conf->wpa_group));
1275 if (os_snprintf_error(end - pos, ret))
1276 return pos - buf;
1277 pos += ret;
1278 }
1279
1280 if ((hapd->conf->wpa & WPA_PROTO_RSN) && hapd->conf->rsn_pairwise) {
1281 ret = os_snprintf(pos, end - pos, "rsn_pairwise_cipher=");
1282 if (os_snprintf_error(end - pos, ret))
1283 return pos - buf;
1284 pos += ret;
1285
1286 ret = wpa_write_ciphers(pos, end, hapd->conf->rsn_pairwise,
1287 " ");
1288 if (ret < 0)
1289 return pos - buf;
1290 pos += ret;
1291
1292 ret = os_snprintf(pos, end - pos, "\n");
1293 if (os_snprintf_error(end - pos, ret))
1294 return pos - buf;
1295 pos += ret;
1296 }
1297
1298 if ((hapd->conf->wpa & WPA_PROTO_WPA) && hapd->conf->wpa_pairwise) {
1299 ret = os_snprintf(pos, end - pos, "wpa_pairwise_cipher=");
1300 if (os_snprintf_error(end - pos, ret))
1301 return pos - buf;
1302 pos += ret;
1303
1304 ret = wpa_write_ciphers(pos, end, hapd->conf->wpa_pairwise,
1305 " ");
1306 if (ret < 0)
1307 return pos - buf;
1308 pos += ret;
1309
1310 ret = os_snprintf(pos, end - pos, "\n");
1311 if (os_snprintf_error(end - pos, ret))
1312 return pos - buf;
1313 pos += ret;
1314 }
1315
1316 return pos - buf;
1317 }
1318
1319
1320 static int hostapd_ctrl_iface_set(struct hostapd_data *hapd, char *cmd)
1321 {
1322 char *value;
1323 int ret = 0;
1324
1325 value = os_strchr(cmd, ' ');
1326 if (value == NULL)
1327 return -1;
1328 *value++ = '\0';
1329
1330 wpa_printf(MSG_DEBUG, "CTRL_IFACE SET '%s'='%s'", cmd, value);
1331 if (0) {
1332 #ifdef CONFIG_WPS_TESTING
1333 } else if (os_strcasecmp(cmd, "wps_version_number") == 0) {
1334 long int val;
1335 val = strtol(value, NULL, 0);
1336 if (val < 0 || val > 0xff) {
1337 ret = -1;
1338 wpa_printf(MSG_DEBUG, "WPS: Invalid "
1339 "wps_version_number %ld", val);
1340 } else {
1341 wps_version_number = val;
1342 wpa_printf(MSG_DEBUG, "WPS: Testing - force WPS "
1343 "version %u.%u",
1344 (wps_version_number & 0xf0) >> 4,
1345 wps_version_number & 0x0f);
1346 hostapd_wps_update_ie(hapd);
1347 }
1348 } else if (os_strcasecmp(cmd, "wps_testing_dummy_cred") == 0) {
1349 wps_testing_dummy_cred = atoi(value);
1350 wpa_printf(MSG_DEBUG, "WPS: Testing - dummy_cred=%d",
1351 wps_testing_dummy_cred);
1352 } else if (os_strcasecmp(cmd, "wps_corrupt_pkhash") == 0) {
1353 wps_corrupt_pkhash = atoi(value);
1354 wpa_printf(MSG_DEBUG, "WPS: Testing - wps_corrupt_pkhash=%d",
1355 wps_corrupt_pkhash);
1356 #endif /* CONFIG_WPS_TESTING */
1357 #ifdef CONFIG_TESTING_OPTIONS
1358 } else if (os_strcasecmp(cmd, "ext_mgmt_frame_handling") == 0) {
1359 hapd->ext_mgmt_frame_handling = atoi(value);
1360 } else if (os_strcasecmp(cmd, "ext_eapol_frame_io") == 0) {
1361 hapd->ext_eapol_frame_io = atoi(value);
1362 #endif /* CONFIG_TESTING_OPTIONS */
1363 #ifdef CONFIG_MBO
1364 } else if (os_strcasecmp(cmd, "mbo_assoc_disallow") == 0) {
1365 int val;
1366
1367 if (!hapd->conf->mbo_enabled)
1368 return -1;
1369
1370 val = atoi(value);
1371 if (val < 0 || val > 1)
1372 return -1;
1373
1374 hapd->mbo_assoc_disallow = val;
1375 ieee802_11_update_beacons(hapd->iface);
1376
1377 /*
1378 * TODO: Need to configure drivers that do AP MLME offload with
1379 * disallowing station logic.
1380 */
1381 #endif /* CONFIG_MBO */
1382 } else {
1383 struct sta_info *sta;
1384 struct vlan_description vlan_id;
1385
1386 ret = hostapd_set_iface(hapd->iconf, hapd->conf, cmd, value);
1387 if (ret)
1388 return ret;
1389
1390 if (os_strcasecmp(cmd, "deny_mac_file") == 0) {
1391 for (sta = hapd->sta_list; sta; sta = sta->next) {
1392 if (hostapd_maclist_found(
1393 hapd->conf->deny_mac,
1394 hapd->conf->num_deny_mac, sta->addr,
1395 &vlan_id) &&
1396 (!vlan_id.notempty ||
1397 !vlan_compare(&vlan_id, sta->vlan_desc)))
1398 ap_sta_disconnect(
1399 hapd, sta, sta->addr,
1400 WLAN_REASON_UNSPECIFIED);
1401 }
1402 } else if (hapd->conf->macaddr_acl == DENY_UNLESS_ACCEPTED &&
1403 os_strcasecmp(cmd, "accept_mac_file") == 0) {
1404 for (sta = hapd->sta_list; sta; sta = sta->next) {
1405 if (!hostapd_maclist_found(
1406 hapd->conf->accept_mac,
1407 hapd->conf->num_accept_mac,
1408 sta->addr, &vlan_id) ||
1409 (vlan_id.notempty &&
1410 vlan_compare(&vlan_id, sta->vlan_desc)))
1411 ap_sta_disconnect(
1412 hapd, sta, sta->addr,
1413 WLAN_REASON_UNSPECIFIED);
1414 }
1415 }
1416 }
1417
1418 return ret;
1419 }
1420
1421
1422 static int hostapd_ctrl_iface_get(struct hostapd_data *hapd, char *cmd,
1423 char *buf, size_t buflen)
1424 {
1425 int res;
1426
1427 wpa_printf(MSG_DEBUG, "CTRL_IFACE GET '%s'", cmd);
1428
1429 if (os_strcmp(cmd, "version") == 0) {
1430 res = os_snprintf(buf, buflen, "%s", VERSION_STR);
1431 if (os_snprintf_error(buflen, res))
1432 return -1;
1433 return res;
1434 } else if (os_strcmp(cmd, "tls_library") == 0) {
1435 res = tls_get_library_version(buf, buflen);
1436 if (os_snprintf_error(buflen, res))
1437 return -1;
1438 return res;
1439 }
1440
1441 return -1;
1442 }
1443
1444
1445 static int hostapd_ctrl_iface_enable(struct hostapd_iface *iface)
1446 {
1447 if (hostapd_enable_iface(iface) < 0) {
1448 wpa_printf(MSG_ERROR, "Enabling of interface failed");
1449 return -1;
1450 }
1451 return 0;
1452 }
1453
1454
1455 static int hostapd_ctrl_iface_reload(struct hostapd_iface *iface)
1456 {
1457 if (hostapd_reload_iface(iface) < 0) {
1458 wpa_printf(MSG_ERROR, "Reloading of interface failed");
1459 return -1;
1460 }
1461 return 0;
1462 }
1463
1464
1465 static int hostapd_ctrl_iface_disable(struct hostapd_iface *iface)
1466 {
1467 if (hostapd_disable_iface(iface) < 0) {
1468 wpa_printf(MSG_ERROR, "Disabling of interface failed");
1469 return -1;
1470 }
1471 return 0;
1472 }
1473
1474
1475 #ifdef CONFIG_TESTING_OPTIONS
1476
1477 static int hostapd_ctrl_iface_radar(struct hostapd_data *hapd, char *cmd)
1478 {
1479 union wpa_event_data data;
1480 char *pos, *param;
1481 enum wpa_event_type event;
1482
1483 wpa_printf(MSG_DEBUG, "RADAR TEST: %s", cmd);
1484
1485 os_memset(&data, 0, sizeof(data));
1486
1487 param = os_strchr(cmd, ' ');
1488 if (param == NULL)
1489 return -1;
1490 *param++ = '\0';
1491
1492 if (os_strcmp(cmd, "DETECTED") == 0)
1493 event = EVENT_DFS_RADAR_DETECTED;
1494 else if (os_strcmp(cmd, "CAC-FINISHED") == 0)
1495 event = EVENT_DFS_CAC_FINISHED;
1496 else if (os_strcmp(cmd, "CAC-ABORTED") == 0)
1497 event = EVENT_DFS_CAC_ABORTED;
1498 else if (os_strcmp(cmd, "NOP-FINISHED") == 0)
1499 event = EVENT_DFS_NOP_FINISHED;
1500 else {
1501 wpa_printf(MSG_DEBUG, "Unsupported RADAR test command: %s",
1502 cmd);
1503 return -1;
1504 }
1505
1506 pos = os_strstr(param, "freq=");
1507 if (pos)
1508 data.dfs_event.freq = atoi(pos + 5);
1509
1510 pos = os_strstr(param, "ht_enabled=1");
1511 if (pos)
1512 data.dfs_event.ht_enabled = 1;
1513
1514 pos = os_strstr(param, "chan_offset=");
1515 if (pos)
1516 data.dfs_event.chan_offset = atoi(pos + 12);
1517
1518 pos = os_strstr(param, "chan_width=");
1519 if (pos)
1520 data.dfs_event.chan_width = atoi(pos + 11);
1521
1522 pos = os_strstr(param, "cf1=");
1523 if (pos)
1524 data.dfs_event.cf1 = atoi(pos + 4);
1525
1526 pos = os_strstr(param, "cf2=");
1527 if (pos)
1528 data.dfs_event.cf2 = atoi(pos + 4);
1529
1530 wpa_supplicant_event(hapd, event, &data);
1531
1532 return 0;
1533 }
1534
1535
1536 static int hostapd_ctrl_iface_mgmt_tx(struct hostapd_data *hapd, char *cmd)
1537 {
1538 size_t len;
1539 u8 *buf;
1540 int res;
1541
1542 wpa_printf(MSG_DEBUG, "External MGMT TX: %s", cmd);
1543
1544 len = os_strlen(cmd);
1545 if (len & 1)
1546 return -1;
1547 len /= 2;
1548
1549 buf = os_malloc(len);
1550 if (buf == NULL)
1551 return -1;
1552
1553 if (hexstr2bin(cmd, buf, len) < 0) {
1554 os_free(buf);
1555 return -1;
1556 }
1557
1558 res = hostapd_drv_send_mlme(hapd, buf, len, 0);
1559 os_free(buf);
1560 return res;
1561 }
1562
1563
1564 static int hostapd_ctrl_iface_mgmt_rx_process(struct hostapd_data *hapd,
1565 char *cmd)
1566 {
1567 char *pos, *param;
1568 size_t len;
1569 u8 *buf;
1570 int freq = 0, datarate = 0, ssi_signal = 0;
1571 union wpa_event_data event;
1572
1573 if (!hapd->ext_mgmt_frame_handling)
1574 return -1;
1575
1576 /* freq=<MHz> datarate=<val> ssi_signal=<val> frame=<frame hexdump> */
1577
1578 wpa_printf(MSG_DEBUG, "External MGMT RX process: %s", cmd);
1579
1580 pos = cmd;
1581 param = os_strstr(pos, "freq=");
1582 if (param) {
1583 param += 5;
1584 freq = atoi(param);
1585 }
1586
1587 param = os_strstr(pos, " datarate=");
1588 if (param) {
1589 param += 10;
1590 datarate = atoi(param);
1591 }
1592
1593 param = os_strstr(pos, " ssi_signal=");
1594 if (param) {
1595 param += 12;
1596 ssi_signal = atoi(param);
1597 }
1598
1599 param = os_strstr(pos, " frame=");
1600 if (param == NULL)
1601 return -1;
1602 param += 7;
1603
1604 len = os_strlen(param);
1605 if (len & 1)
1606 return -1;
1607 len /= 2;
1608
1609 buf = os_malloc(len);
1610 if (buf == NULL)
1611 return -1;
1612
1613 if (hexstr2bin(param, buf, len) < 0) {
1614 os_free(buf);
1615 return -1;
1616 }
1617
1618 os_memset(&event, 0, sizeof(event));
1619 event.rx_mgmt.freq = freq;
1620 event.rx_mgmt.frame = buf;
1621 event.rx_mgmt.frame_len = len;
1622 event.rx_mgmt.ssi_signal = ssi_signal;
1623 event.rx_mgmt.datarate = datarate;
1624 hapd->ext_mgmt_frame_handling = 0;
1625 wpa_supplicant_event(hapd, EVENT_RX_MGMT, &event);
1626 hapd->ext_mgmt_frame_handling = 1;
1627
1628 os_free(buf);
1629
1630 return 0;
1631 }
1632
1633
1634 static int hostapd_ctrl_iface_eapol_rx(struct hostapd_data *hapd, char *cmd)
1635 {
1636 char *pos;
1637 u8 src[ETH_ALEN], *buf;
1638 int used;
1639 size_t len;
1640
1641 wpa_printf(MSG_DEBUG, "External EAPOL RX: %s", cmd);
1642
1643 pos = cmd;
1644 used = hwaddr_aton2(pos, src);
1645 if (used < 0)
1646 return -1;
1647 pos += used;
1648 while (*pos == ' ')
1649 pos++;
1650
1651 len = os_strlen(pos);
1652 if (len & 1)
1653 return -1;
1654 len /= 2;
1655
1656 buf = os_malloc(len);
1657 if (buf == NULL)
1658 return -1;
1659
1660 if (hexstr2bin(pos, buf, len) < 0) {
1661 os_free(buf);
1662 return -1;
1663 }
1664
1665 ieee802_1x_receive(hapd, src, buf, len);
1666 os_free(buf);
1667
1668 return 0;
1669 }
1670
1671
1672 static u16 ipv4_hdr_checksum(const void *buf, size_t len)
1673 {
1674 size_t i;
1675 u32 sum = 0;
1676 const u16 *pos = buf;
1677
1678 for (i = 0; i < len / 2; i++)
1679 sum += *pos++;
1680
1681 while (sum >> 16)
1682 sum = (sum & 0xffff) + (sum >> 16);
1683
1684 return sum ^ 0xffff;
1685 }
1686
1687
1688 #define HWSIM_PACKETLEN 1500
1689 #define HWSIM_IP_LEN (HWSIM_PACKETLEN - sizeof(struct ether_header))
1690
1691 static void hostapd_data_test_rx(void *ctx, const u8 *src_addr, const u8 *buf,
1692 size_t len)
1693 {
1694 struct hostapd_data *hapd = ctx;
1695 const struct ether_header *eth;
1696 struct iphdr ip;
1697 const u8 *pos;
1698 unsigned int i;
1699
1700 if (len != HWSIM_PACKETLEN)
1701 return;
1702
1703 eth = (const struct ether_header *) buf;
1704 os_memcpy(&ip, eth + 1, sizeof(ip));
1705 pos = &buf[sizeof(*eth) + sizeof(ip)];
1706
1707 if (ip.ihl != 5 || ip.version != 4 ||
1708 ntohs(ip.tot_len) != HWSIM_IP_LEN)
1709 return;
1710
1711 for (i = 0; i < HWSIM_IP_LEN - sizeof(ip); i++) {
1712 if (*pos != (u8) i)
1713 return;
1714 pos++;
1715 }
1716
1717 wpa_msg(hapd->msg_ctx, MSG_INFO, "DATA-TEST-RX " MACSTR " " MACSTR,
1718 MAC2STR(eth->ether_dhost), MAC2STR(eth->ether_shost));
1719 }
1720
1721
1722 static int hostapd_ctrl_iface_data_test_config(struct hostapd_data *hapd,
1723 char *cmd)
1724 {
1725 int enabled = atoi(cmd);
1726 char *pos;
1727 const char *ifname;
1728
1729 if (!enabled) {
1730 if (hapd->l2_test) {
1731 l2_packet_deinit(hapd->l2_test);
1732 hapd->l2_test = NULL;
1733 wpa_dbg(hapd->msg_ctx, MSG_DEBUG,
1734 "test data: Disabled");
1735 }
1736 return 0;
1737 }
1738
1739 if (hapd->l2_test)
1740 return 0;
1741
1742 pos = os_strstr(cmd, " ifname=");
1743 if (pos)
1744 ifname = pos + 8;
1745 else
1746 ifname = hapd->conf->iface;
1747
1748 hapd->l2_test = l2_packet_init(ifname, hapd->own_addr,
1749 ETHERTYPE_IP, hostapd_data_test_rx,
1750 hapd, 1);
1751 if (hapd->l2_test == NULL)
1752 return -1;
1753
1754 wpa_dbg(hapd->msg_ctx, MSG_DEBUG, "test data: Enabled");
1755
1756 return 0;
1757 }
1758
1759
1760 static int hostapd_ctrl_iface_data_test_tx(struct hostapd_data *hapd, char *cmd)
1761 {
1762 u8 dst[ETH_ALEN], src[ETH_ALEN];
1763 char *pos;
1764 int used;
1765 long int val;
1766 u8 tos;
1767 u8 buf[2 + HWSIM_PACKETLEN];
1768 struct ether_header *eth;
1769 struct iphdr *ip;
1770 u8 *dpos;
1771 unsigned int i;
1772
1773 if (hapd->l2_test == NULL)
1774 return -1;
1775
1776 /* format: <dst> <src> <tos> */
1777
1778 pos = cmd;
1779 used = hwaddr_aton2(pos, dst);
1780 if (used < 0)
1781 return -1;
1782 pos += used;
1783 while (*pos == ' ')
1784 pos++;
1785 used = hwaddr_aton2(pos, src);
1786 if (used < 0)
1787 return -1;
1788 pos += used;
1789
1790 val = strtol(pos, NULL, 0);
1791 if (val < 0 || val > 0xff)
1792 return -1;
1793 tos = val;
1794
1795 eth = (struct ether_header *) &buf[2];
1796 os_memcpy(eth->ether_dhost, dst, ETH_ALEN);
1797 os_memcpy(eth->ether_shost, src, ETH_ALEN);
1798 eth->ether_type = htons(ETHERTYPE_IP);
1799 ip = (struct iphdr *) (eth + 1);
1800 os_memset(ip, 0, sizeof(*ip));
1801 ip->ihl = 5;
1802 ip->version = 4;
1803 ip->ttl = 64;
1804 ip->tos = tos;
1805 ip->tot_len = htons(HWSIM_IP_LEN);
1806 ip->protocol = 1;
1807 ip->saddr = htonl(192U << 24 | 168 << 16 | 1 << 8 | 1);
1808 ip->daddr = htonl(192U << 24 | 168 << 16 | 1 << 8 | 2);
1809 ip->check = ipv4_hdr_checksum(ip, sizeof(*ip));
1810 dpos = (u8 *) (ip + 1);
1811 for (i = 0; i < HWSIM_IP_LEN - sizeof(*ip); i++)
1812 *dpos++ = i;
1813
1814 if (l2_packet_send(hapd->l2_test, dst, ETHERTYPE_IP, &buf[2],
1815 HWSIM_PACKETLEN) < 0)
1816 return -1;
1817
1818 wpa_dbg(hapd->msg_ctx, MSG_DEBUG, "test data: TX dst=" MACSTR
1819 " src=" MACSTR " tos=0x%x", MAC2STR(dst), MAC2STR(src), tos);
1820
1821 return 0;
1822 }
1823
1824
1825 static int hostapd_ctrl_iface_data_test_frame(struct hostapd_data *hapd,
1826 char *cmd)
1827 {
1828 u8 *buf;
1829 struct ether_header *eth;
1830 struct l2_packet_data *l2 = NULL;
1831 size_t len;
1832 u16 ethertype;
1833 int res = -1;
1834 const char *ifname = hapd->conf->iface;
1835
1836 if (os_strncmp(cmd, "ifname=", 7) == 0) {
1837 cmd += 7;
1838 ifname = cmd;
1839 cmd = os_strchr(cmd, ' ');
1840 if (cmd == NULL)
1841 return -1;
1842 *cmd++ = '\0';
1843 }
1844
1845 len = os_strlen(cmd);
1846 if (len & 1 || len < ETH_HLEN * 2)
1847 return -1;
1848 len /= 2;
1849
1850 buf = os_malloc(len);
1851 if (buf == NULL)
1852 return -1;
1853
1854 if (hexstr2bin(cmd, buf, len) < 0)
1855 goto done;
1856
1857 eth = (struct ether_header *) buf;
1858 ethertype = ntohs(eth->ether_type);
1859
1860 l2 = l2_packet_init(ifname, hapd->own_addr, ethertype,
1861 hostapd_data_test_rx, hapd, 1);
1862 if (l2 == NULL)
1863 goto done;
1864
1865 res = l2_packet_send(l2, eth->ether_dhost, ethertype, buf, len);
1866 wpa_dbg(hapd->msg_ctx, MSG_DEBUG, "test data: TX frame res=%d", res);
1867 done:
1868 if (l2)
1869 l2_packet_deinit(l2);
1870 os_free(buf);
1871
1872 return res < 0 ? -1 : 0;
1873 }
1874
1875
1876 static int hostapd_ctrl_test_alloc_fail(struct hostapd_data *hapd, char *cmd)
1877 {
1878 #ifdef WPA_TRACE_BFD
1879 char *pos;
1880
1881 wpa_trace_fail_after = atoi(cmd);
1882 pos = os_strchr(cmd, ':');
1883 if (pos) {
1884 pos++;
1885 os_strlcpy(wpa_trace_fail_func, pos,
1886 sizeof(wpa_trace_fail_func));
1887 } else {
1888 wpa_trace_fail_after = 0;
1889 }
1890
1891 return 0;
1892 #else /* WPA_TRACE_BFD */
1893 return -1;
1894 #endif /* WPA_TRACE_BFD */
1895 }
1896
1897
1898 static int hostapd_ctrl_get_alloc_fail(struct hostapd_data *hapd,
1899 char *buf, size_t buflen)
1900 {
1901 #ifdef WPA_TRACE_BFD
1902 return os_snprintf(buf, buflen, "%u:%s", wpa_trace_fail_after,
1903 wpa_trace_fail_func);
1904 #else /* WPA_TRACE_BFD */
1905 return -1;
1906 #endif /* WPA_TRACE_BFD */
1907 }
1908
1909
1910 static int hostapd_ctrl_test_fail(struct hostapd_data *hapd, char *cmd)
1911 {
1912 #ifdef WPA_TRACE_BFD
1913 char *pos;
1914
1915 wpa_trace_test_fail_after = atoi(cmd);
1916 pos = os_strchr(cmd, ':');
1917 if (pos) {
1918 pos++;
1919 os_strlcpy(wpa_trace_test_fail_func, pos,
1920 sizeof(wpa_trace_test_fail_func));
1921 } else {
1922 wpa_trace_test_fail_after = 0;
1923 }
1924
1925 return 0;
1926 #else /* WPA_TRACE_BFD */
1927 return -1;
1928 #endif /* WPA_TRACE_BFD */
1929 }
1930
1931
1932 static int hostapd_ctrl_get_fail(struct hostapd_data *hapd,
1933 char *buf, size_t buflen)
1934 {
1935 #ifdef WPA_TRACE_BFD
1936 return os_snprintf(buf, buflen, "%u:%s", wpa_trace_test_fail_after,
1937 wpa_trace_test_fail_func);
1938 #else /* WPA_TRACE_BFD */
1939 return -1;
1940 #endif /* WPA_TRACE_BFD */
1941 }
1942
1943 #endif /* CONFIG_TESTING_OPTIONS */
1944
1945
1946 static int hostapd_ctrl_iface_chan_switch(struct hostapd_iface *iface,
1947 char *pos)
1948 {
1949 #ifdef NEED_AP_MLME
1950 struct csa_settings settings;
1951 int ret;
1952 unsigned int i;
1953
1954 ret = hostapd_parse_csa_settings(pos, &settings);
1955 if (ret)
1956 return ret;
1957
1958 for (i = 0; i < iface->num_bss; i++) {
1959 ret = hostapd_switch_channel(iface->bss[i], &settings);
1960 if (ret) {
1961 /* FIX: What do we do if CSA fails in the middle of
1962 * submitting multi-BSS CSA requests? */
1963 return ret;
1964 }
1965 }
1966
1967 return 0;
1968 #else /* NEED_AP_MLME */
1969 return -1;
1970 #endif /* NEED_AP_MLME */
1971 }
1972
1973
1974 static int hostapd_ctrl_iface_mib(struct hostapd_data *hapd, char *reply,
1975 int reply_size, const char *param)
1976 {
1977 #ifdef RADIUS_SERVER
1978 if (os_strcmp(param, "radius_server") == 0) {
1979 return radius_server_get_mib(hapd->radius_srv, reply,
1980 reply_size);
1981 }
1982 #endif /* RADIUS_SERVER */
1983 return -1;
1984 }
1985
1986
1987 static int hostapd_ctrl_iface_vendor(struct hostapd_data *hapd, char *cmd,
1988 char *buf, size_t buflen)
1989 {
1990 int ret;
1991 char *pos;
1992 u8 *data = NULL;
1993 unsigned int vendor_id, subcmd;
1994 struct wpabuf *reply;
1995 size_t data_len = 0;
1996
1997 /* cmd: <vendor id> <subcommand id> [<hex formatted data>] */
1998 vendor_id = strtoul(cmd, &pos, 16);
1999 if (!isblank((unsigned char) *pos))
2000 return -EINVAL;
2001
2002 subcmd = strtoul(pos, &pos, 10);
2003
2004 if (*pos != '\0') {
2005 if (!isblank((unsigned char) *pos++))
2006 return -EINVAL;
2007 data_len = os_strlen(pos);
2008 }
2009
2010 if (data_len) {
2011 data_len /= 2;
2012 data = os_malloc(data_len);
2013 if (!data)
2014 return -ENOBUFS;
2015
2016 if (hexstr2bin(pos, data, data_len)) {
2017 wpa_printf(MSG_DEBUG,
2018 "Vendor command: wrong parameter format");
2019 os_free(data);
2020 return -EINVAL;
2021 }
2022 }
2023
2024 reply = wpabuf_alloc((buflen - 1) / 2);
2025 if (!reply) {
2026 os_free(data);
2027 return -ENOBUFS;
2028 }
2029
2030 ret = hostapd_drv_vendor_cmd(hapd, vendor_id, subcmd, data, data_len,
2031 reply);
2032
2033 if (ret == 0)
2034 ret = wpa_snprintf_hex(buf, buflen, wpabuf_head_u8(reply),
2035 wpabuf_len(reply));
2036
2037 wpabuf_free(reply);
2038 os_free(data);
2039
2040 return ret;
2041 }
2042
2043
2044 static int hostapd_ctrl_iface_eapol_reauth(struct hostapd_data *hapd,
2045 const char *cmd)
2046 {
2047 u8 addr[ETH_ALEN];
2048 struct sta_info *sta;
2049
2050 if (hwaddr_aton(cmd, addr))
2051 return -1;
2052
2053 sta = ap_get_sta(hapd, addr);
2054 if (!sta || !sta->eapol_sm)
2055 return -1;
2056
2057 eapol_auth_reauthenticate(sta->eapol_sm);
2058 return 0;
2059 }
2060
2061
2062 static int hostapd_ctrl_iface_eapol_set(struct hostapd_data *hapd, char *cmd)
2063 {
2064 u8 addr[ETH_ALEN];
2065 struct sta_info *sta;
2066 char *pos = cmd, *param;
2067
2068 if (hwaddr_aton(pos, addr) || pos[17] != ' ')
2069 return -1;
2070 pos += 18;
2071 param = pos;
2072 pos = os_strchr(pos, ' ');
2073 if (!pos)
2074 return -1;
2075 *pos++ = '\0';
2076
2077 sta = ap_get_sta(hapd, addr);
2078 if (!sta || !sta->eapol_sm)
2079 return -1;
2080
2081 return eapol_auth_set_conf(sta->eapol_sm, param, pos);
2082 }
2083
2084
2085 static int hostapd_ctrl_iface_log_level(struct hostapd_data *hapd, char *cmd,
2086 char *buf, size_t buflen)
2087 {
2088 char *pos, *end, *stamp;
2089 int ret;
2090
2091 /* cmd: "LOG_LEVEL [<level>]" */
2092 if (*cmd == '\0') {
2093 pos = buf;
2094 end = buf + buflen;
2095 ret = os_snprintf(pos, end - pos, "Current level: %s\n"
2096 "Timestamp: %d\n",
2097 debug_level_str(wpa_debug_level),
2098 wpa_debug_timestamp);
2099 if (os_snprintf_error(end - pos, ret))
2100 ret = 0;
2101
2102 return ret;
2103 }
2104
2105 while (*cmd == ' ')
2106 cmd++;
2107
2108 stamp = os_strchr(cmd, ' ');
2109 if (stamp) {
2110 *stamp++ = '\0';
2111 while (*stamp == ' ') {
2112 stamp++;
2113 }
2114 }
2115
2116 if (os_strlen(cmd)) {
2117 int level = str_to_debug_level(cmd);
2118 if (level < 0)
2119 return -1;
2120 wpa_debug_level = level;
2121 }
2122
2123 if (stamp && os_strlen(stamp))
2124 wpa_debug_timestamp = atoi(stamp);
2125
2126 os_memcpy(buf, "OK\n", 3);
2127 return 3;
2128 }
2129
2130
2131 #ifdef NEED_AP_MLME
2132 static int hostapd_ctrl_iface_track_sta_list(struct hostapd_data *hapd,
2133 char *buf, size_t buflen)
2134 {
2135 struct hostapd_iface *iface = hapd->iface;
2136 char *pos, *end;
2137 struct hostapd_sta_info *info;
2138 struct os_reltime now;
2139
2140 if (!iface->num_sta_seen)
2141 return 0;
2142
2143 sta_track_expire(iface, 0);
2144
2145 pos = buf;
2146 end = buf + buflen;
2147
2148 os_get_reltime(&now);
2149 dl_list_for_each_reverse(info, &iface->sta_seen,
2150 struct hostapd_sta_info, list) {
2151 struct os_reltime age;
2152 int ret;
2153
2154 os_reltime_sub(&now, &info->last_seen, &age);
2155 ret = os_snprintf(pos, end - pos, MACSTR " %u %d\n",
2156 MAC2STR(info->addr), (unsigned int) age.sec,
2157 info->ssi_signal);
2158 if (os_snprintf_error(end - pos, ret))
2159 break;
2160 pos += ret;
2161 }
2162
2163 return pos - buf;
2164 }
2165 #endif /* NEED_AP_MLME */
2166
2167
2168 static int hostapd_ctrl_iface_req_lci(struct hostapd_data *hapd,
2169 const char *cmd)
2170 {
2171 u8 addr[ETH_ALEN];
2172
2173 if (hwaddr_aton(cmd, addr)) {
2174 wpa_printf(MSG_INFO, "CTRL: REQ_LCI: Invalid MAC address");
2175 return -1;
2176 }
2177
2178 return hostapd_send_lci_req(hapd, addr);
2179 }
2180
2181
2182 static int hostapd_ctrl_iface_req_range(struct hostapd_data *hapd, char *cmd)
2183 {
2184 u8 addr[ETH_ALEN];
2185 char *token, *context = NULL;
2186 int random_interval, min_ap;
2187 u8 responders[ETH_ALEN * RRM_RANGE_REQ_MAX_RESPONDERS];
2188 unsigned int n_responders;
2189
2190 token = str_token(cmd, " ", &context);
2191 if (!token || hwaddr_aton(token, addr)) {
2192 wpa_printf(MSG_INFO,
2193 "CTRL: REQ_RANGE - Bad destination address");
2194 return -1;
2195 }
2196
2197 token = str_token(cmd, " ", &context);
2198 if (!token)
2199 return -1;
2200
2201 random_interval = atoi(token);
2202 if (random_interval < 0 || random_interval > 0xffff)
2203 return -1;
2204
2205 token = str_token(cmd, " ", &context);
2206 if (!token)
2207 return -1;
2208
2209 min_ap = atoi(token);
2210 if (min_ap <= 0 || min_ap > WLAN_RRM_RANGE_REQ_MAX_MIN_AP)
2211 return -1;
2212
2213 n_responders = 0;
2214 while ((token = str_token(cmd, " ", &context))) {
2215 if (n_responders == RRM_RANGE_REQ_MAX_RESPONDERS) {
2216 wpa_printf(MSG_INFO,
2217 "CTRL: REQ_RANGE: Too many responders");
2218 return -1;
2219 }
2220
2221 if (hwaddr_aton(token, responders + n_responders * ETH_ALEN)) {
2222 wpa_printf(MSG_INFO,
2223 "CTRL: REQ_RANGE: Bad responder address");
2224 return -1;
2225 }
2226
2227 n_responders++;
2228 }
2229
2230 if (!n_responders) {
2231 wpa_printf(MSG_INFO,
2232 "CTRL: REQ_RANGE - No FTM responder address");
2233 return -1;
2234 }
2235
2236 return hostapd_send_range_req(hapd, addr, random_interval, min_ap,
2237 responders, n_responders);
2238 }
2239
2240
2241 static int hostapd_ctrl_iface_req_beacon(struct hostapd_data *hapd,
2242 const char *cmd, char *reply,
2243 size_t reply_size)
2244 {
2245 u8 addr[ETH_ALEN];
2246 const char *pos;
2247 struct wpabuf *req;
2248 int ret;
2249 u8 req_mode = 0;
2250
2251 if (hwaddr_aton(cmd, addr))
2252 return -1;
2253 pos = os_strchr(cmd, ' ');
2254 if (!pos)
2255 return -1;
2256 pos++;
2257 if (os_strncmp(pos, "req_mode=", 9) == 0) {
2258 int val = hex2byte(pos + 9);
2259
2260 if (val < 0)
2261 return -1;
2262 req_mode = val;
2263 pos += 11;
2264 pos = os_strchr(pos, ' ');
2265 if (!pos)
2266 return -1;
2267 pos++;
2268 }
2269 req = wpabuf_parse_bin(pos);
2270 if (!req)
2271 return -1;
2272
2273 ret = hostapd_send_beacon_req(hapd, addr, req_mode, req);
2274 wpabuf_free(req);
2275 if (ret >= 0)
2276 ret = os_snprintf(reply, reply_size, "%d", ret);
2277 return ret;
2278 }
2279
2280
2281 static int hostapd_ctrl_iface_set_neighbor(struct hostapd_data *hapd, char *buf)
2282 {
2283 struct wpa_ssid_value ssid;
2284 u8 bssid[ETH_ALEN];
2285 struct wpabuf *nr, *lci = NULL, *civic = NULL;
2286 int stationary = 0;
2287 char *tmp;
2288 int ret;
2289
2290 if (!(hapd->conf->radio_measurements[0] &
2291 WLAN_RRM_CAPS_NEIGHBOR_REPORT)) {
2292 wpa_printf(MSG_ERROR,
2293 "CTRL: SET_NEIGHBOR: Neighbor report is not enabled");
2294 return -1;
2295 }
2296
2297 if (hwaddr_aton(buf, bssid)) {
2298 wpa_printf(MSG_ERROR, "CTRL: SET_NEIGHBOR: Bad BSSID");
2299 return -1;
2300 }
2301
2302 tmp = os_strstr(buf, "ssid=");
2303 if (!tmp || ssid_parse(tmp + 5, &ssid)) {
2304 wpa_printf(MSG_ERROR,
2305 "CTRL: SET_NEIGHBOR: Bad or missing SSID");
2306 return -1;
2307 }
2308 buf = os_strchr(tmp + 6, tmp[5] == '"' ? '"' : ' ');
2309 if (!buf)
2310 return -1;
2311
2312 tmp = os_strstr(buf, "nr=");
2313 if (!tmp) {
2314 wpa_printf(MSG_ERROR,
2315 "CTRL: SET_NEIGHBOR: Missing Neighbor Report element");
2316 return -1;
2317 }
2318
2319 buf = os_strchr(tmp, ' ');
2320 if (buf)
2321 *buf++ = '\0';
2322
2323 nr = wpabuf_parse_bin(tmp + 3);
2324 if (!nr) {
2325 wpa_printf(MSG_ERROR,
2326 "CTRL: SET_NEIGHBOR: Bad Neighbor Report element");
2327 return -1;
2328 }
2329
2330 if (!buf)
2331 goto set;
2332
2333 tmp = os_strstr(buf, "lci=");
2334 if (tmp) {
2335 buf = os_strchr(tmp, ' ');
2336 if (buf)
2337 *buf++ = '\0';
2338 lci = wpabuf_parse_bin(tmp + 4);
2339 if (!lci) {
2340 wpa_printf(MSG_ERROR,
2341 "CTRL: SET_NEIGHBOR: Bad LCI subelement");
2342 wpabuf_free(nr);
2343 return -1;
2344 }
2345 }
2346
2347 if (!buf)
2348 goto set;
2349
2350 tmp = os_strstr(buf, "civic=");
2351 if (tmp) {
2352 buf = os_strchr(tmp, ' ');
2353 if (buf)
2354 *buf++ = '\0';
2355 civic = wpabuf_parse_bin(tmp + 6);
2356 if (!civic) {
2357 wpa_printf(MSG_ERROR,
2358 "CTRL: SET_NEIGHBOR: Bad civic subelement");
2359 wpabuf_free(nr);
2360 wpabuf_free(lci);
2361 return -1;
2362 }
2363 }
2364
2365 if (!buf)
2366 goto set;
2367
2368 if (os_strstr(buf, "stat"))
2369 stationary = 1;
2370
2371 set:
2372 ret = hostapd_neighbor_set(hapd, bssid, &ssid, nr, lci, civic,
2373 stationary);
2374
2375 wpabuf_free(nr);
2376 wpabuf_free(lci);
2377 wpabuf_free(civic);
2378
2379 return ret;
2380 }
2381
2382
2383 static int hostapd_ctrl_iface_remove_neighbor(struct hostapd_data *hapd,
2384 char *buf)
2385 {
2386 struct wpa_ssid_value ssid;
2387 u8 bssid[ETH_ALEN];
2388 char *tmp;
2389
2390 if (hwaddr_aton(buf, bssid)) {
2391 wpa_printf(MSG_ERROR, "CTRL: REMOVE_NEIGHBOR: Bad BSSID");
2392 return -1;
2393 }
2394
2395 tmp = os_strstr(buf, "ssid=");
2396 if (!tmp || ssid_parse(tmp + 5, &ssid)) {
2397 wpa_printf(MSG_ERROR,
2398 "CTRL: REMOVE_NEIGHBORr: Bad or missing SSID");
2399 return -1;
2400 }
2401
2402 return hostapd_neighbor_remove(hapd, bssid, &ssid);
2403 }
2404
2405
2406 static int hostapd_ctrl_driver_flags(struct hostapd_iface *iface, char *buf,
2407 size_t buflen)
2408 {
2409 int ret, i;
2410 char *pos, *end;
2411
2412 ret = os_snprintf(buf, buflen, "%016llX:\n",
2413 (long long unsigned) iface->drv_flags);
2414 if (os_snprintf_error(buflen, ret))
2415 return -1;
2416
2417 pos = buf + ret;
2418 end = buf + buflen;
2419
2420 for (i = 0; i < 64; i++) {
2421 if (iface->drv_flags & (1LLU << i)) {
2422 ret = os_snprintf(pos, end - pos, "%s\n",
2423 driver_flag_to_string(1LLU << i));
2424 if (os_snprintf_error(end - pos, ret))
2425 return -1;
2426 pos += ret;
2427 }
2428 }
2429
2430 return pos - buf;
2431 }
2432
2433
2434 static int hostapd_ctrl_iface_receive_process(struct hostapd_data *hapd,
2435 char *buf, char *reply,
2436 int reply_size,
2437 struct sockaddr_storage *from,
2438 socklen_t fromlen)
2439 {
2440 int reply_len, res;
2441
2442 os_memcpy(reply, "OK\n", 3);
2443 reply_len = 3;
2444
2445 if (os_strcmp(buf, "PING") == 0) {
2446 os_memcpy(reply, "PONG\n", 5);
2447 reply_len = 5;
2448 } else if (os_strncmp(buf, "RELOG", 5) == 0) {
2449 if (wpa_debug_reopen_file() < 0)
2450 reply_len = -1;
2451 } else if (os_strcmp(buf, "STATUS") == 0) {
2452 reply_len = hostapd_ctrl_iface_status(hapd, reply,
2453 reply_size);
2454 } else if (os_strcmp(buf, "STATUS-DRIVER") == 0) {
2455 reply_len = hostapd_drv_status(hapd, reply, reply_size);
2456 } else if (os_strcmp(buf, "MIB") == 0) {
2457 reply_len = ieee802_11_get_mib(hapd, reply, reply_size);
2458 if (reply_len >= 0) {
2459 res = wpa_get_mib(hapd->wpa_auth, reply + reply_len,
2460 reply_size - reply_len);
2461 if (res < 0)
2462 reply_len = -1;
2463 else
2464 reply_len += res;
2465 }
2466 if (reply_len >= 0) {
2467 res = ieee802_1x_get_mib(hapd, reply + reply_len,
2468 reply_size - reply_len);
2469 if (res < 0)
2470 reply_len = -1;
2471 else
2472 reply_len += res;
2473 }
2474 #ifndef CONFIG_NO_RADIUS
2475 if (reply_len >= 0) {
2476 res = radius_client_get_mib(hapd->radius,
2477 reply + reply_len,
2478 reply_size - reply_len);
2479 if (res < 0)
2480 reply_len = -1;
2481 else
2482 reply_len += res;
2483 }
2484 #endif /* CONFIG_NO_RADIUS */
2485 } else if (os_strncmp(buf, "MIB ", 4) == 0) {
2486 reply_len = hostapd_ctrl_iface_mib(hapd, reply, reply_size,
2487 buf + 4);
2488 } else if (os_strcmp(buf, "STA-FIRST") == 0) {
2489 reply_len = hostapd_ctrl_iface_sta_first(hapd, reply,
2490 reply_size);
2491 } else if (os_strncmp(buf, "STA ", 4) == 0) {
2492 reply_len = hostapd_ctrl_iface_sta(hapd, buf + 4, reply,
2493 reply_size);
2494 } else if (os_strncmp(buf, "STA-NEXT ", 9) == 0) {
2495 reply_len = hostapd_ctrl_iface_sta_next(hapd, buf + 9, reply,
2496 reply_size);
2497 } else if (os_strcmp(buf, "ATTACH") == 0) {
2498 if (hostapd_ctrl_iface_attach(hapd, from, fromlen))
2499 reply_len = -1;
2500 } else if (os_strcmp(buf, "DETACH") == 0) {
2501 if (hostapd_ctrl_iface_detach(hapd, from, fromlen))
2502 reply_len = -1;
2503 } else if (os_strncmp(buf, "LEVEL ", 6) == 0) {
2504 if (hostapd_ctrl_iface_level(hapd, from, fromlen,
2505 buf + 6))
2506 reply_len = -1;
2507 } else if (os_strncmp(buf, "NEW_STA ", 8) == 0) {
2508 if (hostapd_ctrl_iface_new_sta(hapd, buf + 8))
2509 reply_len = -1;
2510 } else if (os_strncmp(buf, "DEAUTHENTICATE ", 15) == 0) {
2511 if (hostapd_ctrl_iface_deauthenticate(hapd, buf + 15))
2512 reply_len = -1;
2513 } else if (os_strncmp(buf, "DISASSOCIATE ", 13) == 0) {
2514 if (hostapd_ctrl_iface_disassociate(hapd, buf + 13))
2515 reply_len = -1;
2516 #ifdef CONFIG_TAXONOMY
2517 } else if (os_strncmp(buf, "SIGNATURE ", 10) == 0) {
2518 reply_len = hostapd_ctrl_iface_signature(hapd, buf + 10,
2519 reply, reply_size);
2520 #endif /* CONFIG_TAXONOMY */
2521 } else if (os_strncmp(buf, "POLL_STA ", 9) == 0) {
2522 if (hostapd_ctrl_iface_poll_sta(hapd, buf + 9))
2523 reply_len = -1;
2524 } else if (os_strcmp(buf, "STOP_AP") == 0) {
2525 if (hostapd_ctrl_iface_stop_ap(hapd))
2526 reply_len = -1;
2527 #ifdef CONFIG_IEEE80211W
2528 #ifdef NEED_AP_MLME
2529 } else if (os_strncmp(buf, "SA_QUERY ", 9) == 0) {
2530 if (hostapd_ctrl_iface_sa_query(hapd, buf + 9))
2531 reply_len = -1;
2532 #endif /* NEED_AP_MLME */
2533 #endif /* CONFIG_IEEE80211W */
2534 #ifdef CONFIG_WPS
2535 } else if (os_strncmp(buf, "WPS_PIN ", 8) == 0) {
2536 if (hostapd_ctrl_iface_wps_pin(hapd, buf + 8))
2537 reply_len = -1;
2538 } else if (os_strncmp(buf, "WPS_CHECK_PIN ", 14) == 0) {
2539 reply_len = hostapd_ctrl_iface_wps_check_pin(
2540 hapd, buf + 14, reply, reply_size);
2541 } else if (os_strcmp(buf, "WPS_PBC") == 0) {
2542 if (hostapd_wps_button_pushed(hapd, NULL))
2543 reply_len = -1;
2544 } else if (os_strcmp(buf, "WPS_CANCEL") == 0) {
2545 if (hostapd_wps_cancel(hapd))
2546 reply_len = -1;
2547 } else if (os_strncmp(buf, "WPS_AP_PIN ", 11) == 0) {
2548 reply_len = hostapd_ctrl_iface_wps_ap_pin(hapd, buf + 11,
2549 reply, reply_size);
2550 } else if (os_strncmp(buf, "WPS_CONFIG ", 11) == 0) {
2551 if (hostapd_ctrl_iface_wps_config(hapd, buf + 11) < 0)
2552 reply_len = -1;
2553 } else if (os_strncmp(buf, "WPS_GET_STATUS", 13) == 0) {
2554 reply_len = hostapd_ctrl_iface_wps_get_status(hapd, reply,
2555 reply_size);
2556 #ifdef CONFIG_WPS_NFC
2557 } else if (os_strncmp(buf, "WPS_NFC_TAG_READ ", 17) == 0) {
2558 if (hostapd_ctrl_iface_wps_nfc_tag_read(hapd, buf + 17))
2559 reply_len = -1;
2560 } else if (os_strncmp(buf, "WPS_NFC_CONFIG_TOKEN ", 21) == 0) {
2561 reply_len = hostapd_ctrl_iface_wps_nfc_config_token(
2562 hapd, buf + 21, reply, reply_size);
2563 } else if (os_strncmp(buf, "WPS_NFC_TOKEN ", 14) == 0) {
2564 reply_len = hostapd_ctrl_iface_wps_nfc_token(
2565 hapd, buf + 14, reply, reply_size);
2566 } else if (os_strncmp(buf, "NFC_GET_HANDOVER_SEL ", 21) == 0) {
2567 reply_len = hostapd_ctrl_iface_nfc_get_handover_sel(
2568 hapd, buf + 21, reply, reply_size);
2569 } else if (os_strncmp(buf, "NFC_REPORT_HANDOVER ", 20) == 0) {
2570 if (hostapd_ctrl_iface_nfc_report_handover(hapd, buf + 20))
2571 reply_len = -1;
2572 #endif /* CONFIG_WPS_NFC */
2573 #endif /* CONFIG_WPS */
2574 #ifdef CONFIG_INTERWORKING
2575 } else if (os_strncmp(buf, "SET_QOS_MAP_SET ", 16) == 0) {
2576 if (hostapd_ctrl_iface_set_qos_map_set(hapd, buf + 16))
2577 reply_len = -1;
2578 } else if (os_strncmp(buf, "SEND_QOS_MAP_CONF ", 18) == 0) {
2579 if (hostapd_ctrl_iface_send_qos_map_conf(hapd, buf + 18))
2580 reply_len = -1;
2581 #endif /* CONFIG_INTERWORKING */
2582 #ifdef CONFIG_HS20
2583 } else if (os_strncmp(buf, "HS20_WNM_NOTIF ", 15) == 0) {
2584 if (hostapd_ctrl_iface_hs20_wnm_notif(hapd, buf + 15))
2585 reply_len = -1;
2586 } else if (os_strncmp(buf, "HS20_DEAUTH_REQ ", 16) == 0) {
2587 if (hostapd_ctrl_iface_hs20_deauth_req(hapd, buf + 16))
2588 reply_len = -1;
2589 #endif /* CONFIG_HS20 */
2590 #ifdef CONFIG_WNM
2591 } else if (os_strncmp(buf, "DISASSOC_IMMINENT ", 18) == 0) {
2592 if (hostapd_ctrl_iface_disassoc_imminent(hapd, buf + 18))
2593 reply_len = -1;
2594 } else if (os_strncmp(buf, "ESS_DISASSOC ", 13) == 0) {
2595 if (hostapd_ctrl_iface_ess_disassoc(hapd, buf + 13))
2596 reply_len = -1;
2597 } else if (os_strncmp(buf, "BSS_TM_REQ ", 11) == 0) {
2598 if (hostapd_ctrl_iface_bss_tm_req(hapd, buf + 11))
2599 reply_len = -1;
2600 #endif /* CONFIG_WNM */
2601 } else if (os_strcmp(buf, "GET_CONFIG") == 0) {
2602 reply_len = hostapd_ctrl_iface_get_config(hapd, reply,
2603 reply_size);
2604 } else if (os_strncmp(buf, "SET ", 4) == 0) {
2605 if (hostapd_ctrl_iface_set(hapd, buf + 4))
2606 reply_len = -1;
2607 } else if (os_strncmp(buf, "GET ", 4) == 0) {
2608 reply_len = hostapd_ctrl_iface_get(hapd, buf + 4, reply,
2609 reply_size);
2610 } else if (os_strncmp(buf, "ENABLE", 6) == 0) {
2611 if (hostapd_ctrl_iface_enable(hapd->iface))
2612 reply_len = -1;
2613 } else if (os_strncmp(buf, "RELOAD", 6) == 0) {
2614 if (hostapd_ctrl_iface_reload(hapd->iface))
2615 reply_len = -1;
2616 } else if (os_strncmp(buf, "DISABLE", 7) == 0) {
2617 if (hostapd_ctrl_iface_disable(hapd->iface))
2618 reply_len = -1;
2619 } else if (os_strcmp(buf, "UPDATE_BEACON") == 0) {
2620 if (ieee802_11_set_beacon(hapd))
2621 reply_len = -1;
2622 #ifdef CONFIG_TESTING_OPTIONS
2623 } else if (os_strncmp(buf, "RADAR ", 6) == 0) {
2624 if (hostapd_ctrl_iface_radar(hapd, buf + 6))
2625 reply_len = -1;
2626 } else if (os_strncmp(buf, "MGMT_TX ", 8) == 0) {
2627 if (hostapd_ctrl_iface_mgmt_tx(hapd, buf + 8))
2628 reply_len = -1;
2629 } else if (os_strncmp(buf, "MGMT_RX_PROCESS ", 16) == 0) {
2630 if (hostapd_ctrl_iface_mgmt_rx_process(hapd, buf + 16) < 0)
2631 reply_len = -1;
2632 } else if (os_strncmp(buf, "EAPOL_RX ", 9) == 0) {
2633 if (hostapd_ctrl_iface_eapol_rx(hapd, buf + 9) < 0)
2634 reply_len = -1;
2635 } else if (os_strncmp(buf, "DATA_TEST_CONFIG ", 17) == 0) {
2636 if (hostapd_ctrl_iface_data_test_config(hapd, buf + 17) < 0)
2637 reply_len = -1;
2638 } else if (os_strncmp(buf, "DATA_TEST_TX ", 13) == 0) {
2639 if (hostapd_ctrl_iface_data_test_tx(hapd, buf + 13) < 0)
2640 reply_len = -1;
2641 } else if (os_strncmp(buf, "DATA_TEST_FRAME ", 16) == 0) {
2642 if (hostapd_ctrl_iface_data_test_frame(hapd, buf + 16) < 0)
2643 reply_len = -1;
2644 } else if (os_strncmp(buf, "TEST_ALLOC_FAIL ", 16) == 0) {
2645 if (hostapd_ctrl_test_alloc_fail(hapd, buf + 16) < 0)
2646 reply_len = -1;
2647 } else if (os_strcmp(buf, "GET_ALLOC_FAIL") == 0) {
2648 reply_len = hostapd_ctrl_get_alloc_fail(hapd, reply,
2649 reply_size);
2650 } else if (os_strncmp(buf, "TEST_FAIL ", 10) == 0) {
2651 if (hostapd_ctrl_test_fail(hapd, buf + 10) < 0)
2652 reply_len = -1;
2653 } else if (os_strcmp(buf, "GET_FAIL") == 0) {
2654 reply_len = hostapd_ctrl_get_fail(hapd, reply, reply_size);
2655 #endif /* CONFIG_TESTING_OPTIONS */
2656 } else if (os_strncmp(buf, "CHAN_SWITCH ", 12) == 0) {
2657 if (hostapd_ctrl_iface_chan_switch(hapd->iface, buf + 12))
2658 reply_len = -1;
2659 } else if (os_strncmp(buf, "VENDOR ", 7) == 0) {
2660 reply_len = hostapd_ctrl_iface_vendor(hapd, buf + 7, reply,
2661 reply_size);
2662 } else if (os_strcmp(buf, "ERP_FLUSH") == 0) {
2663 ieee802_1x_erp_flush(hapd);
2664 #ifdef RADIUS_SERVER
2665 radius_server_erp_flush(hapd->radius_srv);
2666 #endif /* RADIUS_SERVER */
2667 } else if (os_strncmp(buf, "EAPOL_REAUTH ", 13) == 0) {
2668 if (hostapd_ctrl_iface_eapol_reauth(hapd, buf + 13))
2669 reply_len = -1;
2670 } else if (os_strncmp(buf, "EAPOL_SET ", 10) == 0) {
2671 if (hostapd_ctrl_iface_eapol_set(hapd, buf + 10))
2672 reply_len = -1;
2673 } else if (os_strncmp(buf, "LOG_LEVEL", 9) == 0) {
2674 reply_len = hostapd_ctrl_iface_log_level(
2675 hapd, buf + 9, reply, reply_size);
2676 #ifdef NEED_AP_MLME
2677 } else if (os_strcmp(buf, "TRACK_STA_LIST") == 0) {
2678 reply_len = hostapd_ctrl_iface_track_sta_list(
2679 hapd, reply, reply_size);
2680 #endif /* NEED_AP_MLME */
2681 } else if (os_strcmp(buf, "PMKSA") == 0) {
2682 reply_len = hostapd_ctrl_iface_pmksa_list(hapd, reply,
2683 reply_size);
2684 } else if (os_strcmp(buf, "PMKSA_FLUSH") == 0) {
2685 hostapd_ctrl_iface_pmksa_flush(hapd);
2686 } else if (os_strncmp(buf, "SET_NEIGHBOR ", 13) == 0) {
2687 if (hostapd_ctrl_iface_set_neighbor(hapd, buf + 13))
2688 reply_len = -1;
2689 } else if (os_strncmp(buf, "REMOVE_NEIGHBOR ", 16) == 0) {
2690 if (hostapd_ctrl_iface_remove_neighbor(hapd, buf + 16))
2691 reply_len = -1;
2692 } else if (os_strncmp(buf, "REQ_LCI ", 8) == 0) {
2693 if (hostapd_ctrl_iface_req_lci(hapd, buf + 8))
2694 reply_len = -1;
2695 } else if (os_strncmp(buf, "REQ_RANGE ", 10) == 0) {
2696 if (hostapd_ctrl_iface_req_range(hapd, buf + 10))
2697 reply_len = -1;
2698 } else if (os_strncmp(buf, "REQ_BEACON ", 11) == 0) {
2699 reply_len = hostapd_ctrl_iface_req_beacon(hapd, buf + 11,
2700 reply, reply_size);
2701 } else if (os_strcmp(buf, "DRIVER_FLAGS") == 0) {
2702 reply_len = hostapd_ctrl_driver_flags(hapd->iface, reply,
2703 reply_size);
2704 } else if (os_strcmp(buf, "TERMINATE") == 0) {
2705 eloop_terminate();
2706 } else {
2707 os_memcpy(reply, "UNKNOWN COMMAND\n", 16);
2708 reply_len = 16;
2709 }
2710
2711 if (reply_len < 0) {
2712 os_memcpy(reply, "FAIL\n", 5);
2713 reply_len = 5;
2714 }
2715
2716 return reply_len;
2717 }
2718
2719
2720 static void hostapd_ctrl_iface_receive(int sock, void *eloop_ctx,
2721 void *sock_ctx)
2722 {
2723 struct hostapd_data *hapd = eloop_ctx;
2724 char buf[4096];
2725 int res;
2726 struct sockaddr_storage from;
2727 socklen_t fromlen = sizeof(from);
2728 char *reply, *pos = buf;
2729 const int reply_size = 4096;
2730 int reply_len;
2731 int level = MSG_DEBUG;
2732 #ifdef CONFIG_CTRL_IFACE_UDP
2733 unsigned char lcookie[COOKIE_LEN];
2734 #endif /* CONFIG_CTRL_IFACE_UDP */
2735
2736 res = recvfrom(sock, buf, sizeof(buf) - 1, 0,
2737 (struct sockaddr *) &from, &fromlen);
2738 if (res < 0) {
2739 wpa_printf(MSG_ERROR, "recvfrom(ctrl_iface): %s",
2740 strerror(errno));
2741 return;
2742 }
2743 buf[res] = '\0';
2744
2745 reply = os_malloc(reply_size);
2746 if (reply == NULL) {
2747 if (sendto(sock, "FAIL\n", 5, 0, (struct sockaddr *) &from,
2748 fromlen) < 0) {
2749 wpa_printf(MSG_DEBUG, "CTRL: sendto failed: %s",
2750 strerror(errno));
2751 }
2752 return;
2753 }
2754
2755 #ifdef CONFIG_CTRL_IFACE_UDP
2756 if (os_strcmp(buf, "GET_COOKIE") == 0) {
2757 os_memcpy(reply, "COOKIE=", 7);
2758 wpa_snprintf_hex(reply + 7, 2 * COOKIE_LEN + 1,
2759 cookie, COOKIE_LEN);
2760 reply_len = 7 + 2 * COOKIE_LEN;
2761 goto done;
2762 }
2763
2764 if (os_strncmp(buf, "COOKIE=", 7) != 0 ||
2765 hexstr2bin(buf + 7, lcookie, COOKIE_LEN) < 0) {
2766 wpa_printf(MSG_DEBUG,
2767 "CTRL: No cookie in the request - drop request");
2768 os_free(reply);
2769 return;
2770 }
2771
2772 if (os_memcmp(cookie, lcookie, COOKIE_LEN) != 0) {
2773 wpa_printf(MSG_DEBUG,
2774 "CTRL: Invalid cookie in the request - drop request");
2775 os_free(reply);
2776 return;
2777 }
2778
2779 pos = buf + 7 + 2 * COOKIE_LEN;
2780 while (*pos == ' ')
2781 pos++;
2782 #endif /* CONFIG_CTRL_IFACE_UDP */
2783
2784 if (os_strcmp(pos, "PING") == 0)
2785 level = MSG_EXCESSIVE;
2786 wpa_hexdump_ascii(level, "RX ctrl_iface", pos, res);
2787
2788 reply_len = hostapd_ctrl_iface_receive_process(hapd, pos,
2789 reply, reply_size,
2790 &from, fromlen);
2791
2792 #ifdef CONFIG_CTRL_IFACE_UDP
2793 done:
2794 #endif /* CONFIG_CTRL_IFACE_UDP */
2795 if (sendto(sock, reply, reply_len, 0, (struct sockaddr *) &from,
2796 fromlen) < 0) {
2797 wpa_printf(MSG_DEBUG, "CTRL: sendto failed: %s",
2798 strerror(errno));
2799 }
2800 os_free(reply);
2801 }
2802
2803
2804 #ifndef CONFIG_CTRL_IFACE_UDP
2805 static char * hostapd_ctrl_iface_path(struct hostapd_data *hapd)
2806 {
2807 char *buf;
2808 size_t len;
2809
2810 if (hapd->conf->ctrl_interface == NULL)
2811 return NULL;
2812
2813 len = os_strlen(hapd->conf->ctrl_interface) +
2814 os_strlen(hapd->conf->iface) + 2;
2815 buf = os_malloc(len);
2816 if (buf == NULL)
2817 return NULL;
2818
2819 os_snprintf(buf, len, "%s/%s",
2820 hapd->conf->ctrl_interface, hapd->conf->iface);
2821 buf[len - 1] = '\0';
2822 return buf;
2823 }
2824 #endif /* CONFIG_CTRL_IFACE_UDP */
2825
2826
2827 static void hostapd_ctrl_iface_msg_cb(void *ctx, int level,
2828 enum wpa_msg_type type,
2829 const char *txt, size_t len)
2830 {
2831 struct hostapd_data *hapd = ctx;
2832 if (hapd == NULL)
2833 return;
2834 hostapd_ctrl_iface_send(hapd, level, type, txt, len);
2835 }
2836
2837
2838 int hostapd_ctrl_iface_init(struct hostapd_data *hapd)
2839 {
2840 #ifdef CONFIG_CTRL_IFACE_UDP
2841 int port = HOSTAPD_CTRL_IFACE_PORT;
2842 char p[32] = { 0 };
2843 char port_str[40], *tmp;
2844 char *pos;
2845 struct addrinfo hints = { 0 }, *res, *saveres;
2846 int n;
2847
2848 if (hapd->ctrl_sock > -1) {
2849 wpa_printf(MSG_DEBUG, "ctrl_iface already exists!");
2850 return 0;
2851 }
2852
2853 if (hapd->conf->ctrl_interface == NULL)
2854 return 0;
2855
2856 pos = os_strstr(hapd->conf->ctrl_interface, "udp:");
2857 if (pos) {
2858 pos += 4;
2859 port = atoi(pos);
2860 if (port <= 0) {
2861 wpa_printf(MSG_ERROR, "Invalid ctrl_iface UDP port");
2862 goto fail;
2863 }
2864 }
2865
2866 dl_list_init(&hapd->ctrl_dst);
2867 hapd->ctrl_sock = -1;
2868 os_get_random(cookie, COOKIE_LEN);
2869
2870 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE
2871 hints.ai_flags = AI_PASSIVE;
2872 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
2873
2874 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6
2875 hints.ai_family = AF_INET6;
2876 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */
2877 hints.ai_family = AF_INET;
2878 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */
2879 hints.ai_socktype = SOCK_DGRAM;
2880
2881 try_again:
2882 os_snprintf(p, sizeof(p), "%d", port);
2883 n = getaddrinfo(NULL, p, &hints, &res);
2884 if (n) {
2885 wpa_printf(MSG_ERROR, "getaddrinfo(): %s", gai_strerror(n));
2886 goto fail;
2887 }
2888
2889 saveres = res;
2890 hapd->ctrl_sock = socket(res->ai_family, res->ai_socktype,
2891 res->ai_protocol);
2892 if (hapd->ctrl_sock < 0) {
2893 wpa_printf(MSG_ERROR, "socket(PF_INET): %s", strerror(errno));
2894 goto fail;
2895 }
2896
2897 if (bind(hapd->ctrl_sock, res->ai_addr, res->ai_addrlen) < 0) {
2898 port--;
2899 if ((HOSTAPD_CTRL_IFACE_PORT - port) <
2900 HOSTAPD_CTRL_IFACE_PORT_LIMIT && !pos)
2901 goto try_again;
2902 wpa_printf(MSG_ERROR, "bind(AF_INET): %s", strerror(errno));
2903 goto fail;
2904 }
2905
2906 freeaddrinfo(saveres);
2907
2908 os_snprintf(port_str, sizeof(port_str), "udp:%d", port);
2909 tmp = os_strdup(port_str);
2910 if (tmp) {
2911 os_free(hapd->conf->ctrl_interface);
2912 hapd->conf->ctrl_interface = tmp;
2913 }
2914 wpa_printf(MSG_DEBUG, "ctrl_iface_init UDP port: %d", port);
2915
2916 if (eloop_register_read_sock(hapd->ctrl_sock,
2917 hostapd_ctrl_iface_receive, hapd, NULL) <
2918 0) {
2919 hostapd_ctrl_iface_deinit(hapd);
2920 return -1;
2921 }
2922
2923 hapd->msg_ctx = hapd;
2924 wpa_msg_register_cb(hostapd_ctrl_iface_msg_cb);
2925
2926 return 0;
2927
2928 fail:
2929 if (hapd->ctrl_sock >= 0)
2930 close(hapd->ctrl_sock);
2931 return -1;
2932 #else /* CONFIG_CTRL_IFACE_UDP */
2933 struct sockaddr_un addr;
2934 int s = -1;
2935 char *fname = NULL;
2936
2937 if (hapd->ctrl_sock > -1) {
2938 wpa_printf(MSG_DEBUG, "ctrl_iface already exists!");
2939 return 0;
2940 }
2941
2942 dl_list_init(&hapd->ctrl_dst);
2943
2944 if (hapd->conf->ctrl_interface == NULL)
2945 return 0;
2946
2947 if (mkdir(hapd->conf->ctrl_interface, S_IRWXU | S_IRWXG) < 0) {
2948 if (errno == EEXIST) {
2949 wpa_printf(MSG_DEBUG, "Using existing control "
2950 "interface directory.");
2951 } else {
2952 wpa_printf(MSG_ERROR, "mkdir[ctrl_interface]: %s",
2953 strerror(errno));
2954 goto fail;
2955 }
2956 }
2957
2958 if (hapd->conf->ctrl_interface_gid_set &&
2959 chown(hapd->conf->ctrl_interface, -1,
2960 hapd->conf->ctrl_interface_gid) < 0) {
2961 wpa_printf(MSG_ERROR, "chown[ctrl_interface]: %s",
2962 strerror(errno));
2963 return -1;
2964 }
2965
2966 if (!hapd->conf->ctrl_interface_gid_set &&
2967 hapd->iface->interfaces->ctrl_iface_group &&
2968 chown(hapd->conf->ctrl_interface, -1,
2969 hapd->iface->interfaces->ctrl_iface_group) < 0) {
2970 wpa_printf(MSG_ERROR, "chown[ctrl_interface]: %s",
2971 strerror(errno));
2972 return -1;
2973 }
2974
2975 #ifdef ANDROID
2976 /*
2977 * Android is using umask 0077 which would leave the control interface
2978 * directory without group access. This breaks things since Wi-Fi
2979 * framework assumes that this directory can be accessed by other
2980 * applications in the wifi group. Fix this by adding group access even
2981 * if umask value would prevent this.
2982 */
2983 if (chmod(hapd->conf->ctrl_interface, S_IRWXU | S_IRWXG) < 0) {
2984 wpa_printf(MSG_ERROR, "CTRL: Could not chmod directory: %s",
2985 strerror(errno));
2986 /* Try to continue anyway */
2987 }
2988 #endif /* ANDROID */
2989
2990 if (os_strlen(hapd->conf->ctrl_interface) + 1 +
2991 os_strlen(hapd->conf->iface) >= sizeof(addr.sun_path))
2992 goto fail;
2993
2994 s = socket(PF_UNIX, SOCK_DGRAM, 0);
2995 if (s < 0) {
2996 wpa_printf(MSG_ERROR, "socket(PF_UNIX): %s", strerror(errno));
2997 goto fail;
2998 }
2999
3000 os_memset(&addr, 0, sizeof(addr));
3001 #ifdef __FreeBSD__
3002 addr.sun_len = sizeof(addr);
3003 #endif /* __FreeBSD__ */
3004 addr.sun_family = AF_UNIX;
3005 fname = hostapd_ctrl_iface_path(hapd);
3006 if (fname == NULL)
3007 goto fail;
3008 os_strlcpy(addr.sun_path, fname, sizeof(addr.sun_path));
3009 if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
3010 wpa_printf(MSG_DEBUG, "ctrl_iface bind(PF_UNIX) failed: %s",
3011 strerror(errno));
3012 if (connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
3013 wpa_printf(MSG_DEBUG, "ctrl_iface exists, but does not"
3014 " allow connections - assuming it was left"
3015 "over from forced program termination");
3016 if (unlink(fname) < 0) {
3017 wpa_printf(MSG_ERROR,
3018 "Could not unlink existing ctrl_iface socket '%s': %s",
3019 fname, strerror(errno));
3020 goto fail;
3021 }
3022 if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) <
3023 0) {
3024 wpa_printf(MSG_ERROR,
3025 "hostapd-ctrl-iface: bind(PF_UNIX): %s",
3026 strerror(errno));
3027 goto fail;
3028 }
3029 wpa_printf(MSG_DEBUG, "Successfully replaced leftover "
3030 "ctrl_iface socket '%s'", fname);
3031 } else {
3032 wpa_printf(MSG_INFO, "ctrl_iface exists and seems to "
3033 "be in use - cannot override it");
3034 wpa_printf(MSG_INFO, "Delete '%s' manually if it is "
3035 "not used anymore", fname);
3036 os_free(fname);
3037 fname = NULL;
3038 goto fail;
3039 }
3040 }
3041
3042 if (hapd->conf->ctrl_interface_gid_set &&
3043 chown(fname, -1, hapd->conf->ctrl_interface_gid) < 0) {
3044 wpa_printf(MSG_ERROR, "chown[ctrl_interface/ifname]: %s",
3045 strerror(errno));
3046 goto fail;
3047 }
3048
3049 if (!hapd->conf->ctrl_interface_gid_set &&
3050 hapd->iface->interfaces->ctrl_iface_group &&
3051 chown(fname, -1, hapd->iface->interfaces->ctrl_iface_group) < 0) {
3052 wpa_printf(MSG_ERROR, "chown[ctrl_interface/ifname]: %s",
3053 strerror(errno));
3054 goto fail;
3055 }
3056
3057 if (chmod(fname, S_IRWXU | S_IRWXG) < 0) {
3058 wpa_printf(MSG_ERROR, "chmod[ctrl_interface/ifname]: %s",
3059 strerror(errno));
3060 goto fail;
3061 }
3062 os_free(fname);
3063
3064 hapd->ctrl_sock = s;
3065 if (eloop_register_read_sock(s, hostapd_ctrl_iface_receive, hapd,
3066 NULL) < 0) {
3067 hostapd_ctrl_iface_deinit(hapd);
3068 return -1;
3069 }
3070 hapd->msg_ctx = hapd;
3071 wpa_msg_register_cb(hostapd_ctrl_iface_msg_cb);
3072
3073 return 0;
3074
3075 fail:
3076 if (s >= 0)
3077 close(s);
3078 if (fname) {
3079 unlink(fname);
3080 os_free(fname);
3081 }
3082 return -1;
3083 #endif /* CONFIG_CTRL_IFACE_UDP */
3084 }
3085
3086
3087 void hostapd_ctrl_iface_deinit(struct hostapd_data *hapd)
3088 {
3089 struct wpa_ctrl_dst *dst, *prev;
3090
3091 if (hapd->ctrl_sock > -1) {
3092 #ifndef CONFIG_CTRL_IFACE_UDP
3093 char *fname;
3094 #endif /* !CONFIG_CTRL_IFACE_UDP */
3095
3096 eloop_unregister_read_sock(hapd->ctrl_sock);
3097 close(hapd->ctrl_sock);
3098 hapd->ctrl_sock = -1;
3099 #ifndef CONFIG_CTRL_IFACE_UDP
3100 fname = hostapd_ctrl_iface_path(hapd);
3101 if (fname)
3102 unlink(fname);
3103 os_free(fname);
3104
3105 if (hapd->conf->ctrl_interface &&
3106 rmdir(hapd->conf->ctrl_interface) < 0) {
3107 if (errno == ENOTEMPTY) {
3108 wpa_printf(MSG_DEBUG, "Control interface "
3109 "directory not empty - leaving it "
3110 "behind");
3111 } else {
3112 wpa_printf(MSG_ERROR,
3113 "rmdir[ctrl_interface=%s]: %s",
3114 hapd->conf->ctrl_interface,
3115 strerror(errno));
3116 }
3117 }
3118 #endif /* !CONFIG_CTRL_IFACE_UDP */
3119 }
3120
3121 dl_list_for_each_safe(dst, prev, &hapd->ctrl_dst, struct wpa_ctrl_dst,
3122 list)
3123 os_free(dst);
3124
3125 #ifdef CONFIG_TESTING_OPTIONS
3126 l2_packet_deinit(hapd->l2_test);
3127 hapd->l2_test = NULL;
3128 #endif /* CONFIG_TESTING_OPTIONS */
3129 }
3130
3131
3132 static int hostapd_ctrl_iface_add(struct hapd_interfaces *interfaces,
3133 char *buf)
3134 {
3135 if (hostapd_add_iface(interfaces, buf) < 0) {
3136 wpa_printf(MSG_ERROR, "Adding interface %s failed", buf);
3137 return -1;
3138 }
3139 return 0;
3140 }
3141
3142
3143 static int hostapd_ctrl_iface_remove(struct hapd_interfaces *interfaces,
3144 char *buf)
3145 {
3146 if (hostapd_remove_iface(interfaces, buf) < 0) {
3147 wpa_printf(MSG_ERROR, "Removing interface %s failed", buf);
3148 return -1;
3149 }
3150 return 0;
3151 }
3152
3153
3154 static int hostapd_global_ctrl_iface_attach(struct hapd_interfaces *interfaces,
3155 struct sockaddr_storage *from,
3156 socklen_t fromlen)
3157 {
3158 return ctrl_iface_attach(&interfaces->global_ctrl_dst, from, fromlen);
3159 }
3160
3161
3162 static int hostapd_global_ctrl_iface_detach(struct hapd_interfaces *interfaces,
3163 struct sockaddr_storage *from,
3164 socklen_t fromlen)
3165 {
3166 return ctrl_iface_detach(&interfaces->global_ctrl_dst, from, fromlen);
3167 }
3168
3169
3170 static void hostapd_ctrl_iface_flush(struct hapd_interfaces *interfaces)
3171 {
3172 #ifdef CONFIG_WPS_TESTING
3173 wps_version_number = 0x20;
3174 wps_testing_dummy_cred = 0;
3175 wps_corrupt_pkhash = 0;
3176 #endif /* CONFIG_WPS_TESTING */
3177 }
3178
3179
3180 #ifdef CONFIG_FST
3181
3182 static int
3183 hostapd_global_ctrl_iface_fst_attach(struct hapd_interfaces *interfaces,
3184 const char *cmd)
3185 {
3186 char ifname[IFNAMSIZ + 1];
3187 struct fst_iface_cfg cfg;
3188 struct hostapd_data *hapd;
3189 struct fst_wpa_obj iface_obj;
3190
3191 if (!fst_parse_attach_command(cmd, ifname, sizeof(ifname), &cfg)) {
3192 hapd = hostapd_get_iface(interfaces, ifname);
3193 if (hapd) {
3194 if (hapd->iface->fst) {
3195 wpa_printf(MSG_INFO, "FST: Already attached");
3196 return -1;
3197 }
3198 fst_hostapd_fill_iface_obj(hapd, &iface_obj);
3199 hapd->iface->fst = fst_attach(ifname, hapd->own_addr,
3200 &iface_obj, &cfg);
3201 if (hapd->iface->fst)
3202 return 0;
3203 }
3204 }
3205
3206 return -EINVAL;
3207 }
3208
3209
3210 static int
3211 hostapd_global_ctrl_iface_fst_detach(struct hapd_interfaces *interfaces,
3212 const char *cmd)
3213 {
3214 char ifname[IFNAMSIZ + 1];
3215 struct hostapd_data * hapd;
3216
3217 if (!fst_parse_detach_command(cmd, ifname, sizeof(ifname))) {
3218 hapd = hostapd_get_iface(interfaces, ifname);
3219 if (hapd) {
3220 if (!fst_iface_detach(ifname)) {
3221 hapd->iface->fst = NULL;
3222 hapd->iface->fst_ies = NULL;
3223 return 0;
3224 }
3225 }
3226 }
3227
3228 return -EINVAL;
3229 }
3230
3231 #endif /* CONFIG_FST */
3232
3233
3234 static struct hostapd_data *
3235 hostapd_interfaces_get_hapd(struct hapd_interfaces *interfaces,
3236 const char *ifname)
3237 {
3238 size_t i, j;
3239
3240 for (i = 0; i < interfaces->count; i++) {
3241 struct hostapd_iface *iface = interfaces->iface[i];
3242
3243 for (j = 0; j < iface->num_bss; j++) {
3244 struct hostapd_data *hapd;
3245
3246 hapd = iface->bss[j];
3247 if (os_strcmp(ifname, hapd->conf->iface) == 0)
3248 return hapd;
3249 }
3250 }
3251
3252 return NULL;
3253 }
3254
3255
3256 static int hostapd_ctrl_iface_dup_param(struct hostapd_data *src_hapd,
3257 struct hostapd_data *dst_hapd,
3258 const char *param)
3259 {
3260 int res;
3261 char *value;
3262
3263 value = os_zalloc(HOSTAPD_CLI_DUP_VALUE_MAX_LEN);
3264 if (!value) {
3265 wpa_printf(MSG_ERROR,
3266 "DUP: cannot allocate buffer to stringify %s",
3267 param);
3268 goto error_return;
3269 }
3270
3271 if (os_strcmp(param, "wpa") == 0) {
3272 os_snprintf(value, HOSTAPD_CLI_DUP_VALUE_MAX_LEN, "%d",
3273 src_hapd->conf->wpa);
3274 } else if (os_strcmp(param, "wpa_key_mgmt") == 0 &&
3275 src_hapd->conf->wpa_key_mgmt) {
3276 res = hostapd_ctrl_iface_get_key_mgmt(
3277 src_hapd, value, HOSTAPD_CLI_DUP_VALUE_MAX_LEN);
3278 if (os_snprintf_error(HOSTAPD_CLI_DUP_VALUE_MAX_LEN, res))
3279 goto error_stringify;
3280 } else if (os_strcmp(param, "wpa_pairwise") == 0 &&
3281 src_hapd->conf->wpa_pairwise) {
3282 res = wpa_write_ciphers(value,
3283 value + HOSTAPD_CLI_DUP_VALUE_MAX_LEN,
3284 src_hapd->conf->wpa_pairwise, " ");
3285 if (res < 0)
3286 goto error_stringify;
3287 } else if (os_strcmp(param, "rsn_pairwise") == 0 &&
3288 src_hapd->conf->rsn_pairwise) {
3289 res = wpa_write_ciphers(value,
3290 value + HOSTAPD_CLI_DUP_VALUE_MAX_LEN,
3291 src_hapd->conf->rsn_pairwise, " ");
3292 if (res < 0)
3293 goto error_stringify;
3294 } else if (os_strcmp(param, "wpa_passphrase") == 0 &&
3295 src_hapd->conf->ssid.wpa_passphrase) {
3296 os_snprintf(value, HOSTAPD_CLI_DUP_VALUE_MAX_LEN, "%s",
3297 src_hapd->conf->ssid.wpa_passphrase);
3298 } else if (os_strcmp(param, "wpa_psk") == 0 &&
3299 src_hapd->conf->ssid.wpa_psk_set) {
3300 wpa_snprintf_hex(value, HOSTAPD_CLI_DUP_VALUE_MAX_LEN,
3301 src_hapd->conf->ssid.wpa_psk->psk, PMK_LEN);
3302 } else {
3303 wpa_printf(MSG_WARNING, "DUP: %s cannot be duplicated", param);
3304 goto error_return;
3305 }
3306
3307 res = hostapd_set_iface(dst_hapd->iconf, dst_hapd->conf, param, value);
3308 os_free(value);
3309 return res;
3310
3311 error_stringify:
3312 wpa_printf(MSG_ERROR, "DUP: cannot stringify %s", param);
3313 error_return:
3314 os_free(value);
3315 return -1;
3316 }
3317
3318
3319 static int
3320 hostapd_global_ctrl_iface_interfaces(struct hapd_interfaces *interfaces,
3321 const char *input,
3322 char *reply, int reply_size)
3323 {
3324 size_t i, j;
3325 int res;
3326 char *pos, *end;
3327 struct hostapd_iface *iface;
3328 int show_ctrl = 0;
3329
3330 if (input)
3331 show_ctrl = !!os_strstr(input, "ctrl");
3332
3333 pos = reply;
3334 end = reply + reply_size;
3335
3336 for (i = 0; i < interfaces->count; i++) {
3337 iface = interfaces->iface[i];
3338
3339 for (j = 0; j < iface->num_bss; j++) {
3340 struct hostapd_bss_config *conf;
3341
3342 conf = iface->conf->bss[j];
3343 if (show_ctrl)
3344 res = os_snprintf(pos, end - pos,
3345 "%s ctrl_iface=%s\n",
3346 conf->iface,
3347 conf->ctrl_interface ?
3348 conf->ctrl_interface : "N/A");
3349 else
3350 res = os_snprintf(pos, end - pos, "%s\n",
3351 conf->iface);
3352 if (os_snprintf_error(end - pos, res)) {
3353 *pos = '\0';
3354 return pos - reply;
3355 }
3356 pos += res;
3357 }
3358 }
3359
3360 return pos - reply;
3361 }
3362
3363
3364 static int
3365 hostapd_global_ctrl_iface_dup_network(struct hapd_interfaces *interfaces,
3366 char *cmd)
3367 {
3368 char *p_start = cmd, *p_end;
3369 struct hostapd_data *src_hapd, *dst_hapd;
3370
3371 /* cmd: "<src ifname> <dst ifname> <variable name> */
3372
3373 p_end = os_strchr(p_start, ' ');
3374 if (!p_end) {
3375 wpa_printf(MSG_ERROR, "DUP: no src ifname found in cmd: '%s'",
3376 cmd);
3377 return -1;
3378 }
3379
3380 *p_end = '\0';
3381 src_hapd = hostapd_interfaces_get_hapd(interfaces, p_start);
3382 if (!src_hapd) {
3383 wpa_printf(MSG_ERROR, "DUP: no src ifname found: '%s'",
3384 p_start);
3385 return -1;
3386 }
3387
3388 p_start = p_end + 1;
3389 p_end = os_strchr(p_start, ' ');
3390 if (!p_end) {
3391 wpa_printf(MSG_ERROR, "DUP: no dst ifname found in cmd: '%s'",
3392 cmd);
3393 return -1;
3394 }
3395
3396 *p_end = '\0';
3397 dst_hapd = hostapd_interfaces_get_hapd(interfaces, p_start);
3398 if (!dst_hapd) {
3399 wpa_printf(MSG_ERROR, "DUP: no dst ifname found: '%s'",
3400 p_start);
3401 return -1;
3402 }
3403
3404 p_start = p_end + 1;
3405 return hostapd_ctrl_iface_dup_param(src_hapd, dst_hapd, p_start);
3406 }
3407
3408
3409 static int hostapd_global_ctrl_iface_ifname(struct hapd_interfaces *interfaces,
3410 const char *ifname,
3411 char *buf, char *reply,
3412 int reply_size,
3413 struct sockaddr_storage *from,
3414 socklen_t fromlen)
3415 {
3416 struct hostapd_data *hapd;
3417
3418 hapd = hostapd_interfaces_get_hapd(interfaces, ifname);
3419 if (hapd == NULL) {
3420 int res;
3421
3422 res = os_snprintf(reply, reply_size, "FAIL-NO-IFNAME-MATCH\n");
3423 if (os_snprintf_error(reply_size, res))
3424 return -1;
3425 return res;
3426 }
3427
3428 return hostapd_ctrl_iface_receive_process(hapd, buf, reply,reply_size,
3429 from, fromlen);
3430 }
3431
3432
3433 static void hostapd_global_ctrl_iface_receive(int sock, void *eloop_ctx,
3434 void *sock_ctx)
3435 {
3436 void *interfaces = eloop_ctx;
3437 char buffer[256], *buf = buffer;
3438 int res;
3439 struct sockaddr_storage from;
3440 socklen_t fromlen = sizeof(from);
3441 char *reply;
3442 int reply_len;
3443 const int reply_size = 4096;
3444 #ifdef CONFIG_CTRL_IFACE_UDP
3445 unsigned char lcookie[COOKIE_LEN];
3446 #endif /* CONFIG_CTRL_IFACE_UDP */
3447
3448 res = recvfrom(sock, buffer, sizeof(buffer) - 1, 0,
3449 (struct sockaddr *) &from, &fromlen);
3450 if (res < 0) {
3451 wpa_printf(MSG_ERROR, "recvfrom(ctrl_iface): %s",
3452 strerror(errno));
3453 return;
3454 }
3455 buf[res] = '\0';
3456 wpa_printf(MSG_DEBUG, "Global ctrl_iface command: %s", buf);
3457
3458 reply = os_malloc(reply_size);
3459 if (reply == NULL) {
3460 if (sendto(sock, "FAIL\n", 5, 0, (struct sockaddr *) &from,
3461 fromlen) < 0) {
3462 wpa_printf(MSG_DEBUG, "CTRL: sendto failed: %s",
3463 strerror(errno));
3464 }
3465 return;
3466 }
3467
3468 os_memcpy(reply, "OK\n", 3);
3469 reply_len = 3;
3470
3471 #ifdef CONFIG_CTRL_IFACE_UDP
3472 if (os_strcmp(buf, "GET_COOKIE") == 0) {
3473 os_memcpy(reply, "COOKIE=", 7);
3474 wpa_snprintf_hex(reply + 7, 2 * COOKIE_LEN + 1,
3475 gcookie, COOKIE_LEN);
3476 reply_len = 7 + 2 * COOKIE_LEN;
3477 goto send_reply;
3478 }
3479
3480 if (os_strncmp(buf, "COOKIE=", 7) != 0 ||
3481 hexstr2bin(buf + 7, lcookie, COOKIE_LEN) < 0) {
3482 wpa_printf(MSG_DEBUG,
3483 "CTRL: No cookie in the request - drop request");
3484 os_free(reply);
3485 return;
3486 }
3487
3488 if (os_memcmp(gcookie, lcookie, COOKIE_LEN) != 0) {
3489 wpa_printf(MSG_DEBUG,
3490 "CTRL: Invalid cookie in the request - drop request");
3491 os_free(reply);
3492 return;
3493 }
3494
3495 buf += 7 + 2 * COOKIE_LEN;
3496 while (*buf == ' ')
3497 buf++;
3498 #endif /* CONFIG_CTRL_IFACE_UDP */
3499
3500 if (os_strncmp(buf, "IFNAME=", 7) == 0) {
3501 char *pos = os_strchr(buf + 7, ' ');
3502
3503 if (pos) {
3504 *pos++ = '\0';
3505 reply_len = hostapd_global_ctrl_iface_ifname(
3506 interfaces, buf + 7, pos, reply, reply_size,
3507 &from, fromlen);
3508 goto send_reply;
3509 }
3510 }
3511
3512 if (os_strcmp(buf, "PING") == 0) {
3513 os_memcpy(reply, "PONG\n", 5);
3514 reply_len = 5;
3515 } else if (os_strncmp(buf, "RELOG", 5) == 0) {
3516 if (wpa_debug_reopen_file() < 0)
3517 reply_len = -1;
3518 } else if (os_strcmp(buf, "FLUSH") == 0) {
3519 hostapd_ctrl_iface_flush(interfaces);
3520 } else if (os_strncmp(buf, "ADD ", 4) == 0) {
3521 if (hostapd_ctrl_iface_add(interfaces, buf + 4) < 0)
3522 reply_len = -1;
3523 } else if (os_strncmp(buf, "REMOVE ", 7) == 0) {
3524 if (hostapd_ctrl_iface_remove(interfaces, buf + 7) < 0)
3525 reply_len = -1;
3526 } else if (os_strcmp(buf, "ATTACH") == 0) {
3527 if (hostapd_global_ctrl_iface_attach(interfaces, &from,
3528 fromlen))
3529 reply_len = -1;
3530 } else if (os_strcmp(buf, "DETACH") == 0) {
3531 if (hostapd_global_ctrl_iface_detach(interfaces, &from,
3532 fromlen))
3533 reply_len = -1;
3534 #ifdef CONFIG_MODULE_TESTS
3535 } else if (os_strcmp(buf, "MODULE_TESTS") == 0) {
3536 if (hapd_module_tests() < 0)
3537 reply_len = -1;
3538 #endif /* CONFIG_MODULE_TESTS */
3539 #ifdef CONFIG_FST
3540 } else if (os_strncmp(buf, "FST-ATTACH ", 11) == 0) {
3541 if (!hostapd_global_ctrl_iface_fst_attach(interfaces, buf + 11))
3542 reply_len = os_snprintf(reply, reply_size, "OK\n");
3543 else
3544 reply_len = -1;
3545 } else if (os_strncmp(buf, "FST-DETACH ", 11) == 0) {
3546 if (!hostapd_global_ctrl_iface_fst_detach(interfaces, buf + 11))
3547 reply_len = os_snprintf(reply, reply_size, "OK\n");
3548 else
3549 reply_len = -1;
3550 } else if (os_strncmp(buf, "FST-MANAGER ", 12) == 0) {
3551 reply_len = fst_ctrl_iface_receive(buf + 12, reply, reply_size);
3552 #endif /* CONFIG_FST */
3553 } else if (os_strncmp(buf, "DUP_NETWORK ", 12) == 0) {
3554 if (!hostapd_global_ctrl_iface_dup_network(interfaces,
3555 buf + 12))
3556 reply_len = os_snprintf(reply, reply_size, "OK\n");
3557 else
3558 reply_len = -1;
3559 } else if (os_strncmp(buf, "INTERFACES", 10) == 0) {
3560 reply_len = hostapd_global_ctrl_iface_interfaces(
3561 interfaces, buf + 10, reply, sizeof(buffer));
3562 } else if (os_strcmp(buf, "TERMINATE") == 0) {
3563 eloop_terminate();
3564 } else {
3565 wpa_printf(MSG_DEBUG, "Unrecognized global ctrl_iface command "
3566 "ignored");
3567 reply_len = -1;
3568 }
3569
3570 send_reply:
3571 if (reply_len < 0) {
3572 os_memcpy(reply, "FAIL\n", 5);
3573 reply_len = 5;
3574 }
3575
3576 if (sendto(sock, reply, reply_len, 0, (struct sockaddr *) &from,
3577 fromlen) < 0) {
3578 wpa_printf(MSG_DEBUG, "CTRL: sendto failed: %s",
3579 strerror(errno));
3580 }
3581 os_free(reply);
3582 }
3583
3584
3585 #ifndef CONFIG_CTRL_IFACE_UDP
3586 static char * hostapd_global_ctrl_iface_path(struct hapd_interfaces *interface)
3587 {
3588 char *buf;
3589 size_t len;
3590
3591 if (interface->global_iface_path == NULL)
3592 return NULL;
3593
3594 len = os_strlen(interface->global_iface_path) +
3595 os_strlen(interface->global_iface_name) + 2;
3596 buf = os_malloc(len);
3597 if (buf == NULL)
3598 return NULL;
3599
3600 os_snprintf(buf, len, "%s/%s", interface->global_iface_path,
3601 interface->global_iface_name);
3602 buf[len - 1] = '\0';
3603 return buf;
3604 }
3605 #endif /* CONFIG_CTRL_IFACE_UDP */
3606
3607
3608 int hostapd_global_ctrl_iface_init(struct hapd_interfaces *interface)
3609 {
3610 #ifdef CONFIG_CTRL_IFACE_UDP
3611 int port = HOSTAPD_GLOBAL_CTRL_IFACE_PORT;
3612 char p[32] = { 0 };
3613 char *pos;
3614 struct addrinfo hints = { 0 }, *res, *saveres;
3615 int n;
3616
3617 if (interface->global_ctrl_sock > -1) {
3618 wpa_printf(MSG_DEBUG, "ctrl_iface already exists!");
3619 return 0;
3620 }
3621
3622 if (interface->global_iface_path == NULL)
3623 return 0;
3624
3625 pos = os_strstr(interface->global_iface_path, "udp:");
3626 if (pos) {
3627 pos += 4;
3628 port = atoi(pos);
3629 if (port <= 0) {
3630 wpa_printf(MSG_ERROR, "Invalid global ctrl UDP port");
3631 goto fail;
3632 }
3633 }
3634
3635 os_get_random(gcookie, COOKIE_LEN);
3636
3637 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE
3638 hints.ai_flags = AI_PASSIVE;
3639 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
3640
3641 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6
3642 hints.ai_family = AF_INET6;
3643 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */
3644 hints.ai_family = AF_INET;
3645 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */
3646 hints.ai_socktype = SOCK_DGRAM;
3647
3648 try_again:
3649 os_snprintf(p, sizeof(p), "%d", port);
3650 n = getaddrinfo(NULL, p, &hints, &res);
3651 if (n) {
3652 wpa_printf(MSG_ERROR, "getaddrinfo(): %s", gai_strerror(n));
3653 goto fail;
3654 }
3655
3656 saveres = res;
3657 interface->global_ctrl_sock = socket(res->ai_family, res->ai_socktype,
3658 res->ai_protocol);
3659 if (interface->global_ctrl_sock < 0) {
3660 wpa_printf(MSG_ERROR, "socket(PF_INET): %s", strerror(errno));
3661 goto fail;
3662 }
3663
3664 if (bind(interface->global_ctrl_sock, res->ai_addr, res->ai_addrlen) <
3665 0) {
3666 port++;
3667 if ((port - HOSTAPD_GLOBAL_CTRL_IFACE_PORT) <
3668 HOSTAPD_GLOBAL_CTRL_IFACE_PORT_LIMIT && !pos)
3669 goto try_again;
3670 wpa_printf(MSG_ERROR, "bind(AF_INET): %s", strerror(errno));
3671 goto fail;
3672 }
3673
3674 freeaddrinfo(saveres);
3675
3676 wpa_printf(MSG_DEBUG, "global ctrl_iface_init UDP port: %d", port);
3677
3678 if (eloop_register_read_sock(interface->global_ctrl_sock,
3679 hostapd_global_ctrl_iface_receive,
3680 interface, NULL) < 0) {
3681 hostapd_global_ctrl_iface_deinit(interface);
3682 return -1;
3683 }
3684
3685 return 0;
3686
3687 fail:
3688 if (interface->global_ctrl_sock >= 0)
3689 close(interface->global_ctrl_sock);
3690 return -1;
3691 #else /* CONFIG_CTRL_IFACE_UDP */
3692 struct sockaddr_un addr;
3693 int s = -1;
3694 char *fname = NULL;
3695
3696 if (interface->global_iface_path == NULL) {
3697 wpa_printf(MSG_DEBUG, "ctrl_iface not configured!");
3698 return 0;
3699 }
3700
3701 if (mkdir(interface->global_iface_path, S_IRWXU | S_IRWXG) < 0) {
3702 if (errno == EEXIST) {
3703 wpa_printf(MSG_DEBUG, "Using existing control "
3704 "interface directory.");
3705 } else {
3706 wpa_printf(MSG_ERROR, "mkdir[ctrl_interface]: %s",
3707 strerror(errno));
3708 goto fail;
3709 }
3710 } else if (interface->ctrl_iface_group &&
3711 chown(interface->global_iface_path, -1,
3712 interface->ctrl_iface_group) < 0) {
3713 wpa_printf(MSG_ERROR, "chown[ctrl_interface]: %s",
3714 strerror(errno));
3715 goto fail;
3716 }
3717
3718 if (os_strlen(interface->global_iface_path) + 1 +
3719 os_strlen(interface->global_iface_name) >= sizeof(addr.sun_path))
3720 goto fail;
3721
3722 s = socket(PF_UNIX, SOCK_DGRAM, 0);
3723 if (s < 0) {
3724 wpa_printf(MSG_ERROR, "socket(PF_UNIX): %s", strerror(errno));
3725 goto fail;
3726 }
3727
3728 os_memset(&addr, 0, sizeof(addr));
3729 #ifdef __FreeBSD__
3730 addr.sun_len = sizeof(addr);
3731 #endif /* __FreeBSD__ */
3732 addr.sun_family = AF_UNIX;
3733 fname = hostapd_global_ctrl_iface_path(interface);
3734 if (fname == NULL)
3735 goto fail;
3736 os_strlcpy(addr.sun_path, fname, sizeof(addr.sun_path));
3737 if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
3738 wpa_printf(MSG_DEBUG, "ctrl_iface bind(PF_UNIX) failed: %s",
3739 strerror(errno));
3740 if (connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
3741 wpa_printf(MSG_DEBUG, "ctrl_iface exists, but does not"
3742 " allow connections - assuming it was left"
3743 "over from forced program termination");
3744 if (unlink(fname) < 0) {
3745 wpa_printf(MSG_ERROR,
3746 "Could not unlink existing ctrl_iface socket '%s': %s",
3747 fname, strerror(errno));
3748 goto fail;
3749 }
3750 if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) <
3751 0) {
3752 wpa_printf(MSG_ERROR, "bind(PF_UNIX): %s",
3753 strerror(errno));
3754 goto fail;
3755 }
3756 wpa_printf(MSG_DEBUG, "Successfully replaced leftover "
3757 "ctrl_iface socket '%s'", fname);
3758 } else {
3759 wpa_printf(MSG_INFO, "ctrl_iface exists and seems to "
3760 "be in use - cannot override it");
3761 wpa_printf(MSG_INFO, "Delete '%s' manually if it is "
3762 "not used anymore", fname);
3763 os_free(fname);
3764 fname = NULL;
3765 goto fail;
3766 }
3767 }
3768
3769 if (interface->ctrl_iface_group &&
3770 chown(fname, -1, interface->ctrl_iface_group) < 0) {
3771 wpa_printf(MSG_ERROR, "chown[ctrl_interface]: %s",
3772 strerror(errno));
3773 goto fail;
3774 }
3775
3776 if (chmod(fname, S_IRWXU | S_IRWXG) < 0) {
3777 wpa_printf(MSG_ERROR, "chmod[ctrl_interface/ifname]: %s",
3778 strerror(errno));
3779 goto fail;
3780 }
3781 os_free(fname);
3782
3783 interface->global_ctrl_sock = s;
3784 eloop_register_read_sock(s, hostapd_global_ctrl_iface_receive,
3785 interface, NULL);
3786
3787 return 0;
3788
3789 fail:
3790 if (s >= 0)
3791 close(s);
3792 if (fname) {
3793 unlink(fname);
3794 os_free(fname);
3795 }
3796 return -1;
3797 #endif /* CONFIG_CTRL_IFACE_UDP */
3798 }
3799
3800
3801 void hostapd_global_ctrl_iface_deinit(struct hapd_interfaces *interfaces)
3802 {
3803 #ifndef CONFIG_CTRL_IFACE_UDP
3804 char *fname = NULL;
3805 #endif /* CONFIG_CTRL_IFACE_UDP */
3806 struct wpa_ctrl_dst *dst, *prev;
3807
3808 if (interfaces->global_ctrl_sock > -1) {
3809 eloop_unregister_read_sock(interfaces->global_ctrl_sock);
3810 close(interfaces->global_ctrl_sock);
3811 interfaces->global_ctrl_sock = -1;
3812 #ifndef CONFIG_CTRL_IFACE_UDP
3813 fname = hostapd_global_ctrl_iface_path(interfaces);
3814 if (fname) {
3815 unlink(fname);
3816 os_free(fname);
3817 }
3818
3819 if (interfaces->global_iface_path &&
3820 rmdir(interfaces->global_iface_path) < 0) {
3821 if (errno == ENOTEMPTY) {
3822 wpa_printf(MSG_DEBUG, "Control interface "
3823 "directory not empty - leaving it "
3824 "behind");
3825 } else {
3826 wpa_printf(MSG_ERROR,
3827 "rmdir[ctrl_interface=%s]: %s",
3828 interfaces->global_iface_path,
3829 strerror(errno));
3830 }
3831 }
3832 #endif /* CONFIG_CTRL_IFACE_UDP */
3833 }
3834
3835 os_free(interfaces->global_iface_path);
3836 interfaces->global_iface_path = NULL;
3837
3838 dl_list_for_each_safe(dst, prev, &interfaces->global_ctrl_dst,
3839 struct wpa_ctrl_dst, list)
3840 os_free(dst);
3841 }
3842
3843
3844 static void hostapd_ctrl_iface_send(struct hostapd_data *hapd, int level,
3845 enum wpa_msg_type type,
3846 const char *buf, size_t len)
3847 {
3848 struct wpa_ctrl_dst *dst, *next;
3849 struct dl_list *ctrl_dst;
3850 struct msghdr msg;
3851 int idx;
3852 struct iovec io[2];
3853 char levelstr[10];
3854 int s;
3855
3856 if (type != WPA_MSG_ONLY_GLOBAL) {
3857 s = hapd->ctrl_sock;
3858 ctrl_dst = &hapd->ctrl_dst;
3859 } else {
3860 s = hapd->iface->interfaces->global_ctrl_sock;
3861 ctrl_dst = &hapd->iface->interfaces->global_ctrl_dst;
3862 }
3863
3864 if (s < 0 || dl_list_empty(ctrl_dst))
3865 return;
3866
3867 os_snprintf(levelstr, sizeof(levelstr), "<%d>", level);
3868 io[0].iov_base = levelstr;
3869 io[0].iov_len = os_strlen(levelstr);
3870 io[1].iov_base = (char *) buf;
3871 io[1].iov_len = len;
3872 os_memset(&msg, 0, sizeof(msg));
3873 msg.msg_iov = io;
3874 msg.msg_iovlen = 2;
3875
3876 idx = 0;
3877 dl_list_for_each_safe(dst, next, ctrl_dst, struct wpa_ctrl_dst, list) {
3878 if (level >= dst->debug_level) {
3879 sockaddr_print(MSG_DEBUG, "CTRL_IFACE monitor send",
3880 &dst->addr, dst->addrlen);
3881 msg.msg_name = &dst->addr;
3882 msg.msg_namelen = dst->addrlen;
3883 if (sendmsg(s, &msg, 0) < 0) {
3884 int _errno = errno;
3885 wpa_printf(MSG_INFO, "CTRL_IFACE monitor[%d]: "
3886 "%d - %s",
3887 idx, errno, strerror(errno));
3888 dst->errors++;
3889 if (dst->errors > 10 || _errno == ENOENT) {
3890 if (type != WPA_MSG_ONLY_GLOBAL)
3891 hostapd_ctrl_iface_detach(
3892 hapd, &dst->addr,
3893 dst->addrlen);
3894 else
3895 hostapd_global_ctrl_iface_detach(
3896 hapd->iface->interfaces,
3897 &dst->addr,
3898 dst->addrlen);
3899 }
3900 } else
3901 dst->errors = 0;
3902 }
3903 idx++;
3904 }
3905 }
3906
3907 #endif /* CONFIG_NATIVE_WINDOWS */
Unnamed repository; edit this file 'description' to name the repository.