]> git.ipfire.org Git - thirdparty/hostap.git/blob - hostapd/ctrl_iface.c
projects / thirdparty / hostap.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
common: Add candidate list parsing helper function
[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 int nei_len;
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 nei_len = ieee802_11_parse_candidate_list(cmd, nei_rep,
892 sizeof(nei_rep));
893 if (nei_len < 0)
894 return -1;
895
896 pos = os_strstr(cmd, " url=");
897 if (pos) {
898 size_t len;
899 pos += 5;
900 end = os_strchr(pos, ' ');
901 if (end)
902 len = end - pos;
903 else
904 len = os_strlen(pos);
905 url = os_malloc(len + 1);
906 if (url == NULL)
907 return -1;
908 os_memcpy(url, pos, len);
909 url[len] = '\0';
910 req_mode |= WNM_BSS_TM_REQ_ESS_DISASSOC_IMMINENT;
911 }
912
913 if (os_strstr(cmd, " pref=1"))
914 req_mode |= WNM_BSS_TM_REQ_PREF_CAND_LIST_INCLUDED;
915 if (os_strstr(cmd, " abridged=1"))
916 req_mode |= WNM_BSS_TM_REQ_ABRIDGED;
917 if (os_strstr(cmd, " disassoc_imminent=1"))
918 req_mode |= WNM_BSS_TM_REQ_DISASSOC_IMMINENT;
919
920 #ifdef CONFIG_MBO
921 pos = os_strstr(cmd, "mbo=");
922 if (pos) {
923 unsigned int mbo_reason, cell_pref, reassoc_delay;
924 u8 *mbo_pos = mbo;
925
926 ret = sscanf(pos, "mbo=%u:%u:%u", &mbo_reason,
927 &reassoc_delay, &cell_pref);
928 if (ret != 3) {
929 wpa_printf(MSG_DEBUG,
930 "MBO requires three arguments: mbo=<reason>:<reassoc_delay>:<cell_pref>");
931 ret = -1;
932 goto fail;
933 }
934
935 if (mbo_reason > MBO_TRANSITION_REASON_PREMIUM_AP) {
936 wpa_printf(MSG_DEBUG,
937 "Invalid MBO transition reason code %u",
938 mbo_reason);
939 ret = -1;
940 goto fail;
941 }
942
943 /* Valid values for Cellular preference are: 0, 1, 255 */
944 if (cell_pref != 0 && cell_pref != 1 && cell_pref != 255) {
945 wpa_printf(MSG_DEBUG,
946 "Invalid MBO cellular capability %u",
947 cell_pref);
948 ret = -1;
949 goto fail;
950 }
951
952 if (reassoc_delay > 65535 ||
953 (reassoc_delay &&
954 !(req_mode & WNM_BSS_TM_REQ_DISASSOC_IMMINENT))) {
955 wpa_printf(MSG_DEBUG,
956 "MBO: Assoc retry delay is only valid in disassoc imminent mode");
957 ret = -1;
958 goto fail;
959 }
960
961 *mbo_pos++ = MBO_ATTR_ID_TRANSITION_REASON;
962 *mbo_pos++ = 1;
963 *mbo_pos++ = mbo_reason;
964 *mbo_pos++ = MBO_ATTR_ID_CELL_DATA_PREF;
965 *mbo_pos++ = 1;
966 *mbo_pos++ = cell_pref;
967
968 if (reassoc_delay) {
969 *mbo_pos++ = MBO_ATTR_ID_ASSOC_RETRY_DELAY;
970 *mbo_pos++ = 2;
971 WPA_PUT_LE16(mbo_pos, reassoc_delay);
972 mbo_pos += 2;
973 }
974
975 mbo_len = mbo_pos - mbo;
976 }
977 #endif /* CONFIG_MBO */
978
979 ret = wnm_send_bss_tm_req(hapd, sta, req_mode, disassoc_timer,
980 valid_int, bss_term_dur, url,
981 nei_len ? nei_rep : NULL, nei_len,
982 mbo_len ? mbo : NULL, mbo_len);
983 #ifdef CONFIG_MBO
984 fail:
985 #endif /* CONFIG_MBO */
986 os_free(url);
987 return ret;
988 }
989
990 #endif /* CONFIG_WNM */
991
992
993 static int hostapd_ctrl_iface_get_key_mgmt(struct hostapd_data *hapd,
994 char *buf, size_t buflen)
995 {
996 int ret = 0;
997 char *pos, *end;
998
999 pos = buf;
1000 end = buf + buflen;
1001
1002 WPA_ASSERT(hapd->conf->wpa_key_mgmt);
1003
1004 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_PSK) {
1005 ret = os_snprintf(pos, end - pos, "WPA-PSK ");
1006 if (os_snprintf_error(end - pos, ret))
1007 return pos - buf;
1008 pos += ret;
1009 }
1010 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X) {
1011 ret = os_snprintf(pos, end - pos, "WPA-EAP ");
1012 if (os_snprintf_error(end - pos, ret))
1013 return pos - buf;
1014 pos += ret;
1015 }
1016 #ifdef CONFIG_IEEE80211R_AP
1017 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_PSK) {
1018 ret = os_snprintf(pos, end - pos, "FT-PSK ");
1019 if (os_snprintf_error(end - pos, ret))
1020 return pos - buf;
1021 pos += ret;
1022 }
1023 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X) {
1024 ret = os_snprintf(pos, end - pos, "FT-EAP ");
1025 if (os_snprintf_error(end - pos, ret))
1026 return pos - buf;
1027 pos += ret;
1028 }
1029 #ifdef CONFIG_SAE
1030 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_SAE) {
1031 ret = os_snprintf(pos, end - pos, "FT-SAE ");
1032 if (os_snprintf_error(end - pos, ret))
1033 return pos - buf;
1034 pos += ret;
1035 }
1036 #endif /* CONFIG_SAE */
1037 #ifdef CONFIG_FILS
1038 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_FILS_SHA256) {
1039 ret = os_snprintf(pos, end - pos, "FT-FILS-SHA256 ");
1040 if (os_snprintf_error(end - pos, ret))
1041 return pos - buf;
1042 pos += ret;
1043 }
1044 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_FILS_SHA384) {
1045 ret = os_snprintf(pos, end - pos, "FT-FILS-SHA384 ");
1046 if (os_snprintf_error(end - pos, ret))
1047 return pos - buf;
1048 pos += ret;
1049 }
1050 #endif /* CONFIG_FILS */
1051 #endif /* CONFIG_IEEE80211R_AP */
1052 #ifdef CONFIG_IEEE80211W
1053 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_PSK_SHA256) {
1054 ret = os_snprintf(pos, end - pos, "WPA-PSK-SHA256 ");
1055 if (os_snprintf_error(end - pos, ret))
1056 return pos - buf;
1057 pos += ret;
1058 }
1059 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA256) {
1060 ret = os_snprintf(pos, end - pos, "WPA-EAP-SHA256 ");
1061 if (os_snprintf_error(end - pos, ret))
1062 return pos - buf;
1063 pos += ret;
1064 }
1065 #endif /* CONFIG_IEEE80211W */
1066 #ifdef CONFIG_SAE
1067 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_SAE) {
1068 ret = os_snprintf(pos, end - pos, "SAE ");
1069 if (os_snprintf_error(end - pos, ret))
1070 return pos - buf;
1071 pos += ret;
1072 }
1073 #endif /* CONFIG_SAE */
1074 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X_SUITE_B) {
1075 ret = os_snprintf(pos, end - pos, "WPA-EAP-SUITE-B ");
1076 if (os_snprintf_error(end - pos, ret))
1077 return pos - buf;
1078 pos += ret;
1079 }
1080 if (hapd->conf->wpa_key_mgmt &
1081 WPA_KEY_MGMT_IEEE8021X_SUITE_B_192) {
1082 ret = os_snprintf(pos, end - pos,
1083 "WPA-EAP-SUITE-B-192 ");
1084 if (os_snprintf_error(end - pos, ret))
1085 return pos - buf;
1086 pos += ret;
1087 }
1088 #ifdef CONFIG_FILS
1089 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_FILS_SHA256) {
1090 ret = os_snprintf(pos, end - pos, "FILS-SHA256 ");
1091 if (os_snprintf_error(end - pos, ret))
1092 return pos - buf;
1093 pos += ret;
1094 }
1095 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_FILS_SHA384) {
1096 ret = os_snprintf(pos, end - pos, "FILS-SHA384 ");
1097 if (os_snprintf_error(end - pos, ret))
1098 return pos - buf;
1099 pos += ret;
1100 }
1101 #endif /* CONFIG_FILS */
1102
1103 if (pos > buf && *(pos - 1) == ' ') {
1104 *(pos - 1) = '\0';
1105 pos--;
1106 }
1107
1108 return pos - buf;
1109 }
1110
1111
1112 static int hostapd_ctrl_iface_get_config(struct hostapd_data *hapd,
1113 char *buf, size_t buflen)
1114 {
1115 int ret;
1116 char *pos, *end;
1117
1118 pos = buf;
1119 end = buf + buflen;
1120
1121 ret = os_snprintf(pos, end - pos, "bssid=" MACSTR "\n"
1122 "ssid=%s\n",
1123 MAC2STR(hapd->own_addr),
1124 wpa_ssid_txt(hapd->conf->ssid.ssid,
1125 hapd->conf->ssid.ssid_len));
1126 if (os_snprintf_error(end - pos, ret))
1127 return pos - buf;
1128 pos += ret;
1129
1130 #ifdef CONFIG_WPS
1131 ret = os_snprintf(pos, end - pos, "wps_state=%s\n",
1132 hapd->conf->wps_state == 0 ? "disabled" :
1133 (hapd->conf->wps_state == 1 ? "not configured" :
1134 "configured"));
1135 if (os_snprintf_error(end - pos, ret))
1136 return pos - buf;
1137 pos += ret;
1138
1139 if (hapd->conf->wps_state && hapd->conf->wpa &&
1140 hapd->conf->ssid.wpa_passphrase) {
1141 ret = os_snprintf(pos, end - pos, "passphrase=%s\n",
1142 hapd->conf->ssid.wpa_passphrase);
1143 if (os_snprintf_error(end - pos, ret))
1144 return pos - buf;
1145 pos += ret;
1146 }
1147
1148 if (hapd->conf->wps_state && hapd->conf->wpa &&
1149 hapd->conf->ssid.wpa_psk &&
1150 hapd->conf->ssid.wpa_psk->group) {
1151 char hex[PMK_LEN * 2 + 1];
1152 wpa_snprintf_hex(hex, sizeof(hex),
1153 hapd->conf->ssid.wpa_psk->psk, PMK_LEN);
1154 ret = os_snprintf(pos, end - pos, "psk=%s\n", hex);
1155 if (os_snprintf_error(end - pos, ret))
1156 return pos - buf;
1157 pos += ret;
1158 }
1159 #endif /* CONFIG_WPS */
1160
1161 if (hapd->conf->wpa) {
1162 ret = os_snprintf(pos, end - pos, "wpa=%d\n", hapd->conf->wpa);
1163 if (os_snprintf_error(end - pos, ret))
1164 return pos - buf;
1165 pos += ret;
1166 }
1167
1168 if (hapd->conf->wpa && hapd->conf->wpa_key_mgmt) {
1169 ret = os_snprintf(pos, end - pos, "key_mgmt=");
1170 if (os_snprintf_error(end - pos, ret))
1171 return pos - buf;
1172 pos += ret;
1173
1174 pos += hostapd_ctrl_iface_get_key_mgmt(hapd, pos, end - pos);
1175
1176 ret = os_snprintf(pos, end - pos, "\n");
1177 if (os_snprintf_error(end - pos, ret))
1178 return pos - buf;
1179 pos += ret;
1180 }
1181
1182 if (hapd->conf->wpa) {
1183 ret = os_snprintf(pos, end - pos, "group_cipher=%s\n",
1184 wpa_cipher_txt(hapd->conf->wpa_group));
1185 if (os_snprintf_error(end - pos, ret))
1186 return pos - buf;
1187 pos += ret;
1188 }
1189
1190 if ((hapd->conf->wpa & WPA_PROTO_RSN) && hapd->conf->rsn_pairwise) {
1191 ret = os_snprintf(pos, end - pos, "rsn_pairwise_cipher=");
1192 if (os_snprintf_error(end - pos, ret))
1193 return pos - buf;
1194 pos += ret;
1195
1196 ret = wpa_write_ciphers(pos, end, hapd->conf->rsn_pairwise,
1197 " ");
1198 if (ret < 0)
1199 return pos - buf;
1200 pos += ret;
1201
1202 ret = os_snprintf(pos, end - pos, "\n");
1203 if (os_snprintf_error(end - pos, ret))
1204 return pos - buf;
1205 pos += ret;
1206 }
1207
1208 if ((hapd->conf->wpa & WPA_PROTO_WPA) && hapd->conf->wpa_pairwise) {
1209 ret = os_snprintf(pos, end - pos, "wpa_pairwise_cipher=");
1210 if (os_snprintf_error(end - pos, ret))
1211 return pos - buf;
1212 pos += ret;
1213
1214 ret = wpa_write_ciphers(pos, end, hapd->conf->wpa_pairwise,
1215 " ");
1216 if (ret < 0)
1217 return pos - buf;
1218 pos += ret;
1219
1220 ret = os_snprintf(pos, end - pos, "\n");
1221 if (os_snprintf_error(end - pos, ret))
1222 return pos - buf;
1223 pos += ret;
1224 }
1225
1226 return pos - buf;
1227 }
1228
1229
1230 static int hostapd_ctrl_iface_set(struct hostapd_data *hapd, char *cmd)
1231 {
1232 char *value;
1233 int ret = 0;
1234
1235 value = os_strchr(cmd, ' ');
1236 if (value == NULL)
1237 return -1;
1238 *value++ = '\0';
1239
1240 wpa_printf(MSG_DEBUG, "CTRL_IFACE SET '%s'='%s'", cmd, value);
1241 if (0) {
1242 #ifdef CONFIG_WPS_TESTING
1243 } else if (os_strcasecmp(cmd, "wps_version_number") == 0) {
1244 long int val;
1245 val = strtol(value, NULL, 0);
1246 if (val < 0 || val > 0xff) {
1247 ret = -1;
1248 wpa_printf(MSG_DEBUG, "WPS: Invalid "
1249 "wps_version_number %ld", val);
1250 } else {
1251 wps_version_number = val;
1252 wpa_printf(MSG_DEBUG, "WPS: Testing - force WPS "
1253 "version %u.%u",
1254 (wps_version_number & 0xf0) >> 4,
1255 wps_version_number & 0x0f);
1256 hostapd_wps_update_ie(hapd);
1257 }
1258 } else if (os_strcasecmp(cmd, "wps_testing_dummy_cred") == 0) {
1259 wps_testing_dummy_cred = atoi(value);
1260 wpa_printf(MSG_DEBUG, "WPS: Testing - dummy_cred=%d",
1261 wps_testing_dummy_cred);
1262 } else if (os_strcasecmp(cmd, "wps_corrupt_pkhash") == 0) {
1263 wps_corrupt_pkhash = atoi(value);
1264 wpa_printf(MSG_DEBUG, "WPS: Testing - wps_corrupt_pkhash=%d",
1265 wps_corrupt_pkhash);
1266 #endif /* CONFIG_WPS_TESTING */
1267 #ifdef CONFIG_TESTING_OPTIONS
1268 } else if (os_strcasecmp(cmd, "ext_mgmt_frame_handling") == 0) {
1269 hapd->ext_mgmt_frame_handling = atoi(value);
1270 } else if (os_strcasecmp(cmd, "ext_eapol_frame_io") == 0) {
1271 hapd->ext_eapol_frame_io = atoi(value);
1272 #endif /* CONFIG_TESTING_OPTIONS */
1273 #ifdef CONFIG_MBO
1274 } else if (os_strcasecmp(cmd, "mbo_assoc_disallow") == 0) {
1275 int val;
1276
1277 if (!hapd->conf->mbo_enabled)
1278 return -1;
1279
1280 val = atoi(value);
1281 if (val < 0 || val > 1)
1282 return -1;
1283
1284 hapd->mbo_assoc_disallow = val;
1285 ieee802_11_update_beacons(hapd->iface);
1286
1287 /*
1288 * TODO: Need to configure drivers that do AP MLME offload with
1289 * disallowing station logic.
1290 */
1291 #endif /* CONFIG_MBO */
1292 } else {
1293 struct sta_info *sta;
1294 struct vlan_description vlan_id;
1295
1296 ret = hostapd_set_iface(hapd->iconf, hapd->conf, cmd, value);
1297 if (ret)
1298 return ret;
1299
1300 if (os_strcasecmp(cmd, "deny_mac_file") == 0) {
1301 for (sta = hapd->sta_list; sta; sta = sta->next) {
1302 if (hostapd_maclist_found(
1303 hapd->conf->deny_mac,
1304 hapd->conf->num_deny_mac, sta->addr,
1305 &vlan_id) &&
1306 (!vlan_id.notempty ||
1307 !vlan_compare(&vlan_id, sta->vlan_desc)))
1308 ap_sta_disconnect(
1309 hapd, sta, sta->addr,
1310 WLAN_REASON_UNSPECIFIED);
1311 }
1312 } else if (hapd->conf->macaddr_acl == DENY_UNLESS_ACCEPTED &&
1313 os_strcasecmp(cmd, "accept_mac_file") == 0) {
1314 for (sta = hapd->sta_list; sta; sta = sta->next) {
1315 if (!hostapd_maclist_found(
1316 hapd->conf->accept_mac,
1317 hapd->conf->num_accept_mac,
1318 sta->addr, &vlan_id) ||
1319 (vlan_id.notempty &&
1320 vlan_compare(&vlan_id, sta->vlan_desc)))
1321 ap_sta_disconnect(
1322 hapd, sta, sta->addr,
1323 WLAN_REASON_UNSPECIFIED);
1324 }
1325 }
1326 }
1327
1328 return ret;
1329 }
1330
1331
1332 static int hostapd_ctrl_iface_get(struct hostapd_data *hapd, char *cmd,
1333 char *buf, size_t buflen)
1334 {
1335 int res;
1336
1337 wpa_printf(MSG_DEBUG, "CTRL_IFACE GET '%s'", cmd);
1338
1339 if (os_strcmp(cmd, "version") == 0) {
1340 res = os_snprintf(buf, buflen, "%s", VERSION_STR);
1341 if (os_snprintf_error(buflen, res))
1342 return -1;
1343 return res;
1344 } else if (os_strcmp(cmd, "tls_library") == 0) {
1345 res = tls_get_library_version(buf, buflen);
1346 if (os_snprintf_error(buflen, res))
1347 return -1;
1348 return res;
1349 }
1350
1351 return -1;
1352 }
1353
1354
1355 static int hostapd_ctrl_iface_enable(struct hostapd_iface *iface)
1356 {
1357 if (hostapd_enable_iface(iface) < 0) {
1358 wpa_printf(MSG_ERROR, "Enabling of interface failed");
1359 return -1;
1360 }
1361 return 0;
1362 }
1363
1364
1365 static int hostapd_ctrl_iface_reload(struct hostapd_iface *iface)
1366 {
1367 if (hostapd_reload_iface(iface) < 0) {
1368 wpa_printf(MSG_ERROR, "Reloading of interface failed");
1369 return -1;
1370 }
1371 return 0;
1372 }
1373
1374
1375 static int hostapd_ctrl_iface_disable(struct hostapd_iface *iface)
1376 {
1377 if (hostapd_disable_iface(iface) < 0) {
1378 wpa_printf(MSG_ERROR, "Disabling of interface failed");
1379 return -1;
1380 }
1381 return 0;
1382 }
1383
1384
1385 #ifdef CONFIG_TESTING_OPTIONS
1386
1387 static int hostapd_ctrl_iface_radar(struct hostapd_data *hapd, char *cmd)
1388 {
1389 union wpa_event_data data;
1390 char *pos, *param;
1391 enum wpa_event_type event;
1392
1393 wpa_printf(MSG_DEBUG, "RADAR TEST: %s", cmd);
1394
1395 os_memset(&data, 0, sizeof(data));
1396
1397 param = os_strchr(cmd, ' ');
1398 if (param == NULL)
1399 return -1;
1400 *param++ = '\0';
1401
1402 if (os_strcmp(cmd, "DETECTED") == 0)
1403 event = EVENT_DFS_RADAR_DETECTED;
1404 else if (os_strcmp(cmd, "CAC-FINISHED") == 0)
1405 event = EVENT_DFS_CAC_FINISHED;
1406 else if (os_strcmp(cmd, "CAC-ABORTED") == 0)
1407 event = EVENT_DFS_CAC_ABORTED;
1408 else if (os_strcmp(cmd, "NOP-FINISHED") == 0)
1409 event = EVENT_DFS_NOP_FINISHED;
1410 else {
1411 wpa_printf(MSG_DEBUG, "Unsupported RADAR test command: %s",
1412 cmd);
1413 return -1;
1414 }
1415
1416 pos = os_strstr(param, "freq=");
1417 if (pos)
1418 data.dfs_event.freq = atoi(pos + 5);
1419
1420 pos = os_strstr(param, "ht_enabled=1");
1421 if (pos)
1422 data.dfs_event.ht_enabled = 1;
1423
1424 pos = os_strstr(param, "chan_offset=");
1425 if (pos)
1426 data.dfs_event.chan_offset = atoi(pos + 12);
1427
1428 pos = os_strstr(param, "chan_width=");
1429 if (pos)
1430 data.dfs_event.chan_width = atoi(pos + 11);
1431
1432 pos = os_strstr(param, "cf1=");
1433 if (pos)
1434 data.dfs_event.cf1 = atoi(pos + 4);
1435
1436 pos = os_strstr(param, "cf2=");
1437 if (pos)
1438 data.dfs_event.cf2 = atoi(pos + 4);
1439
1440 wpa_supplicant_event(hapd, event, &data);
1441
1442 return 0;
1443 }
1444
1445
1446 static int hostapd_ctrl_iface_mgmt_tx(struct hostapd_data *hapd, char *cmd)
1447 {
1448 size_t len;
1449 u8 *buf;
1450 int res;
1451
1452 wpa_printf(MSG_DEBUG, "External MGMT TX: %s", cmd);
1453
1454 len = os_strlen(cmd);
1455 if (len & 1)
1456 return -1;
1457 len /= 2;
1458
1459 buf = os_malloc(len);
1460 if (buf == NULL)
1461 return -1;
1462
1463 if (hexstr2bin(cmd, buf, len) < 0) {
1464 os_free(buf);
1465 return -1;
1466 }
1467
1468 res = hostapd_drv_send_mlme(hapd, buf, len, 0);
1469 os_free(buf);
1470 return res;
1471 }
1472
1473
1474 static int hostapd_ctrl_iface_mgmt_rx_process(struct hostapd_data *hapd,
1475 char *cmd)
1476 {
1477 char *pos, *param;
1478 size_t len;
1479 u8 *buf;
1480 int freq = 0, datarate = 0, ssi_signal = 0;
1481 union wpa_event_data event;
1482
1483 if (!hapd->ext_mgmt_frame_handling)
1484 return -1;
1485
1486 /* freq=<MHz> datarate=<val> ssi_signal=<val> frame=<frame hexdump> */
1487
1488 wpa_printf(MSG_DEBUG, "External MGMT RX process: %s", cmd);
1489
1490 pos = cmd;
1491 param = os_strstr(pos, "freq=");
1492 if (param) {
1493 param += 5;
1494 freq = atoi(param);
1495 }
1496
1497 param = os_strstr(pos, " datarate=");
1498 if (param) {
1499 param += 10;
1500 datarate = atoi(param);
1501 }
1502
1503 param = os_strstr(pos, " ssi_signal=");
1504 if (param) {
1505 param += 12;
1506 ssi_signal = atoi(param);
1507 }
1508
1509 param = os_strstr(pos, " frame=");
1510 if (param == NULL)
1511 return -1;
1512 param += 7;
1513
1514 len = os_strlen(param);
1515 if (len & 1)
1516 return -1;
1517 len /= 2;
1518
1519 buf = os_malloc(len);
1520 if (buf == NULL)
1521 return -1;
1522
1523 if (hexstr2bin(param, buf, len) < 0) {
1524 os_free(buf);
1525 return -1;
1526 }
1527
1528 os_memset(&event, 0, sizeof(event));
1529 event.rx_mgmt.freq = freq;
1530 event.rx_mgmt.frame = buf;
1531 event.rx_mgmt.frame_len = len;
1532 event.rx_mgmt.ssi_signal = ssi_signal;
1533 event.rx_mgmt.datarate = datarate;
1534 hapd->ext_mgmt_frame_handling = 0;
1535 wpa_supplicant_event(hapd, EVENT_RX_MGMT, &event);
1536 hapd->ext_mgmt_frame_handling = 1;
1537
1538 os_free(buf);
1539
1540 return 0;
1541 }
1542
1543
1544 static int hostapd_ctrl_iface_eapol_rx(struct hostapd_data *hapd, char *cmd)
1545 {
1546 char *pos;
1547 u8 src[ETH_ALEN], *buf;
1548 int used;
1549 size_t len;
1550
1551 wpa_printf(MSG_DEBUG, "External EAPOL RX: %s", cmd);
1552
1553 pos = cmd;
1554 used = hwaddr_aton2(pos, src);
1555 if (used < 0)
1556 return -1;
1557 pos += used;
1558 while (*pos == ' ')
1559 pos++;
1560
1561 len = os_strlen(pos);
1562 if (len & 1)
1563 return -1;
1564 len /= 2;
1565
1566 buf = os_malloc(len);
1567 if (buf == NULL)
1568 return -1;
1569
1570 if (hexstr2bin(pos, buf, len) < 0) {
1571 os_free(buf);
1572 return -1;
1573 }
1574
1575 ieee802_1x_receive(hapd, src, buf, len);
1576 os_free(buf);
1577
1578 return 0;
1579 }
1580
1581
1582 static u16 ipv4_hdr_checksum(const void *buf, size_t len)
1583 {
1584 size_t i;
1585 u32 sum = 0;
1586 const u16 *pos = buf;
1587
1588 for (i = 0; i < len / 2; i++)
1589 sum += *pos++;
1590
1591 while (sum >> 16)
1592 sum = (sum & 0xffff) + (sum >> 16);
1593
1594 return sum ^ 0xffff;
1595 }
1596
1597
1598 #define HWSIM_PACKETLEN 1500
1599 #define HWSIM_IP_LEN (HWSIM_PACKETLEN - sizeof(struct ether_header))
1600
1601 static void hostapd_data_test_rx(void *ctx, const u8 *src_addr, const u8 *buf,
1602 size_t len)
1603 {
1604 struct hostapd_data *hapd = ctx;
1605 const struct ether_header *eth;
1606 struct iphdr ip;
1607 const u8 *pos;
1608 unsigned int i;
1609
1610 if (len != HWSIM_PACKETLEN)
1611 return;
1612
1613 eth = (const struct ether_header *) buf;
1614 os_memcpy(&ip, eth + 1, sizeof(ip));
1615 pos = &buf[sizeof(*eth) + sizeof(ip)];
1616
1617 if (ip.ihl != 5 || ip.version != 4 ||
1618 ntohs(ip.tot_len) != HWSIM_IP_LEN)
1619 return;
1620
1621 for (i = 0; i < HWSIM_IP_LEN - sizeof(ip); i++) {
1622 if (*pos != (u8) i)
1623 return;
1624 pos++;
1625 }
1626
1627 wpa_msg(hapd->msg_ctx, MSG_INFO, "DATA-TEST-RX " MACSTR " " MACSTR,
1628 MAC2STR(eth->ether_dhost), MAC2STR(eth->ether_shost));
1629 }
1630
1631
1632 static int hostapd_ctrl_iface_data_test_config(struct hostapd_data *hapd,
1633 char *cmd)
1634 {
1635 int enabled = atoi(cmd);
1636 char *pos;
1637 const char *ifname;
1638
1639 if (!enabled) {
1640 if (hapd->l2_test) {
1641 l2_packet_deinit(hapd->l2_test);
1642 hapd->l2_test = NULL;
1643 wpa_dbg(hapd->msg_ctx, MSG_DEBUG,
1644 "test data: Disabled");
1645 }
1646 return 0;
1647 }
1648
1649 if (hapd->l2_test)
1650 return 0;
1651
1652 pos = os_strstr(cmd, " ifname=");
1653 if (pos)
1654 ifname = pos + 8;
1655 else
1656 ifname = hapd->conf->iface;
1657
1658 hapd->l2_test = l2_packet_init(ifname, hapd->own_addr,
1659 ETHERTYPE_IP, hostapd_data_test_rx,
1660 hapd, 1);
1661 if (hapd->l2_test == NULL)
1662 return -1;
1663
1664 wpa_dbg(hapd->msg_ctx, MSG_DEBUG, "test data: Enabled");
1665
1666 return 0;
1667 }
1668
1669
1670 static int hostapd_ctrl_iface_data_test_tx(struct hostapd_data *hapd, char *cmd)
1671 {
1672 u8 dst[ETH_ALEN], src[ETH_ALEN];
1673 char *pos;
1674 int used;
1675 long int val;
1676 u8 tos;
1677 u8 buf[2 + HWSIM_PACKETLEN];
1678 struct ether_header *eth;
1679 struct iphdr *ip;
1680 u8 *dpos;
1681 unsigned int i;
1682
1683 if (hapd->l2_test == NULL)
1684 return -1;
1685
1686 /* format: <dst> <src> <tos> */
1687
1688 pos = cmd;
1689 used = hwaddr_aton2(pos, dst);
1690 if (used < 0)
1691 return -1;
1692 pos += used;
1693 while (*pos == ' ')
1694 pos++;
1695 used = hwaddr_aton2(pos, src);
1696 if (used < 0)
1697 return -1;
1698 pos += used;
1699
1700 val = strtol(pos, NULL, 0);
1701 if (val < 0 || val > 0xff)
1702 return -1;
1703 tos = val;
1704
1705 eth = (struct ether_header *) &buf[2];
1706 os_memcpy(eth->ether_dhost, dst, ETH_ALEN);
1707 os_memcpy(eth->ether_shost, src, ETH_ALEN);
1708 eth->ether_type = htons(ETHERTYPE_IP);
1709 ip = (struct iphdr *) (eth + 1);
1710 os_memset(ip, 0, sizeof(*ip));
1711 ip->ihl = 5;
1712 ip->version = 4;
1713 ip->ttl = 64;
1714 ip->tos = tos;
1715 ip->tot_len = htons(HWSIM_IP_LEN);
1716 ip->protocol = 1;
1717 ip->saddr = htonl(192U << 24 | 168 << 16 | 1 << 8 | 1);
1718 ip->daddr = htonl(192U << 24 | 168 << 16 | 1 << 8 | 2);
1719 ip->check = ipv4_hdr_checksum(ip, sizeof(*ip));
1720 dpos = (u8 *) (ip + 1);
1721 for (i = 0; i < HWSIM_IP_LEN - sizeof(*ip); i++)
1722 *dpos++ = i;
1723
1724 if (l2_packet_send(hapd->l2_test, dst, ETHERTYPE_IP, &buf[2],
1725 HWSIM_PACKETLEN) < 0)
1726 return -1;
1727
1728 wpa_dbg(hapd->msg_ctx, MSG_DEBUG, "test data: TX dst=" MACSTR
1729 " src=" MACSTR " tos=0x%x", MAC2STR(dst), MAC2STR(src), tos);
1730
1731 return 0;
1732 }
1733
1734
1735 static int hostapd_ctrl_iface_data_test_frame(struct hostapd_data *hapd,
1736 char *cmd)
1737 {
1738 u8 *buf;
1739 struct ether_header *eth;
1740 struct l2_packet_data *l2 = NULL;
1741 size_t len;
1742 u16 ethertype;
1743 int res = -1;
1744 const char *ifname = hapd->conf->iface;
1745
1746 if (os_strncmp(cmd, "ifname=", 7) == 0) {
1747 cmd += 7;
1748 ifname = cmd;
1749 cmd = os_strchr(cmd, ' ');
1750 if (cmd == NULL)
1751 return -1;
1752 *cmd++ = '\0';
1753 }
1754
1755 len = os_strlen(cmd);
1756 if (len & 1 || len < ETH_HLEN * 2)
1757 return -1;
1758 len /= 2;
1759
1760 buf = os_malloc(len);
1761 if (buf == NULL)
1762 return -1;
1763
1764 if (hexstr2bin(cmd, buf, len) < 0)
1765 goto done;
1766
1767 eth = (struct ether_header *) buf;
1768 ethertype = ntohs(eth->ether_type);
1769
1770 l2 = l2_packet_init(ifname, hapd->own_addr, ethertype,
1771 hostapd_data_test_rx, hapd, 1);
1772 if (l2 == NULL)
1773 goto done;
1774
1775 res = l2_packet_send(l2, eth->ether_dhost, ethertype, buf, len);
1776 wpa_dbg(hapd->msg_ctx, MSG_DEBUG, "test data: TX frame res=%d", res);
1777 done:
1778 if (l2)
1779 l2_packet_deinit(l2);
1780 os_free(buf);
1781
1782 return res < 0 ? -1 : 0;
1783 }
1784
1785
1786 static int hostapd_ctrl_test_alloc_fail(struct hostapd_data *hapd, char *cmd)
1787 {
1788 #ifdef WPA_TRACE_BFD
1789 char *pos;
1790
1791 wpa_trace_fail_after = atoi(cmd);
1792 pos = os_strchr(cmd, ':');
1793 if (pos) {
1794 pos++;
1795 os_strlcpy(wpa_trace_fail_func, pos,
1796 sizeof(wpa_trace_fail_func));
1797 } else {
1798 wpa_trace_fail_after = 0;
1799 }
1800
1801 return 0;
1802 #else /* WPA_TRACE_BFD */
1803 return -1;
1804 #endif /* WPA_TRACE_BFD */
1805 }
1806
1807
1808 static int hostapd_ctrl_get_alloc_fail(struct hostapd_data *hapd,
1809 char *buf, size_t buflen)
1810 {
1811 #ifdef WPA_TRACE_BFD
1812 return os_snprintf(buf, buflen, "%u:%s", wpa_trace_fail_after,
1813 wpa_trace_fail_func);
1814 #else /* WPA_TRACE_BFD */
1815 return -1;
1816 #endif /* WPA_TRACE_BFD */
1817 }
1818
1819
1820 static int hostapd_ctrl_test_fail(struct hostapd_data *hapd, char *cmd)
1821 {
1822 #ifdef WPA_TRACE_BFD
1823 char *pos;
1824
1825 wpa_trace_test_fail_after = atoi(cmd);
1826 pos = os_strchr(cmd, ':');
1827 if (pos) {
1828 pos++;
1829 os_strlcpy(wpa_trace_test_fail_func, pos,
1830 sizeof(wpa_trace_test_fail_func));
1831 } else {
1832 wpa_trace_test_fail_after = 0;
1833 }
1834
1835 return 0;
1836 #else /* WPA_TRACE_BFD */
1837 return -1;
1838 #endif /* WPA_TRACE_BFD */
1839 }
1840
1841
1842 static int hostapd_ctrl_get_fail(struct hostapd_data *hapd,
1843 char *buf, size_t buflen)
1844 {
1845 #ifdef WPA_TRACE_BFD
1846 return os_snprintf(buf, buflen, "%u:%s", wpa_trace_test_fail_after,
1847 wpa_trace_test_fail_func);
1848 #else /* WPA_TRACE_BFD */
1849 return -1;
1850 #endif /* WPA_TRACE_BFD */
1851 }
1852
1853 #endif /* CONFIG_TESTING_OPTIONS */
1854
1855
1856 static int hostapd_ctrl_iface_chan_switch(struct hostapd_iface *iface,
1857 char *pos)
1858 {
1859 #ifdef NEED_AP_MLME
1860 struct csa_settings settings;
1861 int ret;
1862 unsigned int i;
1863
1864 ret = hostapd_parse_csa_settings(pos, &settings);
1865 if (ret)
1866 return ret;
1867
1868 for (i = 0; i < iface->num_bss; i++) {
1869 ret = hostapd_switch_channel(iface->bss[i], &settings);
1870 if (ret) {
1871 /* FIX: What do we do if CSA fails in the middle of
1872 * submitting multi-BSS CSA requests? */
1873 return ret;
1874 }
1875 }
1876
1877 return 0;
1878 #else /* NEED_AP_MLME */
1879 return -1;
1880 #endif /* NEED_AP_MLME */
1881 }
1882
1883
1884 static int hostapd_ctrl_iface_mib(struct hostapd_data *hapd, char *reply,
1885 int reply_size, const char *param)
1886 {
1887 #ifdef RADIUS_SERVER
1888 if (os_strcmp(param, "radius_server") == 0) {
1889 return radius_server_get_mib(hapd->radius_srv, reply,
1890 reply_size);
1891 }
1892 #endif /* RADIUS_SERVER */
1893 return -1;
1894 }
1895
1896
1897 static int hostapd_ctrl_iface_vendor(struct hostapd_data *hapd, char *cmd,
1898 char *buf, size_t buflen)
1899 {
1900 int ret;
1901 char *pos;
1902 u8 *data = NULL;
1903 unsigned int vendor_id, subcmd;
1904 struct wpabuf *reply;
1905 size_t data_len = 0;
1906
1907 /* cmd: <vendor id> <subcommand id> [<hex formatted data>] */
1908 vendor_id = strtoul(cmd, &pos, 16);
1909 if (!isblank((unsigned char) *pos))
1910 return -EINVAL;
1911
1912 subcmd = strtoul(pos, &pos, 10);
1913
1914 if (*pos != '\0') {
1915 if (!isblank((unsigned char) *pos++))
1916 return -EINVAL;
1917 data_len = os_strlen(pos);
1918 }
1919
1920 if (data_len) {
1921 data_len /= 2;
1922 data = os_malloc(data_len);
1923 if (!data)
1924 return -ENOBUFS;
1925
1926 if (hexstr2bin(pos, data, data_len)) {
1927 wpa_printf(MSG_DEBUG,
1928 "Vendor command: wrong parameter format");
1929 os_free(data);
1930 return -EINVAL;
1931 }
1932 }
1933
1934 reply = wpabuf_alloc((buflen - 1) / 2);
1935 if (!reply) {
1936 os_free(data);
1937 return -ENOBUFS;
1938 }
1939
1940 ret = hostapd_drv_vendor_cmd(hapd, vendor_id, subcmd, data, data_len,
1941 reply);
1942
1943 if (ret == 0)
1944 ret = wpa_snprintf_hex(buf, buflen, wpabuf_head_u8(reply),
1945 wpabuf_len(reply));
1946
1947 wpabuf_free(reply);
1948 os_free(data);
1949
1950 return ret;
1951 }
1952
1953
1954 static int hostapd_ctrl_iface_eapol_reauth(struct hostapd_data *hapd,
1955 const char *cmd)
1956 {
1957 u8 addr[ETH_ALEN];
1958 struct sta_info *sta;
1959
1960 if (hwaddr_aton(cmd, addr))
1961 return -1;
1962
1963 sta = ap_get_sta(hapd, addr);
1964 if (!sta || !sta->eapol_sm)
1965 return -1;
1966
1967 eapol_auth_reauthenticate(sta->eapol_sm);
1968 return 0;
1969 }
1970
1971
1972 static int hostapd_ctrl_iface_eapol_set(struct hostapd_data *hapd, char *cmd)
1973 {
1974 u8 addr[ETH_ALEN];
1975 struct sta_info *sta;
1976 char *pos = cmd, *param;
1977
1978 if (hwaddr_aton(pos, addr) || pos[17] != ' ')
1979 return -1;
1980 pos += 18;
1981 param = pos;
1982 pos = os_strchr(pos, ' ');
1983 if (!pos)
1984 return -1;
1985 *pos++ = '\0';
1986
1987 sta = ap_get_sta(hapd, addr);
1988 if (!sta || !sta->eapol_sm)
1989 return -1;
1990
1991 return eapol_auth_set_conf(sta->eapol_sm, param, pos);
1992 }
1993
1994
1995 static int hostapd_ctrl_iface_log_level(struct hostapd_data *hapd, char *cmd,
1996 char *buf, size_t buflen)
1997 {
1998 char *pos, *end, *stamp;
1999 int ret;
2000
2001 /* cmd: "LOG_LEVEL [<level>]" */
2002 if (*cmd == '\0') {
2003 pos = buf;
2004 end = buf + buflen;
2005 ret = os_snprintf(pos, end - pos, "Current level: %s\n"
2006 "Timestamp: %d\n",
2007 debug_level_str(wpa_debug_level),
2008 wpa_debug_timestamp);
2009 if (os_snprintf_error(end - pos, ret))
2010 ret = 0;
2011
2012 return ret;
2013 }
2014
2015 while (*cmd == ' ')
2016 cmd++;
2017
2018 stamp = os_strchr(cmd, ' ');
2019 if (stamp) {
2020 *stamp++ = '\0';
2021 while (*stamp == ' ') {
2022 stamp++;
2023 }
2024 }
2025
2026 if (os_strlen(cmd)) {
2027 int level = str_to_debug_level(cmd);
2028 if (level < 0)
2029 return -1;
2030 wpa_debug_level = level;
2031 }
2032
2033 if (stamp && os_strlen(stamp))
2034 wpa_debug_timestamp = atoi(stamp);
2035
2036 os_memcpy(buf, "OK\n", 3);
2037 return 3;
2038 }
2039
2040
2041 #ifdef NEED_AP_MLME
2042 static int hostapd_ctrl_iface_track_sta_list(struct hostapd_data *hapd,
2043 char *buf, size_t buflen)
2044 {
2045 struct hostapd_iface *iface = hapd->iface;
2046 char *pos, *end;
2047 struct hostapd_sta_info *info;
2048 struct os_reltime now;
2049
2050 if (!iface->num_sta_seen)
2051 return 0;
2052
2053 sta_track_expire(iface, 0);
2054
2055 pos = buf;
2056 end = buf + buflen;
2057
2058 os_get_reltime(&now);
2059 dl_list_for_each_reverse(info, &iface->sta_seen,
2060 struct hostapd_sta_info, list) {
2061 struct os_reltime age;
2062 int ret;
2063
2064 os_reltime_sub(&now, &info->last_seen, &age);
2065 ret = os_snprintf(pos, end - pos, MACSTR " %u %d\n",
2066 MAC2STR(info->addr), (unsigned int) age.sec,
2067 info->ssi_signal);
2068 if (os_snprintf_error(end - pos, ret))
2069 break;
2070 pos += ret;
2071 }
2072
2073 return pos - buf;
2074 }
2075 #endif /* NEED_AP_MLME */
2076
2077
2078 static int hostapd_ctrl_iface_req_lci(struct hostapd_data *hapd,
2079 const char *cmd)
2080 {
2081 u8 addr[ETH_ALEN];
2082
2083 if (hwaddr_aton(cmd, addr)) {
2084 wpa_printf(MSG_INFO, "CTRL: REQ_LCI: Invalid MAC address");
2085 return -1;
2086 }
2087
2088 return hostapd_send_lci_req(hapd, addr);
2089 }
2090
2091
2092 static int hostapd_ctrl_iface_req_range(struct hostapd_data *hapd, char *cmd)
2093 {
2094 u8 addr[ETH_ALEN];
2095 char *token, *context = NULL;
2096 int random_interval, min_ap;
2097 u8 responders[ETH_ALEN * RRM_RANGE_REQ_MAX_RESPONDERS];
2098 unsigned int n_responders;
2099
2100 token = str_token(cmd, " ", &context);
2101 if (!token || hwaddr_aton(token, addr)) {
2102 wpa_printf(MSG_INFO,
2103 "CTRL: REQ_RANGE - Bad destination address");
2104 return -1;
2105 }
2106
2107 token = str_token(cmd, " ", &context);
2108 if (!token)
2109 return -1;
2110
2111 random_interval = atoi(token);
2112 if (random_interval < 0 || random_interval > 0xffff)
2113 return -1;
2114
2115 token = str_token(cmd, " ", &context);
2116 if (!token)
2117 return -1;
2118
2119 min_ap = atoi(token);
2120 if (min_ap <= 0 || min_ap > WLAN_RRM_RANGE_REQ_MAX_MIN_AP)
2121 return -1;
2122
2123 n_responders = 0;
2124 while ((token = str_token(cmd, " ", &context))) {
2125 if (n_responders == RRM_RANGE_REQ_MAX_RESPONDERS) {
2126 wpa_printf(MSG_INFO,
2127 "CTRL: REQ_RANGE: Too many responders");
2128 return -1;
2129 }
2130
2131 if (hwaddr_aton(token, responders + n_responders * ETH_ALEN)) {
2132 wpa_printf(MSG_INFO,
2133 "CTRL: REQ_RANGE: Bad responder address");
2134 return -1;
2135 }
2136
2137 n_responders++;
2138 }
2139
2140 if (!n_responders) {
2141 wpa_printf(MSG_INFO,
2142 "CTRL: REQ_RANGE - No FTM responder address");
2143 return -1;
2144 }
2145
2146 return hostapd_send_range_req(hapd, addr, random_interval, min_ap,
2147 responders, n_responders);
2148 }
2149
2150
2151 static int hostapd_ctrl_iface_req_beacon(struct hostapd_data *hapd,
2152 const char *cmd, char *reply,
2153 size_t reply_size)
2154 {
2155 u8 addr[ETH_ALEN];
2156 const char *pos;
2157 struct wpabuf *req;
2158 int ret;
2159 u8 req_mode = 0;
2160
2161 if (hwaddr_aton(cmd, addr))
2162 return -1;
2163 pos = os_strchr(cmd, ' ');
2164 if (!pos)
2165 return -1;
2166 pos++;
2167 if (os_strncmp(pos, "req_mode=", 9) == 0) {
2168 int val = hex2byte(pos + 9);
2169
2170 if (val < 0)
2171 return -1;
2172 req_mode = val;
2173 pos += 11;
2174 pos = os_strchr(pos, ' ');
2175 if (!pos)
2176 return -1;
2177 pos++;
2178 }
2179 req = wpabuf_parse_bin(pos);
2180 if (!req)
2181 return -1;
2182
2183 ret = hostapd_send_beacon_req(hapd, addr, req_mode, req);
2184 wpabuf_free(req);
2185 if (ret >= 0)
2186 ret = os_snprintf(reply, reply_size, "%d", ret);
2187 return ret;
2188 }
2189
2190
2191 static int hostapd_ctrl_iface_set_neighbor(struct hostapd_data *hapd, char *buf)
2192 {
2193 struct wpa_ssid_value ssid;
2194 u8 bssid[ETH_ALEN];
2195 struct wpabuf *nr, *lci = NULL, *civic = NULL;
2196 int stationary = 0;
2197 char *tmp;
2198 int ret;
2199
2200 if (!(hapd->conf->radio_measurements[0] &
2201 WLAN_RRM_CAPS_NEIGHBOR_REPORT)) {
2202 wpa_printf(MSG_ERROR,
2203 "CTRL: SET_NEIGHBOR: Neighbor report is not enabled");
2204 return -1;
2205 }
2206
2207 if (hwaddr_aton(buf, bssid)) {
2208 wpa_printf(MSG_ERROR, "CTRL: SET_NEIGHBOR: Bad BSSID");
2209 return -1;
2210 }
2211
2212 tmp = os_strstr(buf, "ssid=");
2213 if (!tmp || ssid_parse(tmp + 5, &ssid)) {
2214 wpa_printf(MSG_ERROR,
2215 "CTRL: SET_NEIGHBOR: Bad or missing SSID");
2216 return -1;
2217 }
2218 buf = os_strchr(tmp + 6, tmp[5] == '"' ? '"' : ' ');
2219 if (!buf)
2220 return -1;
2221
2222 tmp = os_strstr(buf, "nr=");
2223 if (!tmp) {
2224 wpa_printf(MSG_ERROR,
2225 "CTRL: SET_NEIGHBOR: Missing Neighbor Report element");
2226 return -1;
2227 }
2228
2229 buf = os_strchr(tmp, ' ');
2230 if (buf)
2231 *buf++ = '\0';
2232
2233 nr = wpabuf_parse_bin(tmp + 3);
2234 if (!nr) {
2235 wpa_printf(MSG_ERROR,
2236 "CTRL: SET_NEIGHBOR: Bad Neighbor Report element");
2237 return -1;
2238 }
2239
2240 if (!buf)
2241 goto set;
2242
2243 tmp = os_strstr(buf, "lci=");
2244 if (tmp) {
2245 buf = os_strchr(tmp, ' ');
2246 if (buf)
2247 *buf++ = '\0';
2248 lci = wpabuf_parse_bin(tmp + 4);
2249 if (!lci) {
2250 wpa_printf(MSG_ERROR,
2251 "CTRL: SET_NEIGHBOR: Bad LCI subelement");
2252 wpabuf_free(nr);
2253 return -1;
2254 }
2255 }
2256
2257 if (!buf)
2258 goto set;
2259
2260 tmp = os_strstr(buf, "civic=");
2261 if (tmp) {
2262 buf = os_strchr(tmp, ' ');
2263 if (buf)
2264 *buf++ = '\0';
2265 civic = wpabuf_parse_bin(tmp + 6);
2266 if (!civic) {
2267 wpa_printf(MSG_ERROR,
2268 "CTRL: SET_NEIGHBOR: Bad civic subelement");
2269 wpabuf_free(nr);
2270 wpabuf_free(lci);
2271 return -1;
2272 }
2273 }
2274
2275 if (!buf)
2276 goto set;
2277
2278 if (os_strstr(buf, "stat"))
2279 stationary = 1;
2280
2281 set:
2282 ret = hostapd_neighbor_set(hapd, bssid, &ssid, nr, lci, civic,
2283 stationary);
2284
2285 wpabuf_free(nr);
2286 wpabuf_free(lci);
2287 wpabuf_free(civic);
2288
2289 return ret;
2290 }
2291
2292
2293 static int hostapd_ctrl_iface_remove_neighbor(struct hostapd_data *hapd,
2294 char *buf)
2295 {
2296 struct wpa_ssid_value ssid;
2297 u8 bssid[ETH_ALEN];
2298 char *tmp;
2299
2300 if (hwaddr_aton(buf, bssid)) {
2301 wpa_printf(MSG_ERROR, "CTRL: REMOVE_NEIGHBOR: Bad BSSID");
2302 return -1;
2303 }
2304
2305 tmp = os_strstr(buf, "ssid=");
2306 if (!tmp || ssid_parse(tmp + 5, &ssid)) {
2307 wpa_printf(MSG_ERROR,
2308 "CTRL: REMOVE_NEIGHBORr: Bad or missing SSID");
2309 return -1;
2310 }
2311
2312 return hostapd_neighbor_remove(hapd, bssid, &ssid);
2313 }
2314
2315
2316 static int hostapd_ctrl_driver_flags(struct hostapd_iface *iface, char *buf,
2317 size_t buflen)
2318 {
2319 int ret, i;
2320 char *pos, *end;
2321
2322 ret = os_snprintf(buf, buflen, "%016llX:\n",
2323 (long long unsigned) iface->drv_flags);
2324 if (os_snprintf_error(buflen, ret))
2325 return -1;
2326
2327 pos = buf + ret;
2328 end = buf + buflen;
2329
2330 for (i = 0; i < 64; i++) {
2331 if (iface->drv_flags & (1LLU << i)) {
2332 ret = os_snprintf(pos, end - pos, "%s\n",
2333 driver_flag_to_string(1LLU << i));
2334 if (os_snprintf_error(end - pos, ret))
2335 return -1;
2336 pos += ret;
2337 }
2338 }
2339
2340 return pos - buf;
2341 }
2342
2343
2344 static int hostapd_ctrl_iface_receive_process(struct hostapd_data *hapd,
2345 char *buf, char *reply,
2346 int reply_size,
2347 struct sockaddr_storage *from,
2348 socklen_t fromlen)
2349 {
2350 int reply_len, res;
2351
2352 os_memcpy(reply, "OK\n", 3);
2353 reply_len = 3;
2354
2355 if (os_strcmp(buf, "PING") == 0) {
2356 os_memcpy(reply, "PONG\n", 5);
2357 reply_len = 5;
2358 } else if (os_strncmp(buf, "RELOG", 5) == 0) {
2359 if (wpa_debug_reopen_file() < 0)
2360 reply_len = -1;
2361 } else if (os_strcmp(buf, "STATUS") == 0) {
2362 reply_len = hostapd_ctrl_iface_status(hapd, reply,
2363 reply_size);
2364 } else if (os_strcmp(buf, "STATUS-DRIVER") == 0) {
2365 reply_len = hostapd_drv_status(hapd, reply, reply_size);
2366 } else if (os_strcmp(buf, "MIB") == 0) {
2367 reply_len = ieee802_11_get_mib(hapd, reply, reply_size);
2368 if (reply_len >= 0) {
2369 res = wpa_get_mib(hapd->wpa_auth, reply + reply_len,
2370 reply_size - reply_len);
2371 if (res < 0)
2372 reply_len = -1;
2373 else
2374 reply_len += res;
2375 }
2376 if (reply_len >= 0) {
2377 res = ieee802_1x_get_mib(hapd, reply + reply_len,
2378 reply_size - reply_len);
2379 if (res < 0)
2380 reply_len = -1;
2381 else
2382 reply_len += res;
2383 }
2384 #ifndef CONFIG_NO_RADIUS
2385 if (reply_len >= 0) {
2386 res = radius_client_get_mib(hapd->radius,
2387 reply + reply_len,
2388 reply_size - reply_len);
2389 if (res < 0)
2390 reply_len = -1;
2391 else
2392 reply_len += res;
2393 }
2394 #endif /* CONFIG_NO_RADIUS */
2395 } else if (os_strncmp(buf, "MIB ", 4) == 0) {
2396 reply_len = hostapd_ctrl_iface_mib(hapd, reply, reply_size,
2397 buf + 4);
2398 } else if (os_strcmp(buf, "STA-FIRST") == 0) {
2399 reply_len = hostapd_ctrl_iface_sta_first(hapd, reply,
2400 reply_size);
2401 } else if (os_strncmp(buf, "STA ", 4) == 0) {
2402 reply_len = hostapd_ctrl_iface_sta(hapd, buf + 4, reply,
2403 reply_size);
2404 } else if (os_strncmp(buf, "STA-NEXT ", 9) == 0) {
2405 reply_len = hostapd_ctrl_iface_sta_next(hapd, buf + 9, reply,
2406 reply_size);
2407 } else if (os_strcmp(buf, "ATTACH") == 0) {
2408 if (hostapd_ctrl_iface_attach(hapd, from, fromlen))
2409 reply_len = -1;
2410 } else if (os_strcmp(buf, "DETACH") == 0) {
2411 if (hostapd_ctrl_iface_detach(hapd, from, fromlen))
2412 reply_len = -1;
2413 } else if (os_strncmp(buf, "LEVEL ", 6) == 0) {
2414 if (hostapd_ctrl_iface_level(hapd, from, fromlen,
2415 buf + 6))
2416 reply_len = -1;
2417 } else if (os_strncmp(buf, "NEW_STA ", 8) == 0) {
2418 if (hostapd_ctrl_iface_new_sta(hapd, buf + 8))
2419 reply_len = -1;
2420 } else if (os_strncmp(buf, "DEAUTHENTICATE ", 15) == 0) {
2421 if (hostapd_ctrl_iface_deauthenticate(hapd, buf + 15))
2422 reply_len = -1;
2423 } else if (os_strncmp(buf, "DISASSOCIATE ", 13) == 0) {
2424 if (hostapd_ctrl_iface_disassociate(hapd, buf + 13))
2425 reply_len = -1;
2426 #ifdef CONFIG_TAXONOMY
2427 } else if (os_strncmp(buf, "SIGNATURE ", 10) == 0) {
2428 reply_len = hostapd_ctrl_iface_signature(hapd, buf + 10,
2429 reply, reply_size);
2430 #endif /* CONFIG_TAXONOMY */
2431 } else if (os_strncmp(buf, "POLL_STA ", 9) == 0) {
2432 if (hostapd_ctrl_iface_poll_sta(hapd, buf + 9))
2433 reply_len = -1;
2434 } else if (os_strcmp(buf, "STOP_AP") == 0) {
2435 if (hostapd_ctrl_iface_stop_ap(hapd))
2436 reply_len = -1;
2437 #ifdef CONFIG_IEEE80211W
2438 #ifdef NEED_AP_MLME
2439 } else if (os_strncmp(buf, "SA_QUERY ", 9) == 0) {
2440 if (hostapd_ctrl_iface_sa_query(hapd, buf + 9))
2441 reply_len = -1;
2442 #endif /* NEED_AP_MLME */
2443 #endif /* CONFIG_IEEE80211W */
2444 #ifdef CONFIG_WPS
2445 } else if (os_strncmp(buf, "WPS_PIN ", 8) == 0) {
2446 if (hostapd_ctrl_iface_wps_pin(hapd, buf + 8))
2447 reply_len = -1;
2448 } else if (os_strncmp(buf, "WPS_CHECK_PIN ", 14) == 0) {
2449 reply_len = hostapd_ctrl_iface_wps_check_pin(
2450 hapd, buf + 14, reply, reply_size);
2451 } else if (os_strcmp(buf, "WPS_PBC") == 0) {
2452 if (hostapd_wps_button_pushed(hapd, NULL))
2453 reply_len = -1;
2454 } else if (os_strcmp(buf, "WPS_CANCEL") == 0) {
2455 if (hostapd_wps_cancel(hapd))
2456 reply_len = -1;
2457 } else if (os_strncmp(buf, "WPS_AP_PIN ", 11) == 0) {
2458 reply_len = hostapd_ctrl_iface_wps_ap_pin(hapd, buf + 11,
2459 reply, reply_size);
2460 } else if (os_strncmp(buf, "WPS_CONFIG ", 11) == 0) {
2461 if (hostapd_ctrl_iface_wps_config(hapd, buf + 11) < 0)
2462 reply_len = -1;
2463 } else if (os_strncmp(buf, "WPS_GET_STATUS", 13) == 0) {
2464 reply_len = hostapd_ctrl_iface_wps_get_status(hapd, reply,
2465 reply_size);
2466 #ifdef CONFIG_WPS_NFC
2467 } else if (os_strncmp(buf, "WPS_NFC_TAG_READ ", 17) == 0) {
2468 if (hostapd_ctrl_iface_wps_nfc_tag_read(hapd, buf + 17))
2469 reply_len = -1;
2470 } else if (os_strncmp(buf, "WPS_NFC_CONFIG_TOKEN ", 21) == 0) {
2471 reply_len = hostapd_ctrl_iface_wps_nfc_config_token(
2472 hapd, buf + 21, reply, reply_size);
2473 } else if (os_strncmp(buf, "WPS_NFC_TOKEN ", 14) == 0) {
2474 reply_len = hostapd_ctrl_iface_wps_nfc_token(
2475 hapd, buf + 14, reply, reply_size);
2476 } else if (os_strncmp(buf, "NFC_GET_HANDOVER_SEL ", 21) == 0) {
2477 reply_len = hostapd_ctrl_iface_nfc_get_handover_sel(
2478 hapd, buf + 21, reply, reply_size);
2479 } else if (os_strncmp(buf, "NFC_REPORT_HANDOVER ", 20) == 0) {
2480 if (hostapd_ctrl_iface_nfc_report_handover(hapd, buf + 20))
2481 reply_len = -1;
2482 #endif /* CONFIG_WPS_NFC */
2483 #endif /* CONFIG_WPS */
2484 #ifdef CONFIG_INTERWORKING
2485 } else if (os_strncmp(buf, "SET_QOS_MAP_SET ", 16) == 0) {
2486 if (hostapd_ctrl_iface_set_qos_map_set(hapd, buf + 16))
2487 reply_len = -1;
2488 } else if (os_strncmp(buf, "SEND_QOS_MAP_CONF ", 18) == 0) {
2489 if (hostapd_ctrl_iface_send_qos_map_conf(hapd, buf + 18))
2490 reply_len = -1;
2491 #endif /* CONFIG_INTERWORKING */
2492 #ifdef CONFIG_HS20
2493 } else if (os_strncmp(buf, "HS20_WNM_NOTIF ", 15) == 0) {
2494 if (hostapd_ctrl_iface_hs20_wnm_notif(hapd, buf + 15))
2495 reply_len = -1;
2496 } else if (os_strncmp(buf, "HS20_DEAUTH_REQ ", 16) == 0) {
2497 if (hostapd_ctrl_iface_hs20_deauth_req(hapd, buf + 16))
2498 reply_len = -1;
2499 #endif /* CONFIG_HS20 */
2500 #ifdef CONFIG_WNM
2501 } else if (os_strncmp(buf, "DISASSOC_IMMINENT ", 18) == 0) {
2502 if (hostapd_ctrl_iface_disassoc_imminent(hapd, buf + 18))
2503 reply_len = -1;
2504 } else if (os_strncmp(buf, "ESS_DISASSOC ", 13) == 0) {
2505 if (hostapd_ctrl_iface_ess_disassoc(hapd, buf + 13))
2506 reply_len = -1;
2507 } else if (os_strncmp(buf, "BSS_TM_REQ ", 11) == 0) {
2508 if (hostapd_ctrl_iface_bss_tm_req(hapd, buf + 11))
2509 reply_len = -1;
2510 #endif /* CONFIG_WNM */
2511 } else if (os_strcmp(buf, "GET_CONFIG") == 0) {
2512 reply_len = hostapd_ctrl_iface_get_config(hapd, reply,
2513 reply_size);
2514 } else if (os_strncmp(buf, "SET ", 4) == 0) {
2515 if (hostapd_ctrl_iface_set(hapd, buf + 4))
2516 reply_len = -1;
2517 } else if (os_strncmp(buf, "GET ", 4) == 0) {
2518 reply_len = hostapd_ctrl_iface_get(hapd, buf + 4, reply,
2519 reply_size);
2520 } else if (os_strncmp(buf, "ENABLE", 6) == 0) {
2521 if (hostapd_ctrl_iface_enable(hapd->iface))
2522 reply_len = -1;
2523 } else if (os_strncmp(buf, "RELOAD", 6) == 0) {
2524 if (hostapd_ctrl_iface_reload(hapd->iface))
2525 reply_len = -1;
2526 } else if (os_strncmp(buf, "DISABLE", 7) == 0) {
2527 if (hostapd_ctrl_iface_disable(hapd->iface))
2528 reply_len = -1;
2529 } else if (os_strcmp(buf, "UPDATE_BEACON") == 0) {
2530 if (ieee802_11_set_beacon(hapd))
2531 reply_len = -1;
2532 #ifdef CONFIG_TESTING_OPTIONS
2533 } else if (os_strncmp(buf, "RADAR ", 6) == 0) {
2534 if (hostapd_ctrl_iface_radar(hapd, buf + 6))
2535 reply_len = -1;
2536 } else if (os_strncmp(buf, "MGMT_TX ", 8) == 0) {
2537 if (hostapd_ctrl_iface_mgmt_tx(hapd, buf + 8))
2538 reply_len = -1;
2539 } else if (os_strncmp(buf, "MGMT_RX_PROCESS ", 16) == 0) {
2540 if (hostapd_ctrl_iface_mgmt_rx_process(hapd, buf + 16) < 0)
2541 reply_len = -1;
2542 } else if (os_strncmp(buf, "EAPOL_RX ", 9) == 0) {
2543 if (hostapd_ctrl_iface_eapol_rx(hapd, buf + 9) < 0)
2544 reply_len = -1;
2545 } else if (os_strncmp(buf, "DATA_TEST_CONFIG ", 17) == 0) {
2546 if (hostapd_ctrl_iface_data_test_config(hapd, buf + 17) < 0)
2547 reply_len = -1;
2548 } else if (os_strncmp(buf, "DATA_TEST_TX ", 13) == 0) {
2549 if (hostapd_ctrl_iface_data_test_tx(hapd, buf + 13) < 0)
2550 reply_len = -1;
2551 } else if (os_strncmp(buf, "DATA_TEST_FRAME ", 16) == 0) {
2552 if (hostapd_ctrl_iface_data_test_frame(hapd, buf + 16) < 0)
2553 reply_len = -1;
2554 } else if (os_strncmp(buf, "TEST_ALLOC_FAIL ", 16) == 0) {
2555 if (hostapd_ctrl_test_alloc_fail(hapd, buf + 16) < 0)
2556 reply_len = -1;
2557 } else if (os_strcmp(buf, "GET_ALLOC_FAIL") == 0) {
2558 reply_len = hostapd_ctrl_get_alloc_fail(hapd, reply,
2559 reply_size);
2560 } else if (os_strncmp(buf, "TEST_FAIL ", 10) == 0) {
2561 if (hostapd_ctrl_test_fail(hapd, buf + 10) < 0)
2562 reply_len = -1;
2563 } else if (os_strcmp(buf, "GET_FAIL") == 0) {
2564 reply_len = hostapd_ctrl_get_fail(hapd, reply, reply_size);
2565 #endif /* CONFIG_TESTING_OPTIONS */
2566 } else if (os_strncmp(buf, "CHAN_SWITCH ", 12) == 0) {
2567 if (hostapd_ctrl_iface_chan_switch(hapd->iface, buf + 12))
2568 reply_len = -1;
2569 } else if (os_strncmp(buf, "VENDOR ", 7) == 0) {
2570 reply_len = hostapd_ctrl_iface_vendor(hapd, buf + 7, reply,
2571 reply_size);
2572 } else if (os_strcmp(buf, "ERP_FLUSH") == 0) {
2573 ieee802_1x_erp_flush(hapd);
2574 #ifdef RADIUS_SERVER
2575 radius_server_erp_flush(hapd->radius_srv);
2576 #endif /* RADIUS_SERVER */
2577 } else if (os_strncmp(buf, "EAPOL_REAUTH ", 13) == 0) {
2578 if (hostapd_ctrl_iface_eapol_reauth(hapd, buf + 13))
2579 reply_len = -1;
2580 } else if (os_strncmp(buf, "EAPOL_SET ", 10) == 0) {
2581 if (hostapd_ctrl_iface_eapol_set(hapd, buf + 10))
2582 reply_len = -1;
2583 } else if (os_strncmp(buf, "LOG_LEVEL", 9) == 0) {
2584 reply_len = hostapd_ctrl_iface_log_level(
2585 hapd, buf + 9, reply, reply_size);
2586 #ifdef NEED_AP_MLME
2587 } else if (os_strcmp(buf, "TRACK_STA_LIST") == 0) {
2588 reply_len = hostapd_ctrl_iface_track_sta_list(
2589 hapd, reply, reply_size);
2590 #endif /* NEED_AP_MLME */
2591 } else if (os_strcmp(buf, "PMKSA") == 0) {
2592 reply_len = hostapd_ctrl_iface_pmksa_list(hapd, reply,
2593 reply_size);
2594 } else if (os_strcmp(buf, "PMKSA_FLUSH") == 0) {
2595 hostapd_ctrl_iface_pmksa_flush(hapd);
2596 } else if (os_strncmp(buf, "SET_NEIGHBOR ", 13) == 0) {
2597 if (hostapd_ctrl_iface_set_neighbor(hapd, buf + 13))
2598 reply_len = -1;
2599 } else if (os_strncmp(buf, "REMOVE_NEIGHBOR ", 16) == 0) {
2600 if (hostapd_ctrl_iface_remove_neighbor(hapd, buf + 16))
2601 reply_len = -1;
2602 } else if (os_strncmp(buf, "REQ_LCI ", 8) == 0) {
2603 if (hostapd_ctrl_iface_req_lci(hapd, buf + 8))
2604 reply_len = -1;
2605 } else if (os_strncmp(buf, "REQ_RANGE ", 10) == 0) {
2606 if (hostapd_ctrl_iface_req_range(hapd, buf + 10))
2607 reply_len = -1;
2608 } else if (os_strncmp(buf, "REQ_BEACON ", 11) == 0) {
2609 reply_len = hostapd_ctrl_iface_req_beacon(hapd, buf + 11,
2610 reply, reply_size);
2611 } else if (os_strcmp(buf, "DRIVER_FLAGS") == 0) {
2612 reply_len = hostapd_ctrl_driver_flags(hapd->iface, reply,
2613 reply_size);
2614 } else if (os_strcmp(buf, "TERMINATE") == 0) {
2615 eloop_terminate();
2616 } else {
2617 os_memcpy(reply, "UNKNOWN COMMAND\n", 16);
2618 reply_len = 16;
2619 }
2620
2621 if (reply_len < 0) {
2622 os_memcpy(reply, "FAIL\n", 5);
2623 reply_len = 5;
2624 }
2625
2626 return reply_len;
2627 }
2628
2629
2630 static void hostapd_ctrl_iface_receive(int sock, void *eloop_ctx,
2631 void *sock_ctx)
2632 {
2633 struct hostapd_data *hapd = eloop_ctx;
2634 char buf[4096];
2635 int res;
2636 struct sockaddr_storage from;
2637 socklen_t fromlen = sizeof(from);
2638 char *reply, *pos = buf;
2639 const int reply_size = 4096;
2640 int reply_len;
2641 int level = MSG_DEBUG;
2642 #ifdef CONFIG_CTRL_IFACE_UDP
2643 unsigned char lcookie[COOKIE_LEN];
2644 #endif /* CONFIG_CTRL_IFACE_UDP */
2645
2646 res = recvfrom(sock, buf, sizeof(buf) - 1, 0,
2647 (struct sockaddr *) &from, &fromlen);
2648 if (res < 0) {
2649 wpa_printf(MSG_ERROR, "recvfrom(ctrl_iface): %s",
2650 strerror(errno));
2651 return;
2652 }
2653 buf[res] = '\0';
2654
2655 reply = os_malloc(reply_size);
2656 if (reply == NULL) {
2657 if (sendto(sock, "FAIL\n", 5, 0, (struct sockaddr *) &from,
2658 fromlen) < 0) {
2659 wpa_printf(MSG_DEBUG, "CTRL: sendto failed: %s",
2660 strerror(errno));
2661 }
2662 return;
2663 }
2664
2665 #ifdef CONFIG_CTRL_IFACE_UDP
2666 if (os_strcmp(buf, "GET_COOKIE") == 0) {
2667 os_memcpy(reply, "COOKIE=", 7);
2668 wpa_snprintf_hex(reply + 7, 2 * COOKIE_LEN + 1,
2669 cookie, COOKIE_LEN);
2670 reply_len = 7 + 2 * COOKIE_LEN;
2671 goto done;
2672 }
2673
2674 if (os_strncmp(buf, "COOKIE=", 7) != 0 ||
2675 hexstr2bin(buf + 7, lcookie, COOKIE_LEN) < 0) {
2676 wpa_printf(MSG_DEBUG,
2677 "CTRL: No cookie in the request - drop request");
2678 os_free(reply);
2679 return;
2680 }
2681
2682 if (os_memcmp(cookie, lcookie, COOKIE_LEN) != 0) {
2683 wpa_printf(MSG_DEBUG,
2684 "CTRL: Invalid cookie in the request - drop request");
2685 os_free(reply);
2686 return;
2687 }
2688
2689 pos = buf + 7 + 2 * COOKIE_LEN;
2690 while (*pos == ' ')
2691 pos++;
2692 #endif /* CONFIG_CTRL_IFACE_UDP */
2693
2694 if (os_strcmp(pos, "PING") == 0)
2695 level = MSG_EXCESSIVE;
2696 wpa_hexdump_ascii(level, "RX ctrl_iface", pos, res);
2697
2698 reply_len = hostapd_ctrl_iface_receive_process(hapd, pos,
2699 reply, reply_size,
2700 &from, fromlen);
2701
2702 #ifdef CONFIG_CTRL_IFACE_UDP
2703 done:
2704 #endif /* CONFIG_CTRL_IFACE_UDP */
2705 if (sendto(sock, reply, reply_len, 0, (struct sockaddr *) &from,
2706 fromlen) < 0) {
2707 wpa_printf(MSG_DEBUG, "CTRL: sendto failed: %s",
2708 strerror(errno));
2709 }
2710 os_free(reply);
2711 }
2712
2713
2714 #ifndef CONFIG_CTRL_IFACE_UDP
2715 static char * hostapd_ctrl_iface_path(struct hostapd_data *hapd)
2716 {
2717 char *buf;
2718 size_t len;
2719
2720 if (hapd->conf->ctrl_interface == NULL)
2721 return NULL;
2722
2723 len = os_strlen(hapd->conf->ctrl_interface) +
2724 os_strlen(hapd->conf->iface) + 2;
2725 buf = os_malloc(len);
2726 if (buf == NULL)
2727 return NULL;
2728
2729 os_snprintf(buf, len, "%s/%s",
2730 hapd->conf->ctrl_interface, hapd->conf->iface);
2731 buf[len - 1] = '\0';
2732 return buf;
2733 }
2734 #endif /* CONFIG_CTRL_IFACE_UDP */
2735
2736
2737 static void hostapd_ctrl_iface_msg_cb(void *ctx, int level,
2738 enum wpa_msg_type type,
2739 const char *txt, size_t len)
2740 {
2741 struct hostapd_data *hapd = ctx;
2742 if (hapd == NULL)
2743 return;
2744 hostapd_ctrl_iface_send(hapd, level, type, txt, len);
2745 }
2746
2747
2748 int hostapd_ctrl_iface_init(struct hostapd_data *hapd)
2749 {
2750 #ifdef CONFIG_CTRL_IFACE_UDP
2751 int port = HOSTAPD_CTRL_IFACE_PORT;
2752 char p[32] = { 0 };
2753 char port_str[40], *tmp;
2754 char *pos;
2755 struct addrinfo hints = { 0 }, *res, *saveres;
2756 int n;
2757
2758 if (hapd->ctrl_sock > -1) {
2759 wpa_printf(MSG_DEBUG, "ctrl_iface already exists!");
2760 return 0;
2761 }
2762
2763 if (hapd->conf->ctrl_interface == NULL)
2764 return 0;
2765
2766 pos = os_strstr(hapd->conf->ctrl_interface, "udp:");
2767 if (pos) {
2768 pos += 4;
2769 port = atoi(pos);
2770 if (port <= 0) {
2771 wpa_printf(MSG_ERROR, "Invalid ctrl_iface UDP port");
2772 goto fail;
2773 }
2774 }
2775
2776 dl_list_init(&hapd->ctrl_dst);
2777 hapd->ctrl_sock = -1;
2778 os_get_random(cookie, COOKIE_LEN);
2779
2780 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE
2781 hints.ai_flags = AI_PASSIVE;
2782 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
2783
2784 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6
2785 hints.ai_family = AF_INET6;
2786 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */
2787 hints.ai_family = AF_INET;
2788 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */
2789 hints.ai_socktype = SOCK_DGRAM;
2790
2791 try_again:
2792 os_snprintf(p, sizeof(p), "%d", port);
2793 n = getaddrinfo(NULL, p, &hints, &res);
2794 if (n) {
2795 wpa_printf(MSG_ERROR, "getaddrinfo(): %s", gai_strerror(n));
2796 goto fail;
2797 }
2798
2799 saveres = res;
2800 hapd->ctrl_sock = socket(res->ai_family, res->ai_socktype,
2801 res->ai_protocol);
2802 if (hapd->ctrl_sock < 0) {
2803 wpa_printf(MSG_ERROR, "socket(PF_INET): %s", strerror(errno));
2804 goto fail;
2805 }
2806
2807 if (bind(hapd->ctrl_sock, res->ai_addr, res->ai_addrlen) < 0) {
2808 port--;
2809 if ((HOSTAPD_CTRL_IFACE_PORT - port) <
2810 HOSTAPD_CTRL_IFACE_PORT_LIMIT && !pos)
2811 goto try_again;
2812 wpa_printf(MSG_ERROR, "bind(AF_INET): %s", strerror(errno));
2813 goto fail;
2814 }
2815
2816 freeaddrinfo(saveres);
2817
2818 os_snprintf(port_str, sizeof(port_str), "udp:%d", port);
2819 tmp = os_strdup(port_str);
2820 if (tmp) {
2821 os_free(hapd->conf->ctrl_interface);
2822 hapd->conf->ctrl_interface = tmp;
2823 }
2824 wpa_printf(MSG_DEBUG, "ctrl_iface_init UDP port: %d", port);
2825
2826 if (eloop_register_read_sock(hapd->ctrl_sock,
2827 hostapd_ctrl_iface_receive, hapd, NULL) <
2828 0) {
2829 hostapd_ctrl_iface_deinit(hapd);
2830 return -1;
2831 }
2832
2833 hapd->msg_ctx = hapd;
2834 wpa_msg_register_cb(hostapd_ctrl_iface_msg_cb);
2835
2836 return 0;
2837
2838 fail:
2839 if (hapd->ctrl_sock >= 0)
2840 close(hapd->ctrl_sock);
2841 return -1;
2842 #else /* CONFIG_CTRL_IFACE_UDP */
2843 struct sockaddr_un addr;
2844 int s = -1;
2845 char *fname = NULL;
2846
2847 if (hapd->ctrl_sock > -1) {
2848 wpa_printf(MSG_DEBUG, "ctrl_iface already exists!");
2849 return 0;
2850 }
2851
2852 dl_list_init(&hapd->ctrl_dst);
2853
2854 if (hapd->conf->ctrl_interface == NULL)
2855 return 0;
2856
2857 if (mkdir(hapd->conf->ctrl_interface, S_IRWXU | S_IRWXG) < 0) {
2858 if (errno == EEXIST) {
2859 wpa_printf(MSG_DEBUG, "Using existing control "
2860 "interface directory.");
2861 } else {
2862 wpa_printf(MSG_ERROR, "mkdir[ctrl_interface]: %s",
2863 strerror(errno));
2864 goto fail;
2865 }
2866 }
2867
2868 if (hapd->conf->ctrl_interface_gid_set &&
2869 chown(hapd->conf->ctrl_interface, -1,
2870 hapd->conf->ctrl_interface_gid) < 0) {
2871 wpa_printf(MSG_ERROR, "chown[ctrl_interface]: %s",
2872 strerror(errno));
2873 return -1;
2874 }
2875
2876 if (!hapd->conf->ctrl_interface_gid_set &&
2877 hapd->iface->interfaces->ctrl_iface_group &&
2878 chown(hapd->conf->ctrl_interface, -1,
2879 hapd->iface->interfaces->ctrl_iface_group) < 0) {
2880 wpa_printf(MSG_ERROR, "chown[ctrl_interface]: %s",
2881 strerror(errno));
2882 return -1;
2883 }
2884
2885 #ifdef ANDROID
2886 /*
2887 * Android is using umask 0077 which would leave the control interface
2888 * directory without group access. This breaks things since Wi-Fi
2889 * framework assumes that this directory can be accessed by other
2890 * applications in the wifi group. Fix this by adding group access even
2891 * if umask value would prevent this.
2892 */
2893 if (chmod(hapd->conf->ctrl_interface, S_IRWXU | S_IRWXG) < 0) {
2894 wpa_printf(MSG_ERROR, "CTRL: Could not chmod directory: %s",
2895 strerror(errno));
2896 /* Try to continue anyway */
2897 }
2898 #endif /* ANDROID */
2899
2900 if (os_strlen(hapd->conf->ctrl_interface) + 1 +
2901 os_strlen(hapd->conf->iface) >= sizeof(addr.sun_path))
2902 goto fail;
2903
2904 s = socket(PF_UNIX, SOCK_DGRAM, 0);
2905 if (s < 0) {
2906 wpa_printf(MSG_ERROR, "socket(PF_UNIX): %s", strerror(errno));
2907 goto fail;
2908 }
2909
2910 os_memset(&addr, 0, sizeof(addr));
2911 #ifdef __FreeBSD__
2912 addr.sun_len = sizeof(addr);
2913 #endif /* __FreeBSD__ */
2914 addr.sun_family = AF_UNIX;
2915 fname = hostapd_ctrl_iface_path(hapd);
2916 if (fname == NULL)
2917 goto fail;
2918 os_strlcpy(addr.sun_path, fname, sizeof(addr.sun_path));
2919 if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
2920 wpa_printf(MSG_DEBUG, "ctrl_iface bind(PF_UNIX) failed: %s",
2921 strerror(errno));
2922 if (connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
2923 wpa_printf(MSG_DEBUG, "ctrl_iface exists, but does not"
2924 " allow connections - assuming it was left"
2925 "over from forced program termination");
2926 if (unlink(fname) < 0) {
2927 wpa_printf(MSG_ERROR,
2928 "Could not unlink existing ctrl_iface socket '%s': %s",
2929 fname, strerror(errno));
2930 goto fail;
2931 }
2932 if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) <
2933 0) {
2934 wpa_printf(MSG_ERROR,
2935 "hostapd-ctrl-iface: bind(PF_UNIX): %s",
2936 strerror(errno));
2937 goto fail;
2938 }
2939 wpa_printf(MSG_DEBUG, "Successfully replaced leftover "
2940 "ctrl_iface socket '%s'", fname);
2941 } else {
2942 wpa_printf(MSG_INFO, "ctrl_iface exists and seems to "
2943 "be in use - cannot override it");
2944 wpa_printf(MSG_INFO, "Delete '%s' manually if it is "
2945 "not used anymore", fname);
2946 os_free(fname);
2947 fname = NULL;
2948 goto fail;
2949 }
2950 }
2951
2952 if (hapd->conf->ctrl_interface_gid_set &&
2953 chown(fname, -1, hapd->conf->ctrl_interface_gid) < 0) {
2954 wpa_printf(MSG_ERROR, "chown[ctrl_interface/ifname]: %s",
2955 strerror(errno));
2956 goto fail;
2957 }
2958
2959 if (!hapd->conf->ctrl_interface_gid_set &&
2960 hapd->iface->interfaces->ctrl_iface_group &&
2961 chown(fname, -1, hapd->iface->interfaces->ctrl_iface_group) < 0) {
2962 wpa_printf(MSG_ERROR, "chown[ctrl_interface/ifname]: %s",
2963 strerror(errno));
2964 goto fail;
2965 }
2966
2967 if (chmod(fname, S_IRWXU | S_IRWXG) < 0) {
2968 wpa_printf(MSG_ERROR, "chmod[ctrl_interface/ifname]: %s",
2969 strerror(errno));
2970 goto fail;
2971 }
2972 os_free(fname);
2973
2974 hapd->ctrl_sock = s;
2975 if (eloop_register_read_sock(s, hostapd_ctrl_iface_receive, hapd,
2976 NULL) < 0) {
2977 hostapd_ctrl_iface_deinit(hapd);
2978 return -1;
2979 }
2980 hapd->msg_ctx = hapd;
2981 wpa_msg_register_cb(hostapd_ctrl_iface_msg_cb);
2982
2983 return 0;
2984
2985 fail:
2986 if (s >= 0)
2987 close(s);
2988 if (fname) {
2989 unlink(fname);
2990 os_free(fname);
2991 }
2992 return -1;
2993 #endif /* CONFIG_CTRL_IFACE_UDP */
2994 }
2995
2996
2997 void hostapd_ctrl_iface_deinit(struct hostapd_data *hapd)
2998 {
2999 struct wpa_ctrl_dst *dst, *prev;
3000
3001 if (hapd->ctrl_sock > -1) {
3002 #ifndef CONFIG_CTRL_IFACE_UDP
3003 char *fname;
3004 #endif /* !CONFIG_CTRL_IFACE_UDP */
3005
3006 eloop_unregister_read_sock(hapd->ctrl_sock);
3007 close(hapd->ctrl_sock);
3008 hapd->ctrl_sock = -1;
3009 #ifndef CONFIG_CTRL_IFACE_UDP
3010 fname = hostapd_ctrl_iface_path(hapd);
3011 if (fname)
3012 unlink(fname);
3013 os_free(fname);
3014
3015 if (hapd->conf->ctrl_interface &&
3016 rmdir(hapd->conf->ctrl_interface) < 0) {
3017 if (errno == ENOTEMPTY) {
3018 wpa_printf(MSG_DEBUG, "Control interface "
3019 "directory not empty - leaving it "
3020 "behind");
3021 } else {
3022 wpa_printf(MSG_ERROR,
3023 "rmdir[ctrl_interface=%s]: %s",
3024 hapd->conf->ctrl_interface,
3025 strerror(errno));
3026 }
3027 }
3028 #endif /* !CONFIG_CTRL_IFACE_UDP */
3029 }
3030
3031 dl_list_for_each_safe(dst, prev, &hapd->ctrl_dst, struct wpa_ctrl_dst,
3032 list)
3033 os_free(dst);
3034
3035 #ifdef CONFIG_TESTING_OPTIONS
3036 l2_packet_deinit(hapd->l2_test);
3037 hapd->l2_test = NULL;
3038 #endif /* CONFIG_TESTING_OPTIONS */
3039 }
3040
3041
3042 static int hostapd_ctrl_iface_add(struct hapd_interfaces *interfaces,
3043 char *buf)
3044 {
3045 if (hostapd_add_iface(interfaces, buf) < 0) {
3046 wpa_printf(MSG_ERROR, "Adding interface %s failed", buf);
3047 return -1;
3048 }
3049 return 0;
3050 }
3051
3052
3053 static int hostapd_ctrl_iface_remove(struct hapd_interfaces *interfaces,
3054 char *buf)
3055 {
3056 if (hostapd_remove_iface(interfaces, buf) < 0) {
3057 wpa_printf(MSG_ERROR, "Removing interface %s failed", buf);
3058 return -1;
3059 }
3060 return 0;
3061 }
3062
3063
3064 static int hostapd_global_ctrl_iface_attach(struct hapd_interfaces *interfaces,
3065 struct sockaddr_storage *from,
3066 socklen_t fromlen)
3067 {
3068 return ctrl_iface_attach(&interfaces->global_ctrl_dst, from, fromlen);
3069 }
3070
3071
3072 static int hostapd_global_ctrl_iface_detach(struct hapd_interfaces *interfaces,
3073 struct sockaddr_storage *from,
3074 socklen_t fromlen)
3075 {
3076 return ctrl_iface_detach(&interfaces->global_ctrl_dst, from, fromlen);
3077 }
3078
3079
3080 static void hostapd_ctrl_iface_flush(struct hapd_interfaces *interfaces)
3081 {
3082 #ifdef CONFIG_WPS_TESTING
3083 wps_version_number = 0x20;
3084 wps_testing_dummy_cred = 0;
3085 wps_corrupt_pkhash = 0;
3086 #endif /* CONFIG_WPS_TESTING */
3087 }
3088
3089
3090 #ifdef CONFIG_FST
3091
3092 static int
3093 hostapd_global_ctrl_iface_fst_attach(struct hapd_interfaces *interfaces,
3094 const char *cmd)
3095 {
3096 char ifname[IFNAMSIZ + 1];
3097 struct fst_iface_cfg cfg;
3098 struct hostapd_data *hapd;
3099 struct fst_wpa_obj iface_obj;
3100
3101 if (!fst_parse_attach_command(cmd, ifname, sizeof(ifname), &cfg)) {
3102 hapd = hostapd_get_iface(interfaces, ifname);
3103 if (hapd) {
3104 if (hapd->iface->fst) {
3105 wpa_printf(MSG_INFO, "FST: Already attached");
3106 return -1;
3107 }
3108 fst_hostapd_fill_iface_obj(hapd, &iface_obj);
3109 hapd->iface->fst = fst_attach(ifname, hapd->own_addr,
3110 &iface_obj, &cfg);
3111 if (hapd->iface->fst)
3112 return 0;
3113 }
3114 }
3115
3116 return -EINVAL;
3117 }
3118
3119
3120 static int
3121 hostapd_global_ctrl_iface_fst_detach(struct hapd_interfaces *interfaces,
3122 const char *cmd)
3123 {
3124 char ifname[IFNAMSIZ + 1];
3125 struct hostapd_data * hapd;
3126
3127 if (!fst_parse_detach_command(cmd, ifname, sizeof(ifname))) {
3128 hapd = hostapd_get_iface(interfaces, ifname);
3129 if (hapd) {
3130 if (!fst_iface_detach(ifname)) {
3131 hapd->iface->fst = NULL;
3132 hapd->iface->fst_ies = NULL;
3133 return 0;
3134 }
3135 }
3136 }
3137
3138 return -EINVAL;
3139 }
3140
3141 #endif /* CONFIG_FST */
3142
3143
3144 static struct hostapd_data *
3145 hostapd_interfaces_get_hapd(struct hapd_interfaces *interfaces,
3146 const char *ifname)
3147 {
3148 size_t i, j;
3149
3150 for (i = 0; i < interfaces->count; i++) {
3151 struct hostapd_iface *iface = interfaces->iface[i];
3152
3153 for (j = 0; j < iface->num_bss; j++) {
3154 struct hostapd_data *hapd;
3155
3156 hapd = iface->bss[j];
3157 if (os_strcmp(ifname, hapd->conf->iface) == 0)
3158 return hapd;
3159 }
3160 }
3161
3162 return NULL;
3163 }
3164
3165
3166 static int hostapd_ctrl_iface_dup_param(struct hostapd_data *src_hapd,
3167 struct hostapd_data *dst_hapd,
3168 const char *param)
3169 {
3170 int res;
3171 char *value;
3172
3173 value = os_zalloc(HOSTAPD_CLI_DUP_VALUE_MAX_LEN);
3174 if (!value) {
3175 wpa_printf(MSG_ERROR,
3176 "DUP: cannot allocate buffer to stringify %s",
3177 param);
3178 goto error_return;
3179 }
3180
3181 if (os_strcmp(param, "wpa") == 0) {
3182 os_snprintf(value, HOSTAPD_CLI_DUP_VALUE_MAX_LEN, "%d",
3183 src_hapd->conf->wpa);
3184 } else if (os_strcmp(param, "wpa_key_mgmt") == 0 &&
3185 src_hapd->conf->wpa_key_mgmt) {
3186 res = hostapd_ctrl_iface_get_key_mgmt(
3187 src_hapd, value, HOSTAPD_CLI_DUP_VALUE_MAX_LEN);
3188 if (os_snprintf_error(HOSTAPD_CLI_DUP_VALUE_MAX_LEN, res))
3189 goto error_stringify;
3190 } else if (os_strcmp(param, "wpa_pairwise") == 0 &&
3191 src_hapd->conf->wpa_pairwise) {
3192 res = wpa_write_ciphers(value,
3193 value + HOSTAPD_CLI_DUP_VALUE_MAX_LEN,
3194 src_hapd->conf->wpa_pairwise, " ");
3195 if (res < 0)
3196 goto error_stringify;
3197 } else if (os_strcmp(param, "rsn_pairwise") == 0 &&
3198 src_hapd->conf->rsn_pairwise) {
3199 res = wpa_write_ciphers(value,
3200 value + HOSTAPD_CLI_DUP_VALUE_MAX_LEN,
3201 src_hapd->conf->rsn_pairwise, " ");
3202 if (res < 0)
3203 goto error_stringify;
3204 } else if (os_strcmp(param, "wpa_passphrase") == 0 &&
3205 src_hapd->conf->ssid.wpa_passphrase) {
3206 os_snprintf(value, HOSTAPD_CLI_DUP_VALUE_MAX_LEN, "%s",
3207 src_hapd->conf->ssid.wpa_passphrase);
3208 } else if (os_strcmp(param, "wpa_psk") == 0 &&
3209 src_hapd->conf->ssid.wpa_psk_set) {
3210 wpa_snprintf_hex(value, HOSTAPD_CLI_DUP_VALUE_MAX_LEN,
3211 src_hapd->conf->ssid.wpa_psk->psk, PMK_LEN);
3212 } else {
3213 wpa_printf(MSG_WARNING, "DUP: %s cannot be duplicated", param);
3214 goto error_return;
3215 }
3216
3217 res = hostapd_set_iface(dst_hapd->iconf, dst_hapd->conf, param, value);
3218 os_free(value);
3219 return res;
3220
3221 error_stringify:
3222 wpa_printf(MSG_ERROR, "DUP: cannot stringify %s", param);
3223 error_return:
3224 os_free(value);
3225 return -1;
3226 }
3227
3228
3229 static int
3230 hostapd_global_ctrl_iface_interfaces(struct hapd_interfaces *interfaces,
3231 const char *input,
3232 char *reply, int reply_size)
3233 {
3234 size_t i, j;
3235 int res;
3236 char *pos, *end;
3237 struct hostapd_iface *iface;
3238 int show_ctrl = 0;
3239
3240 if (input)
3241 show_ctrl = !!os_strstr(input, "ctrl");
3242
3243 pos = reply;
3244 end = reply + reply_size;
3245
3246 for (i = 0; i < interfaces->count; i++) {
3247 iface = interfaces->iface[i];
3248
3249 for (j = 0; j < iface->num_bss; j++) {
3250 struct hostapd_bss_config *conf;
3251
3252 conf = iface->conf->bss[j];
3253 if (show_ctrl)
3254 res = os_snprintf(pos, end - pos,
3255 "%s ctrl_iface=%s\n",
3256 conf->iface,
3257 conf->ctrl_interface ?
3258 conf->ctrl_interface : "N/A");
3259 else
3260 res = os_snprintf(pos, end - pos, "%s\n",
3261 conf->iface);
3262 if (os_snprintf_error(end - pos, res)) {
3263 *pos = '\0';
3264 return pos - reply;
3265 }
3266 pos += res;
3267 }
3268 }
3269
3270 return pos - reply;
3271 }
3272
3273
3274 static int
3275 hostapd_global_ctrl_iface_dup_network(struct hapd_interfaces *interfaces,
3276 char *cmd)
3277 {
3278 char *p_start = cmd, *p_end;
3279 struct hostapd_data *src_hapd, *dst_hapd;
3280
3281 /* cmd: "<src ifname> <dst ifname> <variable name> */
3282
3283 p_end = os_strchr(p_start, ' ');
3284 if (!p_end) {
3285 wpa_printf(MSG_ERROR, "DUP: no src ifname found in cmd: '%s'",
3286 cmd);
3287 return -1;
3288 }
3289
3290 *p_end = '\0';
3291 src_hapd = hostapd_interfaces_get_hapd(interfaces, p_start);
3292 if (!src_hapd) {
3293 wpa_printf(MSG_ERROR, "DUP: no src ifname found: '%s'",
3294 p_start);
3295 return -1;
3296 }
3297
3298 p_start = p_end + 1;
3299 p_end = os_strchr(p_start, ' ');
3300 if (!p_end) {
3301 wpa_printf(MSG_ERROR, "DUP: no dst ifname found in cmd: '%s'",
3302 cmd);
3303 return -1;
3304 }
3305
3306 *p_end = '\0';
3307 dst_hapd = hostapd_interfaces_get_hapd(interfaces, p_start);
3308 if (!dst_hapd) {
3309 wpa_printf(MSG_ERROR, "DUP: no dst ifname found: '%s'",
3310 p_start);
3311 return -1;
3312 }
3313
3314 p_start = p_end + 1;
3315 return hostapd_ctrl_iface_dup_param(src_hapd, dst_hapd, p_start);
3316 }
3317
3318
3319 static int hostapd_global_ctrl_iface_ifname(struct hapd_interfaces *interfaces,
3320 const char *ifname,
3321 char *buf, char *reply,
3322 int reply_size,
3323 struct sockaddr_storage *from,
3324 socklen_t fromlen)
3325 {
3326 struct hostapd_data *hapd;
3327
3328 hapd = hostapd_interfaces_get_hapd(interfaces, ifname);
3329 if (hapd == NULL) {
3330 int res;
3331
3332 res = os_snprintf(reply, reply_size, "FAIL-NO-IFNAME-MATCH\n");
3333 if (os_snprintf_error(reply_size, res))
3334 return -1;
3335 return res;
3336 }
3337
3338 return hostapd_ctrl_iface_receive_process(hapd, buf, reply,reply_size,
3339 from, fromlen);
3340 }
3341
3342
3343 static void hostapd_global_ctrl_iface_receive(int sock, void *eloop_ctx,
3344 void *sock_ctx)
3345 {
3346 void *interfaces = eloop_ctx;
3347 char buffer[256], *buf = buffer;
3348 int res;
3349 struct sockaddr_storage from;
3350 socklen_t fromlen = sizeof(from);
3351 char *reply;
3352 int reply_len;
3353 const int reply_size = 4096;
3354 #ifdef CONFIG_CTRL_IFACE_UDP
3355 unsigned char lcookie[COOKIE_LEN];
3356 #endif /* CONFIG_CTRL_IFACE_UDP */
3357
3358 res = recvfrom(sock, buffer, sizeof(buffer) - 1, 0,
3359 (struct sockaddr *) &from, &fromlen);
3360 if (res < 0) {
3361 wpa_printf(MSG_ERROR, "recvfrom(ctrl_iface): %s",
3362 strerror(errno));
3363 return;
3364 }
3365 buf[res] = '\0';
3366 wpa_printf(MSG_DEBUG, "Global ctrl_iface command: %s", buf);
3367
3368 reply = os_malloc(reply_size);
3369 if (reply == NULL) {
3370 if (sendto(sock, "FAIL\n", 5, 0, (struct sockaddr *) &from,
3371 fromlen) < 0) {
3372 wpa_printf(MSG_DEBUG, "CTRL: sendto failed: %s",
3373 strerror(errno));
3374 }
3375 return;
3376 }
3377
3378 os_memcpy(reply, "OK\n", 3);
3379 reply_len = 3;
3380
3381 #ifdef CONFIG_CTRL_IFACE_UDP
3382 if (os_strcmp(buf, "GET_COOKIE") == 0) {
3383 os_memcpy(reply, "COOKIE=", 7);
3384 wpa_snprintf_hex(reply + 7, 2 * COOKIE_LEN + 1,
3385 gcookie, COOKIE_LEN);
3386 reply_len = 7 + 2 * COOKIE_LEN;
3387 goto send_reply;
3388 }
3389
3390 if (os_strncmp(buf, "COOKIE=", 7) != 0 ||
3391 hexstr2bin(buf + 7, lcookie, COOKIE_LEN) < 0) {
3392 wpa_printf(MSG_DEBUG,
3393 "CTRL: No cookie in the request - drop request");
3394 os_free(reply);
3395 return;
3396 }
3397
3398 if (os_memcmp(gcookie, lcookie, COOKIE_LEN) != 0) {
3399 wpa_printf(MSG_DEBUG,
3400 "CTRL: Invalid cookie in the request - drop request");
3401 os_free(reply);
3402 return;
3403 }
3404
3405 buf += 7 + 2 * COOKIE_LEN;
3406 while (*buf == ' ')
3407 buf++;
3408 #endif /* CONFIG_CTRL_IFACE_UDP */
3409
3410 if (os_strncmp(buf, "IFNAME=", 7) == 0) {
3411 char *pos = os_strchr(buf + 7, ' ');
3412
3413 if (pos) {
3414 *pos++ = '\0';
3415 reply_len = hostapd_global_ctrl_iface_ifname(
3416 interfaces, buf + 7, pos, reply, reply_size,
3417 &from, fromlen);
3418 goto send_reply;
3419 }
3420 }
3421
3422 if (os_strcmp(buf, "PING") == 0) {
3423 os_memcpy(reply, "PONG\n", 5);
3424 reply_len = 5;
3425 } else if (os_strncmp(buf, "RELOG", 5) == 0) {
3426 if (wpa_debug_reopen_file() < 0)
3427 reply_len = -1;
3428 } else if (os_strcmp(buf, "FLUSH") == 0) {
3429 hostapd_ctrl_iface_flush(interfaces);
3430 } else if (os_strncmp(buf, "ADD ", 4) == 0) {
3431 if (hostapd_ctrl_iface_add(interfaces, buf + 4) < 0)
3432 reply_len = -1;
3433 } else if (os_strncmp(buf, "REMOVE ", 7) == 0) {
3434 if (hostapd_ctrl_iface_remove(interfaces, buf + 7) < 0)
3435 reply_len = -1;
3436 } else if (os_strcmp(buf, "ATTACH") == 0) {
3437 if (hostapd_global_ctrl_iface_attach(interfaces, &from,
3438 fromlen))
3439 reply_len = -1;
3440 } else if (os_strcmp(buf, "DETACH") == 0) {
3441 if (hostapd_global_ctrl_iface_detach(interfaces, &from,
3442 fromlen))
3443 reply_len = -1;
3444 #ifdef CONFIG_MODULE_TESTS
3445 } else if (os_strcmp(buf, "MODULE_TESTS") == 0) {
3446 if (hapd_module_tests() < 0)
3447 reply_len = -1;
3448 #endif /* CONFIG_MODULE_TESTS */
3449 #ifdef CONFIG_FST
3450 } else if (os_strncmp(buf, "FST-ATTACH ", 11) == 0) {
3451 if (!hostapd_global_ctrl_iface_fst_attach(interfaces, buf + 11))
3452 reply_len = os_snprintf(reply, reply_size, "OK\n");
3453 else
3454 reply_len = -1;
3455 } else if (os_strncmp(buf, "FST-DETACH ", 11) == 0) {
3456 if (!hostapd_global_ctrl_iface_fst_detach(interfaces, buf + 11))
3457 reply_len = os_snprintf(reply, reply_size, "OK\n");
3458 else
3459 reply_len = -1;
3460 } else if (os_strncmp(buf, "FST-MANAGER ", 12) == 0) {
3461 reply_len = fst_ctrl_iface_receive(buf + 12, reply, reply_size);
3462 #endif /* CONFIG_FST */
3463 } else if (os_strncmp(buf, "DUP_NETWORK ", 12) == 0) {
3464 if (!hostapd_global_ctrl_iface_dup_network(interfaces,
3465 buf + 12))
3466 reply_len = os_snprintf(reply, reply_size, "OK\n");
3467 else
3468 reply_len = -1;
3469 } else if (os_strncmp(buf, "INTERFACES", 10) == 0) {
3470 reply_len = hostapd_global_ctrl_iface_interfaces(
3471 interfaces, buf + 10, reply, sizeof(buffer));
3472 } else if (os_strcmp(buf, "TERMINATE") == 0) {
3473 eloop_terminate();
3474 } else {
3475 wpa_printf(MSG_DEBUG, "Unrecognized global ctrl_iface command "
3476 "ignored");
3477 reply_len = -1;
3478 }
3479
3480 send_reply:
3481 if (reply_len < 0) {
3482 os_memcpy(reply, "FAIL\n", 5);
3483 reply_len = 5;
3484 }
3485
3486 if (sendto(sock, reply, reply_len, 0, (struct sockaddr *) &from,
3487 fromlen) < 0) {
3488 wpa_printf(MSG_DEBUG, "CTRL: sendto failed: %s",
3489 strerror(errno));
3490 }
3491 os_free(reply);
3492 }
3493
3494
3495 #ifndef CONFIG_CTRL_IFACE_UDP
3496 static char * hostapd_global_ctrl_iface_path(struct hapd_interfaces *interface)
3497 {
3498 char *buf;
3499 size_t len;
3500
3501 if (interface->global_iface_path == NULL)
3502 return NULL;
3503
3504 len = os_strlen(interface->global_iface_path) +
3505 os_strlen(interface->global_iface_name) + 2;
3506 buf = os_malloc(len);
3507 if (buf == NULL)
3508 return NULL;
3509
3510 os_snprintf(buf, len, "%s/%s", interface->global_iface_path,
3511 interface->global_iface_name);
3512 buf[len - 1] = '\0';
3513 return buf;
3514 }
3515 #endif /* CONFIG_CTRL_IFACE_UDP */
3516
3517
3518 int hostapd_global_ctrl_iface_init(struct hapd_interfaces *interface)
3519 {
3520 #ifdef CONFIG_CTRL_IFACE_UDP
3521 int port = HOSTAPD_GLOBAL_CTRL_IFACE_PORT;
3522 char p[32] = { 0 };
3523 char *pos;
3524 struct addrinfo hints = { 0 }, *res, *saveres;
3525 int n;
3526
3527 if (interface->global_ctrl_sock > -1) {
3528 wpa_printf(MSG_DEBUG, "ctrl_iface already exists!");
3529 return 0;
3530 }
3531
3532 if (interface->global_iface_path == NULL)
3533 return 0;
3534
3535 pos = os_strstr(interface->global_iface_path, "udp:");
3536 if (pos) {
3537 pos += 4;
3538 port = atoi(pos);
3539 if (port <= 0) {
3540 wpa_printf(MSG_ERROR, "Invalid global ctrl UDP port");
3541 goto fail;
3542 }
3543 }
3544
3545 os_get_random(gcookie, COOKIE_LEN);
3546
3547 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE
3548 hints.ai_flags = AI_PASSIVE;
3549 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */
3550
3551 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6
3552 hints.ai_family = AF_INET6;
3553 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */
3554 hints.ai_family = AF_INET;
3555 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */
3556 hints.ai_socktype = SOCK_DGRAM;
3557
3558 try_again:
3559 os_snprintf(p, sizeof(p), "%d", port);
3560 n = getaddrinfo(NULL, p, &hints, &res);
3561 if (n) {
3562 wpa_printf(MSG_ERROR, "getaddrinfo(): %s", gai_strerror(n));
3563 goto fail;
3564 }
3565
3566 saveres = res;
3567 interface->global_ctrl_sock = socket(res->ai_family, res->ai_socktype,
3568 res->ai_protocol);
3569 if (interface->global_ctrl_sock < 0) {
3570 wpa_printf(MSG_ERROR, "socket(PF_INET): %s", strerror(errno));
3571 goto fail;
3572 }
3573
3574 if (bind(interface->global_ctrl_sock, res->ai_addr, res->ai_addrlen) <
3575 0) {
3576 port++;
3577 if ((port - HOSTAPD_GLOBAL_CTRL_IFACE_PORT) <
3578 HOSTAPD_GLOBAL_CTRL_IFACE_PORT_LIMIT && !pos)
3579 goto try_again;
3580 wpa_printf(MSG_ERROR, "bind(AF_INET): %s", strerror(errno));
3581 goto fail;
3582 }
3583
3584 freeaddrinfo(saveres);
3585
3586 wpa_printf(MSG_DEBUG, "global ctrl_iface_init UDP port: %d", port);
3587
3588 if (eloop_register_read_sock(interface->global_ctrl_sock,
3589 hostapd_global_ctrl_iface_receive,
3590 interface, NULL) < 0) {
3591 hostapd_global_ctrl_iface_deinit(interface);
3592 return -1;
3593 }
3594
3595 return 0;
3596
3597 fail:
3598 if (interface->global_ctrl_sock >= 0)
3599 close(interface->global_ctrl_sock);
3600 return -1;
3601 #else /* CONFIG_CTRL_IFACE_UDP */
3602 struct sockaddr_un addr;
3603 int s = -1;
3604 char *fname = NULL;
3605
3606 if (interface->global_iface_path == NULL) {
3607 wpa_printf(MSG_DEBUG, "ctrl_iface not configured!");
3608 return 0;
3609 }
3610
3611 if (mkdir(interface->global_iface_path, S_IRWXU | S_IRWXG) < 0) {
3612 if (errno == EEXIST) {
3613 wpa_printf(MSG_DEBUG, "Using existing control "
3614 "interface directory.");
3615 } else {
3616 wpa_printf(MSG_ERROR, "mkdir[ctrl_interface]: %s",
3617 strerror(errno));
3618 goto fail;
3619 }
3620 } else if (interface->ctrl_iface_group &&
3621 chown(interface->global_iface_path, -1,
3622 interface->ctrl_iface_group) < 0) {
3623 wpa_printf(MSG_ERROR, "chown[ctrl_interface]: %s",
3624 strerror(errno));
3625 goto fail;
3626 }
3627
3628 if (os_strlen(interface->global_iface_path) + 1 +
3629 os_strlen(interface->global_iface_name) >= sizeof(addr.sun_path))
3630 goto fail;
3631
3632 s = socket(PF_UNIX, SOCK_DGRAM, 0);
3633 if (s < 0) {
3634 wpa_printf(MSG_ERROR, "socket(PF_UNIX): %s", strerror(errno));
3635 goto fail;
3636 }
3637
3638 os_memset(&addr, 0, sizeof(addr));
3639 #ifdef __FreeBSD__
3640 addr.sun_len = sizeof(addr);
3641 #endif /* __FreeBSD__ */
3642 addr.sun_family = AF_UNIX;
3643 fname = hostapd_global_ctrl_iface_path(interface);
3644 if (fname == NULL)
3645 goto fail;
3646 os_strlcpy(addr.sun_path, fname, sizeof(addr.sun_path));
3647 if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
3648 wpa_printf(MSG_DEBUG, "ctrl_iface bind(PF_UNIX) failed: %s",
3649 strerror(errno));
3650 if (connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
3651 wpa_printf(MSG_DEBUG, "ctrl_iface exists, but does not"
3652 " allow connections - assuming it was left"
3653 "over from forced program termination");
3654 if (unlink(fname) < 0) {
3655 wpa_printf(MSG_ERROR,
3656 "Could not unlink existing ctrl_iface socket '%s': %s",
3657 fname, strerror(errno));
3658 goto fail;
3659 }
3660 if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) <
3661 0) {
3662 wpa_printf(MSG_ERROR, "bind(PF_UNIX): %s",
3663 strerror(errno));
3664 goto fail;
3665 }
3666 wpa_printf(MSG_DEBUG, "Successfully replaced leftover "
3667 "ctrl_iface socket '%s'", fname);
3668 } else {
3669 wpa_printf(MSG_INFO, "ctrl_iface exists and seems to "
3670 "be in use - cannot override it");
3671 wpa_printf(MSG_INFO, "Delete '%s' manually if it is "
3672 "not used anymore", fname);
3673 os_free(fname);
3674 fname = NULL;
3675 goto fail;
3676 }
3677 }
3678
3679 if (interface->ctrl_iface_group &&
3680 chown(fname, -1, interface->ctrl_iface_group) < 0) {
3681 wpa_printf(MSG_ERROR, "chown[ctrl_interface]: %s",
3682 strerror(errno));
3683 goto fail;
3684 }
3685
3686 if (chmod(fname, S_IRWXU | S_IRWXG) < 0) {
3687 wpa_printf(MSG_ERROR, "chmod[ctrl_interface/ifname]: %s",
3688 strerror(errno));
3689 goto fail;
3690 }
3691 os_free(fname);
3692
3693 interface->global_ctrl_sock = s;
3694 eloop_register_read_sock(s, hostapd_global_ctrl_iface_receive,
3695 interface, NULL);
3696
3697 return 0;
3698
3699 fail:
3700 if (s >= 0)
3701 close(s);
3702 if (fname) {
3703 unlink(fname);
3704 os_free(fname);
3705 }
3706 return -1;
3707 #endif /* CONFIG_CTRL_IFACE_UDP */
3708 }
3709
3710
3711 void hostapd_global_ctrl_iface_deinit(struct hapd_interfaces *interfaces)
3712 {
3713 #ifndef CONFIG_CTRL_IFACE_UDP
3714 char *fname = NULL;
3715 #endif /* CONFIG_CTRL_IFACE_UDP */
3716 struct wpa_ctrl_dst *dst, *prev;
3717
3718 if (interfaces->global_ctrl_sock > -1) {
3719 eloop_unregister_read_sock(interfaces->global_ctrl_sock);
3720 close(interfaces->global_ctrl_sock);
3721 interfaces->global_ctrl_sock = -1;
3722 #ifndef CONFIG_CTRL_IFACE_UDP
3723 fname = hostapd_global_ctrl_iface_path(interfaces);
3724 if (fname) {
3725 unlink(fname);
3726 os_free(fname);
3727 }
3728
3729 if (interfaces->global_iface_path &&
3730 rmdir(interfaces->global_iface_path) < 0) {
3731 if (errno == ENOTEMPTY) {
3732 wpa_printf(MSG_DEBUG, "Control interface "
3733 "directory not empty - leaving it "
3734 "behind");
3735 } else {
3736 wpa_printf(MSG_ERROR,
3737 "rmdir[ctrl_interface=%s]: %s",
3738 interfaces->global_iface_path,
3739 strerror(errno));
3740 }
3741 }
3742 #endif /* CONFIG_CTRL_IFACE_UDP */
3743 }
3744
3745 os_free(interfaces->global_iface_path);
3746 interfaces->global_iface_path = NULL;
3747
3748 dl_list_for_each_safe(dst, prev, &interfaces->global_ctrl_dst,
3749 struct wpa_ctrl_dst, list)
3750 os_free(dst);
3751 }
3752
3753
3754 static void hostapd_ctrl_iface_send(struct hostapd_data *hapd, int level,
3755 enum wpa_msg_type type,
3756 const char *buf, size_t len)
3757 {
3758 struct wpa_ctrl_dst *dst, *next;
3759 struct dl_list *ctrl_dst;
3760 struct msghdr msg;
3761 int idx;
3762 struct iovec io[2];
3763 char levelstr[10];
3764 int s;
3765
3766 if (type != WPA_MSG_ONLY_GLOBAL) {
3767 s = hapd->ctrl_sock;
3768 ctrl_dst = &hapd->ctrl_dst;
3769 } else {
3770 s = hapd->iface->interfaces->global_ctrl_sock;
3771 ctrl_dst = &hapd->iface->interfaces->global_ctrl_dst;
3772 }
3773
3774 if (s < 0 || dl_list_empty(ctrl_dst))
3775 return;
3776
3777 os_snprintf(levelstr, sizeof(levelstr), "<%d>", level);
3778 io[0].iov_base = levelstr;
3779 io[0].iov_len = os_strlen(levelstr);
3780 io[1].iov_base = (char *) buf;
3781 io[1].iov_len = len;
3782 os_memset(&msg, 0, sizeof(msg));
3783 msg.msg_iov = io;
3784 msg.msg_iovlen = 2;
3785
3786 idx = 0;
3787 dl_list_for_each_safe(dst, next, ctrl_dst, struct wpa_ctrl_dst, list) {
3788 if (level >= dst->debug_level) {
3789 sockaddr_print(MSG_DEBUG, "CTRL_IFACE monitor send",
3790 &dst->addr, dst->addrlen);
3791 msg.msg_name = &dst->addr;
3792 msg.msg_namelen = dst->addrlen;
3793 if (sendmsg(s, &msg, 0) < 0) {
3794 int _errno = errno;
3795 wpa_printf(MSG_INFO, "CTRL_IFACE monitor[%d]: "
3796 "%d - %s",
3797 idx, errno, strerror(errno));
3798 dst->errors++;
3799 if (dst->errors > 10 || _errno == ENOENT) {
3800 if (type != WPA_MSG_ONLY_GLOBAL)
3801 hostapd_ctrl_iface_detach(
3802 hapd, &dst->addr,
3803 dst->addrlen);
3804 else
3805 hostapd_global_ctrl_iface_detach(
3806 hapd->iface->interfaces,
3807 &dst->addr,
3808 dst->addrlen);
3809 }
3810 } else
3811 dst->errors = 0;
3812 }
3813 idx++;
3814 }
3815 }
3816
3817 #endif /* CONFIG_NATIVE_WINDOWS */
Unnamed repository; edit this file 'description' to name the repository.