]> git.ipfire.org Git - thirdparty/hostap.git/blame - wpa_supplicant/ctrl_iface.c
projects / thirdparty / hostap.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Move ap_list_timer() to use common AP periodic cleanup mechanism
[thirdparty/hostap.git] / wpa_supplicant / ctrl_iface.c
CommitLineData
6fc6879b
JM		 1/*
2 * WPA Supplicant / Control interface (shared code for all backends)
5e3b5197 3 * Copyright (c) 2004-2015, Jouni Malinen <j@w1.fi>
6fc6879b 4 *
0f3d578e
JM		 5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
6fc6879b
JM		 7 */
8
3a068632 9#include "utils/includes.h"
4a6cc862
JM		 10#ifdef CONFIG_TESTING_OPTIONS
11#include <net/ethernet.h>
12#include <netinet/ip.h>
13#endif /* CONFIG_TESTING_OPTIONS */
6fc6879b 14
3a068632
JM		 15#include "utils/common.h"
16#include "utils/eloop.h"
8aaafcee 17#include "utils/uuid.h"
acec8d32 18#include "common/version.h"
3a068632 19#include "common/ieee802_11_defs.h"
337c781f 20#include "common/ieee802_11_common.h"
3a068632 21#include "common/wpa_ctrl.h"
a1651451 22#include "crypto/tls.h"
9d4ff04a 23#include "ap/hostapd.h"
3a068632
JM		 24#include "eap_peer/eap.h"
25#include "eapol_supp/eapol_supp_sm.h"
3acb5005 26#include "rsn_supp/wpa.h"
3a068632
JM		 27#include "rsn_supp/preauth.h"
28#include "rsn_supp/pmksa_cache.h"
29#include "l2_packet/l2_packet.h"
30#include "wps/wps.h"
3794af2d 31#include "fst/fst_ctrl_iface.h"
6fc6879b 32#include "config.h"
6fc6879b 33#include "wpa_supplicant_i.h"
2d5b792d 34#include "driver_i.h"
fcc60db4 35#include "wps_supplicant.h"
11ef8d35 36#include "ibss_rsn.h"
3ec97afe 37#include "ap.h"
b563b388
JM		 38#include "p2p_supplicant.h"
39#include "p2p/p2p.h"
a8918e86 40#include "hs20_supplicant.h"
9675ce35 41#include "wifi_display.h"
8bac466b 42#include "notify.h"
3a068632 43#include "bss.h"
9ba9fa07 44#include "scan.h"
3a068632 45#include "ctrl_iface.h"
afc064fe 46#include "interworking.h"
9aa10e2b 47#include "blacklist.h"
bc5d330a 48#include "autoscan.h"
e9199e31 49#include "wnm_sta.h"
60b893df 50#include "offchannel.h"
7a4a93b9 51#include "drivers/driver.h"
79070906 52#include "mesh.h"
6fc6879b 53
4b4a8ae5
JM		 54static int wpa_supplicant_global_iface_list(struct wpa_global *global,
55 char *buf, int len);
6fc6879b
JM		 56static int wpa_supplicant_global_iface_interfaces(struct wpa_global *global,
57 char *buf, int len);
d3c9c35f
DS		 58static int * freq_range_to_channel_list(struct wpa_supplicant *wpa_s,
59 char *val);
6fc6879b 60
d445a5cd
JM		 61static int set_bssid_filter(struct wpa_supplicant *wpa_s, char *val)
62{
63 char *pos;
64 u8 addr[ETH_ALEN], *filter = NULL, *n;
65 size_t count = 0;
66
67 pos = val;
68 while (pos) {
69 if (*pos == '\0')
70 break;
1485ec07
JM		 71 if (hwaddr_aton(pos, addr)) {
72 os_free(filter);
d445a5cd 73 return -1;
1485ec07 74 }
067ffa26 75 n = os_realloc_array(filter, count + 1, ETH_ALEN);
d445a5cd
JM		 76 if (n == NULL) {
77 os_free(filter);
78 return -1;
79 }
80 filter = n;
81 os_memcpy(filter + count * ETH_ALEN, addr, ETH_ALEN);
82 count++;
83
84 pos = os_strchr(pos, ' ');
85 if (pos)
86 pos++;
87 }
88
89 wpa_hexdump(MSG_DEBUG, "bssid_filter", filter, count * ETH_ALEN);
90 os_free(wpa_s->bssid_filter);
91 wpa_s->bssid_filter = filter;
92 wpa_s->bssid_filter_count = count;
93
94 return 0;
95}
96
97
6407f413
JM		 98static int set_disallow_aps(struct wpa_supplicant *wpa_s, char *val)
99{
100 char *pos;
101 u8 addr[ETH_ALEN], *bssid = NULL, *n;
102 struct wpa_ssid_value *ssid = NULL, *ns;
103 size_t count = 0, ssid_count = 0;
104 struct wpa_ssid *c;
105
106 /*
65015b2d 107 * disallow_list ::= <ssid_spec> | <bssid_spec> | <disallow_list> | ""
6407f413
JM		 108 * SSID_SPEC ::= ssid <SSID_HEX>
109 * BSSID_SPEC ::= bssid <BSSID_HEX>
110 */
111
112 pos = val;
113 while (pos) {
114 if (*pos == '\0')
115 break;
116 if (os_strncmp(pos, "bssid ", 6) == 0) {
117 int res;
118 pos += 6;
119 res = hwaddr_aton2(pos, addr);
120 if (res < 0) {
121 os_free(ssid);
122 os_free(bssid);
123 wpa_printf(MSG_DEBUG, "Invalid disallow_aps "
124 "BSSID value '%s'", pos);
125 return -1;
126 }
127 pos += res;
128 n = os_realloc_array(bssid, count + 1, ETH_ALEN);
129 if (n == NULL) {
130 os_free(ssid);
131 os_free(bssid);
132 return -1;
133 }
134 bssid = n;
135 os_memcpy(bssid + count * ETH_ALEN, addr, ETH_ALEN);
136 count++;
137 } else if (os_strncmp(pos, "ssid ", 5) == 0) {
138 char *end;
139 pos += 5;
140
141 end = pos;
142 while (*end) {
143 if (*end == '\0' || *end == ' ')
144 break;
145 end++;
146 }
147
148 ns = os_realloc_array(ssid, ssid_count + 1,
149 sizeof(struct wpa_ssid_value));
150 if (ns == NULL) {
151 os_free(ssid);
152 os_free(bssid);
153 return -1;
154 }
155 ssid = ns;
156
d9d1b952
JM		 157 if ((end - pos) & 0x01 ||
158 end - pos > 2 * SSID_MAX_LEN ||
6407f413
JM		 159 hexstr2bin(pos, ssid[ssid_count].ssid,
160 (end - pos) / 2) < 0) {
161 os_free(ssid);
162 os_free(bssid);
163 wpa_printf(MSG_DEBUG, "Invalid disallow_aps "
164 "SSID value '%s'", pos);
165 return -1;
166 }
167 ssid[ssid_count].ssid_len = (end - pos) / 2;
168 wpa_hexdump_ascii(MSG_DEBUG, "disallow_aps SSID",
169 ssid[ssid_count].ssid,
170 ssid[ssid_count].ssid_len);
171 ssid_count++;
172 pos = end;
173 } else {
174 wpa_printf(MSG_DEBUG, "Unexpected disallow_aps value "
175 "'%s'", pos);
176 os_free(ssid);
177 os_free(bssid);
178 return -1;
179 }
180
181 pos = os_strchr(pos, ' ');
182 if (pos)
183 pos++;
184 }
185
186 wpa_hexdump(MSG_DEBUG, "disallow_aps_bssid", bssid, count * ETH_ALEN);
187 os_free(wpa_s->disallow_aps_bssid);
188 wpa_s->disallow_aps_bssid = bssid;
189 wpa_s->disallow_aps_bssid_count = count;
190
191 wpa_printf(MSG_DEBUG, "disallow_aps_ssid_count %d", (int) ssid_count);
192 os_free(wpa_s->disallow_aps_ssid);
193 wpa_s->disallow_aps_ssid = ssid;
194 wpa_s->disallow_aps_ssid_count = ssid_count;
195
196 if (!wpa_s->current_ssid || wpa_s->wpa_state < WPA_AUTHENTICATING)
197 return 0;
198
199 c = wpa_s->current_ssid;
200 if (c->mode != WPAS_MODE_INFRA && c->mode != WPAS_MODE_IBSS)
201 return 0;
202
203 if (!disallowed_bssid(wpa_s, wpa_s->bssid) &&
204 !disallowed_ssid(wpa_s, c->ssid, c->ssid_len))
205 return 0;
206
207 wpa_printf(MSG_DEBUG, "Disconnect and try to find another network "
208 "because current AP was marked disallowed");
209
210#ifdef CONFIG_SME
211 wpa_s->sme.prev_bssid_set = 0;
212#endif /* CONFIG_SME */
213 wpa_s->reassociate = 1;
c2805909 214 wpa_s->own_disconnect_req = 1;
6407f413
JM		 215 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
216 wpa_supplicant_req_scan(wpa_s, 0, 0);
217
218 return 0;
219}
220
221
1120e452
JM		 222#ifndef CONFIG_NO_CONFIG_BLOBS
223static int wpas_ctrl_set_blob(struct wpa_supplicant *wpa_s, char *pos)
224{
225 char *name = pos;
226 struct wpa_config_blob *blob;
227 size_t len;
228
229 pos = os_strchr(pos, ' ');
230 if (pos == NULL)
231 return -1;
232 *pos++ = '\0';
233 len = os_strlen(pos);
234 if (len & 1)
235 return -1;
236
237 wpa_printf(MSG_DEBUG, "CTRL: Set blob '%s'", name);
238 blob = os_zalloc(sizeof(*blob));
239 if (blob == NULL)
240 return -1;
241 blob->name = os_strdup(name);
242 blob->data = os_malloc(len / 2);
243 if (blob->name == NULL || blob->data == NULL) {
244 wpa_config_free_blob(blob);
245 return -1;
246 }
247
248 if (hexstr2bin(pos, blob->data, len / 2) < 0) {
249 wpa_printf(MSG_DEBUG, "CTRL: Invalid blob hex data");
250 wpa_config_free_blob(blob);
251 return -1;
252 }
253 blob->len = len / 2;
254
255 wpa_config_set_blob(wpa_s->conf, blob);
256
257 return 0;
258}
259#endif /* CONFIG_NO_CONFIG_BLOBS */
260
d3c9c35f
DS		 261
262static int wpas_ctrl_pno(struct wpa_supplicant *wpa_s, char *cmd)
263{
264 char *params;
265 char *pos;
266 int *freqs = NULL;
267 int ret;
268
269 if (atoi(cmd)) {
270 params = os_strchr(cmd, ' ');
271 os_free(wpa_s->manual_sched_scan_freqs);
272 if (params) {
273 params++;
274 pos = os_strstr(params, "freq=");
275 if (pos)
276 freqs = freq_range_to_channel_list(wpa_s,
277 pos + 5);
278 }
279 wpa_s->manual_sched_scan_freqs = freqs;
280 ret = wpas_start_pno(wpa_s);
281 } else {
282 ret = wpas_stop_pno(wpa_s);
283 }
284 return ret;
285}
286
287
6fc6879b
JM		 288static int wpa_supplicant_ctrl_iface_set(struct wpa_supplicant *wpa_s,
289 char *cmd)
290{
291 char *value;
292 int ret = 0;
293
294 value = os_strchr(cmd, ' ');
295 if (value == NULL)
296 return -1;
297 *value++ = '\0';
298
299 wpa_printf(MSG_DEBUG, "CTRL_IFACE SET '%s'='%s'", cmd, value);
300 if (os_strcasecmp(cmd, "EAPOL::heldPeriod") == 0) {
301 eapol_sm_configure(wpa_s->eapol,
302 atoi(value), -1, -1, -1);
303 } else if (os_strcasecmp(cmd, "EAPOL::authPeriod") == 0) {
304 eapol_sm_configure(wpa_s->eapol,
305 -1, atoi(value), -1, -1);
306 } else if (os_strcasecmp(cmd, "EAPOL::startPeriod") == 0) {
307 eapol_sm_configure(wpa_s->eapol,
308 -1, -1, atoi(value), -1);
309 } else if (os_strcasecmp(cmd, "EAPOL::maxStart") == 0) {
310 eapol_sm_configure(wpa_s->eapol,
311 -1, -1, -1, atoi(value));
312 } else if (os_strcasecmp(cmd, "dot11RSNAConfigPMKLifetime") == 0) {
313 if (wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
314 atoi(value)))
315 ret = -1;
316 } else if (os_strcasecmp(cmd, "dot11RSNAConfigPMKReauthThreshold") ==
317 0) {
318 if (wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
319 atoi(value)))
320 ret = -1;
321 } else if (os_strcasecmp(cmd, "dot11RSNAConfigSATimeout") == 0) {
322 if (wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT, atoi(value)))
323 ret = -1;
42f50264
JM		 324 } else if (os_strcasecmp(cmd, "wps_fragment_size") == 0) {
325 wpa_s->wps_fragment_size = atoi(value);
b4e34f2f
JM		 326#ifdef CONFIG_WPS_TESTING
327 } else if (os_strcasecmp(cmd, "wps_version_number") == 0) {
328 long int val;
329 val = strtol(value, NULL, 0);
330 if (val < 0 || val > 0xff) {
331 ret = -1;
332 wpa_printf(MSG_DEBUG, "WPS: Invalid "
333 "wps_version_number %ld", val);
334 } else {
335 wps_version_number = val;
336 wpa_printf(MSG_DEBUG, "WPS: Testing - force WPS "
337 "version %u.%u",
338 (wps_version_number & 0xf0) >> 4,
339 wps_version_number & 0x0f);
340 }
341 } else if (os_strcasecmp(cmd, "wps_testing_dummy_cred") == 0) {
342 wps_testing_dummy_cred = atoi(value);
343 wpa_printf(MSG_DEBUG, "WPS: Testing - dummy_cred=%d",
344 wps_testing_dummy_cred);
91226e0d
JM		 345 } else if (os_strcasecmp(cmd, "wps_corrupt_pkhash") == 0) {
346 wps_corrupt_pkhash = atoi(value);
347 wpa_printf(MSG_DEBUG, "WPS: Testing - wps_corrupt_pkhash=%d",
348 wps_corrupt_pkhash);
b4e34f2f 349#endif /* CONFIG_WPS_TESTING */
b6c79a99
JM		 350 } else if (os_strcasecmp(cmd, "ampdu") == 0) {
351 if (wpa_drv_ampdu(wpa_s, atoi(value)) < 0)
352 ret = -1;
9d2cb3ec 353#ifdef CONFIG_TDLS
5b0e6ece
JM		 354#ifdef CONFIG_TDLS_TESTING
355 } else if (os_strcasecmp(cmd, "tdls_testing") == 0) {
356 extern unsigned int tdls_testing;
357 tdls_testing = strtol(value, NULL, 0);
358 wpa_printf(MSG_DEBUG, "TDLS: tdls_testing=0x%x", tdls_testing);
359#endif /* CONFIG_TDLS_TESTING */
b8f64582
JM		 360 } else if (os_strcasecmp(cmd, "tdls_disabled") == 0) {
361 int disabled = atoi(value);
362 wpa_printf(MSG_DEBUG, "TDLS: tdls_disabled=%d", disabled);
363 if (disabled) {
364 if (wpa_drv_tdls_oper(wpa_s, TDLS_DISABLE, NULL) < 0)
365 ret = -1;
366 } else if (wpa_drv_tdls_oper(wpa_s, TDLS_ENABLE, NULL) < 0)
367 ret = -1;
368 wpa_tdls_enable(wpa_s->wpa, !disabled);
369#endif /* CONFIG_TDLS */
b5c68312 370 } else if (os_strcasecmp(cmd, "pno") == 0) {
d3c9c35f 371 ret = wpas_ctrl_pno(wpa_s, value);
8b9d0bfa
JM		 372 } else if (os_strcasecmp(cmd, "radio_disabled") == 0) {
373 int disabled = atoi(value);
374 if (wpa_drv_radio_disable(wpa_s, disabled) < 0)
375 ret = -1;
376 else if (disabled)
377 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
aa074a64
JM		 378 } else if (os_strcasecmp(cmd, "uapsd") == 0) {
379 if (os_strcmp(value, "disable") == 0)
380 wpa_s->set_sta_uapsd = 0;
381 else {
382 int be, bk, vi, vo;
383 char *pos;
384 /* format: BE,BK,VI,VO;max SP Length */
385 be = atoi(value);
386 pos = os_strchr(value, ',');
387 if (pos == NULL)
388 return -1;
389 pos++;
390 bk = atoi(pos);
391 pos = os_strchr(pos, ',');
392 if (pos == NULL)
393 return -1;
394 pos++;
395 vi = atoi(pos);
396 pos = os_strchr(pos, ',');
397 if (pos == NULL)
398 return -1;
399 pos++;
400 vo = atoi(pos);
401 /* ignore max SP Length for now */
402
403 wpa_s->set_sta_uapsd = 1;
404 wpa_s->sta_uapsd = 0;
405 if (be)
406 wpa_s->sta_uapsd |= BIT(0);
407 if (bk)
408 wpa_s->sta_uapsd |= BIT(1);
409 if (vi)
410 wpa_s->sta_uapsd |= BIT(2);
411 if (vo)
412 wpa_s->sta_uapsd |= BIT(3);
413 }
b2ff1681
JM		 414 } else if (os_strcasecmp(cmd, "ps") == 0) {
415 ret = wpa_drv_set_p2p_powersave(wpa_s, atoi(value), -1, -1);
9675ce35
JM		 416#ifdef CONFIG_WIFI_DISPLAY
417 } else if (os_strcasecmp(cmd, "wifi_display") == 0) {
bab6677a
JM		 418 int enabled = !!atoi(value);
419 if (enabled && !wpa_s->global->p2p)
420 ret = -1;
421 else
422 wifi_display_enable(wpa_s->global, enabled);
9675ce35 423#endif /* CONFIG_WIFI_DISPLAY */
d445a5cd
JM		 424 } else if (os_strcasecmp(cmd, "bssid_filter") == 0) {
425 ret = set_bssid_filter(wpa_s, value);
6407f413
JM		 426 } else if (os_strcasecmp(cmd, "disallow_aps") == 0) {
427 ret = set_disallow_aps(wpa_s, value);
2ec535fd
JM		 428 } else if (os_strcasecmp(cmd, "no_keep_alive") == 0) {
429 wpa_s->no_keep_alive = !!atoi(value);
60b893df
JM		 430#ifdef CONFIG_TESTING_OPTIONS
431 } else if (os_strcasecmp(cmd, "ext_mgmt_frame_handling") == 0) {
432 wpa_s->ext_mgmt_frame_handling = !!atoi(value);
9d4ff04a
JM		 433 } else if (os_strcasecmp(cmd, "ext_eapol_frame_io") == 0) {
434 wpa_s->ext_eapol_frame_io = !!atoi(value);
435#ifdef CONFIG_AP
436 if (wpa_s->ap_iface) {
437 wpa_s->ap_iface->bss[0]->ext_eapol_frame_io =
438 wpa_s->ext_eapol_frame_io;
439 }
440#endif /* CONFIG_AP */
1f94e4ee
JM		 441 } else if (os_strcasecmp(cmd, "extra_roc_dur") == 0) {
442 wpa_s->extra_roc_dur = atoi(value);
911942ee
JM		 443 } else if (os_strcasecmp(cmd, "test_failure") == 0) {
444 wpa_s->test_failure = atoi(value);
60b893df 445#endif /* CONFIG_TESTING_OPTIONS */
1120e452
JM		 446#ifndef CONFIG_NO_CONFIG_BLOBS
447 } else if (os_strcmp(cmd, "blob") == 0) {
448 ret = wpas_ctrl_set_blob(wpa_s, value);
449#endif /* CONFIG_NO_CONFIG_BLOBS */
209702d4
JM		 450 } else if (os_strcasecmp(cmd, "setband") == 0) {
451 if (os_strcmp(value, "AUTO") == 0)
452 wpa_s->setband = WPA_SETBAND_AUTO;
453 else if (os_strcmp(value, "5G") == 0)
454 wpa_s->setband = WPA_SETBAND_5G;
455 else if (os_strcmp(value, "2G") == 0)
456 wpa_s->setband = WPA_SETBAND_2G;
457 else
458 ret = -1;
611aea7d
JM		 459 } else {
460 value[-1] = '=';
461 ret = wpa_config_process_global(wpa_s->conf, cmd, -1);
462 if (ret == 0)
463 wpa_supplicant_update_config(wpa_s);
464 }
6fc6879b
JM		 465
466 return ret;
467}
468
469
acec8d32
JM		 470static int wpa_supplicant_ctrl_iface_get(struct wpa_supplicant *wpa_s,
471 char *cmd, char *buf, size_t buflen)
472{
6ce937b8 473 int res = -1;
acec8d32
JM		 474
475 wpa_printf(MSG_DEBUG, "CTRL_IFACE GET '%s'", cmd);
476
477 if (os_strcmp(cmd, "version") == 0) {
478 res = os_snprintf(buf, buflen, "%s", VERSION_STR);
6ce937b8
DS		 479 } else if (os_strcasecmp(cmd, "country") == 0) {
480 if (wpa_s->conf->country[0] && wpa_s->conf->country[1])
481 res = os_snprintf(buf, buflen, "%c%c",
482 wpa_s->conf->country[0],
483 wpa_s->conf->country[1]);
9675ce35
JM		 484#ifdef CONFIG_WIFI_DISPLAY
485 } else if (os_strcasecmp(cmd, "wifi_display") == 0) {
bab6677a
JM		 486 int enabled;
487 if (wpa_s->global->p2p == NULL ||
488 wpa_s->global->p2p_disabled)
489 enabled = 0;
490 else
491 enabled = wpa_s->global->wifi_display;
492 res = os_snprintf(buf, buflen, "%d", enabled);
9675ce35 493#endif /* CONFIG_WIFI_DISPLAY */
fa7ae950
JM		 494#ifdef CONFIG_TESTING_GET_GTK
495 } else if (os_strcmp(cmd, "gtk") == 0) {
496 if (wpa_s->last_gtk_len == 0)
497 return -1;
498 res = wpa_snprintf_hex(buf, buflen, wpa_s->last_gtk,
499 wpa_s->last_gtk_len);
500 return res;
501#endif /* CONFIG_TESTING_GET_GTK */
a1651451
JM		 502 } else if (os_strcmp(cmd, "tls_library") == 0) {
503 res = tls_get_library_version(buf, buflen);
10263dc2
OO		 504 } else {
505 res = wpa_config_get_value(cmd, wpa_s->conf, buf, buflen);
acec8d32
JM		 506 }
507
1f102d3b 508 if (os_snprintf_error(buflen, res))
6ce937b8
DS		 509 return -1;
510 return res;
acec8d32
JM		 511}
512
513
ec717917 514#ifdef IEEE8021X_EAPOL
6fc6879b
JM		 515static int wpa_supplicant_ctrl_iface_preauth(struct wpa_supplicant *wpa_s,
516 char *addr)
517{
518 u8 bssid[ETH_ALEN];
519 struct wpa_ssid *ssid = wpa_s->current_ssid;
520
521 if (hwaddr_aton(addr, bssid)) {
522 wpa_printf(MSG_DEBUG, "CTRL_IFACE PREAUTH: invalid address "
523 "'%s'", addr);
524 return -1;
525 }
526
527 wpa_printf(MSG_DEBUG, "CTRL_IFACE PREAUTH " MACSTR, MAC2STR(bssid));
528 rsn_preauth_deinit(wpa_s->wpa);
529 if (rsn_preauth_init(wpa_s->wpa, bssid, ssid ? &ssid->eap : NULL))
530 return -1;
531
532 return 0;
533}
ec717917 534#endif /* IEEE8021X_EAPOL */
6fc6879b
JM		 535
536
537#ifdef CONFIG_PEERKEY
538/* MLME-STKSTART.request(peer) */
539static int wpa_supplicant_ctrl_iface_stkstart(
540 struct wpa_supplicant *wpa_s, char *addr)
541{
542 u8 peer[ETH_ALEN];
543
544 if (hwaddr_aton(addr, peer)) {
545 wpa_printf(MSG_DEBUG, "CTRL_IFACE STKSTART: invalid "
a7b6c422 546 "address '%s'", addr);
6fc6879b
JM		 547 return -1;
548 }
549
550 wpa_printf(MSG_DEBUG, "CTRL_IFACE STKSTART " MACSTR,
551 MAC2STR(peer));
552
553 return wpa_sm_stkstart(wpa_s->wpa, peer);
554}
555#endif /* CONFIG_PEERKEY */
556
557
281ff0aa
GP		 558#ifdef CONFIG_TDLS
559
560static int wpa_supplicant_ctrl_iface_tdls_discover(
561 struct wpa_supplicant *wpa_s, char *addr)
562{
563 u8 peer[ETH_ALEN];
2d565a61 564 int ret;
281ff0aa
GP		 565
566 if (hwaddr_aton(addr, peer)) {
567 wpa_printf(MSG_DEBUG, "CTRL_IFACE TDLS_DISCOVER: invalid "
568 "address '%s'", addr);
569 return -1;
570 }
571
572 wpa_printf(MSG_DEBUG, "CTRL_IFACE TDLS_DISCOVER " MACSTR,
573 MAC2STR(peer));
574
2d565a61
AN		 575 if (wpa_tdls_is_external_setup(wpa_s->wpa))
576 ret = wpa_tdls_send_discovery_request(wpa_s->wpa, peer);
577 else
578 ret = wpa_drv_tdls_oper(wpa_s, TDLS_DISCOVERY_REQ, peer);
579
580 return ret;
281ff0aa
GP		 581}
582
583
584static int wpa_supplicant_ctrl_iface_tdls_setup(
585 struct wpa_supplicant *wpa_s, char *addr)
586{
587 u8 peer[ETH_ALEN];
94377fbc 588 int ret;
281ff0aa
GP		 589
590 if (hwaddr_aton(addr, peer)) {
591 wpa_printf(MSG_DEBUG, "CTRL_IFACE TDLS_SETUP: invalid "
592 "address '%s'", addr);
593 return -1;
594 }
595
596 wpa_printf(MSG_DEBUG, "CTRL_IFACE TDLS_SETUP " MACSTR,
597 MAC2STR(peer));
598
800d5872
SD		 599 if ((wpa_s->conf->tdls_external_control) &&
600 wpa_tdls_is_external_setup(wpa_s->wpa))
601 return wpa_drv_tdls_oper(wpa_s, TDLS_SETUP, peer);
602
3887878e
SD		 603 wpa_tdls_remove(wpa_s->wpa, peer);
604
605 if (wpa_tdls_is_external_setup(wpa_s->wpa))
606 ret = wpa_tdls_start(wpa_s->wpa, peer);
607 else
608 ret = wpa_drv_tdls_oper(wpa_s, TDLS_SETUP, peer);
2d565a61 609
94377fbc 610 return ret;
281ff0aa
GP		 611}
612
613
614static int wpa_supplicant_ctrl_iface_tdls_teardown(
615 struct wpa_supplicant *wpa_s, char *addr)
616{
617 u8 peer[ETH_ALEN];
4ed8d954 618 int ret;
281ff0aa 619
38ddccae
AN		 620 if (os_strcmp(addr, "*") == 0) {
621 /* remove everyone */
622 wpa_printf(MSG_DEBUG, "CTRL_IFACE TDLS_TEARDOWN *");
623 wpa_tdls_teardown_peers(wpa_s->wpa);
624 return 0;
625 }
626
281ff0aa
GP		 627 if (hwaddr_aton(addr, peer)) {
628 wpa_printf(MSG_DEBUG, "CTRL_IFACE TDLS_TEARDOWN: invalid "
629 "address '%s'", addr);
630 return -1;
631 }
632
633 wpa_printf(MSG_DEBUG, "CTRL_IFACE TDLS_TEARDOWN " MACSTR,
634 MAC2STR(peer));
635
800d5872
SD		 636 if ((wpa_s->conf->tdls_external_control) &&
637 wpa_tdls_is_external_setup(wpa_s->wpa))
638 return wpa_drv_tdls_oper(wpa_s, TDLS_TEARDOWN, peer);
639
4ed8d954
AS		 640 if (wpa_tdls_is_external_setup(wpa_s->wpa))
641 ret = wpa_tdls_teardown_link(
642 wpa_s->wpa, peer,
643 WLAN_REASON_TDLS_TEARDOWN_UNSPECIFIED);
644 else
645 ret = wpa_drv_tdls_oper(wpa_s, TDLS_TEARDOWN, peer);
646
647 return ret;
281ff0aa
GP		 648}
649
6e9375e4
DS		 650
651static int ctrl_iface_get_capability_tdls(
652 struct wpa_supplicant *wpa_s, char *buf, size_t buflen)
653{
654 int ret;
655
656 ret = os_snprintf(buf, buflen, "%s\n",
657 wpa_s->drv_flags & WPA_DRIVER_FLAGS_TDLS_SUPPORT ?
658 (wpa_s->drv_flags &
659 WPA_DRIVER_FLAGS_TDLS_EXTERNAL_SETUP ?
660 "EXTERNAL" : "INTERNAL") : "UNSUPPORTED");
7bdd8981 661 if (os_snprintf_error(buflen, ret))
6e9375e4
DS		 662 return -1;
663 return ret;
664}
665
6b90deae
AN		 666
667static int wpa_supplicant_ctrl_iface_tdls_chan_switch(
668 struct wpa_supplicant *wpa_s, char *cmd)
669{
670 u8 peer[ETH_ALEN];
671 struct hostapd_freq_params freq_params;
672 u8 oper_class;
673 char *pos, *end;
674
675 if (!wpa_tdls_is_external_setup(wpa_s->wpa)) {
676 wpa_printf(MSG_INFO,
677 "tdls_chanswitch: Only supported with external setup");
678 return -1;
679 }
680
681 os_memset(&freq_params, 0, sizeof(freq_params));
682
683 pos = os_strchr(cmd, ' ');
684 if (pos == NULL)
685 return -1;
686 *pos++ = '\0';
687
688 oper_class = strtol(pos, &end, 10);
689 if (pos == end) {
690 wpa_printf(MSG_INFO,
691 "tdls_chanswitch: Invalid op class provided");
692 return -1;
693 }
694
695 pos = end;
696 freq_params.freq = atoi(pos);
697 if (freq_params.freq == 0) {
698 wpa_printf(MSG_INFO, "tdls_chanswitch: Invalid freq provided");
699 return -1;
700 }
701
702#define SET_FREQ_SETTING(str) \
703 do { \
704 const char *pos2 = os_strstr(pos, " " #str "="); \
705 if (pos2) { \
706 pos2 += sizeof(" " #str "=") - 1; \
707 freq_params.str = atoi(pos2); \
708 } \
709 } while (0)
710
711 SET_FREQ_SETTING(center_freq1);
712 SET_FREQ_SETTING(center_freq2);
713 SET_FREQ_SETTING(bandwidth);
714 SET_FREQ_SETTING(sec_channel_offset);
715#undef SET_FREQ_SETTING
716
717 freq_params.ht_enabled = !!os_strstr(pos, " ht");
718 freq_params.vht_enabled = !!os_strstr(pos, " vht");
719
720 if (hwaddr_aton(cmd, peer)) {
721 wpa_printf(MSG_DEBUG,
722 "CTRL_IFACE TDLS_CHAN_SWITCH: Invalid address '%s'",
723 cmd);
724 return -1;
725 }
726
727 wpa_printf(MSG_DEBUG, "CTRL_IFACE TDLS_CHAN_SWITCH " MACSTR
728 " OP CLASS %d FREQ %d CENTER1 %d CENTER2 %d BW %d SEC_OFFSET %d%s%s",
729 MAC2STR(peer), oper_class, freq_params.freq,
730 freq_params.center_freq1, freq_params.center_freq2,
731 freq_params.bandwidth, freq_params.sec_channel_offset,
732 freq_params.ht_enabled ? " HT" : "",
733 freq_params.vht_enabled ? " VHT" : "");
734
735 return wpa_tdls_enable_chan_switch(wpa_s->wpa, peer, oper_class,
736 &freq_params);
737}
738
739
740static int wpa_supplicant_ctrl_iface_tdls_cancel_chan_switch(
741 struct wpa_supplicant *wpa_s, char *cmd)
742{
743 u8 peer[ETH_ALEN];
744
745 if (!wpa_tdls_is_external_setup(wpa_s->wpa)) {
746 wpa_printf(MSG_INFO,
747 "tdls_chanswitch: Only supported with external setup");
748 return -1;
749 }
750
751 if (hwaddr_aton(cmd, peer)) {
752 wpa_printf(MSG_DEBUG,
753 "CTRL_IFACE TDLS_CANCEL_CHAN_SWITCH: Invalid address '%s'",
754 cmd);
755 return -1;
756 }
757
758 wpa_printf(MSG_DEBUG, "CTRL_IFACE TDLS_CANCEL_CHAN_SWITCH " MACSTR,
759 MAC2STR(peer));
760
761 return wpa_tdls_disable_chan_switch(wpa_s->wpa, peer);
762}
763
4504621f
OG		 764
765static int wpa_supplicant_ctrl_iface_tdls_link_status(
766 struct wpa_supplicant *wpa_s, const char *addr,
767 char *buf, size_t buflen)
768{
769 u8 peer[ETH_ALEN];
770 const char *tdls_status;
771 int ret;
772
773 if (hwaddr_aton(addr, peer)) {
774 wpa_printf(MSG_DEBUG,
775 "CTRL_IFACE TDLS_LINK_STATUS: Invalid address '%s'",
776 addr);
777 return -1;
778 }
779 wpa_printf(MSG_DEBUG, "CTRL_IFACE TDLS_LINK_STATUS " MACSTR,
780 MAC2STR(peer));
781
782 tdls_status = wpa_tdls_get_link_status(wpa_s->wpa, peer);
783 wpa_printf(MSG_DEBUG, "CTRL_IFACE TDLS_LINK_STATUS: %s", tdls_status);
784 ret = os_snprintf(buf, buflen, "TDLS link status: %s\n", tdls_status);
785 if (os_snprintf_error(buflen, ret))
786 return -1;
787
788 return ret;
789}
790
281ff0aa
GP		 791#endif /* CONFIG_TDLS */
792
793
eb2f2088
MB		 794static int wmm_ac_ctrl_addts(struct wpa_supplicant *wpa_s, char *cmd)
795{
796 char *token, *context = NULL;
797 struct wmm_ac_ts_setup_params params = {
798 .tsid = 0xff,
799 .direction = 0xff,
800 };
801
802 while ((token = str_token(cmd, " ", &context))) {
803 if (sscanf(token, "tsid=%i", &params.tsid) == 1 ||
804 sscanf(token, "up=%i", &params.user_priority) == 1 ||
805 sscanf(token, "nominal_msdu_size=%i",
806 &params.nominal_msdu_size) == 1 ||
807 sscanf(token, "mean_data_rate=%i",
808 &params.mean_data_rate) == 1 ||
809 sscanf(token, "min_phy_rate=%i",
810 &params.minimum_phy_rate) == 1 ||
811 sscanf(token, "sba=%i",
812 &params.surplus_bandwidth_allowance) == 1)
813 continue;
814
815 if (os_strcasecmp(token, "downlink") == 0) {
816 params.direction = WMM_TSPEC_DIRECTION_DOWNLINK;
817 } else if (os_strcasecmp(token, "uplink") == 0) {
818 params.direction = WMM_TSPEC_DIRECTION_UPLINK;
819 } else if (os_strcasecmp(token, "bidi") == 0) {
820 params.direction = WMM_TSPEC_DIRECTION_BI_DIRECTIONAL;
821 } else if (os_strcasecmp(token, "fixed_nominal_msdu") == 0) {
822 params.fixed_nominal_msdu = 1;
823 } else {
824 wpa_printf(MSG_DEBUG,
825 "CTRL: Invalid WMM_AC_ADDTS parameter: '%s'",
826 token);
827 return -1;
828 }
829
830 }
831
832 return wpas_wmm_ac_addts(wpa_s, &params);
833}
834
835
836static int wmm_ac_ctrl_delts(struct wpa_supplicant *wpa_s, char *cmd)
837{
838 u8 tsid = atoi(cmd);
839
840 return wpas_wmm_ac_delts(wpa_s, tsid);
841}
842
843
6fc6879b
JM		 844#ifdef CONFIG_IEEE80211R
845static int wpa_supplicant_ctrl_iface_ft_ds(
846 struct wpa_supplicant *wpa_s, char *addr)
847{
848 u8 target_ap[ETH_ALEN];
76b7981d
JM		 849 struct wpa_bss *bss;
850 const u8 *mdie;
6fc6879b
JM		 851
852 if (hwaddr_aton(addr, target_ap)) {
853 wpa_printf(MSG_DEBUG, "CTRL_IFACE FT_DS: invalid "
a7b6c422 854 "address '%s'", addr);
6fc6879b
JM		 855 return -1;
856 }
857
858 wpa_printf(MSG_DEBUG, "CTRL_IFACE FT_DS " MACSTR, MAC2STR(target_ap));
859
76b7981d
JM		 860 bss = wpa_bss_get_bssid(wpa_s, target_ap);
861 if (bss)
862 mdie = wpa_bss_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN);
863 else
864 mdie = NULL;
865
866 return wpa_ft_start_over_ds(wpa_s->wpa, target_ap, mdie);
6fc6879b
JM		 867}
868#endif /* CONFIG_IEEE80211R */
869
870
fcc60db4
JM		 871#ifdef CONFIG_WPS
872static int wpa_supplicant_ctrl_iface_wps_pbc(struct wpa_supplicant *wpa_s,
873 char *cmd)
874{
3ec97afe 875 u8 bssid[ETH_ALEN], *_bssid = bssid;
ceb34f25 876#ifdef CONFIG_P2P
634ce802 877 u8 p2p_dev_addr[ETH_ALEN];
ceb34f25 878#endif /* CONFIG_P2P */
634ce802
JM		 879#ifdef CONFIG_AP
880 u8 *_p2p_dev_addr = NULL;
881#endif /* CONFIG_AP */
fcc60db4 882
d601247c 883 if (cmd == NULL || os_strcmp(cmd, "any") == 0) {
3ec97afe 884 _bssid = NULL;
d601247c
JM		 885#ifdef CONFIG_P2P
886 } else if (os_strncmp(cmd, "p2p_dev_addr=", 13) == 0) {
887 if (hwaddr_aton(cmd + 13, p2p_dev_addr)) {
888 wpa_printf(MSG_DEBUG, "CTRL_IFACE WPS_PBC: invalid "
889 "P2P Device Address '%s'",
890 cmd + 13);
891 return -1;
892 }
893 _p2p_dev_addr = p2p_dev_addr;
894#endif /* CONFIG_P2P */
895 } else if (hwaddr_aton(cmd, bssid)) {
fcc60db4
JM		 896 wpa_printf(MSG_DEBUG, "CTRL_IFACE WPS_PBC: invalid BSSID '%s'",
897 cmd);
898 return -1;
899 }
900
3ec97afe
JM		 901#ifdef CONFIG_AP
902 if (wpa_s->ap_iface)
d601247c 903 return wpa_supplicant_ap_wps_pbc(wpa_s, _bssid, _p2p_dev_addr);
3ec97afe
JM		 904#endif /* CONFIG_AP */
905
9fa243b2 906 return wpas_wps_start_pbc(wpa_s, _bssid, 0);
fcc60db4
JM		 907}
908
909
910static int wpa_supplicant_ctrl_iface_wps_pin(struct wpa_supplicant *wpa_s,
911 char *cmd, char *buf,
912 size_t buflen)
913{
914 u8 bssid[ETH_ALEN], *_bssid = bssid;
915 char *pin;
916 int ret;
917
918 pin = os_strchr(cmd, ' ');
919 if (pin)
920 *pin++ = '\0';
921
922 if (os_strcmp(cmd, "any") == 0)
923 _bssid = NULL;
98aa7ca5
JM		 924 else if (os_strcmp(cmd, "get") == 0) {
925 ret = wps_generate_pin();
926 goto done;
927 } else if (hwaddr_aton(cmd, bssid)) {
3c1e2765 928 wpa_printf(MSG_DEBUG, "CTRL_IFACE WPS_PIN: invalid BSSID '%s'",
fcc60db4
JM		 929 cmd);
930 return -1;
931 }
932
3ec97afe 933#ifdef CONFIG_AP
c423708f
JM		 934 if (wpa_s->ap_iface) {
935 int timeout = 0;
936 char *pos;
937
938 if (pin) {
939 pos = os_strchr(pin, ' ');
940 if (pos) {
941 *pos++ = '\0';
942 timeout = atoi(pos);
943 }
944 }
945
3ec97afe 946 return wpa_supplicant_ap_wps_pin(wpa_s, _bssid, pin,
c423708f
JM		 947 buf, buflen, timeout);
948 }
3ec97afe
JM		 949#endif /* CONFIG_AP */
950
fcc60db4 951 if (pin) {
3c5126a4
JM		 952 ret = wpas_wps_start_pin(wpa_s, _bssid, pin, 0,
953 DEV_PW_DEFAULT);
fcc60db4
JM		 954 if (ret < 0)
955 return -1;
956 ret = os_snprintf(buf, buflen, "%s", pin);
d85e1fc8 957 if (os_snprintf_error(buflen, ret))
fcc60db4
JM		 958 return -1;
959 return ret;
960 }
961
3c5126a4 962 ret = wpas_wps_start_pin(wpa_s, _bssid, NULL, 0, DEV_PW_DEFAULT);
fcc60db4
JM		 963 if (ret < 0)
964 return -1;
965
98aa7ca5 966done:
fcc60db4
JM		 967 /* Return the generated PIN */
968 ret = os_snprintf(buf, buflen, "%08d", ret);
d85e1fc8 969 if (os_snprintf_error(buflen, ret))
fcc60db4
JM		 970 return -1;
971 return ret;
972}
973
974
3981cb3c
JM		 975static int wpa_supplicant_ctrl_iface_wps_check_pin(
976 struct wpa_supplicant *wpa_s, char *cmd, char *buf, size_t buflen)
977{
978 char pin[9];
979 size_t len;
980 char *pos;
981 int ret;
982
983 wpa_hexdump_ascii_key(MSG_DEBUG, "WPS_CHECK_PIN",
984 (u8 *) cmd, os_strlen(cmd));
985 for (pos = cmd, len = 0; *pos != '\0'; pos++) {
986 if (*pos < '0' || *pos > '9')
987 continue;
988 pin[len++] = *pos;
989 if (len == 9) {
990 wpa_printf(MSG_DEBUG, "WPS: Too long PIN");
991 return -1;
992 }
993 }
994 if (len != 4 && len != 8) {
995 wpa_printf(MSG_DEBUG, "WPS: Invalid PIN length %d", (int) len);
996 return -1;
997 }
998 pin[len] = '\0';
999
1000 if (len == 8) {
1001 unsigned int pin_val;
1002 pin_val = atoi(pin);
1003 if (!wps_pin_valid(pin_val)) {
1004 wpa_printf(MSG_DEBUG, "WPS: Invalid checksum digit");
1005 ret = os_snprintf(buf, buflen, "FAIL-CHECKSUM\n");
d85e1fc8 1006 if (os_snprintf_error(buflen, ret))
3981cb3c
JM		 1007 return -1;
1008 return ret;
1009 }
1010 }
1011
1012 ret = os_snprintf(buf, buflen, "%s", pin);
d85e1fc8 1013 if (os_snprintf_error(buflen, ret))
3981cb3c
JM		 1014 return -1;
1015
1016 return ret;
1017}
1018
1019
71892384 1020#ifdef CONFIG_WPS_NFC
3f2c8ba6
JM		 1021
1022static int wpa_supplicant_ctrl_iface_wps_nfc(struct wpa_supplicant *wpa_s,
1023 char *cmd)
1024{
1025 u8 bssid[ETH_ALEN], *_bssid = bssid;
1026
1027 if (cmd == NULL || cmd[0] == '\0')
1028 _bssid = NULL;
1029 else if (hwaddr_aton(cmd, bssid))
1030 return -1;
1031
23318bea 1032 return wpas_wps_start_nfc(wpa_s, NULL, _bssid, NULL, 0, 0, NULL, NULL,
91a65018 1033 0, 0);
3f2c8ba6
JM		 1034}
1035
1036
bbf41865
JM		 1037static int wpa_supplicant_ctrl_iface_wps_nfc_config_token(
1038 struct wpa_supplicant *wpa_s, char *cmd, char *reply, size_t max_len)
1039{
1040 int ndef;
1041 struct wpabuf *buf;
1042 int res;
88c8bf31 1043 char *pos;
bbf41865 1044
88c8bf31
JM		 1045 pos = os_strchr(cmd, ' ');
1046 if (pos)
1047 *pos++ = '\0';
bbf41865
JM		 1048 if (os_strcmp(cmd, "WPS") == 0)
1049 ndef = 0;
1050 else if (os_strcmp(cmd, "NDEF") == 0)
1051 ndef = 1;
1052 else
1053 return -1;
1054
88c8bf31 1055 buf = wpas_wps_nfc_config_token(wpa_s, ndef, pos);
bbf41865
JM		 1056 if (buf == NULL)
1057 return -1;
1058
1059 res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf),
1060 wpabuf_len(buf));
1061 reply[res++] = '\n';
1062 reply[res] = '\0';
1063
1064 wpabuf_free(buf);
1065
1066 return res;
1067}
1068
1069
3f2c8ba6
JM		 1070static int wpa_supplicant_ctrl_iface_wps_nfc_token(
1071 struct wpa_supplicant *wpa_s, char *cmd, char *reply, size_t max_len)
1072{
1073 int ndef;
1074 struct wpabuf *buf;
1075 int res;
1076
1077 if (os_strcmp(cmd, "WPS") == 0)
1078 ndef = 0;
1079 else if (os_strcmp(cmd, "NDEF") == 0)
1080 ndef = 1;
1081 else
1082 return -1;
1083
1084 buf = wpas_wps_nfc_token(wpa_s, ndef);
1085 if (buf == NULL)
1086 return -1;
1087
1088 res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf),
1089 wpabuf_len(buf));
1090 reply[res++] = '\n';
1091 reply[res] = '\0';
1092
1093 wpabuf_free(buf);
1094
1095 return res;
1096}
d7645d23
JM		 1097
1098
1099static int wpa_supplicant_ctrl_iface_wps_nfc_tag_read(
1100 struct wpa_supplicant *wpa_s, char *pos)
1101{
1102 size_t len;
1103 struct wpabuf *buf;
1104 int ret;
b56f6c88
JM		 1105 char *freq;
1106 int forced_freq = 0;
1107
1108 freq = strstr(pos, " freq=");
1109 if (freq) {
1110 *freq = '\0';
1111 freq += 6;
1112 forced_freq = atoi(freq);
1113 }
d7645d23
JM		 1114
1115 len = os_strlen(pos);
1116 if (len & 0x01)
1117 return -1;
1118 len /= 2;
1119
1120 buf = wpabuf_alloc(len);
1121 if (buf == NULL)
1122 return -1;
1123 if (hexstr2bin(pos, wpabuf_put(buf, len), len) < 0) {
1124 wpabuf_free(buf);
1125 return -1;
1126 }
1127
b56f6c88 1128 ret = wpas_wps_nfc_tag_read(wpa_s, buf, forced_freq);
d7645d23
JM		 1129 wpabuf_free(buf);
1130
1131 return ret;
1132}
71892384 1133
e65552dd
JM		 1134
1135static int wpas_ctrl_nfc_get_handover_req_wps(struct wpa_supplicant *wpa_s,
bbaaaee1 1136 char *reply, size_t max_len,
41f9ffb6 1137 int ndef)
e65552dd
JM		 1138{
1139 struct wpabuf *buf;
1140 int res;
1141
41f9ffb6 1142 buf = wpas_wps_nfc_handover_req(wpa_s, ndef);
e65552dd
JM		 1143 if (buf == NULL)
1144 return -1;
1145
1146 res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf),
1147 wpabuf_len(buf));
1148 reply[res++] = '\n';
1149 reply[res] = '\0';
1150
1151 wpabuf_free(buf);
1152
1153 return res;
1154}
1155
1156
88853aed 1157#ifdef CONFIG_P2P
93588780
JM		 1158static int wpas_ctrl_nfc_get_handover_req_p2p(struct wpa_supplicant *wpa_s,
1159 char *reply, size_t max_len,
1160 int ndef)
1161{
1162 struct wpabuf *buf;
1163 int res;
1164
1165 buf = wpas_p2p_nfc_handover_req(wpa_s, ndef);
1166 if (buf == NULL) {
1167 wpa_printf(MSG_DEBUG, "P2P: Could not generate NFC handover request");
1168 return -1;
1169 }
1170
1171 res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf),
1172 wpabuf_len(buf));
1173 reply[res++] = '\n';
1174 reply[res] = '\0';
1175
1176 wpabuf_free(buf);
1177
1178 return res;
1179}
88853aed 1180#endif /* CONFIG_P2P */
93588780
JM		 1181
1182
e65552dd
JM		 1183static int wpas_ctrl_nfc_get_handover_req(struct wpa_supplicant *wpa_s,
1184 char *cmd, char *reply,
1185 size_t max_len)
1186{
1187 char *pos;
41f9ffb6 1188 int ndef;
e65552dd
JM		 1189
1190 pos = os_strchr(cmd, ' ');
1191 if (pos == NULL)
1192 return -1;
1193 *pos++ = '\0';
1194
41f9ffb6
JM		 1195 if (os_strcmp(cmd, "WPS") == 0)
1196 ndef = 0;
1197 else if (os_strcmp(cmd, "NDEF") == 0)
1198 ndef = 1;
1199 else
e65552dd
JM		 1200 return -1;
1201
bbaaaee1 1202 if (os_strcmp(pos, "WPS") == 0 || os_strcmp(pos, "WPS-CR") == 0) {
41f9ffb6
JM		 1203 if (!ndef)
1204 return -1;
bbaaaee1 1205 return wpas_ctrl_nfc_get_handover_req_wps(
41f9ffb6 1206 wpa_s, reply, max_len, ndef);
e65552dd
JM		 1207 }
1208
88853aed 1209#ifdef CONFIG_P2P
93588780
JM		 1210 if (os_strcmp(pos, "P2P-CR") == 0) {
1211 return wpas_ctrl_nfc_get_handover_req_p2p(
1212 wpa_s, reply, max_len, ndef);
1213 }
88853aed 1214#endif /* CONFIG_P2P */
93588780 1215
e65552dd
JM		 1216 return -1;
1217}
1218
1219
1220static int wpas_ctrl_nfc_get_handover_sel_wps(struct wpa_supplicant *wpa_s,
5ab9a6a5 1221 char *reply, size_t max_len,
f3f2ba2e 1222 int ndef, int cr, char *uuid)
e65552dd
JM		 1223{
1224 struct wpabuf *buf;
1225 int res;
1226
f3f2ba2e 1227 buf = wpas_wps_nfc_handover_sel(wpa_s, ndef, cr, uuid);
e65552dd
JM		 1228 if (buf == NULL)
1229 return -1;
1230
1231 res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf),
1232 wpabuf_len(buf));
1233 reply[res++] = '\n';
1234 reply[res] = '\0';
1235
1236 wpabuf_free(buf);
1237
1238 return res;
1239}
1240
1241
88853aed 1242#ifdef CONFIG_P2P
93588780
JM		 1243static int wpas_ctrl_nfc_get_handover_sel_p2p(struct wpa_supplicant *wpa_s,
1244 char *reply, size_t max_len,
1245 int ndef, int tag)
1246{
1247 struct wpabuf *buf;
1248 int res;
1249
1250 buf = wpas_p2p_nfc_handover_sel(wpa_s, ndef, tag);
1251 if (buf == NULL)
1252 return -1;
1253
1254 res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf),
1255 wpabuf_len(buf));
1256 reply[res++] = '\n';
1257 reply[res] = '\0';
1258
1259 wpabuf_free(buf);
1260
1261 return res;
1262}
88853aed 1263#endif /* CONFIG_P2P */
93588780
JM		 1264
1265
e65552dd
JM		 1266static int wpas_ctrl_nfc_get_handover_sel(struct wpa_supplicant *wpa_s,
1267 char *cmd, char *reply,
1268 size_t max_len)
1269{
f3f2ba2e 1270 char *pos, *pos2;
5ab9a6a5 1271 int ndef;
e65552dd
JM		 1272
1273 pos = os_strchr(cmd, ' ');
1274 if (pos == NULL)
1275 return -1;
1276 *pos++ = '\0';
1277
5ab9a6a5
JM		 1278 if (os_strcmp(cmd, "WPS") == 0)
1279 ndef = 0;
1280 else if (os_strcmp(cmd, "NDEF") == 0)
1281 ndef = 1;
1282 else
e65552dd
JM		 1283 return -1;
1284
f3f2ba2e
JM		 1285 pos2 = os_strchr(pos, ' ');
1286 if (pos2)
1287 *pos2++ = '\0';
5ab9a6a5 1288 if (os_strcmp(pos, "WPS") == 0 || os_strcmp(pos, "WPS-CR") == 0) {
93588780
JM		 1289 if (!ndef)
1290 return -1;
5ab9a6a5
JM		 1291 return wpas_ctrl_nfc_get_handover_sel_wps(
1292 wpa_s, reply, max_len, ndef,
f3f2ba2e 1293 os_strcmp(pos, "WPS-CR") == 0, pos2);
e65552dd
JM		 1294 }
1295
88853aed 1296#ifdef CONFIG_P2P
93588780
JM		 1297 if (os_strcmp(pos, "P2P-CR") == 0) {
1298 return wpas_ctrl_nfc_get_handover_sel_p2p(
1299 wpa_s, reply, max_len, ndef, 0);
1300 }
1301
1302 if (os_strcmp(pos, "P2P-CR-TAG") == 0) {
1303 return wpas_ctrl_nfc_get_handover_sel_p2p(
1304 wpa_s, reply, max_len, ndef, 1);
1305 }
88853aed 1306#endif /* CONFIG_P2P */
93588780 1307
e65552dd
JM		 1308 return -1;
1309}
1310
1311
e4758827
JM		 1312static int wpas_ctrl_nfc_report_handover(struct wpa_supplicant *wpa_s,
1313 char *cmd)
1314{
1315 size_t len;
1316 struct wpabuf *req, *sel;
1317 int ret;
1318 char *pos, *role, *type, *pos2;
88853aed 1319#ifdef CONFIG_P2P
b56f6c88
JM		 1320 char *freq;
1321 int forced_freq = 0;
1322
1323 freq = strstr(cmd, " freq=");
1324 if (freq) {
1325 *freq = '\0';
1326 freq += 6;
1327 forced_freq = atoi(freq);
1328 }
88853aed 1329#endif /* CONFIG_P2P */
e4758827
JM		 1330
1331 role = cmd;
1332 pos = os_strchr(role, ' ');
73127764
JM		 1333 if (pos == NULL) {
1334 wpa_printf(MSG_DEBUG, "NFC: Missing type in handover report");
e4758827 1335 return -1;
73127764 1336 }
e4758827
JM		 1337 *pos++ = '\0';
1338
1339 type = pos;
1340 pos = os_strchr(type, ' ');
73127764
JM		 1341 if (pos == NULL) {
1342 wpa_printf(MSG_DEBUG, "NFC: Missing request message in handover report");
e4758827 1343 return -1;
73127764 1344 }
e4758827
JM		 1345 *pos++ = '\0';
1346
1347 pos2 = os_strchr(pos, ' ');
73127764
JM		 1348 if (pos2 == NULL) {
1349 wpa_printf(MSG_DEBUG, "NFC: Missing select message in handover report");
e4758827 1350 return -1;
73127764 1351 }
e4758827
JM		 1352 *pos2++ = '\0';
1353
1354 len = os_strlen(pos);
73127764
JM		 1355 if (len & 0x01) {
1356 wpa_printf(MSG_DEBUG, "NFC: Invalid request message length in handover report");
e4758827 1357 return -1;
73127764 1358 }
e4758827
JM		 1359 len /= 2;
1360
1361 req = wpabuf_alloc(len);
73127764
JM		 1362 if (req == NULL) {
1363 wpa_printf(MSG_DEBUG, "NFC: Failed to allocate memory for request message");
e4758827 1364 return -1;
73127764 1365 }
e4758827 1366 if (hexstr2bin(pos, wpabuf_put(req, len), len) < 0) {
73127764 1367 wpa_printf(MSG_DEBUG, "NFC: Invalid request message hexdump in handover report");
e4758827
JM		 1368 wpabuf_free(req);
1369 return -1;
1370 }
1371
1372 len = os_strlen(pos2);
1373 if (len & 0x01) {
73127764 1374 wpa_printf(MSG_DEBUG, "NFC: Invalid select message length in handover report");
e4758827
JM		 1375 wpabuf_free(req);
1376 return -1;
1377 }
1378 len /= 2;
1379
1380 sel = wpabuf_alloc(len);
1381 if (sel == NULL) {
73127764 1382 wpa_printf(MSG_DEBUG, "NFC: Failed to allocate memory for select message");
e4758827
JM		 1383 wpabuf_free(req);
1384 return -1;
1385 }
1386 if (hexstr2bin(pos2, wpabuf_put(sel, len), len) < 0) {
73127764 1387 wpa_printf(MSG_DEBUG, "NFC: Invalid select message hexdump in handover report");
e4758827
JM		 1388 wpabuf_free(req);
1389 wpabuf_free(sel);
1390 return -1;
1391 }
1392
73127764
JM		 1393 wpa_printf(MSG_DEBUG, "NFC: Connection handover reported - role=%s type=%s req_len=%d sel_len=%d",
1394 role, type, (int) wpabuf_len(req), (int) wpabuf_len(sel));
1395
e4758827
JM		 1396 if (os_strcmp(role, "INIT") == 0 && os_strcmp(type, "WPS") == 0) {
1397 ret = wpas_wps_nfc_report_handover(wpa_s, req, sel);
88853aed 1398#ifdef CONFIG_AP
d9507936
JM		 1399 } else if (os_strcmp(role, "RESP") == 0 && os_strcmp(type, "WPS") == 0)
1400 {
1401 ret = wpas_ap_wps_nfc_report_handover(wpa_s, req, sel);
50d1f890
JM		 1402 if (ret < 0)
1403 ret = wpas_er_wps_nfc_report_handover(wpa_s, req, sel);
88853aed
JM		 1404#endif /* CONFIG_AP */
1405#ifdef CONFIG_P2P
db6ae69e
JM		 1406 } else if (os_strcmp(role, "INIT") == 0 && os_strcmp(type, "P2P") == 0)
1407 {
b56f6c88 1408 ret = wpas_p2p_nfc_report_handover(wpa_s, 1, req, sel, 0);
db6ae69e
JM		 1409 } else if (os_strcmp(role, "RESP") == 0 && os_strcmp(type, "P2P") == 0)
1410 {
b56f6c88
JM		 1411 ret = wpas_p2p_nfc_report_handover(wpa_s, 0, req, sel,
1412 forced_freq);
88853aed 1413#endif /* CONFIG_P2P */
e4758827
JM		 1414 } else {
1415 wpa_printf(MSG_DEBUG, "NFC: Unsupported connection handover "
1416 "reported: role=%s type=%s", role, type);
1417 ret = -1;
1418 }
1419 wpabuf_free(req);
1420 wpabuf_free(sel);
1421
73127764
JM		 1422 if (ret)
1423 wpa_printf(MSG_DEBUG, "NFC: Failed to process reported handover messages");
1424
e4758827
JM		 1425 return ret;
1426}
1427
71892384 1428#endif /* CONFIG_WPS_NFC */
46bdb83a
MH		 1429
1430
fcc60db4
JM		 1431static int wpa_supplicant_ctrl_iface_wps_reg(struct wpa_supplicant *wpa_s,
1432 char *cmd)
1433{
129eb428 1434 u8 bssid[ETH_ALEN];
fcc60db4 1435 char *pin;
52eb293d
JM		 1436 char *new_ssid;
1437 char *new_auth;
1438 char *new_encr;
1439 char *new_key;
1440 struct wps_new_ap_settings ap;
fcc60db4
JM		 1441
1442 pin = os_strchr(cmd, ' ');
1443 if (pin == NULL)
1444 return -1;
1445 *pin++ = '\0';
1446
129eb428 1447 if (hwaddr_aton(cmd, bssid)) {
fcc60db4
JM		 1448 wpa_printf(MSG_DEBUG, "CTRL_IFACE WPS_REG: invalid BSSID '%s'",
1449 cmd);
1450 return -1;
1451 }
1452
52eb293d
JM		 1453 new_ssid = os_strchr(pin, ' ');
1454 if (new_ssid == NULL)
129eb428 1455 return wpas_wps_start_reg(wpa_s, bssid, pin, NULL);
52eb293d
JM		 1456 *new_ssid++ = '\0';
1457
1458 new_auth = os_strchr(new_ssid, ' ');
1459 if (new_auth == NULL)
1460 return -1;
1461 *new_auth++ = '\0';
1462
1463 new_encr = os_strchr(new_auth, ' ');
1464 if (new_encr == NULL)
1465 return -1;
1466 *new_encr++ = '\0';
1467
1468 new_key = os_strchr(new_encr, ' ');
1469 if (new_key == NULL)
1470 return -1;
1471 *new_key++ = '\0';
1472
1473 os_memset(&ap, 0, sizeof(ap));
1474 ap.ssid_hex = new_ssid;
1475 ap.auth = new_auth;
1476 ap.encr = new_encr;
1477 ap.key_hex = new_key;
129eb428 1478 return wpas_wps_start_reg(wpa_s, bssid, pin, &ap);
fcc60db4 1479}
72df2f5f
JM		 1480
1481
70d84f11
JM		 1482#ifdef CONFIG_AP
1483static int wpa_supplicant_ctrl_iface_wps_ap_pin(struct wpa_supplicant *wpa_s,
1484 char *cmd, char *buf,
1485 size_t buflen)
1486{
1487 int timeout = 300;
1488 char *pos;
1489 const char *pin_txt;
1490
1491 if (!wpa_s->ap_iface)
1492 return -1;
1493
1494 pos = os_strchr(cmd, ' ');
1495 if (pos)
1496 *pos++ = '\0';
1497
1498 if (os_strcmp(cmd, "disable") == 0) {
1499 wpas_wps_ap_pin_disable(wpa_s);
1500 return os_snprintf(buf, buflen, "OK\n");
1501 }
1502
1503 if (os_strcmp(cmd, "random") == 0) {
1504 if (pos)
1505 timeout = atoi(pos);
1506 pin_txt = wpas_wps_ap_pin_random(wpa_s, timeout);
1507 if (pin_txt == NULL)
1508 return -1;
1509 return os_snprintf(buf, buflen, "%s", pin_txt);
1510 }
1511
1512 if (os_strcmp(cmd, "get") == 0) {
1513 pin_txt = wpas_wps_ap_pin_get(wpa_s);
1514 if (pin_txt == NULL)
1515 return -1;
1516 return os_snprintf(buf, buflen, "%s", pin_txt);
1517 }
1518
1519 if (os_strcmp(cmd, "set") == 0) {
1520 char *pin;
1521 if (pos == NULL)
1522 return -1;
1523 pin = pos;
1524 pos = os_strchr(pos, ' ');
1525 if (pos) {
1526 *pos++ = '\0';
1527 timeout = atoi(pos);
1528 }
1529 if (os_strlen(pin) > buflen)
1530 return -1;
1531 if (wpas_wps_ap_pin_set(wpa_s, pin, timeout) < 0)
1532 return -1;
1533 return os_snprintf(buf, buflen, "%s", pin);
1534 }
1535
1536 return -1;
1537}
1538#endif /* CONFIG_AP */
1539
1540
72df2f5f
JM		 1541#ifdef CONFIG_WPS_ER
1542static int wpa_supplicant_ctrl_iface_wps_er_pin(struct wpa_supplicant *wpa_s,
1543 char *cmd)
1544{
31fcea93
JM		 1545 char *uuid = cmd, *pin, *pos;
1546 u8 addr_buf[ETH_ALEN], *addr = NULL;
72df2f5f
JM		 1547 pin = os_strchr(uuid, ' ');
1548 if (pin == NULL)
1549 return -1;
1550 *pin++ = '\0';
31fcea93
JM		 1551 pos = os_strchr(pin, ' ');
1552 if (pos) {
1553 *pos++ = '\0';
1554 if (hwaddr_aton(pos, addr_buf) == 0)
1555 addr = addr_buf;
1556 }
1557 return wpas_wps_er_add_pin(wpa_s, addr, uuid, pin);
72df2f5f 1558}
e64dcfd5
JM		 1559
1560
1561static int wpa_supplicant_ctrl_iface_wps_er_learn(struct wpa_supplicant *wpa_s,
1562 char *cmd)
1563{
1564 char *uuid = cmd, *pin;
1565 pin = os_strchr(uuid, ' ');
1566 if (pin == NULL)
1567 return -1;
1568 *pin++ = '\0';
1569 return wpas_wps_er_learn(wpa_s, uuid, pin);
1570}
7d6640a6
JM		 1571
1572
ef10f473
JM		 1573static int wpa_supplicant_ctrl_iface_wps_er_set_config(
1574 struct wpa_supplicant *wpa_s, char *cmd)
1575{
1576 char *uuid = cmd, *id;
1577 id = os_strchr(uuid, ' ');
1578 if (id == NULL)
1579 return -1;
1580 *id++ = '\0';
1581 return wpas_wps_er_set_config(wpa_s, uuid, atoi(id));
1582}
1583
1584
7d6640a6
JM		 1585static int wpa_supplicant_ctrl_iface_wps_er_config(
1586 struct wpa_supplicant *wpa_s, char *cmd)
1587{
1588 char *pin;
1589 char *new_ssid;
1590 char *new_auth;
1591 char *new_encr;
1592 char *new_key;
1593 struct wps_new_ap_settings ap;
1594
1595 pin = os_strchr(cmd, ' ');
1596 if (pin == NULL)
1597 return -1;
1598 *pin++ = '\0';
1599
1600 new_ssid = os_strchr(pin, ' ');
1601 if (new_ssid == NULL)
1602 return -1;
1603 *new_ssid++ = '\0';
1604
1605 new_auth = os_strchr(new_ssid, ' ');
1606 if (new_auth == NULL)
1607 return -1;
1608 *new_auth++ = '\0';
1609
1610 new_encr = os_strchr(new_auth, ' ');
1611 if (new_encr == NULL)
1612 return -1;
1613 *new_encr++ = '\0';
1614
1615 new_key = os_strchr(new_encr, ' ');
1616 if (new_key == NULL)
1617 return -1;
1618 *new_key++ = '\0';
1619
1620 os_memset(&ap, 0, sizeof(ap));
1621 ap.ssid_hex = new_ssid;
1622 ap.auth = new_auth;
1623 ap.encr = new_encr;
1624 ap.key_hex = new_key;
1625 return wpas_wps_er_config(wpa_s, cmd, pin, &ap);
1626}
1cea09a9
JM		 1627
1628
1629#ifdef CONFIG_WPS_NFC
1630static int wpa_supplicant_ctrl_iface_wps_er_nfc_config_token(
1631 struct wpa_supplicant *wpa_s, char *cmd, char *reply, size_t max_len)
1632{
1633 int ndef;
1634 struct wpabuf *buf;
1635 int res;
1636 char *uuid;
1637
1638 uuid = os_strchr(cmd, ' ');
1639 if (uuid == NULL)
1640 return -1;
1641 *uuid++ = '\0';
1642
1643 if (os_strcmp(cmd, "WPS") == 0)
1644 ndef = 0;
1645 else if (os_strcmp(cmd, "NDEF") == 0)
1646 ndef = 1;
1647 else
1648 return -1;
1649
1650 buf = wpas_wps_er_nfc_config_token(wpa_s, ndef, uuid);
1651 if (buf == NULL)
1652 return -1;
1653
1654 res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf),
1655 wpabuf_len(buf));
1656 reply[res++] = '\n';
1657 reply[res] = '\0';
1658
1659 wpabuf_free(buf);
1660
1661 return res;
1662}
1663#endif /* CONFIG_WPS_NFC */
72df2f5f
JM		 1664#endif /* CONFIG_WPS_ER */
1665
fcc60db4
JM		 1666#endif /* CONFIG_WPS */
1667
1668
11ef8d35
JM		 1669#ifdef CONFIG_IBSS_RSN
1670static int wpa_supplicant_ctrl_iface_ibss_rsn(
1671 struct wpa_supplicant *wpa_s, char *addr)
1672{
1673 u8 peer[ETH_ALEN];
1674
1675 if (hwaddr_aton(addr, peer)) {
1676 wpa_printf(MSG_DEBUG, "CTRL_IFACE IBSS_RSN: invalid "
a7b6c422 1677 "address '%s'", addr);
11ef8d35
JM		 1678 return -1;
1679 }
1680
1681 wpa_printf(MSG_DEBUG, "CTRL_IFACE IBSS_RSN " MACSTR,
1682 MAC2STR(peer));
1683
1684 return ibss_rsn_start(wpa_s->ibss_rsn, peer);
1685}
1686#endif /* CONFIG_IBSS_RSN */
1687
1688
7de5688d
DW		 1689static int wpa_supplicant_ctrl_iface_ctrl_rsp(struct wpa_supplicant *wpa_s,
1690 char *rsp)
1691{
1692#ifdef IEEE8021X_EAPOL
1693 char *pos, *id_pos;
1694 int id;
1695 struct wpa_ssid *ssid;
1696
1697 pos = os_strchr(rsp, '-');
1698 if (pos == NULL)
1699 return -1;
1700 *pos++ = '\0';
1701 id_pos = pos;
1702 pos = os_strchr(pos, ':');
1703 if (pos == NULL)
1704 return -1;
1705 *pos++ = '\0';
1706 id = atoi(id_pos);
1707 wpa_printf(MSG_DEBUG, "CTRL_IFACE: field=%s id=%d", rsp, id);
1708 wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: value",
1709 (u8 *) pos, os_strlen(pos));
1710
1711 ssid = wpa_config_get_network(wpa_s->conf, id);
1712 if (ssid == NULL) {
1713 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find SSID id=%d "
1714 "to update", id);
1715 return -1;
1716 }
1717
1718 return wpa_supplicant_ctrl_iface_ctrl_rsp_handle(wpa_s, ssid, rsp,
1719 pos);
6fc6879b
JM		 1720#else /* IEEE8021X_EAPOL */
1721 wpa_printf(MSG_DEBUG, "CTRL_IFACE: 802.1X not included");
1722 return -1;
1723#endif /* IEEE8021X_EAPOL */
1724}
1725
1726
1727static int wpa_supplicant_ctrl_iface_status(struct wpa_supplicant *wpa_s,
1728 const char *params,
1729 char *buf, size_t buflen)
1730{
1731 char *pos, *end, tmp[30];
0bc13468 1732 int res, verbose, wps, ret;
f9cd147d
JM		 1733#ifdef CONFIG_HS20
1734 const u8 *hs20;
1735#endif /* CONFIG_HS20 */
993a8654
JM		 1736 const u8 *sess_id;
1737 size_t sess_id_len;
6fc6879b 1738
a771c07d
JM		 1739 if (os_strcmp(params, "-DRIVER") == 0)
1740 return wpa_drv_status(wpa_s, buf, buflen);
6fc6879b 1741 verbose = os_strcmp(params, "-VERBOSE") == 0;
0bc13468 1742 wps = os_strcmp(params, "-WPS") == 0;
6fc6879b
JM		 1743 pos = buf;
1744 end = buf + buflen;
1745 if (wpa_s->wpa_state >= WPA_ASSOCIATED) {
1746 struct wpa_ssid *ssid = wpa_s->current_ssid;
1747 ret = os_snprintf(pos, end - pos, "bssid=" MACSTR "\n",
1748 MAC2STR(wpa_s->bssid));
d85e1fc8 1749 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 1750 return pos - buf;
1751 pos += ret;
b6ebdfbe
BP		 1752 ret = os_snprintf(pos, end - pos, "freq=%u\n",
1753 wpa_s->assoc_freq);
d85e1fc8 1754 if (os_snprintf_error(end - pos, ret))
b6ebdfbe
BP		 1755 return pos - buf;
1756 pos += ret;
6fc6879b
JM		 1757 if (ssid) {
1758 u8 *_ssid = ssid->ssid;
1759 size_t ssid_len = ssid->ssid_len;
eaa8eefe 1760 u8 ssid_buf[SSID_MAX_LEN];
6fc6879b
JM		 1761 if (ssid_len == 0) {
1762 int _res = wpa_drv_get_ssid(wpa_s, ssid_buf);
1763 if (_res < 0)
1764 ssid_len = 0;
1765 else
1766 ssid_len = _res;
1767 _ssid = ssid_buf;
1768 }
1769 ret = os_snprintf(pos, end - pos, "ssid=%s\nid=%d\n",
1770 wpa_ssid_txt(_ssid, ssid_len),
1771 ssid->id);
d85e1fc8 1772 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 1773 return pos - buf;
1774 pos += ret;
1775
0bc13468
JM		 1776 if (wps && ssid->passphrase &&
1777 wpa_key_mgmt_wpa_psk(ssid->key_mgmt) &&
1778 (ssid->mode == WPAS_MODE_AP ||
1779 ssid->mode == WPAS_MODE_P2P_GO)) {
1780 ret = os_snprintf(pos, end - pos,
1781 "passphrase=%s\n",
1782 ssid->passphrase);
d85e1fc8 1783 if (os_snprintf_error(end - pos, ret))
0bc13468
JM		 1784 return pos - buf;
1785 pos += ret;
1786 }
6fc6879b
JM		 1787 if (ssid->id_str) {
1788 ret = os_snprintf(pos, end - pos,
1789 "id_str=%s\n",
1790 ssid->id_str);
d85e1fc8 1791 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 1792 return pos - buf;
1793 pos += ret;
1794 }
0e15e529
JM		 1795
1796 switch (ssid->mode) {
d7dcba70 1797 case WPAS_MODE_INFRA:
0e15e529
JM		 1798 ret = os_snprintf(pos, end - pos,
1799 "mode=station\n");
1800 break;
d7dcba70 1801 case WPAS_MODE_IBSS:
0e15e529
JM		 1802 ret = os_snprintf(pos, end - pos,
1803 "mode=IBSS\n");
1804 break;
d7dcba70 1805 case WPAS_MODE_AP:
0e15e529
JM		 1806 ret = os_snprintf(pos, end - pos,
1807 "mode=AP\n");
1808 break;
2c5d725c
JM		 1809 case WPAS_MODE_P2P_GO:
1810 ret = os_snprintf(pos, end - pos,
1811 "mode=P2P GO\n");
1812 break;
1813 case WPAS_MODE_P2P_GROUP_FORMATION:
1814 ret = os_snprintf(pos, end - pos,
1815 "mode=P2P GO - group "
1816 "formation\n");
1817 break;
0e15e529
JM		 1818 default:
1819 ret = 0;
1820 break;
1821 }
1f102d3b 1822 if (os_snprintf_error(end - pos, ret))
0e15e529
JM		 1823 return pos - buf;
1824 pos += ret;
6fc6879b
JM		 1825 }
1826
43fb5297
JM		 1827#ifdef CONFIG_AP
1828 if (wpa_s->ap_iface) {
1829 pos += ap_ctrl_iface_wpa_get_status(wpa_s, pos,
1830 end - pos,
1831 verbose);
1832 } else
1833#endif /* CONFIG_AP */
6fc6879b
JM		 1834 pos += wpa_sm_get_status(wpa_s->wpa, pos, end - pos, verbose);
1835 }
4954c859
JM		 1836#ifdef CONFIG_SAE
1837 if (wpa_s->wpa_state >= WPA_ASSOCIATED &&
e1ae5d74
JM		 1838#ifdef CONFIG_AP
1839 !wpa_s->ap_iface &&
1840#endif /* CONFIG_AP */
1841 wpa_s->sme.sae.state == SAE_ACCEPTED) {
4954c859
JM		 1842 ret = os_snprintf(pos, end - pos, "sae_group=%d\n",
1843 wpa_s->sme.sae.group);
d85e1fc8 1844 if (os_snprintf_error(end - pos, ret))
4954c859
JM		 1845 return pos - buf;
1846 pos += ret;
1847 }
1848#endif /* CONFIG_SAE */
6fc6879b
JM		 1849 ret = os_snprintf(pos, end - pos, "wpa_state=%s\n",
1850 wpa_supplicant_state_txt(wpa_s->wpa_state));
d85e1fc8 1851 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 1852 return pos - buf;
1853 pos += ret;
1854
1855 if (wpa_s->l2 &&
1856 l2_packet_get_ip_addr(wpa_s->l2, tmp, sizeof(tmp)) >= 0) {
1857 ret = os_snprintf(pos, end - pos, "ip_address=%s\n", tmp);
d85e1fc8 1858 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 1859 return pos - buf;
1860 pos += ret;
1861 }
1862
d23bd894
JM		 1863#ifdef CONFIG_P2P
1864 if (wpa_s->global->p2p) {
1865 ret = os_snprintf(pos, end - pos, "p2p_device_address=" MACSTR
1866 "\n", MAC2STR(wpa_s->global->p2p_dev_addr));
d85e1fc8 1867 if (os_snprintf_error(end - pos, ret))
d23bd894
JM		 1868 return pos - buf;
1869 pos += ret;
1870 }
b21e2c84 1871#endif /* CONFIG_P2P */
6d4747a9
JM		 1872
1873 ret = os_snprintf(pos, end - pos, "address=" MACSTR "\n",
1874 MAC2STR(wpa_s->own_addr));
d85e1fc8 1875 if (os_snprintf_error(end - pos, ret))
6d4747a9
JM		 1876 return pos - buf;
1877 pos += ret;
d23bd894 1878
64855b96
JM		 1879#ifdef CONFIG_HS20
1880 if (wpa_s->current_bss &&
f9cd147d
JM		 1881 (hs20 = wpa_bss_get_vendor_ie(wpa_s->current_bss,
1882 HS20_IE_VENDOR_TYPE)) &&
4ed34f5a
JM		 1883 wpa_s->wpa_proto == WPA_PROTO_RSN &&
1884 wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
f9cd147d
JM		 1885 int release = 1;
1886 if (hs20[1] >= 5) {
1887 u8 rel_num = (hs20[6] & 0xf0) >> 4;
1888 release = rel_num + 1;
1889 }
1890 ret = os_snprintf(pos, end - pos, "hs20=%d\n", release);
d85e1fc8 1891 if (os_snprintf_error(end - pos, ret))
64855b96
JM		 1892 return pos - buf;
1893 pos += ret;
1894 }
e99b4f3a
JM		 1895
1896 if (wpa_s->current_ssid) {
1897 struct wpa_cred *cred;
1898 char *type;
1899
1900 for (cred = wpa_s->conf->cred; cred; cred = cred->next) {
463c8ffb
JM		 1901 size_t i;
1902
e99b4f3a
JM		 1903 if (wpa_s->current_ssid->parent_cred != cred)
1904 continue;
e99b4f3a 1905
aa26ba68 1906 if (cred->provisioning_sp) {
463c8ffb 1907 ret = os_snprintf(pos, end - pos,
aa26ba68
JM		 1908 "provisioning_sp=%s\n",
1909 cred->provisioning_sp);
d85e1fc8 1910 if (os_snprintf_error(end - pos, ret))
463c8ffb
JM		 1911 return pos - buf;
1912 pos += ret;
1913 }
e99b4f3a 1914
aa26ba68
JM		 1915 if (!cred->domain)
1916 goto no_domain;
1917
1918 i = 0;
1919 if (wpa_s->current_bss && wpa_s->current_bss->anqp) {
1920 struct wpabuf *names =
1921 wpa_s->current_bss->anqp->domain_name;
1922 for (i = 0; names && i < cred->num_domain; i++)
1923 {
1924 if (domain_name_list_contains(
1925 names, cred->domain[i], 1))
1926 break;
1927 }
1928 if (i == cred->num_domain)
1929 i = 0; /* show first entry by default */
1930 }
1931 ret = os_snprintf(pos, end - pos, "home_sp=%s\n",
1932 cred->domain[i]);
d85e1fc8 1933 if (os_snprintf_error(end - pos, ret))
aa26ba68
JM		 1934 return pos - buf;
1935 pos += ret;
1936
1937 no_domain:
e99b4f3a
JM		 1938 if (wpa_s->current_bss == NULL ||
1939 wpa_s->current_bss->anqp == NULL)
1940 res = -1;
1941 else
1942 res = interworking_home_sp_cred(
1943 wpa_s, cred,
1944 wpa_s->current_bss->anqp->domain_name);
1945 if (res > 0)
1946 type = "home";
1947 else if (res == 0)
1948 type = "roaming";
1949 else
1950 type = "unknown";
1951
1952 ret = os_snprintf(pos, end - pos, "sp_type=%s\n", type);
d85e1fc8 1953 if (os_snprintf_error(end - pos, ret))
e99b4f3a
JM		 1954 return pos - buf;
1955 pos += ret;
1956
1957 break;
1958 }
1959 }
64855b96
JM		 1960#endif /* CONFIG_HS20 */
1961
56586197
JM		 1962 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
1963 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
6fc6879b
JM		 1964 res = eapol_sm_get_status(wpa_s->eapol, pos, end - pos,
1965 verbose);
1966 if (res >= 0)
1967 pos += res;
1968 }
1969
993a8654
JM		 1970 sess_id = eapol_sm_get_session_id(wpa_s->eapol, &sess_id_len);
1971 if (sess_id) {
1972 char *start = pos;
1973
1974 ret = os_snprintf(pos, end - pos, "eap_session_id=");
1975 if (os_snprintf_error(end - pos, ret))
1976 return start - buf;
1977 pos += ret;
1978 ret = wpa_snprintf_hex(pos, end - pos, sess_id, sess_id_len);
1979 if (ret <= 0)
1980 return start - buf;
1981 pos += ret;
1982 ret = os_snprintf(pos, end - pos, "\n");
1983 if (os_snprintf_error(end - pos, ret))
1984 return start - buf;
1985 pos += ret;
1986 }
1987
6fc6879b
JM		 1988 res = rsn_preauth_get_status(wpa_s->wpa, pos, end - pos, verbose);
1989 if (res >= 0)
1990 pos += res;
1991
8aaafcee
JM		 1992#ifdef CONFIG_WPS
1993 {
1994 char uuid_str[100];
1995 uuid_bin2str(wpa_s->wps->uuid, uuid_str, sizeof(uuid_str));
1996 ret = os_snprintf(pos, end - pos, "uuid=%s\n", uuid_str);
d85e1fc8 1997 if (os_snprintf_error(end - pos, ret))
8aaafcee
JM		 1998 return pos - buf;
1999 pos += ret;
2000 }
2001#endif /* CONFIG_WPS */
2002
f6c2b8c3 2003#ifdef ANDROID
a6ab82d7 2004 /*
2005 * Allow using the STATUS command with default behavior, say for debug,
2006 * i.e., don't generate a "fake" CONNECTION and SUPPLICANT_STATE_CHANGE
2007 * events with STATUS-NO_EVENTS.
2008 */
2009 if (os_strcmp(params, "-NO_EVENTS")) {
2010 wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_STATE_CHANGE
2011 "id=%d state=%d BSSID=" MACSTR " SSID=%s",
2012 wpa_s->current_ssid ? wpa_s->current_ssid->id : -1,
2013 wpa_s->wpa_state,
2014 MAC2STR(wpa_s->bssid),
2015 wpa_s->current_ssid && wpa_s->current_ssid->ssid ?
2016 wpa_ssid_txt(wpa_s->current_ssid->ssid,
2017 wpa_s->current_ssid->ssid_len) : "");
2018 if (wpa_s->wpa_state == WPA_COMPLETED) {
2019 struct wpa_ssid *ssid = wpa_s->current_ssid;
2020 wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED
2021 "- connection to " MACSTR
2022 " completed %s [id=%d id_str=%s]",
2023 MAC2STR(wpa_s->bssid), "(auth)",
2024 ssid ? ssid->id : -1,
2025 ssid && ssid->id_str ? ssid->id_str : "");
2026 }
f6c2b8c3
DS		 2027 }
2028#endif /* ANDROID */
2029
6fc6879b
JM		 2030 return pos - buf;
2031}
2032
2033
2034static int wpa_supplicant_ctrl_iface_bssid(struct wpa_supplicant *wpa_s,
2035 char *cmd)
2036{
2037 char *pos;
2038 int id;
2039 struct wpa_ssid *ssid;
2040 u8 bssid[ETH_ALEN];
2041
2042 /* cmd: "<network id> <BSSID>" */
2043 pos = os_strchr(cmd, ' ');
2044 if (pos == NULL)
2045 return -1;
2046 *pos++ = '\0';
2047 id = atoi(cmd);
2048 wpa_printf(MSG_DEBUG, "CTRL_IFACE: id=%d bssid='%s'", id, pos);
2049 if (hwaddr_aton(pos, bssid)) {
2050 wpa_printf(MSG_DEBUG ,"CTRL_IFACE: invalid BSSID '%s'", pos);
2051 return -1;
2052 }
2053
2054 ssid = wpa_config_get_network(wpa_s->conf, id);
2055 if (ssid == NULL) {
2056 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find SSID id=%d "
2057 "to update", id);
2058 return -1;
2059 }
2060
2061 os_memcpy(ssid->bssid, bssid, ETH_ALEN);
a8e16edc 2062 ssid->bssid_set = !is_zero_ether_addr(bssid);
6fc6879b
JM		 2063
2064 return 0;
2065}
2066
2067
9aa10e2b
DS		 2068static int wpa_supplicant_ctrl_iface_blacklist(struct wpa_supplicant *wpa_s,
2069 char *cmd, char *buf,
2070 size_t buflen)
2071{
2072 u8 bssid[ETH_ALEN];
2073 struct wpa_blacklist *e;
2074 char *pos, *end;
2075 int ret;
2076
2077 /* cmd: "BLACKLIST [<BSSID>]" */
2078 if (*cmd == '\0') {
2079 pos = buf;
2080 end = buf + buflen;
2081 e = wpa_s->blacklist;
2082 while (e) {
2083 ret = os_snprintf(pos, end - pos, MACSTR "\n",
2084 MAC2STR(e->bssid));
d85e1fc8 2085 if (os_snprintf_error(end - pos, ret))
9aa10e2b
DS		 2086 return pos - buf;
2087 pos += ret;
2088 e = e->next;
2089 }
2090 return pos - buf;
2091 }
2092
2093 cmd++;
2094 if (os_strncmp(cmd, "clear", 5) == 0) {
2095 wpa_blacklist_clear(wpa_s);
2096 os_memcpy(buf, "OK\n", 3);
2097 return 3;
2098 }
2099
2100 wpa_printf(MSG_DEBUG, "CTRL_IFACE: BLACKLIST bssid='%s'", cmd);
2101 if (hwaddr_aton(cmd, bssid)) {
2102 wpa_printf(MSG_DEBUG, "CTRL_IFACE: invalid BSSID '%s'", cmd);
2103 return -1;
2104 }
2105
2106 /*
2107 * Add the BSSID twice, so its count will be 2, causing it to be
2108 * skipped when processing scan results.
2109 */
2110 ret = wpa_blacklist_add(wpa_s, bssid);
bd8838a3 2111 if (ret < 0)
9aa10e2b
DS		 2112 return -1;
2113 ret = wpa_blacklist_add(wpa_s, bssid);
bd8838a3 2114 if (ret < 0)
9aa10e2b
DS		 2115 return -1;
2116 os_memcpy(buf, "OK\n", 3);
2117 return 3;
2118}
2119
2120
0597a5b5
DS		 2121static const char * debug_level_str(int level)
2122{
2123 switch (level) {
2124 case MSG_EXCESSIVE:
2125 return "EXCESSIVE";
2126 case MSG_MSGDUMP:
2127 return "MSGDUMP";
2128 case MSG_DEBUG:
2129 return "DEBUG";
2130 case MSG_INFO:
2131 return "INFO";
2132 case MSG_WARNING:
2133 return "WARNING";
2134 case MSG_ERROR:
2135 return "ERROR";
2136 default:
2137 return "?";
2138 }
2139}
2140
2141
2142static int str_to_debug_level(const char *s)
2143{
2144 if (os_strcasecmp(s, "EXCESSIVE") == 0)
2145 return MSG_EXCESSIVE;
2146 if (os_strcasecmp(s, "MSGDUMP") == 0)
2147 return MSG_MSGDUMP;
2148 if (os_strcasecmp(s, "DEBUG") == 0)
2149 return MSG_DEBUG;
2150 if (os_strcasecmp(s, "INFO") == 0)
2151 return MSG_INFO;
2152 if (os_strcasecmp(s, "WARNING") == 0)
2153 return MSG_WARNING;
2154 if (os_strcasecmp(s, "ERROR") == 0)
2155 return MSG_ERROR;
2156 return -1;
2157}
2158
2159
2160static int wpa_supplicant_ctrl_iface_log_level(struct wpa_supplicant *wpa_s,
2161 char *cmd, char *buf,
2162 size_t buflen)
2163{
2164 char *pos, *end, *stamp;
2165 int ret;
2166
0597a5b5
DS		 2167 /* cmd: "LOG_LEVEL [<level>]" */
2168 if (*cmd == '\0') {
2169 pos = buf;
2170 end = buf + buflen;
2171 ret = os_snprintf(pos, end - pos, "Current level: %s\n"
2172 "Timestamp: %d\n",
2173 debug_level_str(wpa_debug_level),
2174 wpa_debug_timestamp);
d85e1fc8 2175 if (os_snprintf_error(end - pos, ret))
0597a5b5
DS		 2176 ret = 0;
2177
2178 return ret;
2179 }
2180
2181 while (*cmd == ' ')
2182 cmd++;
2183
2184 stamp = os_strchr(cmd, ' ');
2185 if (stamp) {
2186 *stamp++ = '\0';
2187 while (*stamp == ' ') {
2188 stamp++;
2189 }
2190 }
2191
2192 if (cmd && os_strlen(cmd)) {
2193 int level = str_to_debug_level(cmd);
2194 if (level < 0)
2195 return -1;
2196 wpa_debug_level = level;
2197 }
2198
2199 if (stamp && os_strlen(stamp))
2200 wpa_debug_timestamp = atoi(stamp);
2201
2202 os_memcpy(buf, "OK\n", 3);
2203 return 3;
2204}
2205
2206
6fc6879b 2207static int wpa_supplicant_ctrl_iface_list_networks(
90903a77 2208 struct wpa_supplicant *wpa_s, char *cmd, char *buf, size_t buflen)
6fc6879b 2209{
f34891a3 2210 char *pos, *end, *prev;
6fc6879b
JM		 2211 struct wpa_ssid *ssid;
2212 int ret;
2213
2214 pos = buf;
2215 end = buf + buflen;
2216 ret = os_snprintf(pos, end - pos,
2217 "network id / ssid / bssid / flags\n");
d85e1fc8 2218 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 2219 return pos - buf;
2220 pos += ret;
2221
2222 ssid = wpa_s->conf->ssid;
90903a77
VD		 2223
2224 /* skip over ssids until we find next one */
2225 if (cmd != NULL && os_strncmp(cmd, "LAST_ID=", 8) == 0) {
2226 int last_id = atoi(cmd + 8);
2227 if (last_id != -1) {
2228 while (ssid != NULL && ssid->id <= last_id) {
2229 ssid = ssid->next;
2230 }
2231 }
2232 }
2233
6fc6879b 2234 while (ssid) {
f34891a3 2235 prev = pos;
6fc6879b
JM		 2236 ret = os_snprintf(pos, end - pos, "%d\t%s",
2237 ssid->id,
2238 wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
d85e1fc8 2239 if (os_snprintf_error(end - pos, ret))
f34891a3 2240 return prev - buf;
6fc6879b
JM		 2241 pos += ret;
2242 if (ssid->bssid_set) {
2243 ret = os_snprintf(pos, end - pos, "\t" MACSTR,
2244 MAC2STR(ssid->bssid));
2245 } else {
2246 ret = os_snprintf(pos, end - pos, "\tany");
2247 }
d85e1fc8 2248 if (os_snprintf_error(end - pos, ret))
f34891a3 2249 return prev - buf;
6fc6879b 2250 pos += ret;
00e5e3d5 2251 ret = os_snprintf(pos, end - pos, "\t%s%s%s%s",
6fc6879b
JM		 2252 ssid == wpa_s->current_ssid ?
2253 "[CURRENT]" : "",
4dac0245 2254 ssid->disabled ? "[DISABLED]" : "",
00e5e3d5
JM		 2255 ssid->disabled_until.sec ?
2256 "[TEMP-DISABLED]" : "",
4dac0245
JM		 2257 ssid->disabled == 2 ? "[P2P-PERSISTENT]" :
2258 "");
d85e1fc8 2259 if (os_snprintf_error(end - pos, ret))
f34891a3 2260 return prev - buf;
6fc6879b
JM		 2261 pos += ret;
2262 ret = os_snprintf(pos, end - pos, "\n");
d85e1fc8 2263 if (os_snprintf_error(end - pos, ret))
f34891a3 2264 return prev - buf;
6fc6879b
JM		 2265 pos += ret;
2266
2267 ssid = ssid->next;
2268 }
2269
2270 return pos - buf;
2271}
2272
2273
2274static char * wpa_supplicant_cipher_txt(char *pos, char *end, int cipher)
2275{
0282a8c4 2276 int ret;
6fc6879b 2277 ret = os_snprintf(pos, end - pos, "-");
d85e1fc8 2278 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 2279 return pos;
2280 pos += ret;
0282a8c4
JM		 2281 ret = wpa_write_ciphers(pos, end, cipher, "+");
2282 if (ret < 0)
2283 return pos;
2284 pos += ret;
6fc6879b
JM		 2285 return pos;
2286}
2287
2288
2289static char * wpa_supplicant_ie_txt(char *pos, char *end, const char *proto,
2290 const u8 *ie, size_t ie_len)
2291{
2292 struct wpa_ie_data data;
ea3b8c1d
JM		 2293 char *start;
2294 int ret;
6fc6879b
JM		 2295
2296 ret = os_snprintf(pos, end - pos, "[%s-", proto);
d85e1fc8 2297 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 2298 return pos;
2299 pos += ret;
2300
2301 if (wpa_parse_wpa_ie(ie, ie_len, &data) < 0) {
2302 ret = os_snprintf(pos, end - pos, "?]");
d85e1fc8 2303 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 2304 return pos;
2305 pos += ret;
2306 return pos;
2307 }
2308
ea3b8c1d 2309 start = pos;
6fc6879b 2310 if (data.key_mgmt & WPA_KEY_MGMT_IEEE8021X) {
ea3b8c1d
JM		 2311 ret = os_snprintf(pos, end - pos, "%sEAP",
2312 pos == start ? "" : "+");
d85e1fc8 2313 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 2314 return pos;
2315 pos += ret;
6fc6879b
JM		 2316 }
2317 if (data.key_mgmt & WPA_KEY_MGMT_PSK) {
ea3b8c1d
JM		 2318 ret = os_snprintf(pos, end - pos, "%sPSK",
2319 pos == start ? "" : "+");
d85e1fc8 2320 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 2321 return pos;
2322 pos += ret;
6fc6879b
JM		 2323 }
2324 if (data.key_mgmt & WPA_KEY_MGMT_WPA_NONE) {
ea3b8c1d
JM		 2325 ret = os_snprintf(pos, end - pos, "%sNone",
2326 pos == start ? "" : "+");
d85e1fc8 2327 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 2328 return pos;
2329 pos += ret;
6fc6879b 2330 }
be6b29f6
JA		 2331 if (data.key_mgmt & WPA_KEY_MGMT_SAE) {
2332 ret = os_snprintf(pos, end - pos, "%sSAE",
2333 pos == start ? "" : "+");
d85e1fc8 2334 if (os_snprintf_error(end - pos, ret))
be6b29f6
JA		 2335 return pos;
2336 pos += ret;
2337 }
6fc6879b
JM		 2338#ifdef CONFIG_IEEE80211R
2339 if (data.key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X) {
2340 ret = os_snprintf(pos, end - pos, "%sFT/EAP",
ea3b8c1d 2341 pos == start ? "" : "+");
d85e1fc8 2342 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 2343 return pos;
2344 pos += ret;
6fc6879b
JM		 2345 }
2346 if (data.key_mgmt & WPA_KEY_MGMT_FT_PSK) {
2347 ret = os_snprintf(pos, end - pos, "%sFT/PSK",
ea3b8c1d 2348 pos == start ? "" : "+");
d85e1fc8 2349 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 2350 return pos;
2351 pos += ret;
6fc6879b 2352 }
be6b29f6
JA		 2353 if (data.key_mgmt & WPA_KEY_MGMT_FT_SAE) {
2354 ret = os_snprintf(pos, end - pos, "%sFT/SAE",
2355 pos == start ? "" : "+");
d85e1fc8 2356 if (os_snprintf_error(end - pos, ret))
be6b29f6
JA		 2357 return pos;
2358 pos += ret;
2359 }
6fc6879b 2360#endif /* CONFIG_IEEE80211R */
56586197
JM		 2361#ifdef CONFIG_IEEE80211W
2362 if (data.key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA256) {
2363 ret = os_snprintf(pos, end - pos, "%sEAP-SHA256",
ea3b8c1d 2364 pos == start ? "" : "+");
d85e1fc8 2365 if (os_snprintf_error(end - pos, ret))
56586197
JM		 2366 return pos;
2367 pos += ret;
56586197
JM		 2368 }
2369 if (data.key_mgmt & WPA_KEY_MGMT_PSK_SHA256) {
2370 ret = os_snprintf(pos, end - pos, "%sPSK-SHA256",
ea3b8c1d 2371 pos == start ? "" : "+");
d85e1fc8 2372 if (os_snprintf_error(end - pos, ret))
56586197
JM		 2373 return pos;
2374 pos += ret;
56586197
JM		 2375 }
2376#endif /* CONFIG_IEEE80211W */
6fc6879b 2377
5e3b5197 2378#ifdef CONFIG_SUITEB
666497c8
JM		 2379 if (data.key_mgmt & WPA_KEY_MGMT_IEEE8021X_SUITE_B) {
2380 ret = os_snprintf(pos, end - pos, "%sEAP-SUITE-B",
2381 pos == start ? "" : "+");
d85e1fc8 2382 if (os_snprintf_error(end - pos, ret))
666497c8
JM		 2383 return pos;
2384 pos += ret;
2385 }
5e3b5197
JM		 2386#endif /* CONFIG_SUITEB */
2387
2388#ifdef CONFIG_SUITEB192
2389 if (data.key_mgmt & WPA_KEY_MGMT_IEEE8021X_SUITE_B_192) {
2390 ret = os_snprintf(pos, end - pos, "%sEAP-SUITE-B-192",
2391 pos == start ? "" : "+");
2392 if (os_snprintf_error(end - pos, ret))
2393 return pos;
2394 pos += ret;
2395 }
2396#endif /* CONFIG_SUITEB192 */
666497c8 2397
0f8385e6
BG		 2398 if (data.key_mgmt & WPA_KEY_MGMT_OSEN) {
2399 ret = os_snprintf(pos, end - pos, "%sOSEN",
2400 pos == start ? "" : "+");
2401 if (os_snprintf_error(end - pos, ret))
2402 return pos;
2403 pos += ret;
2404 }
2405
6fc6879b
JM		 2406 pos = wpa_supplicant_cipher_txt(pos, end, data.pairwise_cipher);
2407
2408 if (data.capabilities & WPA_CAPABILITY_PREAUTH) {
2409 ret = os_snprintf(pos, end - pos, "-preauth");
d85e1fc8 2410 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 2411 return pos;
2412 pos += ret;
2413 }
2414
2415 ret = os_snprintf(pos, end - pos, "]");
d85e1fc8 2416 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 2417 return pos;
2418 pos += ret;
2419
2420 return pos;
2421}
2422
3a068632 2423
eef7d7a1 2424#ifdef CONFIG_WPS
31fcea93
JM		 2425static char * wpa_supplicant_wps_ie_txt_buf(struct wpa_supplicant *wpa_s,
2426 char *pos, char *end,
3a068632
JM		 2427 struct wpabuf *wps_ie)
2428{
eef7d7a1
JM		 2429 int ret;
2430 const char *txt;
2431
eef7d7a1
JM		 2432 if (wps_ie == NULL)
2433 return pos;
eef7d7a1
JM		 2434 if (wps_is_selected_pbc_registrar(wps_ie))
2435 txt = "[WPS-PBC]";
31fcea93
JM		 2436 else if (wps_is_addr_authorized(wps_ie, wpa_s->own_addr, 0))
2437 txt = "[WPS-AUTH]";
eef7d7a1
JM		 2438 else if (wps_is_selected_pin_registrar(wps_ie))
2439 txt = "[WPS-PIN]";
2440 else
2441 txt = "[WPS]";
2442
2443 ret = os_snprintf(pos, end - pos, "%s", txt);
a80ba67a 2444 if (!os_snprintf_error(end - pos, ret))
eef7d7a1
JM		 2445 pos += ret;
2446 wpabuf_free(wps_ie);
3a068632
JM		 2447 return pos;
2448}
2449#endif /* CONFIG_WPS */
2450
2451
31fcea93
JM		 2452static char * wpa_supplicant_wps_ie_txt(struct wpa_supplicant *wpa_s,
2453 char *pos, char *end,
16b71ac2 2454 const struct wpa_bss *bss)
3a068632
JM		 2455{
2456#ifdef CONFIG_WPS
2457 struct wpabuf *wps_ie;
2458 wps_ie = wpa_bss_get_vendor_ie_multi(bss, WPS_IE_VENDOR_TYPE);
31fcea93 2459 return wpa_supplicant_wps_ie_txt_buf(wpa_s, pos, end, wps_ie);
3a068632 2460#else /* CONFIG_WPS */
eef7d7a1 2461 return pos;
3a068632 2462#endif /* CONFIG_WPS */
eef7d7a1
JM		 2463}
2464
6fc6879b
JM		 2465
2466/* Format one result on one text line into a buffer. */
2467static int wpa_supplicant_ctrl_iface_scan_result(
31fcea93 2468 struct wpa_supplicant *wpa_s,
16b71ac2 2469 const struct wpa_bss *bss, char *buf, size_t buflen)
6fc6879b
JM		 2470{
2471 char *pos, *end;
2472 int ret;
0f8385e6 2473 const u8 *ie, *ie2, *osen_ie, *p2p, *mesh;
0c6b310e 2474
638d9456 2475 mesh = wpa_bss_get_ie(bss, WLAN_EID_MESH_ID);
0c6b310e 2476 p2p = wpa_bss_get_vendor_ie(bss, P2P_IE_VENDOR_TYPE);
bb50ae43
JM		 2477 if (!p2p)
2478 p2p = wpa_bss_get_vendor_ie_beacon(bss, P2P_IE_VENDOR_TYPE);
0c6b310e
JM		 2479 if (p2p && bss->ssid_len == P2P_WILDCARD_SSID_LEN &&
2480 os_memcmp(bss->ssid, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN) ==
2481 0)
2482 return 0; /* Do not show P2P listen discovery results here */
6fc6879b
JM		 2483
2484 pos = buf;
2485 end = buf + buflen;
2486
2487 ret = os_snprintf(pos, end - pos, MACSTR "\t%d\t%d\t",
16b71ac2 2488 MAC2STR(bss->bssid), bss->freq, bss->level);
d85e1fc8 2489 if (os_snprintf_error(end - pos, ret))
fb0e5bd7 2490 return -1;
6fc6879b 2491 pos += ret;
16b71ac2 2492 ie = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
6fc6879b
JM		 2493 if (ie)
2494 pos = wpa_supplicant_ie_txt(pos, end, "WPA", ie, 2 + ie[1]);
16b71ac2 2495 ie2 = wpa_bss_get_ie(bss, WLAN_EID_RSN);
638d9456
JA		 2496 if (ie2) {
2497 pos = wpa_supplicant_ie_txt(pos, end, mesh ? "RSN" : "WPA2",
2498 ie2, 2 + ie2[1]);
2499 }
0f8385e6
BG		 2500 osen_ie = wpa_bss_get_vendor_ie(bss, OSEN_IE_VENDOR_TYPE);
2501 if (osen_ie)
2502 pos = wpa_supplicant_ie_txt(pos, end, "OSEN",
2503 osen_ie, 2 + osen_ie[1]);
31fcea93 2504 pos = wpa_supplicant_wps_ie_txt(wpa_s, pos, end, bss);
0f8385e6 2505 if (!ie && !ie2 && !osen_ie && (bss->caps & IEEE80211_CAP_PRIVACY)) {
6fc6879b 2506 ret = os_snprintf(pos, end - pos, "[WEP]");
d85e1fc8 2507 if (os_snprintf_error(end - pos, ret))
fb0e5bd7 2508 return -1;
6fc6879b
JM		 2509 pos += ret;
2510 }
638d9456
JA		 2511 if (mesh) {
2512 ret = os_snprintf(pos, end - pos, "[MESH]");
d85e1fc8 2513 if (os_snprintf_error(end - pos, ret))
638d9456
JA		 2514 return -1;
2515 pos += ret;
2516 }
e403ba85
BS		 2517 if (bss_is_dmg(bss)) {
2518 const char *s;
2519 ret = os_snprintf(pos, end - pos, "[DMG]");
d85e1fc8 2520 if (os_snprintf_error(end - pos, ret))
fb0e5bd7 2521 return -1;
6fc6879b 2522 pos += ret;
e403ba85
BS		 2523 switch (bss->caps & IEEE80211_CAP_DMG_MASK) {
2524 case IEEE80211_CAP_DMG_IBSS:
2525 s = "[IBSS]";
2526 break;
2527 case IEEE80211_CAP_DMG_AP:
2528 s = "[ESS]";
2529 break;
2530 case IEEE80211_CAP_DMG_PBSS:
2531 s = "[PBSS]";
2532 break;
2533 default:
2534 s = "";
2535 break;
2536 }
2537 ret = os_snprintf(pos, end - pos, "%s", s);
d85e1fc8 2538 if (os_snprintf_error(end - pos, ret))
fb0e5bd7 2539 return -1;
bd1af96a 2540 pos += ret;
e403ba85
BS		 2541 } else {
2542 if (bss->caps & IEEE80211_CAP_IBSS) {
2543 ret = os_snprintf(pos, end - pos, "[IBSS]");
d85e1fc8 2544 if (os_snprintf_error(end - pos, ret))
e403ba85
BS		 2545 return -1;
2546 pos += ret;
2547 }
2548 if (bss->caps & IEEE80211_CAP_ESS) {
2549 ret = os_snprintf(pos, end - pos, "[ESS]");
d85e1fc8 2550 if (os_snprintf_error(end - pos, ret))
e403ba85
BS		 2551 return -1;
2552 pos += ret;
2553 }
bd1af96a 2554 }
0c6b310e
JM		 2555 if (p2p) {
2556 ret = os_snprintf(pos, end - pos, "[P2P]");
d85e1fc8 2557 if (os_snprintf_error(end - pos, ret))
fb0e5bd7 2558 return -1;
0c6b310e
JM		 2559 pos += ret;
2560 }
64855b96 2561#ifdef CONFIG_HS20
4ed34f5a 2562 if (wpa_bss_get_vendor_ie(bss, HS20_IE_VENDOR_TYPE) && ie2) {
64855b96 2563 ret = os_snprintf(pos, end - pos, "[HS20]");
d85e1fc8 2564 if (os_snprintf_error(end - pos, ret))
64855b96
JM		 2565 return -1;
2566 pos += ret;
2567 }
2568#endif /* CONFIG_HS20 */
55de4d4b
AN		 2569#ifdef CONFIG_FST
2570 if (wpa_bss_get_ie(bss, WLAN_EID_MULTI_BAND)) {
2571 ret = os_snprintf(pos, end - pos, "[FST]");
2572 if (os_snprintf_error(end - pos, ret))
2573 return -1;
2574 pos += ret;
2575 }
2576#endif /* CONFIG_FST */
6fc6879b 2577
6fc6879b 2578 ret = os_snprintf(pos, end - pos, "\t%s",
16b71ac2 2579 wpa_ssid_txt(bss->ssid, bss->ssid_len));
d85e1fc8 2580 if (os_snprintf_error(end - pos, ret))
fb0e5bd7 2581 return -1;
6fc6879b
JM		 2582 pos += ret;
2583
2584 ret = os_snprintf(pos, end - pos, "\n");
d85e1fc8 2585 if (os_snprintf_error(end - pos, ret))
fb0e5bd7 2586 return -1;
6fc6879b
JM		 2587 pos += ret;
2588
2589 return pos - buf;
2590}
2591
2592
2593static int wpa_supplicant_ctrl_iface_scan_results(
2594 struct wpa_supplicant *wpa_s, char *buf, size_t buflen)
2595{
2596 char *pos, *end;
16b71ac2 2597 struct wpa_bss *bss;
6fc6879b 2598 int ret;
6fc6879b
JM		 2599
2600 pos = buf;
2601 end = buf + buflen;
2602 ret = os_snprintf(pos, end - pos, "bssid / frequency / signal level / "
2603 "flags / ssid\n");
d85e1fc8 2604 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 2605 return pos - buf;
2606 pos += ret;
2607
16b71ac2 2608 dl_list_for_each(bss, &wpa_s->bss_id, struct wpa_bss, list_id) {
31fcea93 2609 ret = wpa_supplicant_ctrl_iface_scan_result(wpa_s, bss, pos,
6fc6879b
JM		 2610 end - pos);
2611 if (ret < 0 || ret >= end - pos)
2612 return pos - buf;
2613 pos += ret;
2614 }
2615
2616 return pos - buf;
2617}
2618
2619
603a3f34
JL		 2620#ifdef CONFIG_MESH
2621
5b78493f
MH		 2622static int wpa_supplicant_ctrl_iface_mesh_interface_add(
2623 struct wpa_supplicant *wpa_s, char *cmd, char *reply, size_t max_len)
2624{
2625 char *pos, ifname[IFNAMSIZ + 1];
2626
2627 ifname[0] = '\0';
2628
2629 pos = os_strstr(cmd, "ifname=");
2630 if (pos) {
2631 pos += 7;
2632 os_strlcpy(ifname, pos, sizeof(ifname));
2633 }
2634
2635 if (wpas_mesh_add_interface(wpa_s, ifname, sizeof(ifname)) < 0)
2636 return -1;
2637
2638 os_strlcpy(reply, ifname, max_len);
2639 return os_strlen(ifname);
2640}
2641
2642
603a3f34
JL		 2643static int wpa_supplicant_ctrl_iface_mesh_group_add(
2644 struct wpa_supplicant *wpa_s, char *cmd)
2645{
2646 int id;
2647 struct wpa_ssid *ssid;
2648
2649 id = atoi(cmd);
2650 wpa_printf(MSG_DEBUG, "CTRL_IFACE: MESH_GROUP_ADD id=%d", id);
2651
2652 ssid = wpa_config_get_network(wpa_s->conf, id);
2653 if (ssid == NULL) {
2654 wpa_printf(MSG_DEBUG,
2655 "CTRL_IFACE: Could not find network id=%d", id);
2656 return -1;
2657 }
2658 if (ssid->mode != WPAS_MODE_MESH) {
2659 wpa_printf(MSG_DEBUG,
2660 "CTRL_IFACE: Cannot use MESH_GROUP_ADD on a non mesh network");
2661 return -1;
2662 }
0c6099f3
MH		 2663 if (ssid->key_mgmt != WPA_KEY_MGMT_NONE &&
2664 ssid->key_mgmt != WPA_KEY_MGMT_SAE) {
2665 wpa_printf(MSG_ERROR,
2666 "CTRL_IFACE: key_mgmt for mesh network should be open or SAE");
2667 return -1;
2668 }
603a3f34
JL		 2669
2670 /*
2671 * TODO: If necessary write our own group_add function,
2672 * for now we can reuse select_network
2673 */
2674 wpa_supplicant_select_network(wpa_s, ssid);
2675
2676 return 0;
2677}
2678
2679
2680static int wpa_supplicant_ctrl_iface_mesh_group_remove(
2681 struct wpa_supplicant *wpa_s, char *cmd)
2682{
5b78493f
MH		 2683 struct wpa_supplicant *orig;
2684 struct wpa_global *global;
2685 int found = 0;
2686
2687 wpa_printf(MSG_DEBUG, "CTRL_IFACE: MESH_GROUP_REMOVE ifname=%s", cmd);
2688
2689 global = wpa_s->global;
2690 orig = wpa_s;
2691
2692 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
2693 if (os_strcmp(wpa_s->ifname, cmd) == 0) {
2694 found = 1;
2695 break;
2696 }
2697 }
2698 if (!found) {
2699 wpa_printf(MSG_ERROR,
2700 "CTRL_IFACE: MESH_GROUP_REMOVE ifname=%s not found",
603a3f34
JL		 2701 cmd);
2702 return -1;
2703 }
5b78493f
MH		 2704 if (wpa_s->mesh_if_created && wpa_s == orig) {
2705 wpa_printf(MSG_ERROR,
2706 "CTRL_IFACE: MESH_GROUP_REMOVE can't remove itself");
2707 return -1;
2708 }
603a3f34
JL		 2709
2710 wpa_s->reassociate = 0;
2711 wpa_s->disconnected = 1;
2712 wpa_supplicant_cancel_sched_scan(wpa_s);
2713 wpa_supplicant_cancel_scan(wpa_s);
2714
2715 /*
2716 * TODO: If necessary write our own group_remove function,
2717 * for now we can reuse deauthenticate
2718 */
2719 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2720
5b78493f
MH		 2721 if (wpa_s->mesh_if_created)
2722 wpa_supplicant_remove_iface(global, wpa_s, 0);
2723
603a3f34
JL		 2724 return 0;
2725}
2726
2727#endif /* CONFIG_MESH */
2728
2729
6fc6879b
JM		 2730static int wpa_supplicant_ctrl_iface_select_network(
2731 struct wpa_supplicant *wpa_s, char *cmd)
2732{
2733 int id;
2734 struct wpa_ssid *ssid;
204c9ac4 2735 char *pos;
6fc6879b
JM		 2736
2737 /* cmd: "<network id>" or "any" */
204c9ac4 2738 if (os_strncmp(cmd, "any", 3) == 0) {
6fc6879b 2739 wpa_printf(MSG_DEBUG, "CTRL_IFACE: SELECT_NETWORK any");
86b89452
WS		 2740 ssid = NULL;
2741 } else {
2742 id = atoi(cmd);
2743 wpa_printf(MSG_DEBUG, "CTRL_IFACE: SELECT_NETWORK id=%d", id);
6fc6879b 2744
86b89452
WS		 2745 ssid = wpa_config_get_network(wpa_s->conf, id);
2746 if (ssid == NULL) {
2747 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find "
2748 "network id=%d", id);
2749 return -1;
2750 }
4dac0245
JM		 2751 if (ssid->disabled == 2) {
2752 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Cannot use "
2753 "SELECT_NETWORK with persistent P2P group");
2754 return -1;
2755 }
6fc6879b
JM		 2756 }
2757
204c9ac4
DS		 2758 pos = os_strstr(cmd, " freq=");
2759 if (pos) {
2760 int *freqs = freq_range_to_channel_list(wpa_s, pos + 6);
2761 if (freqs) {
2762 wpa_s->scan_req = MANUAL_SCAN_REQ;
2763 os_free(wpa_s->manual_scan_freqs);
2764 wpa_s->manual_scan_freqs = freqs;
2765 }
2766 }
2767
86b89452 2768 wpa_supplicant_select_network(wpa_s, ssid);
6fc6879b
JM		 2769
2770 return 0;
2771}
2772
2773
2774static int wpa_supplicant_ctrl_iface_enable_network(
2775 struct wpa_supplicant *wpa_s, char *cmd)
2776{
2777 int id;
2778 struct wpa_ssid *ssid;
2779
2780 /* cmd: "<network id>" or "all" */
2781 if (os_strcmp(cmd, "all") == 0) {
2782 wpa_printf(MSG_DEBUG, "CTRL_IFACE: ENABLE_NETWORK all");
86b89452
WS		 2783 ssid = NULL;
2784 } else {
2785 id = atoi(cmd);
2786 wpa_printf(MSG_DEBUG, "CTRL_IFACE: ENABLE_NETWORK id=%d", id);
6fc6879b 2787
86b89452
WS		 2788 ssid = wpa_config_get_network(wpa_s->conf, id);
2789 if (ssid == NULL) {
2790 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find "
2791 "network id=%d", id);
2792 return -1;
2793 }
4dac0245
JM		 2794 if (ssid->disabled == 2) {
2795 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Cannot use "
2796 "ENABLE_NETWORK with persistent P2P group");
2797 return -1;
2798 }
84c78f95
JM		 2799
2800 if (os_strstr(cmd, " no-connect")) {
2801 ssid->disabled = 0;
2802 return 0;
2803 }
6fc6879b 2804 }
86b89452 2805 wpa_supplicant_enable_network(wpa_s, ssid);
6fc6879b
JM		 2806
2807 return 0;
2808}
2809
2810
2811static int wpa_supplicant_ctrl_iface_disable_network(
2812 struct wpa_supplicant *wpa_s, char *cmd)
2813{
2814 int id;
2815 struct wpa_ssid *ssid;
2816
2817 /* cmd: "<network id>" or "all" */
2818 if (os_strcmp(cmd, "all") == 0) {
2819 wpa_printf(MSG_DEBUG, "CTRL_IFACE: DISABLE_NETWORK all");
86b89452
WS		 2820 ssid = NULL;
2821 } else {
2822 id = atoi(cmd);
2823 wpa_printf(MSG_DEBUG, "CTRL_IFACE: DISABLE_NETWORK id=%d", id);
6fc6879b 2824
86b89452
WS		 2825 ssid = wpa_config_get_network(wpa_s->conf, id);
2826 if (ssid == NULL) {
2827 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find "
2828 "network id=%d", id);
2829 return -1;
2830 }
4dac0245
JM		 2831 if (ssid->disabled == 2) {
2832 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Cannot use "
2833 "DISABLE_NETWORK with persistent P2P "
2834 "group");
2835 return -1;
2836 }
6fc6879b 2837 }
86b89452 2838 wpa_supplicant_disable_network(wpa_s, ssid);
6fc6879b
JM		 2839
2840 return 0;
2841}
2842
2843
2844static int wpa_supplicant_ctrl_iface_add_network(
2845 struct wpa_supplicant *wpa_s, char *buf, size_t buflen)
2846{
2847 struct wpa_ssid *ssid;
2848 int ret;
2849
2850 wpa_printf(MSG_DEBUG, "CTRL_IFACE: ADD_NETWORK");
2851
2852 ssid = wpa_config_add_network(wpa_s->conf);
2853 if (ssid == NULL)
2854 return -1;
8bac466b
JM		 2855
2856 wpas_notify_network_added(wpa_s, ssid);
2857
6fc6879b
JM		 2858 ssid->disabled = 1;
2859 wpa_config_set_network_defaults(ssid);
2860
2861 ret = os_snprintf(buf, buflen, "%d\n", ssid->id);
d85e1fc8 2862 if (os_snprintf_error(buflen, ret))
6fc6879b
JM		 2863 return -1;
2864 return ret;
2865}
2866
2867
2868static int wpa_supplicant_ctrl_iface_remove_network(
2869 struct wpa_supplicant *wpa_s, char *cmd)
2870{
2871 int id;
2872 struct wpa_ssid *ssid;
725fc39e 2873 int was_disabled;
6fc6879b
JM		 2874
2875 /* cmd: "<network id>" or "all" */
2876 if (os_strcmp(cmd, "all") == 0) {
2877 wpa_printf(MSG_DEBUG, "CTRL_IFACE: REMOVE_NETWORK all");
725fc39e
DS		 2878 if (wpa_s->sched_scanning)
2879 wpa_supplicant_cancel_sched_scan(wpa_s);
2880
d8a790b9 2881 eapol_sm_invalidate_cached_session(wpa_s->eapol);
6fc6879b 2882 if (wpa_s->current_ssid) {
83df8149
JM		 2883#ifdef CONFIG_SME
2884 wpa_s->sme.prev_bssid_set = 0;
2885#endif /* CONFIG_SME */
20a0b03d
JM		 2886 wpa_sm_set_config(wpa_s->wpa, NULL);
2887 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
e66bcedd
JM		 2888 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
2889 wpa_s->own_disconnect_req = 1;
07783eaa
JM		 2890 wpa_supplicant_deauthenticate(
2891 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
6fc6879b 2892 }
391f4925
JK		 2893 ssid = wpa_s->conf->ssid;
2894 while (ssid) {
2895 struct wpa_ssid *remove_ssid = ssid;
2896 id = ssid->id;
2897 ssid = ssid->next;
c267753b
JM		 2898 if (wpa_s->last_ssid == remove_ssid)
2899 wpa_s->last_ssid = NULL;
391f4925
JK		 2900 wpas_notify_network_removed(wpa_s, remove_ssid);
2901 wpa_config_remove_network(wpa_s->conf, id);
2902 }
6fc6879b
JM		 2903 return 0;
2904 }
2905
2906 id = atoi(cmd);
2907 wpa_printf(MSG_DEBUG, "CTRL_IFACE: REMOVE_NETWORK id=%d", id);
2908
2909 ssid = wpa_config_get_network(wpa_s->conf, id);
f3857c2e
JM		 2910 if (ssid)
2911 wpas_notify_network_removed(wpa_s, ssid);
59ff6653 2912 if (ssid == NULL) {
6fc6879b
JM		 2913 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find network "
2914 "id=%d", id);
2915 return -1;
2916 }
2917
c267753b
JM		 2918 if (wpa_s->last_ssid == ssid)
2919 wpa_s->last_ssid = NULL;
2920
d8a790b9 2921 if (ssid == wpa_s->current_ssid || wpa_s->current_ssid == NULL) {
83df8149
JM		 2922#ifdef CONFIG_SME
2923 wpa_s->sme.prev_bssid_set = 0;
2924#endif /* CONFIG_SME */
6fc6879b 2925 /*
d8a790b9
JM		 2926 * Invalidate the EAP session cache if the current or
2927 * previously used network is removed.
6fc6879b
JM		 2928 */
2929 eapol_sm_invalidate_cached_session(wpa_s->eapol);
d8a790b9
JM		 2930 }
2931
2932 if (ssid == wpa_s->current_ssid) {
20a0b03d
JM		 2933 wpa_sm_set_config(wpa_s->wpa, NULL);
2934 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
6fc6879b 2935
e66bcedd
JM		 2936 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
2937 wpa_s->own_disconnect_req = 1;
07783eaa
JM		 2938 wpa_supplicant_deauthenticate(wpa_s,
2939 WLAN_REASON_DEAUTH_LEAVING);
6fc6879b
JM		 2940 }
2941
725fc39e
DS		 2942 was_disabled = ssid->disabled;
2943
59ff6653
DG		 2944 if (wpa_config_remove_network(wpa_s->conf, id) < 0) {
2945 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Not able to remove the "
2946 "network id=%d", id);
2947 return -1;
2948 }
2949
725fc39e
DS		 2950 if (!was_disabled && wpa_s->sched_scanning) {
2951 wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan to remove "
2952 "network from filters");
2953 wpa_supplicant_cancel_sched_scan(wpa_s);
2954 wpa_supplicant_req_scan(wpa_s, 0, 0);
2955 }
2956
6fc6879b
JM		 2957 return 0;
2958}
2959
2960
1c330a2f
DS		 2961static int wpa_supplicant_ctrl_iface_update_network(
2962 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
2963 char *name, char *value)
2964{
2965 if (wpa_config_set(ssid, name, value, 0) < 0) {
2966 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Failed to set network "
2967 "variable '%s'", name);
2968 return -1;
2969 }
2970
2971 if (os_strcmp(name, "bssid") != 0 &&
2972 os_strcmp(name, "priority") != 0)
2973 wpa_sm_pmksa_cache_flush(wpa_s->wpa, ssid);
2974
2975 if (wpa_s->current_ssid == ssid || wpa_s->current_ssid == NULL) {
2976 /*
2977 * Invalidate the EAP session cache if anything in the current
2978 * or previously used configuration changes.
2979 */
2980 eapol_sm_invalidate_cached_session(wpa_s->eapol);
2981 }
2982
2983 if ((os_strcmp(name, "psk") == 0 &&
2984 value[0] == '"' && ssid->ssid_len) ||
2985 (os_strcmp(name, "ssid") == 0 && ssid->passphrase))
2986 wpa_config_update_psk(ssid);
2987 else if (os_strcmp(name, "priority") == 0)
2988 wpa_config_update_prio_list(wpa_s->conf);
2989
2990 return 0;
2991}
2992
2993
6fc6879b
JM		 2994static int wpa_supplicant_ctrl_iface_set_network(
2995 struct wpa_supplicant *wpa_s, char *cmd)
2996{
1e529832 2997 int id, ret, prev_bssid_set, prev_disabled;
6fc6879b
JM		 2998 struct wpa_ssid *ssid;
2999 char *name, *value;
0ef023e4 3000 u8 prev_bssid[ETH_ALEN];
6fc6879b
JM		 3001
3002 /* cmd: "<network id> <variable name> <value>" */
3003 name = os_strchr(cmd, ' ');
3004 if (name == NULL)
3005 return -1;
3006 *name++ = '\0';
3007
3008 value = os_strchr(name, ' ');
3009 if (value == NULL)
3010 return -1;
3011 *value++ = '\0';
3012
3013 id = atoi(cmd);
3014 wpa_printf(MSG_DEBUG, "CTRL_IFACE: SET_NETWORK id=%d name='%s'",
3015 id, name);
3016 wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: value",
3017 (u8 *) value, os_strlen(value));
3018
3019 ssid = wpa_config_get_network(wpa_s->conf, id);
3020 if (ssid == NULL) {
3021 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find network "
3022 "id=%d", id);
3023 return -1;
3024 }
3025
0ef023e4 3026 prev_bssid_set = ssid->bssid_set;
1e529832 3027 prev_disabled = ssid->disabled;
0ef023e4
JM		 3028 os_memcpy(prev_bssid, ssid->bssid, ETH_ALEN);
3029 ret = wpa_supplicant_ctrl_iface_update_network(wpa_s, ssid, name,
3030 value);
3031 if (ret == 0 &&
3032 (ssid->bssid_set != prev_bssid_set ||
3033 os_memcmp(ssid->bssid, prev_bssid, ETH_ALEN) != 0))
3034 wpas_notify_network_bssid_set_changed(wpa_s, ssid);
1e529832
JM		 3035
3036 if (prev_disabled != ssid->disabled &&
3037 (prev_disabled == 2 || ssid->disabled == 2))
3038 wpas_notify_network_type_changed(wpa_s, ssid);
3039
0ef023e4 3040 return ret;
6fc6879b
JM		 3041}
3042
3043
3044static int wpa_supplicant_ctrl_iface_get_network(
3045 struct wpa_supplicant *wpa_s, char *cmd, char *buf, size_t buflen)
3046{
3047 int id;
3048 size_t res;
3049 struct wpa_ssid *ssid;
3050 char *name, *value;
3051
3052 /* cmd: "<network id> <variable name>" */
3053 name = os_strchr(cmd, ' ');
3054 if (name == NULL || buflen == 0)
3055 return -1;
3056 *name++ = '\0';
3057
3058 id = atoi(cmd);
3059 wpa_printf(MSG_DEBUG, "CTRL_IFACE: GET_NETWORK id=%d name='%s'",
3060 id, name);
3061
3062 ssid = wpa_config_get_network(wpa_s->conf, id);
3063 if (ssid == NULL) {
3064 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find network "
3065 "id=%d", id);
3066 return -1;
3067 }
3068
3069 value = wpa_config_get_no_key(ssid, name);
3070 if (value == NULL) {
3071 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Failed to get network "
3072 "variable '%s'", name);
3073 return -1;
3074 }
3075
3076 res = os_strlcpy(buf, value, buflen);
3077 if (res >= buflen) {
3078 os_free(value);
3079 return -1;
3080 }
3081
3082 os_free(value);
3083
3084 return res;
3085}
3086
3087
1c330a2f 3088static int wpa_supplicant_ctrl_iface_dup_network(
daae4995
AN		 3089 struct wpa_supplicant *wpa_s, char *cmd,
3090 struct wpa_supplicant *dst_wpa_s)
1c330a2f
DS		 3091{
3092 struct wpa_ssid *ssid_s, *ssid_d;
3093 char *name, *id, *value;
3094 int id_s, id_d, ret;
3095
3096 /* cmd: "<src network id> <dst network id> <variable name>" */
3097 id = os_strchr(cmd, ' ');
3098 if (id == NULL)
3099 return -1;
3100 *id++ = '\0';
3101
3102 name = os_strchr(id, ' ');
3103 if (name == NULL)
3104 return -1;
3105 *name++ = '\0';
3106
3107 id_s = atoi(cmd);
3108 id_d = atoi(id);
daae4995
AN		 3109
3110 wpa_printf(MSG_DEBUG,
3111 "CTRL_IFACE: DUP_NETWORK ifname=%s->%s id=%d->%d name='%s'",
3112 wpa_s->ifname, dst_wpa_s->ifname, id_s, id_d, name);
1c330a2f
DS		 3113
3114 ssid_s = wpa_config_get_network(wpa_s->conf, id_s);
3115 if (ssid_s == NULL) {
3116 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find "
3117 "network id=%d", id_s);
3118 return -1;
3119 }
3120
daae4995 3121 ssid_d = wpa_config_get_network(dst_wpa_s->conf, id_d);
1c330a2f
DS		 3122 if (ssid_d == NULL) {
3123 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find "
c0541906 3124 "network id=%d", id_d);
1c330a2f
DS		 3125 return -1;
3126 }
3127
3128 value = wpa_config_get(ssid_s, name);
3129 if (value == NULL) {
3130 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Failed to get network "
3131 "variable '%s'", name);
3132 return -1;
3133 }
3134
daae4995 3135 ret = wpa_supplicant_ctrl_iface_update_network(dst_wpa_s, ssid_d, name,
1c330a2f
DS		 3136 value);
3137
3138 os_free(value);
3139
3140 return ret;
3141}
3142
3143
d94c9ee6
JM		 3144static int wpa_supplicant_ctrl_iface_list_creds(struct wpa_supplicant *wpa_s,
3145 char *buf, size_t buflen)
3146{
3147 char *pos, *end;
3148 struct wpa_cred *cred;
3149 int ret;
3150
3151 pos = buf;
3152 end = buf + buflen;
3153 ret = os_snprintf(pos, end - pos,
3154 "cred id / realm / username / domain / imsi\n");
d85e1fc8 3155 if (os_snprintf_error(end - pos, ret))
d94c9ee6
JM		 3156 return pos - buf;
3157 pos += ret;
3158
3159 cred = wpa_s->conf->cred;
3160 while (cred) {
3161 ret = os_snprintf(pos, end - pos, "%d\t%s\t%s\t%s\t%s\n",
3162 cred->id, cred->realm ? cred->realm : "",
3163 cred->username ? cred->username : "",
463c8ffb 3164 cred->domain ? cred->domain[0] : "",
d94c9ee6 3165 cred->imsi ? cred->imsi : "");
d85e1fc8 3166 if (os_snprintf_error(end - pos, ret))
d94c9ee6
JM		 3167 return pos - buf;
3168 pos += ret;
3169
3170 cred = cred->next;
3171 }
3172
3173 return pos - buf;
3174}
3175
3176
3177static int wpa_supplicant_ctrl_iface_add_cred(struct wpa_supplicant *wpa_s,
3178 char *buf, size_t buflen)
3179{
3180 struct wpa_cred *cred;
3181 int ret;
3182
3183 wpa_printf(MSG_DEBUG, "CTRL_IFACE: ADD_CRED");
3184
3185 cred = wpa_config_add_cred(wpa_s->conf);
3186 if (cred == NULL)
3187 return -1;
3188
1619e9d5
JM		 3189 wpa_msg(wpa_s, MSG_INFO, CRED_ADDED "%d", cred->id);
3190
d94c9ee6 3191 ret = os_snprintf(buf, buflen, "%d\n", cred->id);
d85e1fc8 3192 if (os_snprintf_error(buflen, ret))
d94c9ee6
JM		 3193 return -1;
3194 return ret;
3195}
3196
3197
736d4f2d
JM		 3198static int wpas_ctrl_remove_cred(struct wpa_supplicant *wpa_s,
3199 struct wpa_cred *cred)
3200{
3201 struct wpa_ssid *ssid;
3202 char str[20];
1619e9d5 3203 int id;
736d4f2d 3204
1619e9d5 3205 if (cred == NULL) {
736d4f2d
JM		 3206 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find cred");
3207 return -1;
3208 }
3209
1619e9d5
JM		 3210 id = cred->id;
3211 if (wpa_config_remove_cred(wpa_s->conf, id) < 0) {
3212 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find cred");
3213 return -1;
3214 }
3215
3216 wpa_msg(wpa_s, MSG_INFO, CRED_REMOVED "%d", id);
3217
736d4f2d
JM		 3218 /* Remove any network entry created based on the removed credential */
3219 ssid = wpa_s->conf->ssid;
3220 while (ssid) {
3221 if (ssid->parent_cred == cred) {
1d399771
JM		 3222 int res;
3223
736d4f2d
JM		 3224 wpa_printf(MSG_DEBUG, "Remove network id %d since it "
3225 "used the removed credential", ssid->id);
1d399771
JM		 3226 res = os_snprintf(str, sizeof(str), "%d", ssid->id);
3227 if (os_snprintf_error(sizeof(str), res))
3228 str[sizeof(str) - 1] = '\0';
736d4f2d
JM		 3229 ssid = ssid->next;
3230 wpa_supplicant_ctrl_iface_remove_network(wpa_s, str);
3231 } else
3232 ssid = ssid->next;
3233 }
3234
3235 return 0;
3236}
3237
3238
d94c9ee6
JM		 3239static int wpa_supplicant_ctrl_iface_remove_cred(struct wpa_supplicant *wpa_s,
3240 char *cmd)
3241{
3242 int id;
736d4f2d 3243 struct wpa_cred *cred, *prev;
d94c9ee6 3244
aa26ba68
JM		 3245 /* cmd: "<cred id>", "all", "sp_fqdn=<FQDN>", or
3246 * "provisioning_sp=<FQDN> */
d94c9ee6
JM		 3247 if (os_strcmp(cmd, "all") == 0) {
3248 wpa_printf(MSG_DEBUG, "CTRL_IFACE: REMOVE_CRED all");
3249 cred = wpa_s->conf->cred;
3250 while (cred) {
736d4f2d 3251 prev = cred;
d94c9ee6 3252 cred = cred->next;
736d4f2d 3253 wpas_ctrl_remove_cred(wpa_s, prev);
d94c9ee6
JM		 3254 }
3255 return 0;
3256 }
3257
9afe52eb
JM		 3258 if (os_strncmp(cmd, "sp_fqdn=", 8) == 0) {
3259 wpa_printf(MSG_DEBUG, "CTRL_IFACE: REMOVE_CRED SP FQDN '%s'",
3260 cmd + 8);
3261 cred = wpa_s->conf->cred;
3262 while (cred) {
3263 prev = cred;
3264 cred = cred->next;
463c8ffb
JM		 3265 if (prev->domain) {
3266 size_t i;
3267 for (i = 0; i < prev->num_domain; i++) {
3268 if (os_strcmp(prev->domain[i], cmd + 8)
3269 != 0)
3270 continue;
3271 wpas_ctrl_remove_cred(wpa_s, prev);
3272 break;
3273 }
3274 }
9afe52eb
JM		 3275 }
3276 return 0;
3277 }
3278
aa26ba68
JM		 3279 if (os_strncmp(cmd, "provisioning_sp=", 16) == 0) {
3280 wpa_printf(MSG_DEBUG, "CTRL_IFACE: REMOVE_CRED provisioning SP FQDN '%s'",
3281 cmd + 16);
3282 cred = wpa_s->conf->cred;
3283 while (cred) {
3284 prev = cred;
3285 cred = cred->next;
3286 if (prev->provisioning_sp &&
3287 os_strcmp(prev->provisioning_sp, cmd + 16) == 0)
3288 wpas_ctrl_remove_cred(wpa_s, prev);
3289 }
3290 return 0;
3291 }
3292
d94c9ee6
JM		 3293 id = atoi(cmd);
3294 wpa_printf(MSG_DEBUG, "CTRL_IFACE: REMOVE_CRED id=%d", id);
3295
3296 cred = wpa_config_get_cred(wpa_s->conf, id);
736d4f2d 3297 return wpas_ctrl_remove_cred(wpa_s, cred);
d94c9ee6
JM		 3298}
3299
3300
3301static int wpa_supplicant_ctrl_iface_set_cred(struct wpa_supplicant *wpa_s,
3302 char *cmd)
3303{
3304 int id;
3305 struct wpa_cred *cred;
3306 char *name, *value;
3307
3308 /* cmd: "<cred id> <variable name> <value>" */
3309 name = os_strchr(cmd, ' ');
3310 if (name == NULL)
3311 return -1;
3312 *name++ = '\0';
3313
3314 value = os_strchr(name, ' ');
3315 if (value == NULL)
3316 return -1;
3317 *value++ = '\0';
3318
3319 id = atoi(cmd);
3320 wpa_printf(MSG_DEBUG, "CTRL_IFACE: SET_CRED id=%d name='%s'",
3321 id, name);
3322 wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: value",
3323 (u8 *) value, os_strlen(value));
3324
3325 cred = wpa_config_get_cred(wpa_s->conf, id);
3326 if (cred == NULL) {
3327 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find cred id=%d",
3328 id);
3329 return -1;
3330 }
3331
3332 if (wpa_config_set_cred(cred, name, value, 0) < 0) {
3333 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Failed to set cred "
3334 "variable '%s'", name);
3335 return -1;
3336 }
3337
1619e9d5
JM		 3338 wpa_msg(wpa_s, MSG_INFO, CRED_MODIFIED "%d %s", cred->id, name);
3339
d94c9ee6
JM		 3340 return 0;
3341}
3342
3343
c880ab87
JM		 3344static int wpa_supplicant_ctrl_iface_get_cred(struct wpa_supplicant *wpa_s,
3345 char *cmd, char *buf,
3346 size_t buflen)
3347{
3348 int id;
3349 size_t res;
3350 struct wpa_cred *cred;
3351 char *name, *value;
3352
3353 /* cmd: "<cred id> <variable name>" */
3354 name = os_strchr(cmd, ' ');
3355 if (name == NULL)
3356 return -1;
3357 *name++ = '\0';
3358
3359 id = atoi(cmd);
3360 wpa_printf(MSG_DEBUG, "CTRL_IFACE: GET_CRED id=%d name='%s'",
3361 id, name);
3362
3363 cred = wpa_config_get_cred(wpa_s->conf, id);
3364 if (cred == NULL) {
3365 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find cred id=%d",
3366 id);
3367 return -1;
3368 }
3369
3370 value = wpa_config_get_cred_no_key(cred, name);
3371 if (value == NULL) {
3372 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Failed to get cred variable '%s'",
3373 name);
3374 return -1;
3375 }
3376
3377 res = os_strlcpy(buf, value, buflen);
3378 if (res >= buflen) {
3379 os_free(value);
3380 return -1;
3381 }
3382
3383 os_free(value);
3384
3385 return res;
3386}
3387
3388
6fc6879b
JM		 3389#ifndef CONFIG_NO_CONFIG_WRITE
3390static int wpa_supplicant_ctrl_iface_save_config(struct wpa_supplicant *wpa_s)
3391{
3392 int ret;
3393
3394 if (!wpa_s->conf->update_config) {
3395 wpa_printf(MSG_DEBUG, "CTRL_IFACE: SAVE_CONFIG - Not allowed "
3396 "to update configuration (update_config=0)");
3397 return -1;
3398 }
3399
3400 ret = wpa_config_write(wpa_s->confname, wpa_s->conf);
3401 if (ret) {
3402 wpa_printf(MSG_DEBUG, "CTRL_IFACE: SAVE_CONFIG - Failed to "
3403 "update configuration");
3404 } else {
3405 wpa_printf(MSG_DEBUG, "CTRL_IFACE: SAVE_CONFIG - Configuration"
3406 " updated");
3407 }
3408
3409 return ret;
3410}
3411#endif /* CONFIG_NO_CONFIG_WRITE */
3412
3413
4daa011b
JM		 3414struct cipher_info {
3415 unsigned int capa;
3416 const char *name;
3417 int group_only;
3418};
3419
3420static const struct cipher_info ciphers[] = {
3421 { WPA_DRIVER_CAPA_ENC_CCMP_256, "CCMP-256", 0 },
3422 { WPA_DRIVER_CAPA_ENC_GCMP_256, "GCMP-256", 0 },
3423 { WPA_DRIVER_CAPA_ENC_CCMP, "CCMP", 0 },
3424 { WPA_DRIVER_CAPA_ENC_GCMP, "GCMP", 0 },
3425 { WPA_DRIVER_CAPA_ENC_TKIP, "TKIP", 0 },
3426 { WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE, "NONE", 0 },
3427 { WPA_DRIVER_CAPA_ENC_WEP104, "WEP104", 1 },
3428 { WPA_DRIVER_CAPA_ENC_WEP40, "WEP40", 1 }
3429};
3430
b5f045de
JM		 3431static const struct cipher_info ciphers_group_mgmt[] = {
3432 { WPA_DRIVER_CAPA_ENC_BIP, "AES-128-CMAC", 1 },
3433 { WPA_DRIVER_CAPA_ENC_BIP_GMAC_128, "BIP-GMAC-128", 1 },
3434 { WPA_DRIVER_CAPA_ENC_BIP_GMAC_256, "BIP-GMAC-256", 1 },
3435 { WPA_DRIVER_CAPA_ENC_BIP_CMAC_256, "BIP-CMAC-256", 1 },
3436};
3437
4daa011b 3438
6fc6879b
JM		 3439static int ctrl_iface_get_capability_pairwise(int res, char *strict,
3440 struct wpa_driver_capa *capa,
3441 char *buf, size_t buflen)
3442{
ea3b8c1d 3443 int ret;
6fc6879b
JM		 3444 char *pos, *end;
3445 size_t len;
4daa011b 3446 unsigned int i;
6fc6879b
JM		 3447
3448 pos = buf;
3449 end = pos + buflen;
3450
3451 if (res < 0) {
3452 if (strict)
3453 return 0;
3454 len = os_strlcpy(buf, "CCMP TKIP NONE", buflen);
3455 if (len >= buflen)
3456 return -1;
3457 return len;
3458 }
3459
4daa011b
JM		 3460 for (i = 0; i < ARRAY_SIZE(ciphers); i++) {
3461 if (!ciphers[i].group_only && capa->enc & ciphers[i].capa) {
3462 ret = os_snprintf(pos, end - pos, "%s%s",
ea3b8c1d
JM		 3463 pos == buf ? "" : " ",
3464 ciphers[i].name);
d85e1fc8 3465 if (os_snprintf_error(end - pos, ret))
4daa011b
JM		 3466 return pos - buf;
3467 pos += ret;
4daa011b 3468 }
6fc6879b
JM		 3469 }
3470
3471 return pos - buf;
3472}
3473
3474
3475static int ctrl_iface_get_capability_group(int res, char *strict,
3476 struct wpa_driver_capa *capa,
3477 char *buf, size_t buflen)
3478{
ea3b8c1d 3479 int ret;
6fc6879b
JM		 3480 char *pos, *end;
3481 size_t len;
4daa011b 3482 unsigned int i;
6fc6879b
JM		 3483
3484 pos = buf;
3485 end = pos + buflen;
3486
3487 if (res < 0) {
3488 if (strict)
3489 return 0;
3490 len = os_strlcpy(buf, "CCMP TKIP WEP104 WEP40", buflen);
3491 if (len >= buflen)
3492 return -1;
3493 return len;
3494 }
3495
4daa011b
JM		 3496 for (i = 0; i < ARRAY_SIZE(ciphers); i++) {
3497 if (capa->enc & ciphers[i].capa) {
3498 ret = os_snprintf(pos, end - pos, "%s%s",
ea3b8c1d
JM		 3499 pos == buf ? "" : " ",
3500 ciphers[i].name);
d85e1fc8 3501 if (os_snprintf_error(end - pos, ret))
4daa011b
JM		 3502 return pos - buf;
3503 pos += ret;
4daa011b 3504 }
6fc6879b
JM		 3505 }
3506
3507 return pos - buf;
3508}
3509
3510
b5f045de
JM		 3511static int ctrl_iface_get_capability_group_mgmt(int res, char *strict,
3512 struct wpa_driver_capa *capa,
3513 char *buf, size_t buflen)
3514{
3515 int ret;
3516 char *pos, *end;
3517 unsigned int i;
3518
3519 pos = buf;
3520 end = pos + buflen;
3521
3522 if (res < 0)
3523 return 0;
3524
3525 for (i = 0; i < ARRAY_SIZE(ciphers_group_mgmt); i++) {
3526 if (capa->enc & ciphers_group_mgmt[i].capa) {
3527 ret = os_snprintf(pos, end - pos, "%s%s",
3528 pos == buf ? "" : " ",
3529 ciphers_group_mgmt[i].name);
3530 if (os_snprintf_error(end - pos, ret))
3531 return pos - buf;
3532 pos += ret;
3533 }
3534 }
3535
3536 return pos - buf;
3537}
3538
3539
6fc6879b
JM		 3540static int ctrl_iface_get_capability_key_mgmt(int res, char *strict,
3541 struct wpa_driver_capa *capa,
3542 char *buf, size_t buflen)
3543{
3544 int ret;
3545 char *pos, *end;
3546 size_t len;
3547
3548 pos = buf;
3549 end = pos + buflen;
3550
3551 if (res < 0) {
3552 if (strict)
3553 return 0;
3554 len = os_strlcpy(buf, "WPA-PSK WPA-EAP IEEE8021X WPA-NONE "
3555 "NONE", buflen);
3556 if (len >= buflen)
3557 return -1;
3558 return len;
3559 }
3560
3561 ret = os_snprintf(pos, end - pos, "NONE IEEE8021X");
d85e1fc8 3562 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 3563 return pos - buf;
3564 pos += ret;
3565
3566 if (capa->key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA |
3567 WPA_DRIVER_CAPA_KEY_MGMT_WPA2)) {
3568 ret = os_snprintf(pos, end - pos, " WPA-EAP");
d85e1fc8 3569 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 3570 return pos - buf;
3571 pos += ret;
3572 }
3573
3574 if (capa->key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK |
3575 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK)) {
3576 ret = os_snprintf(pos, end - pos, " WPA-PSK");
d85e1fc8 3577 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 3578 return pos - buf;
3579 pos += ret;
3580 }
3581
3582 if (capa->key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE) {
3583 ret = os_snprintf(pos, end - pos, " WPA-NONE");
d85e1fc8 3584 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 3585 return pos - buf;
3586 pos += ret;
3587 }
3588
399e6135
JM		 3589#ifdef CONFIG_SUITEB
3590 if (capa->key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_SUITE_B) {
3591 ret = os_snprintf(pos, end - pos, " WPA-EAP-SUITE-B");
3592 if (os_snprintf_error(end - pos, ret))
3593 return pos - buf;
3594 pos += ret;
3595 }
3596#endif /* CONFIG_SUITEB */
3597#ifdef CONFIG_SUITEB192
3598 if (capa->key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_SUITE_B_192) {
3599 ret = os_snprintf(pos, end - pos, " WPA-EAP-SUITE-B-192");
3600 if (os_snprintf_error(end - pos, ret))
3601 return pos - buf;
3602 pos += ret;
3603 }
3604#endif /* CONFIG_SUITEB192 */
3605
6fc6879b
JM		 3606 return pos - buf;
3607}
3608
3609
3610static int ctrl_iface_get_capability_proto(int res, char *strict,
3611 struct wpa_driver_capa *capa,
3612 char *buf, size_t buflen)
3613{
ea3b8c1d 3614 int ret;
6fc6879b
JM		 3615 char *pos, *end;
3616 size_t len;
3617
3618 pos = buf;
3619 end = pos + buflen;
3620
3621 if (res < 0) {
3622 if (strict)
3623 return 0;
3624 len = os_strlcpy(buf, "RSN WPA", buflen);
3625 if (len >= buflen)
3626 return -1;
3627 return len;
3628 }
3629
3630 if (capa->key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA2 |
3631 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK)) {
ea3b8c1d
JM		 3632 ret = os_snprintf(pos, end - pos, "%sRSN",
3633 pos == buf ? "" : " ");
d85e1fc8 3634 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 3635 return pos - buf;
3636 pos += ret;
6fc6879b
JM		 3637 }
3638
3639 if (capa->key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA |
3640 WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK)) {
ea3b8c1d
JM		 3641 ret = os_snprintf(pos, end - pos, "%sWPA",
3642 pos == buf ? "" : " ");
d85e1fc8 3643 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 3644 return pos - buf;
3645 pos += ret;
6fc6879b
JM		 3646 }
3647
3648 return pos - buf;
3649}
3650
3651
db5adfe7
JM		 3652static int ctrl_iface_get_capability_auth_alg(struct wpa_supplicant *wpa_s,
3653 int res, char *strict,
6fc6879b
JM		 3654 struct wpa_driver_capa *capa,
3655 char *buf, size_t buflen)
3656{
ea3b8c1d 3657 int ret;
6fc6879b
JM		 3658 char *pos, *end;
3659 size_t len;
3660
3661 pos = buf;
3662 end = pos + buflen;
3663
3664 if (res < 0) {
3665 if (strict)
3666 return 0;
3667 len = os_strlcpy(buf, "OPEN SHARED LEAP", buflen);
3668 if (len >= buflen)
3669 return -1;
3670 return len;
3671 }
3672
3673 if (capa->auth & (WPA_DRIVER_AUTH_OPEN)) {
ea3b8c1d
JM		 3674 ret = os_snprintf(pos, end - pos, "%sOPEN",
3675 pos == buf ? "" : " ");
d85e1fc8 3676 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 3677 return pos - buf;
3678 pos += ret;
6fc6879b
JM		 3679 }
3680
3681 if (capa->auth & (WPA_DRIVER_AUTH_SHARED)) {
3682 ret = os_snprintf(pos, end - pos, "%sSHARED",
ea3b8c1d 3683 pos == buf ? "" : " ");
d85e1fc8 3684 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 3685 return pos - buf;
3686 pos += ret;
6fc6879b
JM		 3687 }
3688
3689 if (capa->auth & (WPA_DRIVER_AUTH_LEAP)) {
ea3b8c1d
JM		 3690 ret = os_snprintf(pos, end - pos, "%sLEAP",
3691 pos == buf ? "" : " ");
d85e1fc8 3692 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 3693 return pos - buf;
3694 pos += ret;
6fc6879b
JM		 3695 }
3696
db5adfe7
JM		 3697#ifdef CONFIG_SAE
3698 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAE) {
3699 ret = os_snprintf(pos, end - pos, "%sSAE",
3700 pos == buf ? "" : " ");
3701 if (os_snprintf_error(end - pos, ret))
3702 return pos - buf;
3703 pos += ret;
3704 }
3705#endif /* CONFIG_SAE */
3706
6fc6879b
JM		 3707 return pos - buf;
3708}
3709
3710
65d52fc1
BR		 3711static int ctrl_iface_get_capability_modes(int res, char *strict,
3712 struct wpa_driver_capa *capa,
3713 char *buf, size_t buflen)
3714{
ea3b8c1d 3715 int ret;
65d52fc1
BR		 3716 char *pos, *end;
3717 size_t len;
3718
3719 pos = buf;
3720 end = pos + buflen;
3721
3722 if (res < 0) {
3723 if (strict)
3724 return 0;
3725 len = os_strlcpy(buf, "IBSS AP", buflen);
3726 if (len >= buflen)
3727 return -1;
3728 return len;
3729 }
3730
3731 if (capa->flags & WPA_DRIVER_FLAGS_IBSS) {
ea3b8c1d
JM		 3732 ret = os_snprintf(pos, end - pos, "%sIBSS",
3733 pos == buf ? "" : " ");
d85e1fc8 3734 if (os_snprintf_error(end - pos, ret))
65d52fc1
BR		 3735 return pos - buf;
3736 pos += ret;
65d52fc1
BR		 3737 }
3738
3739 if (capa->flags & WPA_DRIVER_FLAGS_AP) {
ea3b8c1d
JM		 3740 ret = os_snprintf(pos, end - pos, "%sAP",
3741 pos == buf ? "" : " ");
d85e1fc8 3742 if (os_snprintf_error(end - pos, ret))
65d52fc1
BR		 3743 return pos - buf;
3744 pos += ret;
65d52fc1
BR		 3745 }
3746
cf08e9b1
JM		 3747#ifdef CONFIG_MESH
3748 if (capa->flags & WPA_DRIVER_FLAGS_MESH) {
3749 ret = os_snprintf(pos, end - pos, "%sMESH",
3750 pos == buf ? "" : " ");
3751 if (os_snprintf_error(end - pos, ret))
3752 return pos - buf;
3753 pos += ret;
3754 }
3755#endif /* CONFIG_MESH */
3756
65d52fc1
BR		 3757 return pos - buf;
3758}
3759
3760
35aa088a
DS		 3761static int ctrl_iface_get_capability_channels(struct wpa_supplicant *wpa_s,
3762 char *buf, size_t buflen)
3763{
3764 struct hostapd_channel_data *chnl;
3765 int ret, i, j;
3766 char *pos, *end, *hmode;
3767
3768 pos = buf;
3769 end = pos + buflen;
3770
3771 for (j = 0; j < wpa_s->hw.num_modes; j++) {
3772 switch (wpa_s->hw.modes[j].mode) {
3773 case HOSTAPD_MODE_IEEE80211B:
3774 hmode = "B";
3775 break;
3776 case HOSTAPD_MODE_IEEE80211G:
3777 hmode = "G";
3778 break;
3779 case HOSTAPD_MODE_IEEE80211A:
3780 hmode = "A";
3781 break;
7829894c
VK		 3782 case HOSTAPD_MODE_IEEE80211AD:
3783 hmode = "AD";
3784 break;
35aa088a
DS		 3785 default:
3786 continue;
3787 }
3788 ret = os_snprintf(pos, end - pos, "Mode[%s] Channels:", hmode);
d85e1fc8 3789 if (os_snprintf_error(end - pos, ret))
35aa088a
DS		 3790 return pos - buf;
3791 pos += ret;
3792 chnl = wpa_s->hw.modes[j].channels;
3793 for (i = 0; i < wpa_s->hw.modes[j].num_channels; i++) {
3794 if (chnl[i].flag & HOSTAPD_CHAN_DISABLED)
3795 continue;
3796 ret = os_snprintf(pos, end - pos, " %d", chnl[i].chan);
d85e1fc8 3797 if (os_snprintf_error(end - pos, ret))
35aa088a
DS		 3798 return pos - buf;
3799 pos += ret;
3800 }
3801 ret = os_snprintf(pos, end - pos, "\n");
d85e1fc8 3802 if (os_snprintf_error(end - pos, ret))
35aa088a
DS		 3803 return pos - buf;
3804 pos += ret;
3805 }
3806
3807 return pos - buf;
3808}
3809
3810
06060522
BR		 3811static int ctrl_iface_get_capability_freq(struct wpa_supplicant *wpa_s,
3812 char *buf, size_t buflen)
3813{
3814 struct hostapd_channel_data *chnl;
3815 int ret, i, j;
3816 char *pos, *end, *hmode;
3817
3818 pos = buf;
3819 end = pos + buflen;
3820
3821 for (j = 0; j < wpa_s->hw.num_modes; j++) {
3822 switch (wpa_s->hw.modes[j].mode) {
3823 case HOSTAPD_MODE_IEEE80211B:
3824 hmode = "B";
3825 break;
3826 case HOSTAPD_MODE_IEEE80211G:
3827 hmode = "G";
3828 break;
3829 case HOSTAPD_MODE_IEEE80211A:
3830 hmode = "A";
3831 break;
3832 case HOSTAPD_MODE_IEEE80211AD:
3833 hmode = "AD";
3834 break;
3835 default:
3836 continue;
3837 }
3838 ret = os_snprintf(pos, end - pos, "Mode[%s] Channels:\n",
3839 hmode);
d85e1fc8 3840 if (os_snprintf_error(end - pos, ret))
06060522
BR		 3841 return pos - buf;
3842 pos += ret;
3843 chnl = wpa_s->hw.modes[j].channels;
3844 for (i = 0; i < wpa_s->hw.modes[j].num_channels; i++) {
3845 if (chnl[i].flag & HOSTAPD_CHAN_DISABLED)
3846 continue;
0547124d 3847 ret = os_snprintf(pos, end - pos, " %d = %d MHz%s%s\n",
06060522 3848 chnl[i].chan, chnl[i].freq,
0a443580
IP		 3849 chnl[i].flag & HOSTAPD_CHAN_NO_IR ?
3850 " (NO_IR)" : "",
0547124d
DS		 3851 chnl[i].flag & HOSTAPD_CHAN_RADAR ?
3852 " (DFS)" : "");
3853
d85e1fc8 3854 if (os_snprintf_error(end - pos, ret))
06060522
BR		 3855 return pos - buf;
3856 pos += ret;
3857 }
3858 ret = os_snprintf(pos, end - pos, "\n");
d85e1fc8 3859 if (os_snprintf_error(end - pos, ret))
06060522
BR		 3860 return pos - buf;
3861 pos += ret;
3862 }
3863
3864 return pos - buf;
3865}
3866
3867
6fc6879b
JM		 3868static int wpa_supplicant_ctrl_iface_get_capability(
3869 struct wpa_supplicant *wpa_s, const char *_field, char *buf,
3870 size_t buflen)
3871{
3872 struct wpa_driver_capa capa;
3873 int res;
3874 char *strict;
3875 char field[30];
3876 size_t len;
3877
3878 /* Determine whether or not strict checking was requested */
3879 len = os_strlcpy(field, _field, sizeof(field));
3880 if (len >= sizeof(field))
3881 return -1;
3882 strict = os_strchr(field, ' ');
3883 if (strict != NULL) {
3884 *strict++ = '\0';
3885 if (os_strcmp(strict, "strict") != 0)
3886 return -1;
3887 }
3888
3889 wpa_printf(MSG_DEBUG, "CTRL_IFACE: GET_CAPABILITY '%s' %s",
3890 field, strict ? strict : "");
3891
3892 if (os_strcmp(field, "eap") == 0) {
3893 return eap_get_names(buf, buflen);
3894 }
3895
3896 res = wpa_drv_get_capa(wpa_s, &capa);
3897
3898 if (os_strcmp(field, "pairwise") == 0)
3899 return ctrl_iface_get_capability_pairwise(res, strict, &capa,
3900 buf, buflen);
3901
3902 if (os_strcmp(field, "group") == 0)
3903 return ctrl_iface_get_capability_group(res, strict, &capa,
3904 buf, buflen);
3905
b5f045de
JM		 3906 if (os_strcmp(field, "group_mgmt") == 0)
3907 return ctrl_iface_get_capability_group_mgmt(res, strict, &capa,
3908 buf, buflen);
3909
6fc6879b
JM		 3910 if (os_strcmp(field, "key_mgmt") == 0)
3911 return ctrl_iface_get_capability_key_mgmt(res, strict, &capa,
3912 buf, buflen);
3913
3914 if (os_strcmp(field, "proto") == 0)
3915 return ctrl_iface_get_capability_proto(res, strict, &capa,
3916 buf, buflen);
3917
3918 if (os_strcmp(field, "auth_alg") == 0)
db5adfe7
JM		 3919 return ctrl_iface_get_capability_auth_alg(wpa_s, res, strict,
3920 &capa, buf, buflen);
6fc6879b 3921
65d52fc1
BR		 3922 if (os_strcmp(field, "modes") == 0)
3923 return ctrl_iface_get_capability_modes(res, strict, &capa,
3924 buf, buflen);
3925
35aa088a
DS		 3926 if (os_strcmp(field, "channels") == 0)
3927 return ctrl_iface_get_capability_channels(wpa_s, buf, buflen);
3928
06060522
BR		 3929 if (os_strcmp(field, "freq") == 0)
3930 return ctrl_iface_get_capability_freq(wpa_s, buf, buflen);
3931
6e9375e4
DS		 3932#ifdef CONFIG_TDLS
3933 if (os_strcmp(field, "tdls") == 0)
3934 return ctrl_iface_get_capability_tdls(wpa_s, buf, buflen);
3935#endif /* CONFIG_TDLS */
3936
02a8d45a
JM		 3937#ifdef CONFIG_ERP
3938 if (os_strcmp(field, "erp") == 0) {
3939 res = os_snprintf(buf, buflen, "ERP");
d85e1fc8 3940 if (os_snprintf_error(buflen, res))
02a8d45a
JM		 3941 return -1;
3942 return res;
3943 }
3944#endif /* CONFIG_EPR */
3945
6fc6879b
JM		 3946 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Unknown GET_CAPABILITY field '%s'",
3947 field);
3948
3949 return -1;
3950}
3951
3952
afc064fe
JM		 3953#ifdef CONFIG_INTERWORKING
3954static char * anqp_add_hex(char *pos, char *end, const char *title,
3955 struct wpabuf *data)
3956{
3957 char *start = pos;
3958 size_t i;
3959 int ret;
3960 const u8 *d;
3961
3962 if (data == NULL)
3963 return start;
3964
3965 ret = os_snprintf(pos, end - pos, "%s=", title);
d85e1fc8 3966 if (os_snprintf_error(end - pos, ret))
afc064fe
JM		 3967 return start;
3968 pos += ret;
3969
3970 d = wpabuf_head_u8(data);
3971 for (i = 0; i < wpabuf_len(data); i++) {
3972 ret = os_snprintf(pos, end - pos, "%02x", *d++);
d85e1fc8 3973 if (os_snprintf_error(end - pos, ret))
afc064fe
JM		 3974 return start;
3975 pos += ret;
3976 }
3977
3978 ret = os_snprintf(pos, end - pos, "\n");
d85e1fc8 3979 if (os_snprintf_error(end - pos, ret))
afc064fe
JM		 3980 return start;
3981 pos += ret;
3982
3983 return pos;
3984}
3985#endif /* CONFIG_INTERWORKING */
3986
3987
61ce9085 3988static int print_bss_info(struct wpa_supplicant *wpa_s, struct wpa_bss *bss,
5f97dd1c 3989 unsigned long mask, char *buf, size_t buflen)
6fc6879b 3990{
6fc6879b 3991 size_t i;
6fc6879b
JM		 3992 int ret;
3993 char *pos, *end;
0f8385e6 3994 const u8 *ie, *ie2, *osen_ie;
6fc6879b 3995
6fc6879b
JM		 3996 pos = buf;
3997 end = buf + buflen;
6fc6879b 3998
5f97dd1c
DS		 3999 if (mask & WPA_BSS_MASK_ID) {
4000 ret = os_snprintf(pos, end - pos, "id=%u\n", bss->id);
d85e1fc8 4001 if (os_snprintf_error(end - pos, ret))
5f97dd1c 4002 return 0;
6fc6879b
JM		 4003 pos += ret;
4004 }
4005
5f97dd1c
DS		 4006 if (mask & WPA_BSS_MASK_BSSID) {
4007 ret = os_snprintf(pos, end - pos, "bssid=" MACSTR "\n",
4008 MAC2STR(bss->bssid));
d85e1fc8 4009 if (os_snprintf_error(end - pos, ret))
5f97dd1c
DS		 4010 return 0;
4011 pos += ret;
4012 }
6fc6879b 4013
5f97dd1c
DS		 4014 if (mask & WPA_BSS_MASK_FREQ) {
4015 ret = os_snprintf(pos, end - pos, "freq=%d\n", bss->freq);
d85e1fc8 4016 if (os_snprintf_error(end - pos, ret))
5f97dd1c
DS		 4017 return 0;
4018 pos += ret;
4019 }
6fc6879b 4020
5f97dd1c
DS		 4021 if (mask & WPA_BSS_MASK_BEACON_INT) {
4022 ret = os_snprintf(pos, end - pos, "beacon_int=%d\n",
4023 bss->beacon_int);
d85e1fc8 4024 if (os_snprintf_error(end - pos, ret))
5f97dd1c 4025 return 0;
6fc6879b
JM		 4026 pos += ret;
4027 }
5f97dd1c
DS		 4028
4029 if (mask & WPA_BSS_MASK_CAPABILITIES) {
4030 ret = os_snprintf(pos, end - pos, "capabilities=0x%04x\n",
4031 bss->caps);
d85e1fc8 4032 if (os_snprintf_error(end - pos, ret))
5f97dd1c 4033 return 0;
6fc6879b
JM		 4034 pos += ret;
4035 }
5f97dd1c
DS		 4036
4037 if (mask & WPA_BSS_MASK_QUAL) {
4038 ret = os_snprintf(pos, end - pos, "qual=%d\n", bss->qual);
d85e1fc8 4039 if (os_snprintf_error(end - pos, ret))
5f97dd1c 4040 return 0;
bd1af96a
JM		 4041 pos += ret;
4042 }
5f97dd1c
DS		 4043
4044 if (mask & WPA_BSS_MASK_NOISE) {
4045 ret = os_snprintf(pos, end - pos, "noise=%d\n", bss->noise);
d85e1fc8 4046 if (os_snprintf_error(end - pos, ret))
5f97dd1c 4047 return 0;
cc81110d
JM		 4048 pos += ret;
4049 }
6fc6879b 4050
5f97dd1c
DS		 4051 if (mask & WPA_BSS_MASK_LEVEL) {
4052 ret = os_snprintf(pos, end - pos, "level=%d\n", bss->level);
d85e1fc8 4053 if (os_snprintf_error(end - pos, ret))
5f97dd1c
DS		 4054 return 0;
4055 pos += ret;
4056 }
6fc6879b 4057
5f97dd1c
DS		 4058 if (mask & WPA_BSS_MASK_TSF) {
4059 ret = os_snprintf(pos, end - pos, "tsf=%016llu\n",
4060 (unsigned long long) bss->tsf);
d85e1fc8 4061 if (os_snprintf_error(end - pos, ret))
5f97dd1c
DS		 4062 return 0;
4063 pos += ret;
4064 }
4065
4066 if (mask & WPA_BSS_MASK_AGE) {
acb69cec 4067 struct os_reltime now;
5f97dd1c 4068
acb69cec 4069 os_get_reltime(&now);
5f97dd1c
DS		 4070 ret = os_snprintf(pos, end - pos, "age=%d\n",
4071 (int) (now.sec - bss->last_update.sec));
d85e1fc8 4072 if (os_snprintf_error(end - pos, ret))
5f97dd1c
DS		 4073 return 0;
4074 pos += ret;
4075 }
4076
4077 if (mask & WPA_BSS_MASK_IE) {
4078 ret = os_snprintf(pos, end - pos, "ie=");
d85e1fc8 4079 if (os_snprintf_error(end - pos, ret))
5f97dd1c
DS		 4080 return 0;
4081 pos += ret;
4082
4083 ie = (const u8 *) (bss + 1);
4084 for (i = 0; i < bss->ie_len; i++) {
4085 ret = os_snprintf(pos, end - pos, "%02x", *ie++);
d85e1fc8 4086 if (os_snprintf_error(end - pos, ret))
5f97dd1c
DS		 4087 return 0;
4088 pos += ret;
4089 }
4090
4091 ret = os_snprintf(pos, end - pos, "\n");
d85e1fc8 4092 if (os_snprintf_error(end - pos, ret))
5f97dd1c
DS		 4093 return 0;
4094 pos += ret;
4095 }
4096
4097 if (mask & WPA_BSS_MASK_FLAGS) {
4098 ret = os_snprintf(pos, end - pos, "flags=");
d85e1fc8 4099 if (os_snprintf_error(end - pos, ret))
5f97dd1c
DS		 4100 return 0;
4101 pos += ret;
4102
4103 ie = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
4104 if (ie)
4105 pos = wpa_supplicant_ie_txt(pos, end, "WPA", ie,
4106 2 + ie[1]);
4107 ie2 = wpa_bss_get_ie(bss, WLAN_EID_RSN);
4108 if (ie2)
4109 pos = wpa_supplicant_ie_txt(pos, end, "WPA2", ie2,
4110 2 + ie2[1]);
0f8385e6
BG		 4111 osen_ie = wpa_bss_get_vendor_ie(bss, OSEN_IE_VENDOR_TYPE);
4112 if (osen_ie)
4113 pos = wpa_supplicant_ie_txt(pos, end, "OSEN",
4114 osen_ie, 2 + osen_ie[1]);
5f97dd1c 4115 pos = wpa_supplicant_wps_ie_txt(wpa_s, pos, end, bss);
0f8385e6
BG		 4116 if (!ie && !ie2 && !osen_ie &&
4117 (bss->caps & IEEE80211_CAP_PRIVACY)) {
5f97dd1c 4118 ret = os_snprintf(pos, end - pos, "[WEP]");
d85e1fc8 4119 if (os_snprintf_error(end - pos, ret))
5f97dd1c
DS		 4120 return 0;
4121 pos += ret;
4122 }
e403ba85
BS		 4123 if (bss_is_dmg(bss)) {
4124 const char *s;
4125 ret = os_snprintf(pos, end - pos, "[DMG]");
d85e1fc8 4126 if (os_snprintf_error(end - pos, ret))
5f97dd1c
DS		 4127 return 0;
4128 pos += ret;
e403ba85
BS		 4129 switch (bss->caps & IEEE80211_CAP_DMG_MASK) {
4130 case IEEE80211_CAP_DMG_IBSS:
4131 s = "[IBSS]";
4132 break;
4133 case IEEE80211_CAP_DMG_AP:
4134 s = "[ESS]";
4135 break;
4136 case IEEE80211_CAP_DMG_PBSS:
4137 s = "[PBSS]";
4138 break;
4139 default:
4140 s = "";
4141 break;
4142 }
4143 ret = os_snprintf(pos, end - pos, "%s", s);
d85e1fc8 4144 if (os_snprintf_error(end - pos, ret))
5f97dd1c
DS		 4145 return 0;
4146 pos += ret;
e403ba85
BS		 4147 } else {
4148 if (bss->caps & IEEE80211_CAP_IBSS) {
4149 ret = os_snprintf(pos, end - pos, "[IBSS]");
d85e1fc8 4150 if (os_snprintf_error(end - pos, ret))
e403ba85
BS		 4151 return 0;
4152 pos += ret;
4153 }
4154 if (bss->caps & IEEE80211_CAP_ESS) {
4155 ret = os_snprintf(pos, end - pos, "[ESS]");
d85e1fc8 4156 if (os_snprintf_error(end - pos, ret))
e403ba85
BS		 4157 return 0;
4158 pos += ret;
4159 }
5f97dd1c 4160 }
bb50ae43
JM		 4161 if (wpa_bss_get_vendor_ie(bss, P2P_IE_VENDOR_TYPE) ||
4162 wpa_bss_get_vendor_ie_beacon(bss, P2P_IE_VENDOR_TYPE)) {
5f97dd1c 4163 ret = os_snprintf(pos, end - pos, "[P2P]");
d85e1fc8 4164 if (os_snprintf_error(end - pos, ret))
5f97dd1c
DS		 4165 return 0;
4166 pos += ret;
4167 }
64855b96
JM		 4168#ifdef CONFIG_HS20
4169 if (wpa_bss_get_vendor_ie(bss, HS20_IE_VENDOR_TYPE)) {
4170 ret = os_snprintf(pos, end - pos, "[HS20]");
d85e1fc8 4171 if (os_snprintf_error(end - pos, ret))
ff486913 4172 return 0;
64855b96
JM		 4173 pos += ret;
4174 }
4175#endif /* CONFIG_HS20 */
5f97dd1c
DS		 4176
4177 ret = os_snprintf(pos, end - pos, "\n");
d85e1fc8 4178 if (os_snprintf_error(end - pos, ret))
5f97dd1c
DS		 4179 return 0;
4180 pos += ret;
4181 }
4182
4183 if (mask & WPA_BSS_MASK_SSID) {
4184 ret = os_snprintf(pos, end - pos, "ssid=%s\n",
4185 wpa_ssid_txt(bss->ssid, bss->ssid_len));
d85e1fc8 4186 if (os_snprintf_error(end - pos, ret))
5f97dd1c
DS		 4187 return 0;
4188 pos += ret;
4189 }
6fc6879b 4190
611ed491 4191#ifdef CONFIG_WPS
5f97dd1c
DS		 4192 if (mask & WPA_BSS_MASK_WPS_SCAN) {
4193 ie = (const u8 *) (bss + 1);
4194 ret = wpas_wps_scan_result_text(ie, bss->ie_len, pos, end);
4195 if (ret < 0 || ret >= end - pos)
4196 return 0;
4197 pos += ret;
4198 }
611ed491
JM		 4199#endif /* CONFIG_WPS */
4200
0c6b310e 4201#ifdef CONFIG_P2P
5f97dd1c
DS		 4202 if (mask & WPA_BSS_MASK_P2P_SCAN) {
4203 ie = (const u8 *) (bss + 1);
4204 ret = wpas_p2p_scan_result_text(ie, bss->ie_len, pos, end);
4205 if (ret < 0 || ret >= end - pos)
4206 return 0;
4207 pos += ret;
4208 }
0c6b310e
JM		 4209#endif /* CONFIG_P2P */
4210
337c781f
JM		 4211#ifdef CONFIG_WIFI_DISPLAY
4212 if (mask & WPA_BSS_MASK_WIFI_DISPLAY) {
4213 struct wpabuf *wfd;
4214 ie = (const u8 *) (bss + 1);
4215 wfd = ieee802_11_vendor_ie_concat(ie, bss->ie_len,
4216 WFD_IE_VENDOR_TYPE);
4217 if (wfd) {
4218 ret = os_snprintf(pos, end - pos, "wfd_subelems=");
d85e1fc8 4219 if (os_snprintf_error(end - pos, ret)) {
5e6aa04b 4220 wpabuf_free(wfd);
ff486913 4221 return 0;
5e6aa04b 4222 }
337c781f
JM		 4223 pos += ret;
4224
4225 pos += wpa_snprintf_hex(pos, end - pos,
4226 wpabuf_head(wfd),
4227 wpabuf_len(wfd));
4228 wpabuf_free(wfd);
4229
4230 ret = os_snprintf(pos, end - pos, "\n");
d85e1fc8 4231 if (os_snprintf_error(end - pos, ret))
ff486913 4232 return 0;
337c781f
JM		 4233 pos += ret;
4234 }
4235 }
4236#endif /* CONFIG_WIFI_DISPLAY */
4237
afc064fe 4238#ifdef CONFIG_INTERWORKING
476aed35
JM		 4239 if ((mask & WPA_BSS_MASK_INTERNETW) && bss->anqp) {
4240 struct wpa_bss_anqp *anqp = bss->anqp;
5ce6ac11
AN		 4241 pos = anqp_add_hex(pos, end, "anqp_capability_list",
4242 anqp->capability_list);
5f97dd1c 4243 pos = anqp_add_hex(pos, end, "anqp_venue_name",
476aed35 4244 anqp->venue_name);
5f97dd1c 4245 pos = anqp_add_hex(pos, end, "anqp_network_auth_type",
476aed35 4246 anqp->network_auth_type);
5f97dd1c 4247 pos = anqp_add_hex(pos, end, "anqp_roaming_consortium",
476aed35 4248 anqp->roaming_consortium);
5f97dd1c 4249 pos = anqp_add_hex(pos, end, "anqp_ip_addr_type_availability",
476aed35 4250 anqp->ip_addr_type_availability);
5f97dd1c 4251 pos = anqp_add_hex(pos, end, "anqp_nai_realm",
476aed35
JM		 4252 anqp->nai_realm);
4253 pos = anqp_add_hex(pos, end, "anqp_3gpp", anqp->anqp_3gpp);
5f97dd1c 4254 pos = anqp_add_hex(pos, end, "anqp_domain_name",
476aed35 4255 anqp->domain_name);
25471fe3 4256#ifdef CONFIG_HS20
185ada47
AN		 4257 pos = anqp_add_hex(pos, end, "hs20_capability_list",
4258 anqp->hs20_capability_list);
25471fe3 4259 pos = anqp_add_hex(pos, end, "hs20_operator_friendly_name",
476aed35 4260 anqp->hs20_operator_friendly_name);
25471fe3 4261 pos = anqp_add_hex(pos, end, "hs20_wan_metrics",
476aed35 4262 anqp->hs20_wan_metrics);
25471fe3 4263 pos = anqp_add_hex(pos, end, "hs20_connection_capability",
476aed35 4264 anqp->hs20_connection_capability);
1d2215fc
JM		 4265 pos = anqp_add_hex(pos, end, "hs20_operating_class",
4266 anqp->hs20_operating_class);
4267 pos = anqp_add_hex(pos, end, "hs20_osu_providers_list",
4268 anqp->hs20_osu_providers_list);
25471fe3 4269#endif /* CONFIG_HS20 */
5f97dd1c 4270 }
afc064fe
JM		 4271#endif /* CONFIG_INTERWORKING */
4272
79070906
MH		 4273#ifdef CONFIG_MESH
4274 if (mask & WPA_BSS_MASK_MESH_SCAN) {
4275 ie = (const u8 *) (bss + 1);
4276 ret = wpas_mesh_scan_result_text(ie, bss->ie_len, pos, end);
4277 if (ret < 0 || ret >= end - pos)
4278 return 0;
4279 pos += ret;
4280 }
4281#endif /* CONFIG_MESH */
4282
1d747e2a
JM		 4283 if (mask & WPA_BSS_MASK_SNR) {
4284 ret = os_snprintf(pos, end - pos, "snr=%d\n", bss->snr);
4285 if (os_snprintf_error(end - pos, ret))
4286 return 0;
4287 pos += ret;
4288 }
4289
4290 if (mask & WPA_BSS_MASK_EST_THROUGHPUT) {
4291 ret = os_snprintf(pos, end - pos, "est_throughput=%d\n",
4292 bss->est_throughput);
4293 if (os_snprintf_error(end - pos, ret))
4294 return 0;
4295 pos += ret;
4296 }
4297
3794af2d
AN		 4298#ifdef CONFIG_FST
4299 if (mask & WPA_BSS_MASK_FST) {
4300 ret = fst_ctrl_iface_mb_info(bss->bssid, pos, end - pos);
4301 if (ret < 0 || ret >= end - pos)
4302 return 0;
4303 pos += ret;
4304 }
4305#endif /* CONFIG_FST */
4306
c6673429
DS		 4307 if (mask & WPA_BSS_MASK_DELIM) {
4308 ret = os_snprintf(pos, end - pos, "====\n");
d85e1fc8 4309 if (os_snprintf_error(end - pos, ret))
c6673429
DS		 4310 return 0;
4311 pos += ret;
4312 }
4313
6fc6879b
JM		 4314 return pos - buf;
4315}
4316
4317
61ce9085
DS		 4318static int wpa_supplicant_ctrl_iface_bss(struct wpa_supplicant *wpa_s,
4319 const char *cmd, char *buf,
4320 size_t buflen)
4321{
4322 u8 bssid[ETH_ALEN];
4323 size_t i;
4324 struct wpa_bss *bss;
eff1a95b
DS		 4325 struct wpa_bss *bsslast = NULL;
4326 struct dl_list *next;
4327 int ret = 0;
4328 int len;
1d399771 4329 char *ctmp, *end = buf + buflen;
5f97dd1c 4330 unsigned long mask = WPA_BSS_MASK_ALL;
61ce9085 4331
eff1a95b
DS		 4332 if (os_strncmp(cmd, "RANGE=", 6) == 0) {
4333 if (os_strncmp(cmd + 6, "ALL", 3) == 0) {
4334 bss = dl_list_first(&wpa_s->bss_id, struct wpa_bss,
4335 list_id);
4336 bsslast = dl_list_last(&wpa_s->bss_id, struct wpa_bss,
4337 list_id);
4338 } else { /* N1-N2 */
4339 unsigned int id1, id2;
4340
4341 if ((ctmp = os_strchr(cmd + 6, '-')) == NULL) {
4342 wpa_printf(MSG_INFO, "Wrong BSS range "
4343 "format");
4344 return 0;
4345 }
4346
9f42d49c
AS		 4347 if (*(cmd + 6) == '-')
4348 id1 = 0;
4349 else
4350 id1 = atoi(cmd + 6);
4351 ctmp++;
4352 if (*ctmp >= '0' && *ctmp <= '9')
4353 id2 = atoi(ctmp);
4354 else
4355 id2 = (unsigned int) -1;
4356 bss = wpa_bss_get_id_range(wpa_s, id1, id2);
4357 if (id2 == (unsigned int) -1)
eff1a95b
DS		 4358 bsslast = dl_list_last(&wpa_s->bss_id,
4359 struct wpa_bss,
4360 list_id);
4361 else {
4362 bsslast = wpa_bss_get_id(wpa_s, id2);
4363 if (bsslast == NULL && bss && id2 > id1) {
4364 struct wpa_bss *tmp = bss;
4365 for (;;) {
4366 next = tmp->list_id.next;
4367 if (next == &wpa_s->bss_id)
4368 break;
4369 tmp = dl_list_entry(
4370 next, struct wpa_bss,
4371 list_id);
4372 if (tmp->id > id2)
4373 break;
4374 bsslast = tmp;
4375 }
4376 }
4377 }
4378 }
f330b4b4 4379 } else if (os_strncmp(cmd, "FIRST", 5) == 0)
51a0c3d4 4380 bss = dl_list_first(&wpa_s->bss_id, struct wpa_bss, list_id);
cc03d0fe
AS		 4381 else if (os_strncmp(cmd, "LAST", 4) == 0)
4382 bss = dl_list_last(&wpa_s->bss_id, struct wpa_bss, list_id);
61ce9085
DS		 4383 else if (os_strncmp(cmd, "ID-", 3) == 0) {
4384 i = atoi(cmd + 3);
4385 bss = wpa_bss_get_id(wpa_s, i);
4386 } else if (os_strncmp(cmd, "NEXT-", 5) == 0) {
4387 i = atoi(cmd + 5);
4388 bss = wpa_bss_get_id(wpa_s, i);
4389 if (bss) {
eff1a95b 4390 next = bss->list_id.next;
61ce9085
DS		 4391 if (next == &wpa_s->bss_id)
4392 bss = NULL;
4393 else
4394 bss = dl_list_entry(next, struct wpa_bss,
4395 list_id);
4396 }
4397#ifdef CONFIG_P2P
4398 } else if (os_strncmp(cmd, "p2p_dev_addr=", 13) == 0) {
4399 if (hwaddr_aton(cmd + 13, bssid) == 0)
4400 bss = wpa_bss_get_p2p_dev_addr(wpa_s, bssid);
4401 else
4402 bss = NULL;
4403#endif /* CONFIG_P2P */
4404 } else if (hwaddr_aton(cmd, bssid) == 0)
4405 bss = wpa_bss_get_bssid(wpa_s, bssid);
4406 else {
4407 struct wpa_bss *tmp;
4408 i = atoi(cmd);
4409 bss = NULL;
4410 dl_list_for_each(tmp, &wpa_s->bss_id, struct wpa_bss, list_id)
4411 {
4412 if (i-- == 0) {
4413 bss = tmp;
4414 break;
4415 }
4416 }
4417 }
4418
5f97dd1c
DS		 4419 if ((ctmp = os_strstr(cmd, "MASK=")) != NULL) {
4420 mask = strtoul(ctmp + 5, NULL, 0x10);
4421 if (mask == 0)
4422 mask = WPA_BSS_MASK_ALL;
4423 }
4424
61ce9085
DS		 4425 if (bss == NULL)
4426 return 0;
4427
eff1a95b
DS		 4428 if (bsslast == NULL)
4429 bsslast = bss;
4430 do {
4431 len = print_bss_info(wpa_s, bss, mask, buf, buflen);
4432 ret += len;
4433 buf += len;
4434 buflen -= len;
cfd42c94
DS		 4435 if (bss == bsslast) {
4436 if ((mask & WPA_BSS_MASK_DELIM) && len &&
4437 (bss == dl_list_last(&wpa_s->bss_id,
1d399771
JM		 4438 struct wpa_bss, list_id))) {
4439 int res;
4440
4441 res = os_snprintf(buf - 5, end - buf + 5,
4442 "####\n");
4443 if (os_snprintf_error(end - buf + 5, res)) {
4444 wpa_printf(MSG_DEBUG,
4445 "Could not add end delim");
4446 }
4447 }
eff1a95b 4448 break;
cfd42c94 4449 }
eff1a95b
DS		 4450 next = bss->list_id.next;
4451 if (next == &wpa_s->bss_id)
4452 break;
4453 bss = dl_list_entry(next, struct wpa_bss, list_id);
4454 } while (bss && len);
4455
4456 return ret;
61ce9085
DS		 4457}
4458
4459
6fc6879b
JM		 4460static int wpa_supplicant_ctrl_iface_ap_scan(
4461 struct wpa_supplicant *wpa_s, char *cmd)
4462{
4463 int ap_scan = atoi(cmd);
86b89452 4464 return wpa_supplicant_set_ap_scan(wpa_s, ap_scan);
6fc6879b
JM		 4465}
4466
4467
67b9bd08
DS		 4468static int wpa_supplicant_ctrl_iface_scan_interval(
4469 struct wpa_supplicant *wpa_s, char *cmd)
4470{
4471 int scan_int = atoi(cmd);
c6e86b63 4472 return wpa_supplicant_set_scan_interval(wpa_s, scan_int);
67b9bd08
DS		 4473}
4474
4475
78633c37
SL		 4476static int wpa_supplicant_ctrl_iface_bss_expire_age(
4477 struct wpa_supplicant *wpa_s, char *cmd)
4478{
4479 int expire_age = atoi(cmd);
4480 return wpa_supplicant_set_bss_expiration_age(wpa_s, expire_age);
4481}
4482
4483
4484static int wpa_supplicant_ctrl_iface_bss_expire_count(
4485 struct wpa_supplicant *wpa_s, char *cmd)
4486{
4487 int expire_count = atoi(cmd);
4488 return wpa_supplicant_set_bss_expiration_count(wpa_s, expire_count);
4489}
4490
4491
a1144000 4492static void wpa_supplicant_ctrl_iface_bss_flush(
39ee845f
DS		 4493 struct wpa_supplicant *wpa_s, char *cmd)
4494{
4495 int flush_age = atoi(cmd);
4496
4497 if (flush_age == 0)
4498 wpa_bss_flush(wpa_s);
4499 else
4500 wpa_bss_flush_by_age(wpa_s, flush_age);
39ee845f
DS		 4501}
4502
4503
9ff4de6d 4504#ifdef CONFIG_TESTING_OPTIONS
32d5295f
JM		 4505static void wpa_supplicant_ctrl_iface_drop_sa(struct wpa_supplicant *wpa_s)
4506{
32d5295f
JM		 4507 wpa_printf(MSG_DEBUG, "Dropping SA without deauthentication");
4508 /* MLME-DELETEKEYS.request */
0382097e
JM		 4509 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 0, 0, NULL, 0, NULL, 0);
4510 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 1, 0, NULL, 0, NULL, 0);
4511 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 2, 0, NULL, 0, NULL, 0);
4512 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 3, 0, NULL, 0, NULL, 0);
32d5295f 4513#ifdef CONFIG_IEEE80211W
0382097e
JM		 4514 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 4, 0, NULL, 0, NULL, 0);
4515 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 5, 0, NULL, 0, NULL, 0);
32d5295f
JM		 4516#endif /* CONFIG_IEEE80211W */
4517
4518 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, wpa_s->bssid, 0, 0, NULL, 0, NULL,
4519 0);
4520 /* MLME-SETPROTECTION.request(None) */
4521 wpa_drv_mlme_setprotection(wpa_s, wpa_s->bssid,
4522 MLME_SETPROTECTION_PROTECT_TYPE_NONE,
4523 MLME_SETPROTECTION_KEY_TYPE_PAIRWISE);
4524 wpa_sm_drop_sa(wpa_s->wpa);
4525}
9ff4de6d 4526#endif /* CONFIG_TESTING_OPTIONS */
32d5295f
JM		 4527
4528
86d4f806
JM		 4529static int wpa_supplicant_ctrl_iface_roam(struct wpa_supplicant *wpa_s,
4530 char *addr)
4531{
90b8fc8f
JM		 4532#ifdef CONFIG_NO_SCAN_PROCESSING
4533 return -1;
4534#else /* CONFIG_NO_SCAN_PROCESSING */
86d4f806
JM		 4535 u8 bssid[ETH_ALEN];
4536 struct wpa_bss *bss;
4537 struct wpa_ssid *ssid = wpa_s->current_ssid;
4538
4539 if (hwaddr_aton(addr, bssid)) {
4540 wpa_printf(MSG_DEBUG, "CTRL_IFACE ROAM: invalid "
4541 "address '%s'", addr);
4542 return -1;
4543 }
4544
4545 wpa_printf(MSG_DEBUG, "CTRL_IFACE ROAM " MACSTR, MAC2STR(bssid));
4546
2f9b66d3
JM		 4547 if (!ssid) {
4548 wpa_printf(MSG_DEBUG, "CTRL_IFACE ROAM: No network "
4549 "configuration known for the target AP");
4550 return -1;
4551 }
4552
4553 bss = wpa_bss_get(wpa_s, bssid, ssid->ssid, ssid->ssid_len);
86d4f806
JM		 4554 if (!bss) {
4555 wpa_printf(MSG_DEBUG, "CTRL_IFACE ROAM: Target AP not found "
4556 "from BSS table");
4557 return -1;
4558 }
4559
4560 /*
4561 * TODO: Find best network configuration block from configuration to
4562 * allow roaming to other networks
4563 */
4564
86d4f806
JM		 4565 wpa_s->reassociate = 1;
4566 wpa_supplicant_connect(wpa_s, bss, ssid);
4567
4568 return 0;
90b8fc8f 4569#endif /* CONFIG_NO_SCAN_PROCESSING */
86d4f806
JM		 4570}
4571
4572
b563b388
JM		 4573#ifdef CONFIG_P2P
4574static int p2p_ctrl_find(struct wpa_supplicant *wpa_s, char *cmd)
4575{
4576 unsigned int timeout = atoi(cmd);
4577 enum p2p_discovery_type type = P2P_FIND_START_WITH_FULL;
6d92fa6e 4578 u8 dev_id[ETH_ALEN], *_dev_id = NULL;
2b384109 4579 u8 dev_type[WPS_DEV_TYPE_LEN], *_dev_type = NULL;
6d92fa6e 4580 char *pos;
05a77b3b 4581 unsigned int search_delay;
9542f21f 4582 const char *_seek[P2P_MAX_QUERY_HASH + 1], **seek = NULL;
51775096 4583 u8 seek_count = 0;
fa9f381f 4584 int freq = 0;
b563b388 4585
e9eb648e
JM		 4586 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
4587 wpa_dbg(wpa_s, MSG_INFO,
4588 "Reject P2P_FIND since interface is disabled");
4589 return -1;
4590 }
b563b388
JM		 4591 if (os_strstr(cmd, "type=social"))
4592 type = P2P_FIND_ONLY_SOCIAL;
4593 else if (os_strstr(cmd, "type=progressive"))
4594 type = P2P_FIND_PROGRESSIVE;
4595
6d92fa6e
JM		 4596 pos = os_strstr(cmd, "dev_id=");
4597 if (pos) {
4598 pos += 7;
4599 if (hwaddr_aton(pos, dev_id))
4600 return -1;
4601 _dev_id = dev_id;
4602 }
4603
2b384109
JM		 4604 pos = os_strstr(cmd, "dev_type=");
4605 if (pos) {
4606 pos += 9;
4607 if (wps_dev_type_str2bin(pos, dev_type) < 0)
4608 return -1;
4609 _dev_type = dev_type;
4610 }
4611
37448ede
JM		 4612 pos = os_strstr(cmd, "delay=");
4613 if (pos) {
4614 pos += 6;
4615 search_delay = atoi(pos);
05a77b3b
JM		 4616 } else
4617 search_delay = wpas_p2p_search_delay(wpa_s);
37448ede 4618
a9ea609c
SM		 4619 pos = os_strstr(cmd, "freq=");
4620 if (pos) {
4621 pos += 5;
4622 freq = atoi(pos);
4623 if (freq <= 0)
4624 return -1;
4625 }
4626
51775096
BG		 4627 /* Must be searched for last, because it adds nul termination */
4628 pos = os_strstr(cmd, " seek=");
129b6216
JM		 4629 if (pos)
4630 pos += 6;
51775096
BG		 4631 while (pos && seek_count < P2P_MAX_QUERY_HASH + 1) {
4632 char *term;
4633
129b6216 4634 _seek[seek_count++] = pos;
9542f21f 4635 seek = _seek;
129b6216
JM		 4636 term = os_strchr(pos, ' ');
4637 if (!term)
4638 break;
4639 *term = '\0';
4640 pos = os_strstr(term + 1, "seek=");
4641 if (pos)
4642 pos += 5;
51775096 4643 }
9542f21f
JM		 4644 if (seek_count > P2P_MAX_QUERY_HASH) {
4645 seek[0] = NULL;
4646 seek_count = 1;
4647 }
51775096 4648
2b384109 4649 return wpas_p2p_find(wpa_s, timeout, type, _dev_type != NULL, _dev_type,
fa9f381f 4650 _dev_id, search_delay, seek_count, seek, freq);
b563b388
JM		 4651}
4652
4653
f309c18e
KV		 4654static struct p2ps_provision * p2p_parse_asp_provision_cmd(const char *cmd)
4655{
4656 struct p2ps_provision *p2ps_prov;
4657 char *pos;
4658 size_t info_len = 0;
4659 char *info = NULL;
4660 u8 role = P2PS_SETUP_NONE;
4661 long long unsigned val;
4662
4663 pos = os_strstr(cmd, "info=");
4664 if (pos) {
4665 pos += 5;
4666 info_len = os_strlen(pos);
4667
4668 if (info_len) {
4669 info = os_malloc(info_len + 1);
4670 if (info) {
4671 info_len = utf8_unescape(pos, info_len,
4672 info, info_len + 1);
4673 } else
4674 info_len = 0;
4675 }
4676 }
4677
4678 p2ps_prov = os_zalloc(sizeof(struct p2ps_provision) + info_len + 1);
4679 if (p2ps_prov == NULL) {
4680 os_free(info);
4681 return NULL;
4682 }
4683
4684 if (info) {
4685 os_memcpy(p2ps_prov->info, info, info_len);
4686 p2ps_prov->info[info_len] = '\0';
4687 os_free(info);
4688 }
4689
4690 pos = os_strstr(cmd, "status=");
4691 if (pos)
4692 p2ps_prov->status = atoi(pos + 7);
4693 else
4694 p2ps_prov->status = -1;
4695
4696 pos = os_strstr(cmd, "adv_id=");
4697 if (!pos || sscanf(pos + 7, "%llx", &val) != 1 || val > 0xffffffffULL)
4698 goto invalid_args;
4699 p2ps_prov->adv_id = val;
4700
4701 pos = os_strstr(cmd, "method=");
4702 if (pos)
4703 p2ps_prov->method = strtol(pos + 7, NULL, 16);
4704 else
4705 p2ps_prov->method = 0;
4706
4707 pos = os_strstr(cmd, "session=");
4708 if (!pos || sscanf(pos + 8, "%llx", &val) != 1 || val > 0xffffffffULL)
4709 goto invalid_args;
4710 p2ps_prov->session_id = val;
4711
4712 pos = os_strstr(cmd, "adv_mac=");
4713 if (!pos || hwaddr_aton(pos + 8, p2ps_prov->adv_mac))
4714 goto invalid_args;
4715
4716 pos = os_strstr(cmd, "session_mac=");
4717 if (!pos || hwaddr_aton(pos + 12, p2ps_prov->session_mac))
4718 goto invalid_args;
4719
4720 /* force conncap with tstCap (no sanity checks) */
4721 pos = os_strstr(cmd, "tstCap=");
4722 if (pos) {
4723 role = strtol(pos + 7, NULL, 16);
4724 } else {
4725 pos = os_strstr(cmd, "role=");
4726 if (pos) {
4727 role = strtol(pos + 5, NULL, 16);
4728 if (role != P2PS_SETUP_CLIENT &&
4729 role != P2PS_SETUP_GROUP_OWNER)
4730 role = P2PS_SETUP_NONE;
4731 }
4732 }
4733 p2ps_prov->role = role;
4734
4735 return p2ps_prov;
4736
4737invalid_args:
4738 os_free(p2ps_prov);
4739 return NULL;
4740}
4741
4742
4743static int p2p_ctrl_asp_provision_resp(struct wpa_supplicant *wpa_s, char *cmd)
4744{
4745 u8 addr[ETH_ALEN];
4746 struct p2ps_provision *p2ps_prov;
4747 char *pos;
4748
4749 /* <addr> id=<adv_id> [role=<conncap>] [info=<infodata>] */
4750
4751 wpa_printf(MSG_DEBUG, "%s: %s", __func__, cmd);
4752
4753 if (hwaddr_aton(cmd, addr))
4754 return -1;
4755
4756 pos = cmd + 17;
4757 if (*pos != ' ')
4758 return -1;
4759
4760 p2ps_prov = p2p_parse_asp_provision_cmd(pos);
4761 if (!p2ps_prov)
4762 return -1;
4763
4764 if (p2ps_prov->status < 0) {
4765 os_free(p2ps_prov);
4766 return -1;
4767 }
4768
4769 return wpas_p2p_prov_disc(wpa_s, addr, NULL, WPAS_P2P_PD_FOR_ASP,
4770 p2ps_prov);
4771}
4772
4773
4774static int p2p_ctrl_asp_provision(struct wpa_supplicant *wpa_s, char *cmd)
4775{
4776 u8 addr[ETH_ALEN];
4777 struct p2ps_provision *p2ps_prov;
4778 char *pos;
4779
4780 /* <addr> id=<adv_id> adv_mac=<adv_mac> conncap=<conncap>
4781 * session=<ses_id> mac=<ses_mac> [info=<infodata>]
4782 */
4783
4784 wpa_printf(MSG_DEBUG, "%s: %s", __func__, cmd);
4785 if (hwaddr_aton(cmd, addr))
4786 return -1;
4787
4788 pos = cmd + 17;
4789 if (*pos != ' ')
4790 return -1;
4791
4792 p2ps_prov = p2p_parse_asp_provision_cmd(pos);
4793 if (!p2ps_prov)
4794 return -1;
4795
4796 return wpas_p2p_prov_disc(wpa_s, addr, NULL, WPAS_P2P_PD_FOR_ASP,
4797 p2ps_prov);
4798}
4799
4800
b563b388
JM		 4801static int p2p_ctrl_connect(struct wpa_supplicant *wpa_s, char *cmd,
4802 char *buf, size_t buflen)
4803{
4804 u8 addr[ETH_ALEN];
4805 char *pos, *pos2;
4806 char *pin = NULL;
4807 enum p2p_wps_method wps_method;
4808 int new_pin;
4809 int ret;
23c84252 4810 int persistent_group, persistent_id = -1;
b563b388
JM		 4811 int join;
4812 int auth;
b31be3a0 4813 int automatic;
b563b388
JM		 4814 int go_intent = -1;
4815 int freq = 0;
3bc462cb 4816 int pd;
20ea1ca4 4817 int ht40, vht;
b563b388 4818
bdf0518b
JM		 4819 if (!wpa_s->global->p2p_init_wpa_s)
4820 return -1;
4821 if (wpa_s->global->p2p_init_wpa_s != wpa_s) {
4822 wpa_dbg(wpa_s, MSG_DEBUG, "Direct P2P_CONNECT command to %s",
4823 wpa_s->global->p2p_init_wpa_s->ifname);
4824 wpa_s = wpa_s->global->p2p_init_wpa_s;
4825 }
4826
4f88fc04 4827 /* <addr> <"pbc" | "pin" | PIN> [label|display|keypad|p2ps]
23c84252 4828 * [persistent|persistent=<network id>]
e2308e4b 4829 * [join] [auth] [go_intent=<0..15>] [freq=<in MHz>] [provdisc]
5b74e086 4830 * [ht40] [vht] [auto] */
b563b388
JM		 4831
4832 if (hwaddr_aton(cmd, addr))
4833 return -1;
4834
4835 pos = cmd + 17;
4836 if (*pos != ' ')
4837 return -1;
4838 pos++;
4839
4840 persistent_group = os_strstr(pos, " persistent") != NULL;
23c84252
JM		 4841 pos2 = os_strstr(pos, " persistent=");
4842 if (pos2) {
4843 struct wpa_ssid *ssid;
4844 persistent_id = atoi(pos2 + 12);
4845 ssid = wpa_config_get_network(wpa_s->conf, persistent_id);
4846 if (ssid == NULL || ssid->disabled != 2 ||
4847 ssid->mode != WPAS_MODE_P2P_GO) {
4848 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find "
4849 "SSID id=%d for persistent P2P group (GO)",
4850 persistent_id);
4851 return -1;
4852 }
4853 }
b563b388
JM		 4854 join = os_strstr(pos, " join") != NULL;
4855 auth = os_strstr(pos, " auth") != NULL;
b31be3a0 4856 automatic = os_strstr(pos, " auto") != NULL;
3bc462cb 4857 pd = os_strstr(pos, " provdisc") != NULL;
20ea1ca4
EP		 4858 vht = (os_strstr(cmd, " vht") != NULL) || wpa_s->conf->p2p_go_vht;
4859 ht40 = (os_strstr(cmd, " ht40") != NULL) || wpa_s->conf->p2p_go_ht40 ||
4860 vht;
b563b388
JM		 4861
4862 pos2 = os_strstr(pos, " go_intent=");
4863 if (pos2) {
4864 pos2 += 11;
4865 go_intent = atoi(pos2);
4866 if (go_intent < 0 || go_intent > 15)
4867 return -1;
4868 }
4869
4870 pos2 = os_strstr(pos, " freq=");
4871 if (pos2) {
4872 pos2 += 6;
4873 freq = atoi(pos2);
4874 if (freq <= 0)
4875 return -1;
4876 }
4877
4878 if (os_strncmp(pos, "pin", 3) == 0) {
4879 /* Request random PIN (to be displayed) and enable the PIN */
4880 wps_method = WPS_PIN_DISPLAY;
4881 } else if (os_strncmp(pos, "pbc", 3) == 0) {
4882 wps_method = WPS_PBC;
4883 } else {
4884 pin = pos;
4885 pos = os_strchr(pin, ' ');
4886 wps_method = WPS_PIN_KEYPAD;
4887 if (pos) {
4888 *pos++ = '\0';
07fecd39 4889 if (os_strncmp(pos, "display", 7) == 0)
b563b388 4890 wps_method = WPS_PIN_DISPLAY;
4f88fc04
BG		 4891 else if (os_strncmp(pos, "p2ps", 4) == 0)
4892 wps_method = WPS_P2PS;
b563b388 4893 }
dcc33057 4894 if (!wps_pin_str_valid(pin)) {
36ebf7a1
MH		 4895 os_memcpy(buf, "FAIL-INVALID-PIN\n", 17);
4896 return 17;
4897 }
b563b388
JM		 4898 }
4899
4900 new_pin = wpas_p2p_connect(wpa_s, addr, pin, wps_method,
b31be3a0 4901 persistent_group, automatic, join,
e2308e4b 4902 auth, go_intent, freq, persistent_id, pd,
20ea1ca4 4903 ht40, vht);
d054a462
JM		 4904 if (new_pin == -2) {
4905 os_memcpy(buf, "FAIL-CHANNEL-UNAVAILABLE\n", 25);
4906 return 25;
4907 }
4908 if (new_pin == -3) {
4909 os_memcpy(buf, "FAIL-CHANNEL-UNSUPPORTED\n", 25);
4910 return 25;
4911 }
b563b388
JM		 4912 if (new_pin < 0)
4913 return -1;
4914 if (wps_method == WPS_PIN_DISPLAY && pin == NULL) {
4915 ret = os_snprintf(buf, buflen, "%08d", new_pin);
d85e1fc8 4916 if (os_snprintf_error(buflen, ret))
b563b388
JM		 4917 return -1;
4918 return ret;
4919 }
4920
4921 os_memcpy(buf, "OK\n", 3);
4922 return 3;
4923}
4924
4925
4926static int p2p_ctrl_listen(struct wpa_supplicant *wpa_s, char *cmd)
4927{
4928 unsigned int timeout = atoi(cmd);
e9eb648e
JM		 4929 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
4930 wpa_dbg(wpa_s, MSG_INFO,
4931 "Reject P2P_LISTEN since interface is disabled");
4932 return -1;
4933 }
b563b388
JM		 4934 return wpas_p2p_listen(wpa_s, timeout);
4935}
4936
4937
4938static int p2p_ctrl_prov_disc(struct wpa_supplicant *wpa_s, char *cmd)
4939{
4940 u8 addr[ETH_ALEN];
4941 char *pos;
0918c4bf 4942 enum wpas_p2p_prov_disc_use use = WPAS_P2P_PD_FOR_GO_NEG;
b563b388 4943
0918c4bf 4944 /* <addr> <config method> [join|auto] */
b563b388
JM		 4945
4946 if (hwaddr_aton(cmd, addr))
4947 return -1;
4948
4949 pos = cmd + 17;
4950 if (*pos != ' ')
4951 return -1;
4952 pos++;
4953
0918c4bf
JM		 4954 if (os_strstr(pos, " join") != NULL)
4955 use = WPAS_P2P_PD_FOR_JOIN;
4956 else if (os_strstr(pos, " auto") != NULL)
4957 use = WPAS_P2P_PD_AUTO;
4958
6d908514 4959 return wpas_p2p_prov_disc(wpa_s, addr, pos, use, NULL);
b563b388
JM		 4960}
4961
4962
4963static int p2p_get_passphrase(struct wpa_supplicant *wpa_s, char *buf,
4964 size_t buflen)
4965{
4966 struct wpa_ssid *ssid = wpa_s->current_ssid;
4967
4968 if (ssid == NULL || ssid->mode != WPAS_MODE_P2P_GO ||
4969 ssid->passphrase == NULL)
4970 return -1;
4971
4972 os_strlcpy(buf, ssid->passphrase, buflen);
4973 return os_strlen(buf);
4974}
4975
4976
4977static int p2p_ctrl_serv_disc_req(struct wpa_supplicant *wpa_s, char *cmd,
4978 char *buf, size_t buflen)
4979{
4980 u64 ref;
4981 int res;
4982 u8 dst_buf[ETH_ALEN], *dst;
4983 struct wpabuf *tlvs;
4984 char *pos;
4985 size_t len;
4986
4987 if (hwaddr_aton(cmd, dst_buf))
4988 return -1;
4989 dst = dst_buf;
4990 if (dst[0] == 0 && dst[1] == 0 && dst[2] == 0 &&
4991 dst[3] == 0 && dst[4] == 0 && dst[5] == 0)
4992 dst = NULL;
4993 pos = cmd + 17;
4994 if (*pos != ' ')
4995 return -1;
4996 pos++;
4997
4998 if (os_strncmp(pos, "upnp ", 5) == 0) {
4999 u8 version;
5000 pos += 5;
5001 if (hexstr2bin(pos, &version, 1) < 0)
5002 return -1;
5003 pos += 2;
5004 if (*pos != ' ')
5005 return -1;
5006 pos++;
7165c5dc 5007 ref = wpas_p2p_sd_request_upnp(wpa_s, dst, version, pos);
347d6a5b
JM		 5008#ifdef CONFIG_WIFI_DISPLAY
5009 } else if (os_strncmp(pos, "wifi-display ", 13) == 0) {
5010 ref = wpas_p2p_sd_request_wifi_display(wpa_s, dst, pos + 13);
5011#endif /* CONFIG_WIFI_DISPLAY */
5a4102ce
KV		 5012 } else if (os_strncmp(pos, "asp ", 4) == 0) {
5013 char *svc_str;
5014 char *svc_info = NULL;
5015 u32 id;
5016
5017 pos += 4;
5018 if (sscanf(pos, "%x", &id) != 1 || id > 0xff)
5019 return -1;
5020
5021 pos = os_strchr(pos, ' ');
5022 if (pos == NULL || pos[1] == '\0' || pos[1] == ' ')
5023 return -1;
5024
5025 svc_str = pos + 1;
5026
5027 pos = os_strchr(svc_str, ' ');
5028
5029 if (pos)
5030 *pos++ = '\0';
5031
5032 /* All remaining data is the svc_info string */
5033 if (pos && pos[0] && pos[0] != ' ') {
5034 len = os_strlen(pos);
5035
5036 /* Unescape in place */
5037 len = utf8_unescape(pos, len, pos, len);
5038 if (len > 0xff)
5039 return -1;
5040
5041 svc_info = pos;
5042 }
5043
5044 ref = wpas_p2p_sd_request_asp(wpa_s, dst, (u8) id,
5045 svc_str, svc_info);
b563b388
JM		 5046 } else {
5047 len = os_strlen(pos);
5048 if (len & 1)
5049 return -1;
5050 len /= 2;
5051 tlvs = wpabuf_alloc(len);
5052 if (tlvs == NULL)
5053 return -1;
5054 if (hexstr2bin(pos, wpabuf_put(tlvs, len), len) < 0) {
5055 wpabuf_free(tlvs);
5056 return -1;
5057 }
5058
7165c5dc 5059 ref = wpas_p2p_sd_request(wpa_s, dst, tlvs);
b563b388
JM		 5060 wpabuf_free(tlvs);
5061 }
7165c5dc
JM		 5062 if (ref == 0)
5063 return -1;
b563b388 5064 res = os_snprintf(buf, buflen, "%llx", (long long unsigned) ref);
d85e1fc8 5065 if (os_snprintf_error(buflen, res))
b563b388
JM		 5066 return -1;
5067 return res;
5068}
5069
5070
5071static int p2p_ctrl_serv_disc_cancel_req(struct wpa_supplicant *wpa_s,
5072 char *cmd)
5073{
5074 long long unsigned val;
5075 u64 req;
5076 if (sscanf(cmd, "%llx", &val) != 1)
5077 return -1;
5078 req = val;
7165c5dc 5079 return wpas_p2p_sd_cancel_request(wpa_s, req);
b563b388
JM		 5080}
5081
5082
5083static int p2p_ctrl_serv_disc_resp(struct wpa_supplicant *wpa_s, char *cmd)
5084{
5085 int freq;
d25f7212 5086 u8 dst[ETH_ALEN];
b563b388
JM		 5087 u8 dialog_token;
5088 struct wpabuf *resp_tlvs;
5089 char *pos, *pos2;
5090 size_t len;
5091
5092 pos = os_strchr(cmd, ' ');
5093 if (pos == NULL)
5094 return -1;
5095 *pos++ = '\0';
5096 freq = atoi(cmd);
5097 if (freq == 0)
5098 return -1;
5099
d25f7212 5100 if (hwaddr_aton(pos, dst))
b563b388 5101 return -1;
b563b388
JM		 5102 pos += 17;
5103 if (*pos != ' ')
5104 return -1;
5105 pos++;
5106
5107 pos2 = os_strchr(pos, ' ');
5108 if (pos2 == NULL)
5109 return -1;
5110 *pos2++ = '\0';
5111 dialog_token = atoi(pos);
5112
5113 len = os_strlen(pos2);
5114 if (len & 1)
5115 return -1;
5116 len /= 2;
5117 resp_tlvs = wpabuf_alloc(len);
5118 if (resp_tlvs == NULL)
5119 return -1;
5120 if (hexstr2bin(pos2, wpabuf_put(resp_tlvs, len), len) < 0) {
5121 wpabuf_free(resp_tlvs);
5122 return -1;
5123 }
5124
5125 wpas_p2p_sd_response(wpa_s, freq, dst, dialog_token, resp_tlvs);
5126 wpabuf_free(resp_tlvs);
5127 return 0;
5128}
5129
5130
5131static int p2p_ctrl_serv_disc_external(struct wpa_supplicant *wpa_s,
5132 char *cmd)
5133{
28ef705d
GB		 5134 if (os_strcmp(cmd, "0") && os_strcmp(cmd, "1"))
5135 return -1;
b563b388
JM		 5136 wpa_s->p2p_sd_over_ctrl_iface = atoi(cmd);
5137 return 0;
5138}
5139
5140
5141static int p2p_ctrl_service_add_bonjour(struct wpa_supplicant *wpa_s,
5142 char *cmd)
5143{
5144 char *pos;
5145 size_t len;
5146 struct wpabuf *query, *resp;
5147
5148 pos = os_strchr(cmd, ' ');
5149 if (pos == NULL)
5150 return -1;
5151 *pos++ = '\0';
5152
5153 len = os_strlen(cmd);
5154 if (len & 1)
5155 return -1;
5156 len /= 2;
5157 query = wpabuf_alloc(len);
5158 if (query == NULL)
5159 return -1;
5160 if (hexstr2bin(cmd, wpabuf_put(query, len), len) < 0) {
5161 wpabuf_free(query);
5162 return -1;
5163 }
5164
5165 len = os_strlen(pos);
5166 if (len & 1) {
5167 wpabuf_free(query);
5168 return -1;
5169 }
5170 len /= 2;
5171 resp = wpabuf_alloc(len);
5172 if (resp == NULL) {
5173 wpabuf_free(query);
5174 return -1;
5175 }
5176 if (hexstr2bin(pos, wpabuf_put(resp, len), len) < 0) {
5177 wpabuf_free(query);
5178 wpabuf_free(resp);
5179 return -1;
5180 }
5181
5182 if (wpas_p2p_service_add_bonjour(wpa_s, query, resp) < 0) {
5183 wpabuf_free(query);
5184 wpabuf_free(resp);
5185 return -1;
5186 }
5187 return 0;
5188}
5189
5190
5191static int p2p_ctrl_service_add_upnp(struct wpa_supplicant *wpa_s, char *cmd)
5192{
5193 char *pos;
5194 u8 version;
5195
5196 pos = os_strchr(cmd, ' ');
5197 if (pos == NULL)
5198 return -1;
5199 *pos++ = '\0';
5200
5201 if (hexstr2bin(cmd, &version, 1) < 0)
5202 return -1;
5203
5204 return wpas_p2p_service_add_upnp(wpa_s, version, pos);
5205}
5206
5207
ae9d45f3
KV		 5208static int p2p_ctrl_service_add_asp(struct wpa_supplicant *wpa_s,
5209 u8 replace, char *cmd)
5210{
5211 char *pos;
5212 char *adv_str;
5213 u32 auto_accept, adv_id, svc_state, config_methods;
5214 char *svc_info = NULL;
5215
5216 pos = os_strchr(cmd, ' ');
5217 if (pos == NULL)
5218 return -1;
5219 *pos++ = '\0';
5220
5221 /* Auto-Accept value is mandatory, and must be one of the
5222 * single values (0, 1, 2, 4) */
5223 auto_accept = atoi(cmd);
5224 switch (auto_accept) {
5225 case P2PS_SETUP_NONE: /* No auto-accept */
5226 case P2PS_SETUP_NEW:
5227 case P2PS_SETUP_CLIENT:
5228 case P2PS_SETUP_GROUP_OWNER:
5229 break;
5230 default:
5231 return -1;
5232 }
5233
5234 /* Advertisement ID is mandatory */
5235 cmd = pos;
5236 pos = os_strchr(cmd, ' ');
5237 if (pos == NULL)
5238 return -1;
5239 *pos++ = '\0';
5240
5241 /* Handle Adv_ID == 0 (wildcard "org.wi-fi.wfds") internally. */
5242 if (sscanf(cmd, "%x", &adv_id) != 1 || adv_id == 0)
5243 return -1;
5244
5245 /* Only allow replacements if exist, and adds if not */
5246 if (wpas_p2p_service_p2ps_id_exists(wpa_s, adv_id)) {
5247 if (!replace)
5248 return -1;
5249 } else {
5250 if (replace)
5251 return -1;
5252 }
5253
5254 /* svc_state between 0 - 0xff is mandatory */
5255 if (sscanf(pos, "%x", &svc_state) != 1 || svc_state > 0xff)
5256 return -1;
5257
5258 pos = os_strchr(pos, ' ');
5259 if (pos == NULL)
5260 return -1;
5261
5262 /* config_methods is mandatory */
5263 pos++;
5264 if (sscanf(pos, "%x", &config_methods) != 1)
5265 return -1;
5266
5267 if (!(config_methods &
5268 (WPS_CONFIG_DISPLAY | WPS_CONFIG_KEYPAD | WPS_CONFIG_P2PS)))
5269 return -1;
5270
5271 pos = os_strchr(pos, ' ');
5272 if (pos == NULL)
5273 return -1;
5274
5275 pos++;
5276 adv_str = pos;
5277
5278 /* Advertisement string is mandatory */
5279 if (!pos[0] || pos[0] == ' ')
5280 return -1;
5281
5282 /* Terminate svc string */
5283 pos = os_strchr(pos, ' ');
5284 if (pos != NULL)
5285 *pos++ = '\0';
5286
5287 /* Service and Response Information are optional */
5288 if (pos && pos[0]) {
5289 size_t len;
5290
5291 /* Note the bare ' included, which cannot exist legally
5292 * in unescaped string. */
5293 svc_info = os_strstr(pos, "svc_info='");
5294
5295 if (svc_info) {
5296 svc_info += 9;
5297 len = os_strlen(svc_info);
5298 utf8_unescape(svc_info, len, svc_info, len);
5299 }
5300 }
5301
5302 return wpas_p2p_service_add_asp(wpa_s, auto_accept, adv_id, adv_str,
5303 (u8) svc_state, (u16) config_methods,
5304 svc_info);
5305}
5306
5307
b563b388
JM		 5308static int p2p_ctrl_service_add(struct wpa_supplicant *wpa_s, char *cmd)
5309{
5310 char *pos;
5311
5312 pos = os_strchr(cmd, ' ');
5313 if (pos == NULL)
5314 return -1;
5315 *pos++ = '\0';
5316
5317 if (os_strcmp(cmd, "bonjour") == 0)
5318 return p2p_ctrl_service_add_bonjour(wpa_s, pos);
5319 if (os_strcmp(cmd, "upnp") == 0)
5320 return p2p_ctrl_service_add_upnp(wpa_s, pos);
ae9d45f3
KV		 5321 if (os_strcmp(cmd, "asp") == 0)
5322 return p2p_ctrl_service_add_asp(wpa_s, 0, pos);
b563b388
JM		 5323 wpa_printf(MSG_DEBUG, "Unknown service '%s'", cmd);
5324 return -1;
5325}
5326
5327
5328static int p2p_ctrl_service_del_bonjour(struct wpa_supplicant *wpa_s,
5329 char *cmd)
5330{
5331 size_t len;
5332 struct wpabuf *query;
5333 int ret;
5334
5335 len = os_strlen(cmd);
5336 if (len & 1)
5337 return -1;
5338 len /= 2;
5339 query = wpabuf_alloc(len);
5340 if (query == NULL)
5341 return -1;
5342 if (hexstr2bin(cmd, wpabuf_put(query, len), len) < 0) {
5343 wpabuf_free(query);
5344 return -1;
5345 }
5346
5347 ret = wpas_p2p_service_del_bonjour(wpa_s, query);
5348 wpabuf_free(query);
5349 return ret;
5350}
5351
5352
5353static int p2p_ctrl_service_del_upnp(struct wpa_supplicant *wpa_s, char *cmd)
5354{
5355 char *pos;
5356 u8 version;
5357
5358 pos = os_strchr(cmd, ' ');
5359 if (pos == NULL)
5360 return -1;
5361 *pos++ = '\0';
5362
5363 if (hexstr2bin(cmd, &version, 1) < 0)
5364 return -1;
5365
5366 return wpas_p2p_service_del_upnp(wpa_s, version, pos);
5367}
5368
5369
ae9d45f3
KV		 5370static int p2p_ctrl_service_del_asp(struct wpa_supplicant *wpa_s, char *cmd)
5371{
5372 u32 adv_id;
5373
e9d28050
MS		 5374 if (os_strcmp(cmd, "all") == 0) {
5375 wpas_p2p_service_flush_asp(wpa_s);
5376 return 0;
5377 }
5378
ae9d45f3
KV		 5379 if (sscanf(cmd, "%x", &adv_id) != 1)
5380 return -1;
5381
5382 return wpas_p2p_service_del_asp(wpa_s, adv_id);
5383}
5384
5385
b563b388
JM		 5386static int p2p_ctrl_service_del(struct wpa_supplicant *wpa_s, char *cmd)
5387{
5388 char *pos;
5389
5390 pos = os_strchr(cmd, ' ');
5391 if (pos == NULL)
5392 return -1;
5393 *pos++ = '\0';
5394
5395 if (os_strcmp(cmd, "bonjour") == 0)
5396 return p2p_ctrl_service_del_bonjour(wpa_s, pos);
5397 if (os_strcmp(cmd, "upnp") == 0)
5398 return p2p_ctrl_service_del_upnp(wpa_s, pos);
ae9d45f3
KV		 5399 if (os_strcmp(cmd, "asp") == 0)
5400 return p2p_ctrl_service_del_asp(wpa_s, pos);
5401 wpa_printf(MSG_DEBUG, "Unknown service '%s'", cmd);
5402 return -1;
5403}
5404
5405
5406static int p2p_ctrl_service_replace(struct wpa_supplicant *wpa_s, char *cmd)
5407{
5408 char *pos;
5409
5410 pos = os_strchr(cmd, ' ');
5411 if (pos == NULL)
5412 return -1;
5413 *pos++ = '\0';
5414
5415 if (os_strcmp(cmd, "asp") == 0)
5416 return p2p_ctrl_service_add_asp(wpa_s, 1, pos);
5417
b563b388
JM		 5418 wpa_printf(MSG_DEBUG, "Unknown service '%s'", cmd);
5419 return -1;
5420}
5421
5422
5423static int p2p_ctrl_reject(struct wpa_supplicant *wpa_s, char *cmd)
5424{
5425 u8 addr[ETH_ALEN];
5426
5427 /* <addr> */
5428
5429 if (hwaddr_aton(cmd, addr))
5430 return -1;
5431
5432 return wpas_p2p_reject(wpa_s, addr);
5433}
5434
5435
5436static int p2p_ctrl_invite_persistent(struct wpa_supplicant *wpa_s, char *cmd)
5437{
5438 char *pos;
5439 int id;
5440 struct wpa_ssid *ssid;
54c61e6e 5441 u8 *_peer = NULL, peer[ETH_ALEN];
f5877af0 5442 int freq = 0, pref_freq = 0;
20ea1ca4 5443 int ht40, vht;
b563b388
JM		 5444
5445 id = atoi(cmd);
5446 pos = os_strstr(cmd, " peer=");
5447 if (pos) {
5448 pos += 6;
5449 if (hwaddr_aton(pos, peer))
5450 return -1;
54c61e6e 5451 _peer = peer;
b563b388
JM		 5452 }
5453 ssid = wpa_config_get_network(wpa_s->conf, id);
5454 if (ssid == NULL || ssid->disabled != 2) {
5455 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find SSID id=%d "
5456 "for persistent P2P group",
5457 id);
5458 return -1;
5459 }
5460
4d32c0c4
JM		 5461 pos = os_strstr(cmd, " freq=");
5462 if (pos) {
5463 pos += 6;
5464 freq = atoi(pos);
5465 if (freq <= 0)
5466 return -1;
5467 }
5468
f5877af0
JM		 5469 pos = os_strstr(cmd, " pref=");
5470 if (pos) {
5471 pos += 6;
5472 pref_freq = atoi(pos);
5473 if (pref_freq <= 0)
5474 return -1;
5475 }
5476
20ea1ca4
EP		 5477 vht = (os_strstr(cmd, " vht") != NULL) || wpa_s->conf->p2p_go_vht;
5478 ht40 = (os_strstr(cmd, " ht40") != NULL) || wpa_s->conf->p2p_go_ht40 ||
5479 vht;
4d32c0c4 5480
20ea1ca4
EP		 5481 return wpas_p2p_invite(wpa_s, _peer, ssid, NULL, freq, ht40, vht,
5482 pref_freq);
b563b388
JM		 5483}
5484
5485
5486static int p2p_ctrl_invite_group(struct wpa_supplicant *wpa_s, char *cmd)
5487{
5488 char *pos;
5489 u8 peer[ETH_ALEN], go_dev_addr[ETH_ALEN], *go_dev = NULL;
5490
5491 pos = os_strstr(cmd, " peer=");
5492 if (!pos)
5493 return -1;
5494
5495 *pos = '\0';
5496 pos += 6;
5497 if (hwaddr_aton(pos, peer)) {
5498 wpa_printf(MSG_DEBUG, "P2P: Invalid MAC address '%s'", pos);
5499 return -1;
5500 }
5501
5502 pos = os_strstr(pos, " go_dev_addr=");
5503 if (pos) {
5504 pos += 13;
5505 if (hwaddr_aton(pos, go_dev_addr)) {
5506 wpa_printf(MSG_DEBUG, "P2P: Invalid MAC address '%s'",
5507 pos);
5508 return -1;
5509 }
5510 go_dev = go_dev_addr;
5511 }
5512
5513 return wpas_p2p_invite_group(wpa_s, cmd, peer, go_dev);
5514}
5515
5516
5517static int p2p_ctrl_invite(struct wpa_supplicant *wpa_s, char *cmd)
5518{
5519 if (os_strncmp(cmd, "persistent=", 11) == 0)
5520 return p2p_ctrl_invite_persistent(wpa_s, cmd + 11);
5521 if (os_strncmp(cmd, "group=", 6) == 0)
5522 return p2p_ctrl_invite_group(wpa_s, cmd + 6);
5523
5524 return -1;
5525}
5526
5527
5528static int p2p_ctrl_group_add_persistent(struct wpa_supplicant *wpa_s,
29292d53 5529 int id, int freq, int ht40, int vht)
b563b388 5530{
b563b388
JM		 5531 struct wpa_ssid *ssid;
5532
b563b388
JM		 5533 ssid = wpa_config_get_network(wpa_s->conf, id);
5534 if (ssid == NULL || ssid->disabled != 2) {
5535 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find SSID id=%d "
5536 "for persistent P2P group",
5537 id);
5538 return -1;
5539 }
5540
062a7c0d 5541 return wpas_p2p_group_add_persistent(wpa_s, ssid, 0, freq, 0, ht40, vht,
20ea1ca4 5542 NULL, 0);
b563b388
JM		 5543}
5544
5545
5546static int p2p_ctrl_group_add(struct wpa_supplicant *wpa_s, char *cmd)
5547{
29292d53
EP		 5548 int freq = 0, persistent = 0, group_id = -1;
5549 int vht = wpa_s->conf->p2p_go_vht;
5550 int ht40 = wpa_s->conf->p2p_go_ht40 || vht;
5551 char *token, *context = NULL;
e11776a5 5552
29292d53
EP		 5553 while ((token = str_token(cmd, " ", &context))) {
5554 if (sscanf(token, "freq=%d", &freq) == 1 ||
5555 sscanf(token, "persistent=%d", &group_id) == 1) {
5556 continue;
5557 } else if (os_strcmp(token, "ht40") == 0) {
5558 ht40 = 1;
5559 } else if (os_strcmp(token, "vht") == 0) {
5560 vht = 1;
5561 ht40 = 1;
5562 } else if (os_strcmp(token, "persistent") == 0) {
5563 persistent = 1;
5564 } else {
5565 wpa_printf(MSG_DEBUG,
5566 "CTRL: Invalid P2P_GROUP_ADD parameter: '%s'",
5567 token);
5568 return -1;
5569 }
e11776a5
PK		 5570 }
5571
29292d53
EP		 5572 if (group_id >= 0)
5573 return p2p_ctrl_group_add_persistent(wpa_s, group_id,
5574 freq, ht40, vht);
5575
5576 return wpas_p2p_group_add(wpa_s, persistent, freq, ht40, vht);
b563b388
JM		 5577}
5578
5579
5580static int p2p_ctrl_peer(struct wpa_supplicant *wpa_s, char *cmd,
5581 char *buf, size_t buflen)
5582{
5583 u8 addr[ETH_ALEN], *addr_ptr;
b3ffc80b
JM		 5584 int next, res;
5585 const struct p2p_peer_info *info;
5586 char *pos, *end;
5587 char devtype[WPS_DEV_TYPE_BUFSIZE];
87f841a1 5588 struct wpa_ssid *ssid;
f3989ced 5589 size_t i;
b563b388
JM		 5590
5591 if (!wpa_s->global->p2p)
5592 return -1;
5593
5594 if (os_strcmp(cmd, "FIRST") == 0) {
5595 addr_ptr = NULL;
5596 next = 0;
5597 } else if (os_strncmp(cmd, "NEXT-", 5) == 0) {
5598 if (hwaddr_aton(cmd + 5, addr) < 0)
5599 return -1;
5600 addr_ptr = addr;
5601 next = 1;
5602 } else {
5603 if (hwaddr_aton(cmd, addr) < 0)
5604 return -1;
5605 addr_ptr = addr;
5606 next = 0;
5607 }
5608
b3ffc80b
JM		 5609 info = p2p_get_peer_info(wpa_s->global->p2p, addr_ptr, next);
5610 if (info == NULL)
5611 return -1;
5612
5613 pos = buf;
5614 end = buf + buflen;
5615
5616 res = os_snprintf(pos, end - pos, MACSTR "\n"
5617 "pri_dev_type=%s\n"
5618 "device_name=%s\n"
5619 "manufacturer=%s\n"
5620 "model_name=%s\n"
5621 "model_number=%s\n"
5622 "serial_number=%s\n"
5623 "config_methods=0x%x\n"
5624 "dev_capab=0x%x\n"
5625 "group_capab=0x%x\n"
5626 "level=%d\n",
5627 MAC2STR(info->p2p_device_addr),
5628 wps_dev_type_bin2str(info->pri_dev_type,
5629 devtype, sizeof(devtype)),
5630 info->device_name,
5631 info->manufacturer,
5632 info->model_name,
5633 info->model_number,
5634 info->serial_number,
5635 info->config_methods,
5636 info->dev_capab,
5637 info->group_capab,
5638 info->level);
d85e1fc8 5639 if (os_snprintf_error(end - pos, res))
b3ffc80b
JM		 5640 return pos - buf;
5641 pos += res;
5642
f3989ced
JM		 5643 for (i = 0; i < info->wps_sec_dev_type_list_len / WPS_DEV_TYPE_LEN; i++)
5644 {
5645 const u8 *t;
5646 t = &info->wps_sec_dev_type_list[i * WPS_DEV_TYPE_LEN];
5647 res = os_snprintf(pos, end - pos, "sec_dev_type=%s\n",
5648 wps_dev_type_bin2str(t, devtype,
5649 sizeof(devtype)));
d85e1fc8 5650 if (os_snprintf_error(end - pos, res))
f3989ced
JM		 5651 return pos - buf;
5652 pos += res;
5653 }
5654
c427ac92 5655 ssid = wpas_p2p_get_persistent(wpa_s, info->p2p_device_addr, NULL, 0);
87f841a1
JM		 5656 if (ssid) {
5657 res = os_snprintf(pos, end - pos, "persistent=%d\n", ssid->id);
d85e1fc8 5658 if (os_snprintf_error(end - pos, res))
87f841a1
JM		 5659 return pos - buf;
5660 pos += res;
5661 }
5662
b3ffc80b
JM		 5663 res = p2p_get_peer_info_txt(info, pos, end - pos);
5664 if (res < 0)
87f841a1 5665 return pos - buf;
b3ffc80b
JM		 5666 pos += res;
5667
71a0e395
JM		 5668 if (info->vendor_elems) {
5669 res = os_snprintf(pos, end - pos, "vendor_elems=");
d85e1fc8 5670 if (os_snprintf_error(end - pos, res))
71a0e395
JM		 5671 return pos - buf;
5672 pos += res;
5673
5674 pos += wpa_snprintf_hex(pos, end - pos,
5675 wpabuf_head(info->vendor_elems),
5676 wpabuf_len(info->vendor_elems));
5677
5678 res = os_snprintf(pos, end - pos, "\n");
d85e1fc8 5679 if (os_snprintf_error(end - pos, res))
71a0e395
JM		 5680 return pos - buf;
5681 pos += res;
5682 }
5683
b3ffc80b 5684 return pos - buf;
b563b388
JM		 5685}
5686
5687
6f3bc72b
JM		 5688static int p2p_ctrl_disallow_freq(struct wpa_supplicant *wpa_s,
5689 const char *param)
5690{
af8a827b 5691 unsigned int i;
6f3bc72b
JM		 5692
5693 if (wpa_s->global->p2p == NULL)
5694 return -1;
5695
af8a827b
JM		 5696 if (freq_range_list_parse(&wpa_s->global->p2p_disallow_freq, param) < 0)
5697 return -1;
6f3bc72b 5698
af8a827b
JM		 5699 for (i = 0; i < wpa_s->global->p2p_disallow_freq.num; i++) {
5700 struct wpa_freq_range *freq;
5701 freq = &wpa_s->global->p2p_disallow_freq.range[i];
6f3bc72b 5702 wpa_printf(MSG_DEBUG, "P2P: Disallowed frequency range %u-%u",
af8a827b 5703 freq->min, freq->max);
6f3bc72b
JM		 5704 }
5705
6f3bc72b
JM		 5706 wpas_p2p_update_channel_list(wpa_s);
5707 return 0;
5708}
5709
5710
b563b388
JM		 5711static int p2p_ctrl_set(struct wpa_supplicant *wpa_s, char *cmd)
5712{
5713 char *param;
5714
5715 if (wpa_s->global->p2p == NULL)
5716 return -1;
5717
5718 param = os_strchr(cmd, ' ');
5719 if (param == NULL)
5720 return -1;
5721 *param++ = '\0';
5722
5723 if (os_strcmp(cmd, "discoverability") == 0) {
5724 p2p_set_client_discoverability(wpa_s->global->p2p,
5725 atoi(param));
5726 return 0;
5727 }
5728
5729 if (os_strcmp(cmd, "managed") == 0) {
5730 p2p_set_managed_oper(wpa_s->global->p2p, atoi(param));
5731 return 0;
5732 }
5733
5734 if (os_strcmp(cmd, "listen_channel") == 0) {
5735 return p2p_set_listen_channel(wpa_s->global->p2p, 81,
e3bd6e9d 5736 atoi(param), 1);
b563b388
JM		 5737 }
5738
5739 if (os_strcmp(cmd, "ssid_postfix") == 0) {
5740 return p2p_set_ssid_postfix(wpa_s->global->p2p, (u8 *) param,
5741 os_strlen(param));
5742 }
5743
5744 if (os_strcmp(cmd, "noa") == 0) {
5745 char *pos;
5746 int count, start, duration;
5747 /* GO NoA parameters: count,start_offset(ms),duration(ms) */
5748 count = atoi(param);
5749 pos = os_strchr(param, ',');
5750 if (pos == NULL)
5751 return -1;
5752 pos++;
5753 start = atoi(pos);
5754 pos = os_strchr(pos, ',');
5755 if (pos == NULL)
5756 return -1;
5757 pos++;
5758 duration = atoi(pos);
5759 if (count < 0 || count > 255 || start < 0 || duration < 0)
5760 return -1;
5761 if (count == 0 && duration > 0)
5762 return -1;
5763 wpa_printf(MSG_DEBUG, "CTRL_IFACE: P2P_SET GO NoA: count=%d "
5764 "start=%d duration=%d", count, start, duration);
aefb53bd 5765 return wpas_p2p_set_noa(wpa_s, count, start, duration);
b563b388
JM		 5766 }
5767
c381508d
JM		 5768 if (os_strcmp(cmd, "ps") == 0)
5769 return wpa_drv_set_p2p_powersave(wpa_s, atoi(param), -1, -1);
5770
5771 if (os_strcmp(cmd, "oppps") == 0)
5772 return wpa_drv_set_p2p_powersave(wpa_s, -1, atoi(param), -1);
5773
5774 if (os_strcmp(cmd, "ctwindow") == 0)
5775 return wpa_drv_set_p2p_powersave(wpa_s, -1, -1, atoi(param));
5776
b563b388
JM		 5777 if (os_strcmp(cmd, "disabled") == 0) {
5778 wpa_s->global->p2p_disabled = atoi(param);
5779 wpa_printf(MSG_DEBUG, "P2P functionality %s",
5780 wpa_s->global->p2p_disabled ?
5781 "disabled" : "enabled");
5782 if (wpa_s->global->p2p_disabled) {
5783 wpas_p2p_stop_find(wpa_s);
108def93 5784 os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
b563b388
JM		 5785 p2p_flush(wpa_s->global->p2p);
5786 }
5787 return 0;
5788 }
5789
b9cfc09a
JJ		 5790 if (os_strcmp(cmd, "conc_pref") == 0) {
5791 if (os_strcmp(param, "sta") == 0)
5792 wpa_s->global->conc_pref = WPA_CONC_PREF_STA;
5793 else if (os_strcmp(param, "p2p") == 0)
5794 wpa_s->global->conc_pref = WPA_CONC_PREF_P2P;
5795 else {
5796 wpa_printf(MSG_INFO, "Invalid conc_pref value");
5797 return -1;
5798 }
5799 wpa_printf(MSG_DEBUG, "Single channel concurrency preference: "
5800 "%s", param);
5801 return 0;
5802 }
5803
6e6963ea
JM		 5804 if (os_strcmp(cmd, "force_long_sd") == 0) {
5805 wpa_s->force_long_sd = atoi(param);
5806 return 0;
5807 }
5808
80c9582a
JM		 5809 if (os_strcmp(cmd, "peer_filter") == 0) {
5810 u8 addr[ETH_ALEN];
5811 if (hwaddr_aton(param, addr))
5812 return -1;
5813 p2p_set_peer_filter(wpa_s->global->p2p, addr);
5814 return 0;
5815 }
5816
72044390
JM		 5817 if (os_strcmp(cmd, "cross_connect") == 0)
5818 return wpas_p2p_set_cross_connect(wpa_s, atoi(param));
5819
eea2fd9e
JM		 5820 if (os_strcmp(cmd, "go_apsd") == 0) {
5821 if (os_strcmp(param, "disable") == 0)
5822 wpa_s->set_ap_uapsd = 0;
5823 else {
5824 wpa_s->set_ap_uapsd = 1;
5825 wpa_s->ap_uapsd = atoi(param);
5826 }
5827 return 0;
5828 }
5829
5830 if (os_strcmp(cmd, "client_apsd") == 0) {
5831 if (os_strcmp(param, "disable") == 0)
5832 wpa_s->set_sta_uapsd = 0;
5833 else {
5834 int be, bk, vi, vo;
5835 char *pos;
5836 /* format: BE,BK,VI,VO;max SP Length */
5837 be = atoi(param);
5838 pos = os_strchr(param, ',');
5839 if (pos == NULL)
5840 return -1;
5841 pos++;
5842 bk = atoi(pos);
5843 pos = os_strchr(pos, ',');
5844 if (pos == NULL)
5845 return -1;
5846 pos++;
5847 vi = atoi(pos);
5848 pos = os_strchr(pos, ',');
5849 if (pos == NULL)
5850 return -1;
5851 pos++;
5852 vo = atoi(pos);
5853 /* ignore max SP Length for now */
5854
5855 wpa_s->set_sta_uapsd = 1;
5856 wpa_s->sta_uapsd = 0;
5857 if (be)
5858 wpa_s->sta_uapsd |= BIT(0);
5859 if (bk)
5860 wpa_s->sta_uapsd |= BIT(1);
5861 if (vi)
5862 wpa_s->sta_uapsd |= BIT(2);
5863 if (vo)
5864 wpa_s->sta_uapsd |= BIT(3);
5865 }
5866 return 0;
5867 }
5868
6f3bc72b
JM		 5869 if (os_strcmp(cmd, "disallow_freq") == 0)
5870 return p2p_ctrl_disallow_freq(wpa_s, param);
5871
96beff11
JM		 5872 if (os_strcmp(cmd, "disc_int") == 0) {
5873 int min_disc_int, max_disc_int, max_disc_tu;
5874 char *pos;
5875
5876 pos = param;
5877
5878 min_disc_int = atoi(pos);
5879 pos = os_strchr(pos, ' ');
5880 if (pos == NULL)
5881 return -1;
5882 *pos++ = '\0';
5883
5884 max_disc_int = atoi(pos);
5885 pos = os_strchr(pos, ' ');
5886 if (pos == NULL)
5887 return -1;
5888 *pos++ = '\0';
5889
5890 max_disc_tu = atoi(pos);
5891
5892 return p2p_set_disc_int(wpa_s->global->p2p, min_disc_int,
5893 max_disc_int, max_disc_tu);
5894 }
5895
05766ed8
JM		 5896 if (os_strcmp(cmd, "per_sta_psk") == 0) {
5897 wpa_s->global->p2p_per_sta_psk = !!atoi(param);
5898 return 0;
5899 }
5900
c4f87a70
JM		 5901#ifdef CONFIG_WPS_NFC
5902 if (os_strcmp(cmd, "nfc_tag") == 0)
5903 return wpas_p2p_nfc_tag_enabled(wpa_s, !!atoi(param));
5904#endif /* CONFIG_WPS_NFC */
5905
201b0f5f
JM		 5906 if (os_strcmp(cmd, "disable_ip_addr_req") == 0) {
5907 wpa_s->p2p_disable_ip_addr_req = !!atoi(param);
5908 return 0;
5909 }
5910
b563b388
JM		 5911 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Unknown P2P_SET field value '%s'",
5912 cmd);
5913
5914 return -1;
5915}
5916
5917
acb54643
JM		 5918static void p2p_ctrl_flush(struct wpa_supplicant *wpa_s)
5919{
5920 os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
5921 wpa_s->force_long_sd = 0;
477b082c 5922 wpas_p2p_stop_find(wpa_s);
acb54643
JM		 5923 if (wpa_s->global->p2p)
5924 p2p_flush(wpa_s->global->p2p);
5925}
5926
5927
b563b388
JM		 5928static int p2p_ctrl_presence_req(struct wpa_supplicant *wpa_s, char *cmd)
5929{
5930 char *pos, *pos2;
5931 unsigned int dur1 = 0, int1 = 0, dur2 = 0, int2 = 0;
5932
5933 if (cmd[0]) {
5934 pos = os_strchr(cmd, ' ');
5935 if (pos == NULL)
5936 return -1;
5937 *pos++ = '\0';
5938 dur1 = atoi(cmd);
5939
5940 pos2 = os_strchr(pos, ' ');
5941 if (pos2)
5942 *pos2++ = '\0';
5943 int1 = atoi(pos);
5944 } else
5945 pos2 = NULL;
5946
5947 if (pos2) {
5948 pos = os_strchr(pos2, ' ');
5949 if (pos == NULL)
5950 return -1;
5951 *pos++ = '\0';
5952 dur2 = atoi(pos2);
5953 int2 = atoi(pos);
5954 }
5955
5956 return wpas_p2p_presence_req(wpa_s, dur1, int1, dur2, int2);
5957}
5958
5959
5960static int p2p_ctrl_ext_listen(struct wpa_supplicant *wpa_s, char *cmd)
5961{
5962 char *pos;
5963 unsigned int period = 0, interval = 0;
5964
5965 if (cmd[0]) {
5966 pos = os_strchr(cmd, ' ');
5967 if (pos == NULL)
5968 return -1;
5969 *pos++ = '\0';
5970 period = atoi(cmd);
5971 interval = atoi(pos);
5972 }
5973
5974 return wpas_p2p_ext_listen(wpa_s, period, interval);
5975}
5976
f2c56602
JM		 5977
5978static int p2p_ctrl_remove_client(struct wpa_supplicant *wpa_s, const char *cmd)
5979{
5980 const char *pos;
5981 u8 peer[ETH_ALEN];
5982 int iface_addr = 0;
5983
5984 pos = cmd;
5985 if (os_strncmp(pos, "iface=", 6) == 0) {
5986 iface_addr = 1;
5987 pos += 6;
5988 }
5989 if (hwaddr_aton(pos, peer))
5990 return -1;
5991
5992 wpas_p2p_remove_client(wpa_s, peer, iface_addr);
5993 return 0;
5994}
5995
b563b388
JM		 5996#endif /* CONFIG_P2P */
5997
5998
356d1488
JM		 5999static int * freq_range_to_channel_list(struct wpa_supplicant *wpa_s, char *val)
6000{
6001 struct wpa_freq_range_list ranges;
6002 int *freqs = NULL;
6003 struct hostapd_hw_modes *mode;
6004 u16 i;
6005
6006 if (wpa_s->hw.modes == NULL)
6007 return NULL;
6008
6009 os_memset(&ranges, 0, sizeof(ranges));
6010 if (freq_range_list_parse(&ranges, val) < 0)
6011 return NULL;
6012
6013 for (i = 0; i < wpa_s->hw.num_modes; i++) {
6014 int j;
6015
6016 mode = &wpa_s->hw.modes[i];
6017 for (j = 0; j < mode->num_channels; j++) {
6018 unsigned int freq;
6019
6020 if (mode->channels[j].flag & HOSTAPD_CHAN_DISABLED)
6021 continue;
6022
6023 freq = mode->channels[j].freq;
6024 if (!freq_range_list_includes(&ranges, freq))
6025 continue;
6026
6027 int_array_add_unique(&freqs, freq);
6028 }
6029 }
6030
6031 os_free(ranges.range);
6032 return freqs;
6033}
6034
6035
afc064fe 6036#ifdef CONFIG_INTERWORKING
356d1488
JM		 6037
6038static int ctrl_interworking_select(struct wpa_supplicant *wpa_s, char *param)
6039{
6040 int auto_sel = 0;
6041 int *freqs = NULL;
6042
6043 if (param) {
6044 char *pos;
6045
6046 auto_sel = os_strstr(param, "auto") != NULL;
6047
6048 pos = os_strstr(param, "freq=");
6049 if (pos) {
6050 freqs = freq_range_to_channel_list(wpa_s, pos + 5);
6051 if (freqs == NULL)
6052 return -1;
6053 }
6054
6055 }
6056
6057 return interworking_select(wpa_s, auto_sel, freqs);
6058}
6059
6060
f91a512f
JM		 6061static int ctrl_interworking_connect(struct wpa_supplicant *wpa_s, char *dst,
6062 int only_add)
b02fe7ff
JM		 6063{
6064 u8 bssid[ETH_ALEN];
6065 struct wpa_bss *bss;
6066
6067 if (hwaddr_aton(dst, bssid)) {
6068 wpa_printf(MSG_DEBUG, "Invalid BSSID '%s'", dst);
6069 return -1;
6070 }
6071
6072 bss = wpa_bss_get_bssid(wpa_s, bssid);
6073 if (bss == NULL) {
6074 wpa_printf(MSG_DEBUG, "Could not find BSS " MACSTR,
6075 MAC2STR(bssid));
6076 return -1;
6077 }
6078
783b2a97
JM		 6079 if (bss->ssid_len == 0) {
6080 int found = 0;
6081
6082 wpa_printf(MSG_DEBUG, "Selected BSS entry for " MACSTR
6083 " does not have SSID information", MAC2STR(bssid));
6084
6085 dl_list_for_each_reverse(bss, &wpa_s->bss, struct wpa_bss,
6086 list) {
6087 if (os_memcmp(bss->bssid, bssid, ETH_ALEN) == 0 &&
6088 bss->ssid_len > 0) {
6089 found = 1;
6090 break;
6091 }
6092 }
6093
6094 if (!found)
6095 return -1;
6096 wpa_printf(MSG_DEBUG,
6097 "Found another matching BSS entry with SSID");
6098 }
6099
f91a512f 6100 return interworking_connect(wpa_s, bss, only_add);
b02fe7ff
JM		 6101}
6102
6103
afc064fe
JM		 6104static int get_anqp(struct wpa_supplicant *wpa_s, char *dst)
6105{
6106 u8 dst_addr[ETH_ALEN];
6107 int used;
6108 char *pos;
6109#define MAX_ANQP_INFO_ID 100
6110 u16 id[MAX_ANQP_INFO_ID];
6111 size_t num_id = 0;
cf28c66b 6112 u32 subtypes = 0;
afc064fe
JM		 6113
6114 used = hwaddr_aton2(dst, dst_addr);
6115 if (used < 0)
6116 return -1;
6117 pos = dst + used;
b68d602d
JM		 6118 if (*pos == ' ')
6119 pos++;
afc064fe 6120 while (num_id < MAX_ANQP_INFO_ID) {
cf28c66b
DS		 6121 if (os_strncmp(pos, "hs20:", 5) == 0) {
6122#ifdef CONFIG_HS20
6123 int num = atoi(pos + 5);
6124 if (num <= 0 || num > 31)
6125 return -1;
6126 subtypes |= BIT(num);
6127#else /* CONFIG_HS20 */
6128 return -1;
6129#endif /* CONFIG_HS20 */
6130 } else {
6131 id[num_id] = atoi(pos);
6132 if (id[num_id])
6133 num_id++;
6134 }
afc064fe
JM		 6135 pos = os_strchr(pos + 1, ',');
6136 if (pos == NULL)
6137 break;
6138 pos++;
6139 }
6140
6141 if (num_id == 0)
6142 return -1;
6143
cf28c66b 6144 return anqp_send_req(wpa_s, dst_addr, id, num_id, subtypes);
afc064fe 6145}
b1f12296
JM		 6146
6147
6148static int gas_request(struct wpa_supplicant *wpa_s, char *cmd)
6149{
6150 u8 dst_addr[ETH_ALEN];
6151 struct wpabuf *advproto, *query = NULL;
6152 int used, ret = -1;
6153 char *pos, *end;
6154 size_t len;
6155
6156 used = hwaddr_aton2(cmd, dst_addr);
6157 if (used < 0)
6158 return -1;
6159
6160 pos = cmd + used;
6161 while (*pos == ' ')
6162 pos++;
6163
6164 /* Advertisement Protocol ID */
6165 end = os_strchr(pos, ' ');
6166 if (end)
6167 len = end - pos;
6168 else
6169 len = os_strlen(pos);
6170 if (len & 0x01)
6171 return -1;
6172 len /= 2;
6173 if (len == 0)
6174 return -1;
6175 advproto = wpabuf_alloc(len);
6176 if (advproto == NULL)
6177 return -1;
6178 if (hexstr2bin(pos, wpabuf_put(advproto, len), len) < 0)
6179 goto fail;
6180
6181 if (end) {
6182 /* Optional Query Request */
6183 pos = end + 1;
6184 while (*pos == ' ')
6185 pos++;
6186
6187 len = os_strlen(pos);
6188 if (len) {
6189 if (len & 0x01)
6190 goto fail;
6191 len /= 2;
6192 if (len == 0)
6193 goto fail;
6194 query = wpabuf_alloc(len);
6195 if (query == NULL)
6196 goto fail;
6197 if (hexstr2bin(pos, wpabuf_put(query, len), len) < 0)
6198 goto fail;
6199 }
6200 }
6201
6202 ret = gas_send_request(wpa_s, dst_addr, advproto, query);
6203
6204fail:
6205 wpabuf_free(advproto);
6206 wpabuf_free(query);
6207
6208 return ret;
6209}
6210
6211
6212static int gas_response_get(struct wpa_supplicant *wpa_s, char *cmd, char *buf,
6213 size_t buflen)
6214{
6215 u8 addr[ETH_ALEN];
6216 int dialog_token;
6217 int used;
6218 char *pos;
6219 size_t resp_len, start, requested_len;
b6a9590b
JM		 6220 struct wpabuf *resp;
6221 int ret;
b1f12296
JM		 6222
6223 used = hwaddr_aton2(cmd, addr);
6224 if (used < 0)
6225 return -1;
6226
6227 pos = cmd + used;
6228 while (*pos == ' ')
6229 pos++;
6230 dialog_token = atoi(pos);
6231
b6a9590b
JM		 6232 if (wpa_s->last_gas_resp &&
6233 os_memcmp(addr, wpa_s->last_gas_addr, ETH_ALEN) == 0 &&
6234 dialog_token == wpa_s->last_gas_dialog_token)
6235 resp = wpa_s->last_gas_resp;
6236 else if (wpa_s->prev_gas_resp &&
6237 os_memcmp(addr, wpa_s->prev_gas_addr, ETH_ALEN) == 0 &&
6238 dialog_token == wpa_s->prev_gas_dialog_token)
6239 resp = wpa_s->prev_gas_resp;
6240 else
b1f12296
JM		 6241 return -1;
6242
b6a9590b 6243 resp_len = wpabuf_len(resp);
b1f12296
JM		 6244 start = 0;
6245 requested_len = resp_len;
6246
6247 pos = os_strchr(pos, ' ');
6248 if (pos) {
6249 start = atoi(pos);
6250 if (start > resp_len)
6251 return os_snprintf(buf, buflen, "FAIL-Invalid range");
6252 pos = os_strchr(pos, ',');
6253 if (pos == NULL)
6254 return -1;
6255 pos++;
6256 requested_len = atoi(pos);
6257 if (start + requested_len > resp_len)
6258 return os_snprintf(buf, buflen, "FAIL-Invalid range");
6259 }
6260
6261 if (requested_len * 2 + 1 > buflen)
6262 return os_snprintf(buf, buflen, "FAIL-Too long response");
6263
b6a9590b
JM		 6264 ret = wpa_snprintf_hex(buf, buflen, wpabuf_head_u8(resp) + start,
6265 requested_len);
6266
6267 if (start + requested_len == resp_len) {
6268 /*
6269 * Free memory by dropping the response after it has been
6270 * fetched.
6271 */
6272 if (resp == wpa_s->prev_gas_resp) {
6273 wpabuf_free(wpa_s->prev_gas_resp);
6274 wpa_s->prev_gas_resp = NULL;
6275 } else {
6276 wpabuf_free(wpa_s->last_gas_resp);
6277 wpa_s->last_gas_resp = NULL;
6278 }
6279 }
6280
6281 return ret;
b1f12296 6282}
afc064fe
JM		 6283#endif /* CONFIG_INTERWORKING */
6284
6285
a8918e86
JK		 6286#ifdef CONFIG_HS20
6287
6288static int get_hs20_anqp(struct wpa_supplicant *wpa_s, char *dst)
6289{
6290 u8 dst_addr[ETH_ALEN];
6291 int used;
6292 char *pos;
6293 u32 subtypes = 0;
6294
6295 used = hwaddr_aton2(dst, dst_addr);
6296 if (used < 0)
6297 return -1;
6298 pos = dst + used;
b68d602d
JM		 6299 if (*pos == ' ')
6300 pos++;
a8918e86
JK		 6301 for (;;) {
6302 int num = atoi(pos);
6303 if (num <= 0 || num > 31)
6304 return -1;
6305 subtypes |= BIT(num);
6306 pos = os_strchr(pos + 1, ',');
6307 if (pos == NULL)
6308 break;
6309 pos++;
6310 }
6311
6312 if (subtypes == 0)
6313 return -1;
6314
6315 return hs20_anqp_send_req(wpa_s, dst_addr, subtypes, NULL, 0);
6316}
6317
6318
6319static int hs20_nai_home_realm_list(struct wpa_supplicant *wpa_s,
6320 const u8 *addr, const char *realm)
6321{
6322 u8 *buf;
6323 size_t rlen, len;
6324 int ret;
6325
6326 rlen = os_strlen(realm);
6327 len = 3 + rlen;
6328 buf = os_malloc(len);
6329 if (buf == NULL)
6330 return -1;
6331 buf[0] = 1; /* NAI Home Realm Count */
6332 buf[1] = 0; /* Formatted in accordance with RFC 4282 */
6333 buf[2] = rlen;
6334 os_memcpy(buf + 3, realm, rlen);
6335
6336 ret = hs20_anqp_send_req(wpa_s, addr,
6337 BIT(HS20_STYPE_NAI_HOME_REALM_QUERY),
6338 buf, len);
6339
6340 os_free(buf);
6341
6342 return ret;
6343}
6344
6345
6346static int hs20_get_nai_home_realm_list(struct wpa_supplicant *wpa_s,
6347 char *dst)
6348{
6349 struct wpa_cred *cred = wpa_s->conf->cred;
6350 u8 dst_addr[ETH_ALEN];
6351 int used;
6352 u8 *buf;
6353 size_t len;
6354 int ret;
6355
6356 used = hwaddr_aton2(dst, dst_addr);
6357 if (used < 0)
6358 return -1;
6359
6360 while (dst[used] == ' ')
6361 used++;
6362 if (os_strncmp(dst + used, "realm=", 6) == 0)
6363 return hs20_nai_home_realm_list(wpa_s, dst_addr,
6364 dst + used + 6);
6365
6366 len = os_strlen(dst + used);
6367
6368 if (len == 0 && cred && cred->realm)
6369 return hs20_nai_home_realm_list(wpa_s, dst_addr, cred->realm);
6370
0e87e798 6371 if (len & 1)
a8918e86
JK		 6372 return -1;
6373 len /= 2;
6374 buf = os_malloc(len);
6375 if (buf == NULL)
6376 return -1;
6377 if (hexstr2bin(dst + used, buf, len) < 0) {
6378 os_free(buf);
6379 return -1;
6380 }
6381
6382 ret = hs20_anqp_send_req(wpa_s, dst_addr,
6383 BIT(HS20_STYPE_NAI_HOME_REALM_QUERY),
6384 buf, len);
6385 os_free(buf);
6386
6387 return ret;
6388}
6389
184e110c
JM		 6390
6391static int hs20_icon_request(struct wpa_supplicant *wpa_s, char *cmd)
6392{
6393 u8 dst_addr[ETH_ALEN];
6394 int used;
6395 char *icon;
6396
6397 used = hwaddr_aton2(cmd, dst_addr);
6398 if (used < 0)
6399 return -1;
6400
6401 while (cmd[used] == ' ')
6402 used++;
6403 icon = &cmd[used];
6404
b572df86 6405 wpa_s->fetch_osu_icon_in_progress = 0;
184e110c
JM		 6406 return hs20_anqp_send_req(wpa_s, dst_addr, BIT(HS20_STYPE_ICON_REQUEST),
6407 (u8 *) icon, os_strlen(icon));
6408}
6409
a8918e86
JK		 6410#endif /* CONFIG_HS20 */
6411
6412
bc5d330a
TB		 6413#ifdef CONFIG_AUTOSCAN
6414
6415static int wpa_supplicant_ctrl_iface_autoscan(struct wpa_supplicant *wpa_s,
6416 char *cmd)
6417{
6418 enum wpa_states state = wpa_s->wpa_state;
6419 char *new_params = NULL;
6420
6421 if (os_strlen(cmd) > 0) {
6422 new_params = os_strdup(cmd);
6423 if (new_params == NULL)
6424 return -1;
6425 }
6426
6427 os_free(wpa_s->conf->autoscan);
6428 wpa_s->conf->autoscan = new_params;
6429
6430 if (wpa_s->conf->autoscan == NULL)
6431 autoscan_deinit(wpa_s);
6432 else if (state == WPA_DISCONNECTED || state == WPA_INACTIVE)
99218999 6433 autoscan_init(wpa_s, 1);
99f00324
JM		 6434 else if (state == WPA_SCANNING)
6435 wpa_supplicant_reinit_autoscan(wpa_s);
bc5d330a
TB		 6436
6437 return 0;
6438}
6439
6440#endif /* CONFIG_AUTOSCAN */
6441
6442
e9199e31
JM		 6443#ifdef CONFIG_WNM
6444
6445static int wpas_ctrl_iface_wnm_sleep(struct wpa_supplicant *wpa_s, char *cmd)
6446{
6447 int enter;
6448 int intval = 0;
6449 char *pos;
cd0ef657
JM		 6450 int ret;
6451 struct wpabuf *tfs_req = NULL;
e9199e31
JM		 6452
6453 if (os_strncmp(cmd, "enter", 5) == 0)
6454 enter = 1;
6455 else if (os_strncmp(cmd, "exit", 4) == 0)
6456 enter = 0;
6457 else
6458 return -1;
6459
6460 pos = os_strstr(cmd, " interval=");
6461 if (pos)
6462 intval = atoi(pos + 10);
6463
cd0ef657
JM		 6464 pos = os_strstr(cmd, " tfs_req=");
6465 if (pos) {
6466 char *end;
6467 size_t len;
6468 pos += 9;
6469 end = os_strchr(pos, ' ');
6470 if (end)
6471 len = end - pos;
6472 else
6473 len = os_strlen(pos);
6474 if (len & 1)
6475 return -1;
6476 len /= 2;
6477 tfs_req = wpabuf_alloc(len);
6478 if (tfs_req == NULL)
6479 return -1;
6480 if (hexstr2bin(pos, wpabuf_put(tfs_req, len), len) < 0) {
6481 wpabuf_free(tfs_req);
6482 return -1;
6483 }
6484 }
6485
df80a0cc
JM		 6486 ret = ieee802_11_send_wnmsleep_req(wpa_s, enter ? WNM_SLEEP_MODE_ENTER :
6487 WNM_SLEEP_MODE_EXIT, intval,
cd0ef657
JM		 6488 tfs_req);
6489 wpabuf_free(tfs_req);
6490
6491 return ret;
e9199e31
JM		 6492}
6493
65bcd0a9
VK		 6494
6495static int wpas_ctrl_iface_wnm_bss_query(struct wpa_supplicant *wpa_s, char *cmd)
6496{
6497 int query_reason;
6498
6499 query_reason = atoi(cmd);
6500
6501 wpa_printf(MSG_DEBUG, "CTRL_IFACE: WNM_BSS_QUERY query_reason=%d",
6502 query_reason);
6503
6504 return wnm_send_bss_transition_mgmt_query(wpa_s, query_reason);
6505}
6506
e9199e31
JM		 6507#endif /* CONFIG_WNM */
6508
6509
60b24b0d
DS		 6510static int wpa_supplicant_signal_poll(struct wpa_supplicant *wpa_s, char *buf,
6511 size_t buflen)
6512{
6513 struct wpa_signal_info si;
6514 int ret;
2cc8d8f4 6515 char *pos, *end;
60b24b0d
DS		 6516
6517 ret = wpa_drv_signal_poll(wpa_s, &si);
6518 if (ret)
6519 return -1;
6520
2cc8d8f4
AO		 6521 pos = buf;
6522 end = buf + buflen;
6523
6524 ret = os_snprintf(pos, end - pos, "RSSI=%d\nLINKSPEED=%d\n"
60b24b0d
DS		 6525 "NOISE=%d\nFREQUENCY=%u\n",
6526 si.current_signal, si.current_txrate / 1000,
6527 si.current_noise, si.frequency);
7bdd8981 6528 if (os_snprintf_error(end - pos, ret))
60b24b0d 6529 return -1;
2cc8d8f4
AO		 6530 pos += ret;
6531
6532 if (si.chanwidth != CHAN_WIDTH_UNKNOWN) {
6533 ret = os_snprintf(pos, end - pos, "WIDTH=%s\n",
7a4a93b9 6534 channel_width_to_string(si.chanwidth));
7bdd8981 6535 if (os_snprintf_error(end - pos, ret))
2cc8d8f4
AO		 6536 return -1;
6537 pos += ret;
6538 }
6539
6540 if (si.center_frq1 > 0 && si.center_frq2 > 0) {
6541 ret = os_snprintf(pos, end - pos,
6542 "CENTER_FRQ1=%d\nCENTER_FRQ2=%d\n",
6543 si.center_frq1, si.center_frq2);
7bdd8981 6544 if (os_snprintf_error(end - pos, ret))
2cc8d8f4
AO		 6545 return -1;
6546 pos += ret;
6547 }
6548
95783298
AO		 6549 if (si.avg_signal) {
6550 ret = os_snprintf(pos, end - pos,
6551 "AVG_RSSI=%d\n", si.avg_signal);
d85e1fc8 6552 if (os_snprintf_error(end - pos, ret))
95783298
AO		 6553 return -1;
6554 pos += ret;
6555 }
6556
74fa78b2
JM		 6557 if (si.avg_beacon_signal) {
6558 ret = os_snprintf(pos, end - pos,
6559 "AVG_BEACON_RSSI=%d\n", si.avg_beacon_signal);
6560 if (os_snprintf_error(end - pos, ret))
6561 return -1;
6562 pos += ret;
6563 }
6564
2cc8d8f4 6565 return pos - buf;
60b24b0d
DS		 6566}
6567
6568
dc7785f8
YZ		 6569static int wpa_supplicant_pktcnt_poll(struct wpa_supplicant *wpa_s, char *buf,
6570 size_t buflen)
6571{
6572 struct hostap_sta_driver_data sta;
6573 int ret;
6574
6575 ret = wpa_drv_pktcnt_poll(wpa_s, &sta);
6576 if (ret)
6577 return -1;
6578
6579 ret = os_snprintf(buf, buflen, "TXGOOD=%lu\nTXBAD=%lu\nRXGOOD=%lu\n",
6580 sta.tx_packets, sta.tx_retry_failed, sta.rx_packets);
7bdd8981 6581 if (os_snprintf_error(buflen, ret))
dc7785f8
YZ		 6582 return -1;
6583 return ret;
6584}
6585
6586
5e2c3490
JM		 6587#ifdef ANDROID
6588static int wpa_supplicant_driver_cmd(struct wpa_supplicant *wpa_s, char *cmd,
6589 char *buf, size_t buflen)
6590{
6591 int ret;
6592
6593 ret = wpa_drv_driver_cmd(wpa_s, cmd, buf, buflen);
a94737ea
DS		 6594 if (ret == 0) {
6595 if (os_strncasecmp(cmd, "COUNTRY", 7) == 0) {
6596 struct p2p_data *p2p = wpa_s->global->p2p;
6597 if (p2p) {
6598 char country[3];
6599 country[0] = cmd[8];
6600 country[1] = cmd[9];
6601 country[2] = 0x04;
6602 p2p_set_country(p2p, country);
6603 }
6604 }
5e2c3490 6605 ret = os_snprintf(buf, buflen, "%s\n", "OK");
aaadd727
JM		 6606 if (os_snprintf_error(buflen, ret))
6607 ret = -1;
a94737ea 6608 }
5e2c3490
JM		 6609 return ret;
6610}
6611#endif /* ANDROID */
6612
6613
adef8948
BL		 6614static int wpa_supplicant_vendor_cmd(struct wpa_supplicant *wpa_s, char *cmd,
6615 char *buf, size_t buflen)
6616{
6617 int ret;
6618 char *pos;
6619 u8 *data = NULL;
6620 unsigned int vendor_id, subcmd;
6621 struct wpabuf *reply;
6622 size_t data_len = 0;
6623
6624 /* cmd: <vendor id> <subcommand id> [<hex formatted data>] */
6625 vendor_id = strtoul(cmd, &pos, 16);
6626 if (!isblank(*pos))
6627 return -EINVAL;
6628
6629 subcmd = strtoul(pos, &pos, 10);
6630
6631 if (*pos != '\0') {
6632 if (!isblank(*pos++))
6633 return -EINVAL;
6634 data_len = os_strlen(pos);
6635 }
6636
6637 if (data_len) {
6638 data_len /= 2;
6639 data = os_malloc(data_len);
6640 if (!data)
2cebdee6 6641 return -1;
adef8948
BL		 6642
6643 if (hexstr2bin(pos, data, data_len)) {
6644 wpa_printf(MSG_DEBUG,
6645 "Vendor command: wrong parameter format");
6646 os_free(data);
6647 return -EINVAL;
6648 }
6649 }
6650
6651 reply = wpabuf_alloc((buflen - 1) / 2);
6652 if (!reply) {
6653 os_free(data);
2cebdee6 6654 return -1;
adef8948
BL		 6655 }
6656
6657 ret = wpa_drv_vendor_cmd(wpa_s, vendor_id, subcmd, data, data_len,
6658 reply);
6659
6660 if (ret == 0)
6661 ret = wpa_snprintf_hex(buf, buflen, wpabuf_head_u8(reply),
6662 wpabuf_len(reply));
6663
6664 wpabuf_free(reply);
6665 os_free(data);
6666
6667 return ret;
6668}
6669
6670
acb54643
JM		 6671static void wpa_supplicant_ctrl_iface_flush(struct wpa_supplicant *wpa_s)
6672{
7e608d1d
IP		 6673#ifdef CONFIG_P2P
6674 struct wpa_supplicant *p2p_wpa_s = wpa_s->global->p2p_init_wpa_s ?
6675 wpa_s->global->p2p_init_wpa_s : wpa_s;
6676#endif /* CONFIG_P2P */
6677
acb54643
JM		 6678 wpa_dbg(wpa_s, MSG_DEBUG, "Flush all wpa_supplicant state");
6679
6680#ifdef CONFIG_P2P
7e608d1d
IP		 6681 wpas_p2p_cancel(p2p_wpa_s);
6682 p2p_ctrl_flush(p2p_wpa_s);
6683 wpas_p2p_group_remove(p2p_wpa_s, "*");
6684 wpas_p2p_service_flush(p2p_wpa_s);
6685 p2p_wpa_s->global->p2p_disabled = 0;
6686 p2p_wpa_s->global->p2p_per_sta_psk = 0;
6687 p2p_wpa_s->conf->num_sec_device_types = 0;
6688 p2p_wpa_s->p2p_disable_ip_addr_req = 0;
6689 os_free(p2p_wpa_s->global->p2p_go_avoid_freq.range);
6690 p2p_wpa_s->global->p2p_go_avoid_freq.range = NULL;
9a58e521 6691 p2p_wpa_s->global->pending_p2ps_group = 0;
acb54643
JM		 6692#endif /* CONFIG_P2P */
6693
6694#ifdef CONFIG_WPS_TESTING
6695 wps_version_number = 0x20;
6696 wps_testing_dummy_cred = 0;
91226e0d 6697 wps_corrupt_pkhash = 0;
acb54643
JM		 6698#endif /* CONFIG_WPS_TESTING */
6699#ifdef CONFIG_WPS
7b02375a 6700 wpa_s->wps_fragment_size = 0;
acb54643 6701 wpas_wps_cancel(wpa_s);
422ba11e 6702 wps_registrar_flush(wpa_s->wps->registrar);
acb54643 6703#endif /* CONFIG_WPS */
7255983b 6704 wpa_s->after_wps = 0;
4d9fb08d 6705 wpa_s->known_wps_freq = 0;
acb54643 6706
9d2cb3ec 6707#ifdef CONFIG_TDLS
acb54643
JM		 6708#ifdef CONFIG_TDLS_TESTING
6709 extern unsigned int tdls_testing;
6710 tdls_testing = 0;
6711#endif /* CONFIG_TDLS_TESTING */
acb54643
JM		 6712 wpa_drv_tdls_oper(wpa_s, TDLS_ENABLE, NULL);
6713 wpa_tdls_enable(wpa_s->wpa, 1);
6714#endif /* CONFIG_TDLS */
6715
e78aaca0
JM		 6716 eloop_cancel_timeout(wpa_supplicant_stop_countermeasures, wpa_s, NULL);
6717 wpa_supplicant_stop_countermeasures(wpa_s, NULL);
6718
acb54643 6719 wpa_s->no_keep_alive = 0;
c2805909 6720 wpa_s->own_disconnect_req = 0;
acb54643
JM		 6721
6722 os_free(wpa_s->disallow_aps_bssid);
6723 wpa_s->disallow_aps_bssid = NULL;
6724 wpa_s->disallow_aps_bssid_count = 0;
6725 os_free(wpa_s->disallow_aps_ssid);
6726 wpa_s->disallow_aps_ssid = NULL;
6727 wpa_s->disallow_aps_ssid_count = 0;
6728
6729 wpa_s->set_sta_uapsd = 0;
6730 wpa_s->sta_uapsd = 0;
6731
6732 wpa_drv_radio_disable(wpa_s, 0);
acb54643 6733 wpa_blacklist_clear(wpa_s);
a8a7890d 6734 wpa_s->extra_blacklist_count = 0;
acb54643
JM		 6735 wpa_supplicant_ctrl_iface_remove_network(wpa_s, "all");
6736 wpa_supplicant_ctrl_iface_remove_cred(wpa_s, "all");
d9bb2821 6737 wpa_config_flush_blobs(wpa_s->conf);
ea6e040c
JM		 6738 wpa_s->conf->auto_interworking = 0;
6739 wpa_s->conf->okc = 0;
04f7ecc6 6740
b925506a
JM		 6741 wpa_sm_pmksa_cache_flush(wpa_s->wpa, NULL);
6742 rsn_preauth_deinit(wpa_s->wpa);
6743
04f7ecc6
JM		 6744 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME, 43200);
6745 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD, 70);
6746 wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT, 60);
0d79b50a 6747 eapol_sm_notify_logoff(wpa_s->eapol, FALSE);
b1ae396f 6748
b3253ebb 6749 radio_remove_works(wpa_s, NULL, 1);
e3745228 6750 wpa_s->ext_work_in_progress = 0;
3d910ef4
JM		 6751
6752 wpa_s->next_ssid = NULL;
b572df86
JM		 6753
6754#ifdef CONFIG_INTERWORKING
6755 hs20_cancel_fetch_osu(wpa_s);
6756#endif /* CONFIG_INTERWORKING */
60b893df
JM		 6757
6758 wpa_s->ext_mgmt_frame_handling = 0;
9d4ff04a 6759 wpa_s->ext_eapol_frame_io = 0;
1f94e4ee
JM		 6760#ifdef CONFIG_TESTING_OPTIONS
6761 wpa_s->extra_roc_dur = 0;
911942ee 6762 wpa_s->test_failure = WPAS_TEST_FAILURE_NONE;
1f94e4ee 6763#endif /* CONFIG_TESTING_OPTIONS */
97cfe110
JM		 6764
6765 wpa_s->disconnected = 0;
b8db1dfc
JM		 6766 os_free(wpa_s->next_scan_freqs);
6767 wpa_s->next_scan_freqs = NULL;
6c699913
JM		 6768
6769 wpa_bss_flush(wpa_s);
6770 if (!dl_list_empty(&wpa_s->bss)) {
6771 wpa_printf(MSG_DEBUG,
6772 "BSS table not empty after flush: %u entries, current_bss=%p bssid="
6773 MACSTR " pending_bssid=" MACSTR,
6774 dl_list_len(&wpa_s->bss), wpa_s->current_bss,
6775 MAC2STR(wpa_s->bssid),
6776 MAC2STR(wpa_s->pending_bssid));
6777 }
9bd566a3
AS		 6778
6779 eloop_cancel_timeout(wpas_network_reenabled, wpa_s, NULL);
acb54643
JM		 6780}
6781
6782
1f965e62
JM		 6783static int wpas_ctrl_radio_work_show(struct wpa_supplicant *wpa_s,
6784 char *buf, size_t buflen)
6785{
6786 struct wpa_radio_work *work;
6787 char *pos, *end;
6788 struct os_reltime now, diff;
6789
6790 pos = buf;
6791 end = buf + buflen;
6792
6793 os_get_reltime(&now);
6794
6795 dl_list_for_each(work, &wpa_s->radio->work, struct wpa_radio_work, list)
6796 {
6797 int ret;
6798
6799 os_reltime_sub(&now, &work->time, &diff);
6800 ret = os_snprintf(pos, end - pos, "%s@%s:%u:%u:%ld.%06ld\n",
6801 work->type, work->wpa_s->ifname, work->freq,
6802 work->started, diff.sec, diff.usec);
d85e1fc8 6803 if (os_snprintf_error(end - pos, ret))
1f965e62
JM		 6804 break;
6805 pos += ret;
6806 }
6807
6808 return pos - buf;
6809}
6810
6811
6812static void wpas_ctrl_radio_work_timeout(void *eloop_ctx, void *timeout_ctx)
6813{
6814 struct wpa_radio_work *work = eloop_ctx;
6815 struct wpa_external_work *ework = work->ctx;
6816
6817 wpa_dbg(work->wpa_s, MSG_DEBUG,
6818 "Timing out external radio work %u (%s)",
6819 ework->id, work->type);
6820 wpa_msg(work->wpa_s, MSG_INFO, EXT_RADIO_WORK_TIMEOUT "%u", ework->id);
e3745228 6821 work->wpa_s->ext_work_in_progress = 0;
1f965e62 6822 radio_work_done(work);
df48efc5 6823 os_free(ework);
1f965e62
JM		 6824}
6825
6826
6827static void wpas_ctrl_radio_work_cb(struct wpa_radio_work *work, int deinit)
6828{
6829 struct wpa_external_work *ework = work->ctx;
6830
6831 if (deinit) {
b3253ebb
AO		 6832 if (work->started)
6833 eloop_cancel_timeout(wpas_ctrl_radio_work_timeout,
6834 work, NULL);
6835
1f965e62
JM		 6836 os_free(ework);
6837 return;
6838 }
6839
6840 wpa_dbg(work->wpa_s, MSG_DEBUG, "Starting external radio work %u (%s)",
6841 ework->id, ework->type);
6842 wpa_msg(work->wpa_s, MSG_INFO, EXT_RADIO_WORK_START "%u", ework->id);
e3745228 6843 work->wpa_s->ext_work_in_progress = 1;
1f965e62
JM		 6844 if (!ework->timeout)
6845 ework->timeout = 10;
6846 eloop_register_timeout(ework->timeout, 0, wpas_ctrl_radio_work_timeout,
6847 work, NULL);
6848}
6849
6850
6851static int wpas_ctrl_radio_work_add(struct wpa_supplicant *wpa_s, char *cmd,
6852 char *buf, size_t buflen)
6853{
6854 struct wpa_external_work *ework;
6855 char *pos, *pos2;
6856 size_t type_len;
6857 int ret;
6858 unsigned int freq = 0;
6859
6860 /* format: <name> [freq=<MHz>] [timeout=<seconds>] */
6861
6862 ework = os_zalloc(sizeof(*ework));
6863 if (ework == NULL)
6864 return -1;
6865
6866 pos = os_strchr(cmd, ' ');
6867 if (pos) {
6868 type_len = pos - cmd;
6869 pos++;
6870
6871 pos2 = os_strstr(pos, "freq=");
6872 if (pos2)
6873 freq = atoi(pos2 + 5);
6874
6875 pos2 = os_strstr(pos, "timeout=");
6876 if (pos2)
6877 ework->timeout = atoi(pos2 + 8);
6878 } else {
6879 type_len = os_strlen(cmd);
6880 }
6881 if (4 + type_len >= sizeof(ework->type))
6882 type_len = sizeof(ework->type) - 4 - 1;
6883 os_strlcpy(ework->type, "ext:", sizeof(ework->type));
6884 os_memcpy(ework->type + 4, cmd, type_len);
6885 ework->type[4 + type_len] = '\0';
6886
6887 wpa_s->ext_work_id++;
6888 if (wpa_s->ext_work_id == 0)
6889 wpa_s->ext_work_id++;
6890 ework->id = wpa_s->ext_work_id;
6891
6892 if (radio_add_work(wpa_s, freq, ework->type, 0, wpas_ctrl_radio_work_cb,
6893 ework) < 0) {
6894 os_free(ework);
6895 return -1;
6896 }
6897
6898 ret = os_snprintf(buf, buflen, "%u", ework->id);
d85e1fc8 6899 if (os_snprintf_error(buflen, ret))
1f965e62
JM		 6900 return -1;
6901 return ret;
6902}
6903
6904
6905static int wpas_ctrl_radio_work_done(struct wpa_supplicant *wpa_s, char *cmd)
6906{
6907 struct wpa_radio_work *work;
6908 unsigned int id = atoi(cmd);
6909
6910 dl_list_for_each(work, &wpa_s->radio->work, struct wpa_radio_work, list)
6911 {
6912 struct wpa_external_work *ework;
6913
6914 if (os_strncmp(work->type, "ext:", 4) != 0)
6915 continue;
6916 ework = work->ctx;
6917 if (id && ework->id != id)
6918 continue;
6919 wpa_dbg(wpa_s, MSG_DEBUG,
6920 "Completed external radio work %u (%s)",
6921 ework->id, ework->type);
6922 eloop_cancel_timeout(wpas_ctrl_radio_work_timeout, work, NULL);
e3745228 6923 wpa_s->ext_work_in_progress = 0;
1f965e62 6924 radio_work_done(work);
6829da39 6925 os_free(ework);
1f965e62
JM		 6926 return 3; /* "OK\n" */
6927 }
6928
6929 return -1;
6930}
6931
6932
6933static int wpas_ctrl_radio_work(struct wpa_supplicant *wpa_s, char *cmd,
6934 char *buf, size_t buflen)
6935{
6936 if (os_strcmp(cmd, "show") == 0)
6937 return wpas_ctrl_radio_work_show(wpa_s, buf, buflen);
6938 if (os_strncmp(cmd, "add ", 4) == 0)
6939 return wpas_ctrl_radio_work_add(wpa_s, cmd + 4, buf, buflen);
6940 if (os_strncmp(cmd, "done ", 5) == 0)
6941 return wpas_ctrl_radio_work_done(wpa_s, cmd + 4);
6942 return -1;
6943}
6944
6945
6946void wpas_ctrl_radio_work_flush(struct wpa_supplicant *wpa_s)
6947{
6948 struct wpa_radio_work *work, *tmp;
6949
a6cff8bf
MS		 6950 if (!wpa_s || !wpa_s->radio)
6951 return;
6952
1f965e62
JM		 6953 dl_list_for_each_safe(work, tmp, &wpa_s->radio->work,
6954 struct wpa_radio_work, list) {
6955 struct wpa_external_work *ework;
6956
6957 if (os_strncmp(work->type, "ext:", 4) != 0)
6958 continue;
6959 ework = work->ctx;
6960 wpa_dbg(wpa_s, MSG_DEBUG,
023b466d 6961 "Flushing%s external radio work %u (%s)",
1f965e62
JM		 6962 work->started ? " started" : "", ework->id,
6963 ework->type);
6964 if (work->started)
6965 eloop_cancel_timeout(wpas_ctrl_radio_work_timeout,
6966 work, NULL);
1f965e62 6967 radio_work_done(work);
df48efc5 6968 os_free(ework);
1f965e62
JM		 6969 }
6970}
6971
6972
bceb8431
JM		 6973static void wpas_ctrl_eapol_response(void *eloop_ctx, void *timeout_ctx)
6974{
6975 struct wpa_supplicant *wpa_s = eloop_ctx;
6976 eapol_sm_notify_ctrl_response(wpa_s->eapol);
6977}
6978
6979
43a66ecb
JM		 6980static int scan_id_list_parse(struct wpa_supplicant *wpa_s, const char *value,
6981 unsigned int *scan_id_count, int scan_id[])
6891f0e6
LJ		 6982{
6983 const char *pos = value;
6984
6985 while (pos) {
6986 if (*pos == ' ' || *pos == '\0')
6987 break;
43a66ecb 6988 if (*scan_id_count == MAX_SCAN_ID)
6891f0e6 6989 return -1;
43a66ecb 6990 scan_id[(*scan_id_count)++] = atoi(pos);
6891f0e6
LJ		 6991 pos = os_strchr(pos, ',');
6992 if (pos)
6993 pos++;
6994 }
6995
6996 return 0;
6997}
6998
6999
fee52342
JM		 7000static void wpas_ctrl_scan(struct wpa_supplicant *wpa_s, char *params,
7001 char *reply, int reply_size, int *reply_len)
7002{
7003 char *pos;
43a66ecb
JM		 7004 unsigned int manual_scan_passive = 0;
7005 unsigned int manual_scan_use_id = 0;
7006 unsigned int manual_scan_only_new = 0;
7007 unsigned int scan_only = 0;
7008 unsigned int scan_id_count = 0;
7009 int scan_id[MAX_SCAN_ID];
7010 void (*scan_res_handler)(struct wpa_supplicant *wpa_s,
7011 struct wpa_scan_results *scan_res);
7012 int *manual_scan_freqs = NULL;
a80651d0
KV		 7013 struct wpa_ssid_value *ssid = NULL, *ns;
7014 unsigned int ssid_count = 0;
fee52342
JM		 7015
7016 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
7017 *reply_len = -1;
7018 return;
7019 }
7020
e69ae5ff
JM		 7021 if (radio_work_pending(wpa_s, "scan")) {
7022 wpa_printf(MSG_DEBUG,
7023 "Pending scan scheduled - reject new request");
7024 *reply_len = os_snprintf(reply, reply_size, "FAIL-BUSY\n");
7025 return;
7026 }
7027
9772af66
NM		 7028#ifdef CONFIG_INTERWORKING
7029 if (wpa_s->fetch_anqp_in_progress || wpa_s->network_select) {
7030 wpa_printf(MSG_DEBUG,
7031 "Interworking select in progress - reject new scan");
7032 *reply_len = os_snprintf(reply, reply_size, "FAIL-BUSY\n");
7033 return;
7034 }
7035#endif /* CONFIG_INTERWORKING */
7036
fee52342
JM		 7037 if (params) {
7038 if (os_strncasecmp(params, "TYPE=ONLY", 9) == 0)
43a66ecb 7039 scan_only = 1;
fee52342
JM		 7040
7041 pos = os_strstr(params, "freq=");
43a66ecb
JM		 7042 if (pos) {
7043 manual_scan_freqs = freq_range_to_channel_list(wpa_s,
7044 pos + 5);
7045 if (manual_scan_freqs == NULL) {
7046 *reply_len = -1;
7047 goto done;
7048 }
fee52342 7049 }
88c2d488
JM		 7050
7051 pos = os_strstr(params, "passive=");
7052 if (pos)
43a66ecb 7053 manual_scan_passive = !!atoi(pos + 8);
d81c73be
JM		 7054
7055 pos = os_strstr(params, "use_id=");
7056 if (pos)
43a66ecb 7057 manual_scan_use_id = atoi(pos + 7);
949938aa
JM		 7058
7059 pos = os_strstr(params, "only_new=1");
7060 if (pos)
43a66ecb 7061 manual_scan_only_new = 1;
6891f0e6
LJ		 7062
7063 pos = os_strstr(params, "scan_id=");
43a66ecb
JM		 7064 if (pos && scan_id_list_parse(wpa_s, pos + 8, &scan_id_count,
7065 scan_id) < 0) {
6891f0e6 7066 *reply_len = -1;
43a66ecb 7067 goto done;
6891f0e6 7068 }
a80651d0
KV		 7069
7070 pos = params;
7071 while (pos && *pos != '\0') {
7072 if (os_strncmp(pos, "ssid ", 5) == 0) {
7073 char *end;
7074
7075 pos += 5;
7076 end = pos;
7077 while (*end) {
7078 if (*end == '\0' || *end == ' ')
7079 break;
7080 end++;
7081 }
7082
7083 ns = os_realloc_array(
7084 ssid, ssid_count + 1,
7085 sizeof(struct wpa_ssid_value));
7086 if (ns == NULL) {
7087 *reply_len = -1;
7088 goto done;
7089 }
7090 ssid = ns;
7091
7092 if ((end - pos) & 0x01 ||
7093 end - pos > 2 * SSID_MAX_LEN ||
7094 hexstr2bin(pos, ssid[ssid_count].ssid,
7095 (end - pos) / 2) < 0) {
7096 wpa_printf(MSG_DEBUG,
7097 "Invalid SSID value '%s'",
7098 pos);
7099 *reply_len = -1;
7100 goto done;
7101 }
7102 ssid[ssid_count].ssid_len = (end - pos) / 2;
7103 wpa_hexdump_ascii(MSG_DEBUG, "scan SSID",
7104 ssid[ssid_count].ssid,
7105 ssid[ssid_count].ssid_len);
7106 ssid_count++;
7107 pos = end;
7108 }
7109
7110 pos = os_strchr(pos, ' ');
7111 if (pos)
7112 pos++;
7113 }
7114 }
7115
7116 wpa_s->num_ssids_from_scan_req = ssid_count;
7117 os_free(wpa_s->ssids_from_scan_req);
7118 if (ssid_count) {
7119 wpa_s->ssids_from_scan_req = ssid;
7120 ssid = NULL;
7121 } else {
7122 wpa_s->ssids_from_scan_req = NULL;
fee52342
JM		 7123 }
7124
43a66ecb
JM		 7125 if (scan_only)
7126 scan_res_handler = scan_only_handler;
7127 else if (wpa_s->scan_res_handler == scan_only_handler)
7128 scan_res_handler = NULL;
7129 else
7130 scan_res_handler = wpa_s->scan_res_handler;
7131
fee52342
JM		 7132 if (!wpa_s->sched_scanning && !wpa_s->scanning &&
7133 ((wpa_s->wpa_state <= WPA_SCANNING) ||
7134 (wpa_s->wpa_state == WPA_COMPLETED))) {
43a66ecb
JM		 7135 wpa_s->manual_scan_passive = manual_scan_passive;
7136 wpa_s->manual_scan_use_id = manual_scan_use_id;
7137 wpa_s->manual_scan_only_new = manual_scan_only_new;
7138 wpa_s->scan_id_count = scan_id_count;
7139 os_memcpy(wpa_s->scan_id, scan_id, scan_id_count * sizeof(int));
7140 wpa_s->scan_res_handler = scan_res_handler;
7141 os_free(wpa_s->manual_scan_freqs);
7142 wpa_s->manual_scan_freqs = manual_scan_freqs;
7143 manual_scan_freqs = NULL;
7144
fee52342
JM		 7145 wpa_s->normal_scans = 0;
7146 wpa_s->scan_req = MANUAL_SCAN_REQ;
7147 wpa_s->after_wps = 0;
7148 wpa_s->known_wps_freq = 0;
7149 wpa_supplicant_req_scan(wpa_s, 0, 0);
d81c73be
JM		 7150 if (wpa_s->manual_scan_use_id) {
7151 wpa_s->manual_scan_id++;
7152 wpa_dbg(wpa_s, MSG_DEBUG, "Assigned scan id %u",
7153 wpa_s->manual_scan_id);
7154 *reply_len = os_snprintf(reply, reply_size, "%u\n",
7155 wpa_s->manual_scan_id);
7156 }
fee52342 7157 } else if (wpa_s->sched_scanning) {
43a66ecb
JM		 7158 wpa_s->manual_scan_passive = manual_scan_passive;
7159 wpa_s->manual_scan_use_id = manual_scan_use_id;
7160 wpa_s->manual_scan_only_new = manual_scan_only_new;
7161 wpa_s->scan_id_count = scan_id_count;
7162 os_memcpy(wpa_s->scan_id, scan_id, scan_id_count * sizeof(int));
7163 wpa_s->scan_res_handler = scan_res_handler;
7164 os_free(wpa_s->manual_scan_freqs);
7165 wpa_s->manual_scan_freqs = manual_scan_freqs;
7166 manual_scan_freqs = NULL;
7167
fee52342
JM		 7168 wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan to allow requested full scan to proceed");
7169 wpa_supplicant_cancel_sched_scan(wpa_s);
7170 wpa_s->scan_req = MANUAL_SCAN_REQ;
7171 wpa_supplicant_req_scan(wpa_s, 0, 0);
d81c73be
JM		 7172 if (wpa_s->manual_scan_use_id) {
7173 wpa_s->manual_scan_id++;
7174 *reply_len = os_snprintf(reply, reply_size, "%u\n",
7175 wpa_s->manual_scan_id);
7176 wpa_dbg(wpa_s, MSG_DEBUG, "Assigned scan id %u",
7177 wpa_s->manual_scan_id);
7178 }
fee52342
JM		 7179 } else {
7180 wpa_printf(MSG_DEBUG, "Ongoing scan action - reject new request");
7181 *reply_len = os_snprintf(reply, reply_size, "FAIL-BUSY\n");
7182 }
43a66ecb
JM		 7183
7184done:
7185 os_free(manual_scan_freqs);
a80651d0 7186 os_free(ssid);
fee52342
JM		 7187}
7188
7189
60b893df
JM		 7190#ifdef CONFIG_TESTING_OPTIONS
7191
7192static void wpas_ctrl_iface_mgmt_tx_cb(struct wpa_supplicant *wpa_s,
7193 unsigned int freq, const u8 *dst,
7194 const u8 *src, const u8 *bssid,
7195 const u8 *data, size_t data_len,
7196 enum offchannel_send_action_result
7197 result)
7198{
7199 wpa_msg(wpa_s, MSG_INFO, "MGMT-TX-STATUS freq=%u dst=" MACSTR
7200 " src=" MACSTR " bssid=" MACSTR " result=%s",
7201 freq, MAC2STR(dst), MAC2STR(src), MAC2STR(bssid),
7202 result == OFFCHANNEL_SEND_ACTION_SUCCESS ?
7203 "SUCCESS" : (result == OFFCHANNEL_SEND_ACTION_NO_ACK ?
7204 "NO_ACK" : "FAILED"));
7205}
7206
7207
7208static int wpas_ctrl_iface_mgmt_tx(struct wpa_supplicant *wpa_s, char *cmd)
7209{
7210 char *pos, *param;
7211 size_t len;
7212 u8 *buf, da[ETH_ALEN], bssid[ETH_ALEN];
7213 int res, used;
7214 int freq = 0, no_cck = 0, wait_time = 0;
7215
7216 /* <DA> <BSSID> [freq=<MHz>] [wait_time=<ms>] [no_cck=1]
7217 * <action=Action frame payload> */
7218
7219 wpa_printf(MSG_DEBUG, "External MGMT TX: %s", cmd);
7220
7221 pos = cmd;
7222 used = hwaddr_aton2(pos, da);
7223 if (used < 0)
7224 return -1;
7225 pos += used;
7226 while (*pos == ' ')
7227 pos++;
7228 used = hwaddr_aton2(pos, bssid);
7229 if (used < 0)
7230 return -1;
7231 pos += used;
7232
7233 param = os_strstr(pos, " freq=");
7234 if (param) {
7235 param += 6;
7236 freq = atoi(param);
7237 }
7238
7239 param = os_strstr(pos, " no_cck=");
7240 if (param) {
7241 param += 8;
7242 no_cck = atoi(param);
7243 }
7244
7245 param = os_strstr(pos, " wait_time=");
7246 if (param) {
7247 param += 11;
7248 wait_time = atoi(param);
7249 }
7250
7251 param = os_strstr(pos, " action=");
7252 if (param == NULL)
7253 return -1;
7254 param += 8;
7255
7256 len = os_strlen(param);
7257 if (len & 1)
7258 return -1;
7259 len /= 2;
7260
7261 buf = os_malloc(len);
7262 if (buf == NULL)
7263 return -1;
7264
7265 if (hexstr2bin(param, buf, len) < 0) {
7266 os_free(buf);
7267 return -1;
7268 }
7269
7270 res = offchannel_send_action(wpa_s, freq, da, wpa_s->own_addr, bssid,
7271 buf, len, wait_time,
7272 wpas_ctrl_iface_mgmt_tx_cb, no_cck);
7273 os_free(buf);
7274 return res;
7275}
7276
7277
7278static void wpas_ctrl_iface_mgmt_tx_done(struct wpa_supplicant *wpa_s)
7279{
7280 wpa_printf(MSG_DEBUG, "External MGMT TX - done waiting");
7281 offchannel_send_action_done(wpa_s);
7282}
7283
ad12f2f4
JM		 7284
7285static int wpas_ctrl_iface_driver_event(struct wpa_supplicant *wpa_s, char *cmd)
7286{
7287 char *pos, *param;
7288 union wpa_event_data event;
7289 enum wpa_event_type ev;
7290
7291 /* <event name> [parameters..] */
7292
7293 wpa_dbg(wpa_s, MSG_DEBUG, "Testing - external driver event: %s", cmd);
7294
7295 pos = cmd;
7296 param = os_strchr(pos, ' ');
7297 if (param)
7298 *param++ = '\0';
7299
7300 os_memset(&event, 0, sizeof(event));
7301
7302 if (os_strcmp(cmd, "INTERFACE_ENABLED") == 0) {
7303 ev = EVENT_INTERFACE_ENABLED;
7304 } else if (os_strcmp(cmd, "INTERFACE_DISABLED") == 0) {
7305 ev = EVENT_INTERFACE_DISABLED;
7bb70909
JM		 7306 } else if (os_strcmp(cmd, "AVOID_FREQUENCIES") == 0) {
7307 ev = EVENT_AVOID_FREQUENCIES;
7308 if (param == NULL)
7309 param = "";
7310 if (freq_range_list_parse(&event.freq_range, param) < 0)
7311 return -1;
7312 wpa_supplicant_event(wpa_s, ev, &event);
7313 os_free(event.freq_range.range);
7314 return 0;
ad12f2f4
JM		 7315 } else {
7316 wpa_dbg(wpa_s, MSG_DEBUG, "Testing - unknown driver event: %s",
7317 cmd);
7318 return -1;
7319 }
7320
7321 wpa_supplicant_event(wpa_s, ev, &event);
7322
7323 return 0;
7324}
7325
9d4ff04a
JM		 7326
7327static int wpas_ctrl_iface_eapol_rx(struct wpa_supplicant *wpa_s, char *cmd)
7328{
7329 char *pos;
7330 u8 src[ETH_ALEN], *buf;
7331 int used;
7332 size_t len;
7333
7334 wpa_printf(MSG_DEBUG, "External EAPOL RX: %s", cmd);
7335
7336 pos = cmd;
7337 used = hwaddr_aton2(pos, src);
7338 if (used < 0)
7339 return -1;
7340 pos += used;
7341 while (*pos == ' ')
7342 pos++;
7343
7344 len = os_strlen(pos);
7345 if (len & 1)
7346 return -1;
7347 len /= 2;
7348
7349 buf = os_malloc(len);
7350 if (buf == NULL)
7351 return -1;
7352
7353 if (hexstr2bin(pos, buf, len) < 0) {
7354 os_free(buf);
7355 return -1;
7356 }
7357
7358 wpa_supplicant_rx_eapol(wpa_s, src, buf, len);
7359 os_free(buf);
7360
7361 return 0;
7362}
7363
4a6cc862
JM		 7364
7365static u16 ipv4_hdr_checksum(const void *buf, size_t len)
7366{
7367 size_t i;
7368 u32 sum = 0;
7369 const u16 *pos = buf;
7370
7371 for (i = 0; i < len / 2; i++)
7372 sum += *pos++;
7373
7374 while (sum >> 16)
7375 sum = (sum & 0xffff) + (sum >> 16);
7376
7377 return sum ^ 0xffff;
7378}
7379
7380
7381#define HWSIM_PACKETLEN 1500
7382#define HWSIM_IP_LEN (HWSIM_PACKETLEN - sizeof(struct ether_header))
7383
7384void wpas_data_test_rx(void *ctx, const u8 *src_addr, const u8 *buf, size_t len)
7385{
7386 struct wpa_supplicant *wpa_s = ctx;
7387 const struct ether_header *eth;
75352270 7388 struct iphdr ip;
4a6cc862
JM		 7389 const u8 *pos;
7390 unsigned int i;
7391
7392 if (len != HWSIM_PACKETLEN)
7393 return;
7394
7395 eth = (const struct ether_header *) buf;
75352270
JM		 7396 os_memcpy(&ip, eth + 1, sizeof(ip));
7397 pos = &buf[sizeof(*eth) + sizeof(ip)];
4a6cc862 7398
75352270
JM		 7399 if (ip.ihl != 5 || ip.version != 4 ||
7400 ntohs(ip.tot_len) != HWSIM_IP_LEN)
4a6cc862
JM		 7401 return;
7402
75352270 7403 for (i = 0; i < HWSIM_IP_LEN - sizeof(ip); i++) {
4a6cc862
JM		 7404 if (*pos != (u8) i)
7405 return;
7406 pos++;
7407 }
7408
7409 wpa_msg(wpa_s, MSG_INFO, "DATA-TEST-RX " MACSTR " " MACSTR,
7410 MAC2STR(eth->ether_dhost), MAC2STR(eth->ether_shost));
7411}
7412
7413
7414static int wpas_ctrl_iface_data_test_config(struct wpa_supplicant *wpa_s,
7415 char *cmd)
7416{
7417 int enabled = atoi(cmd);
7418
7419 if (!enabled) {
7420 if (wpa_s->l2_test) {
7421 l2_packet_deinit(wpa_s->l2_test);
7422 wpa_s->l2_test = NULL;
7423 wpa_dbg(wpa_s, MSG_DEBUG, "test data: Disabled");
7424 }
7425 return 0;
7426 }
7427
7428 if (wpa_s->l2_test)
7429 return 0;
7430
7431 wpa_s->l2_test = l2_packet_init(wpa_s->ifname, wpa_s->own_addr,
7432 ETHERTYPE_IP, wpas_data_test_rx,
7433 wpa_s, 1);
7434 if (wpa_s->l2_test == NULL)
7435 return -1;
7436
7437 wpa_dbg(wpa_s, MSG_DEBUG, "test data: Enabled");
7438
7439 return 0;
7440}
7441
7442
7443static int wpas_ctrl_iface_data_test_tx(struct wpa_supplicant *wpa_s, char *cmd)
7444{
7445 u8 dst[ETH_ALEN], src[ETH_ALEN];
7446 char *pos;
7447 int used;
7448 long int val;
7449 u8 tos;
75352270 7450 u8 buf[2 + HWSIM_PACKETLEN];
4a6cc862
JM		 7451 struct ether_header *eth;
7452 struct iphdr *ip;
7453 u8 *dpos;
7454 unsigned int i;
7455
7456 if (wpa_s->l2_test == NULL)
7457 return -1;
7458
7459 /* format: <dst> <src> <tos> */
7460
7461 pos = cmd;
7462 used = hwaddr_aton2(pos, dst);
7463 if (used < 0)
7464 return -1;
7465 pos += used;
7466 while (*pos == ' ')
7467 pos++;
7468 used = hwaddr_aton2(pos, src);
7469 if (used < 0)
7470 return -1;
7471 pos += used;
7472
7473 val = strtol(pos, NULL, 0);
7474 if (val < 0 || val > 0xff)
7475 return -1;
7476 tos = val;
7477
75352270 7478 eth = (struct ether_header *) &buf[2];
4a6cc862
JM		 7479 os_memcpy(eth->ether_dhost, dst, ETH_ALEN);
7480 os_memcpy(eth->ether_shost, src, ETH_ALEN);
7481 eth->ether_type = htons(ETHERTYPE_IP);
7482 ip = (struct iphdr *) (eth + 1);
7483 os_memset(ip, 0, sizeof(*ip));
7484 ip->ihl = 5;
7485 ip->version = 4;
7486 ip->ttl = 64;
7487 ip->tos = tos;
7488 ip->tot_len = htons(HWSIM_IP_LEN);
7489 ip->protocol = 1;
66f1e078
JM		 7490 ip->saddr = htonl(192U << 24 | 168 << 16 | 1 << 8 | 1);
7491 ip->daddr = htonl(192U << 24 | 168 << 16 | 1 << 8 | 2);
4a6cc862
JM		 7492 ip->check = ipv4_hdr_checksum(ip, sizeof(*ip));
7493 dpos = (u8 *) (ip + 1);
7494 for (i = 0; i < HWSIM_IP_LEN - sizeof(*ip); i++)
7495 *dpos++ = i;
7496
75352270 7497 if (l2_packet_send(wpa_s->l2_test, dst, ETHERTYPE_IP, &buf[2],
4a6cc862
JM		 7498 HWSIM_PACKETLEN) < 0)
7499 return -1;
7500
7501 wpa_dbg(wpa_s, MSG_DEBUG, "test data: TX dst=" MACSTR " src=" MACSTR
7502 " tos=0x%x", MAC2STR(dst), MAC2STR(src), tos);
7503
7504 return 0;
7505}
7506
fc0ef7c0
JM		 7507
7508static int wpas_ctrl_iface_data_test_frame(struct wpa_supplicant *wpa_s,
7509 char *cmd)
7510{
7511 u8 *buf;
7512 struct ether_header *eth;
7513 struct l2_packet_data *l2 = NULL;
7514 size_t len;
7515 u16 ethertype;
7516 int res = -1;
7517
7518 len = os_strlen(cmd);
7519 if (len & 1 || len < ETH_HLEN * 2)
7520 return -1;
7521 len /= 2;
7522
7523 buf = os_malloc(len);
7524 if (buf == NULL)
7525 return -1;
7526
7527 if (hexstr2bin(cmd, buf, len) < 0)
7528 goto done;
7529
7530 eth = (struct ether_header *) buf;
7531 ethertype = ntohs(eth->ether_type);
7532
7533 l2 = l2_packet_init(wpa_s->ifname, wpa_s->own_addr, ethertype,
7534 wpas_data_test_rx, wpa_s, 1);
7535 if (l2 == NULL)
7536 goto done;
7537
7538 res = l2_packet_send(l2, eth->ether_dhost, ethertype, buf, len);
7539 wpa_dbg(wpa_s, MSG_DEBUG, "test data: TX frame res=%d", res);
7540done:
7541 if (l2)
7542 l2_packet_deinit(l2);
7543 os_free(buf);
7544
7545 return res < 0 ? -1 : 0;
7546}
7547
a156ffda
JM		 7548
7549static int wpas_ctrl_test_alloc_fail(struct wpa_supplicant *wpa_s, char *cmd)
7550{
7551#ifdef WPA_TRACE_BFD
7552 extern char wpa_trace_fail_func[256];
7553 extern unsigned int wpa_trace_fail_after;
7554 char *pos;
7555
7556 wpa_trace_fail_after = atoi(cmd);
7557 pos = os_strchr(cmd, ':');
7558 if (pos) {
7559 pos++;
7560 os_strlcpy(wpa_trace_fail_func, pos,
7561 sizeof(wpa_trace_fail_func));
7562 } else {
7563 wpa_trace_fail_after = 0;
7564 }
7565 return 0;
7566#else /* WPA_TRACE_BFD */
7567 return -1;
7568#endif /* WPA_TRACE_BFD */
7569}
7570
7571
7572static int wpas_ctrl_get_alloc_fail(struct wpa_supplicant *wpa_s,
7573 char *buf, size_t buflen)
7574{
7575#ifdef WPA_TRACE_BFD
7576 extern char wpa_trace_fail_func[256];
7577 extern unsigned int wpa_trace_fail_after;
7578
7579 return os_snprintf(buf, buflen, "%u:%s", wpa_trace_fail_after,
7580 wpa_trace_fail_func);
7581#else /* WPA_TRACE_BFD */
7582 return -1;
7583#endif /* WPA_TRACE_BFD */
7584}
7585
2da52565
JM		 7586
7587static int wpas_ctrl_test_fail(struct wpa_supplicant *wpa_s, char *cmd)
7588{
7589#ifdef WPA_TRACE_BFD
7590 extern char wpa_trace_test_fail_func[256];
7591 extern unsigned int wpa_trace_test_fail_after;
7592 char *pos;
7593
7594 wpa_trace_test_fail_after = atoi(cmd);
7595 pos = os_strchr(cmd, ':');
7596 if (pos) {
7597 pos++;
7598 os_strlcpy(wpa_trace_test_fail_func, pos,
7599 sizeof(wpa_trace_test_fail_func));
7600 } else {
7601 wpa_trace_test_fail_after = 0;
7602 }
7603 return 0;
7604#else /* WPA_TRACE_BFD */
7605 return -1;
7606#endif /* WPA_TRACE_BFD */
7607}
7608
7609
7610static int wpas_ctrl_get_fail(struct wpa_supplicant *wpa_s,
7611 char *buf, size_t buflen)
7612{
7613#ifdef WPA_TRACE_BFD
7614 extern char wpa_trace_test_fail_func[256];
7615 extern unsigned int wpa_trace_test_fail_after;
7616
7617 return os_snprintf(buf, buflen, "%u:%s", wpa_trace_test_fail_after,
7618 wpa_trace_test_fail_func);
7619#else /* WPA_TRACE_BFD */
7620 return -1;
7621#endif /* WPA_TRACE_BFD */
7622}
7623
60b893df
JM		 7624#endif /* CONFIG_TESTING_OPTIONS */
7625
7626
86bd36f0
JM		 7627static void wpas_ctrl_vendor_elem_update(struct wpa_supplicant *wpa_s)
7628{
7629 unsigned int i;
7630 char buf[30];
7631
7632 wpa_printf(MSG_DEBUG, "Update vendor elements");
7633
7634 for (i = 0; i < NUM_VENDOR_ELEM_FRAMES; i++) {
7635 if (wpa_s->vendor_elem[i]) {
1d399771
JM		 7636 int res;
7637
7638 res = os_snprintf(buf, sizeof(buf), "frame[%u]", i);
7639 if (!os_snprintf_error(sizeof(buf), res)) {
7640 wpa_hexdump_buf(MSG_DEBUG, buf,
7641 wpa_s->vendor_elem[i]);
7642 }
86bd36f0
JM		 7643 }
7644 }
7645
7646#ifdef CONFIG_P2P
7647 if (wpa_s->parent == wpa_s &&
7648 wpa_s->global->p2p &&
7649 !wpa_s->global->p2p_disabled)
7650 p2p_set_vendor_elems(wpa_s->global->p2p, wpa_s->vendor_elem);
7651#endif /* CONFIG_P2P */
7652}
7653
7654
7655static struct wpa_supplicant *
7656wpas_ctrl_vendor_elem_iface(struct wpa_supplicant *wpa_s,
7657 enum wpa_vendor_elem_frame frame)
7658{
7659 switch (frame) {
7660#ifdef CONFIG_P2P
7661 case VENDOR_ELEM_PROBE_REQ_P2P:
7662 case VENDOR_ELEM_PROBE_RESP_P2P:
7663 case VENDOR_ELEM_PROBE_RESP_P2P_GO:
7664 case VENDOR_ELEM_BEACON_P2P_GO:
7665 case VENDOR_ELEM_P2P_PD_REQ:
7666 case VENDOR_ELEM_P2P_PD_RESP:
7667 case VENDOR_ELEM_P2P_GO_NEG_REQ:
7668 case VENDOR_ELEM_P2P_GO_NEG_RESP:
7669 case VENDOR_ELEM_P2P_GO_NEG_CONF:
7670 case VENDOR_ELEM_P2P_INV_REQ:
7671 case VENDOR_ELEM_P2P_INV_RESP:
7672 case VENDOR_ELEM_P2P_ASSOC_REQ:
7673 return wpa_s->parent;
7674#endif /* CONFIG_P2P */
7675 default:
7676 return wpa_s;
7677 }
7678}
7679
7680
7681static int wpas_ctrl_vendor_elem_add(struct wpa_supplicant *wpa_s, char *cmd)
7682{
7683 char *pos = cmd;
7684 int frame;
7685 size_t len;
7686 struct wpabuf *buf;
7687 struct ieee802_11_elems elems;
7688
7689 frame = atoi(pos);
7690 if (frame < 0 || frame >= NUM_VENDOR_ELEM_FRAMES)
7691 return -1;
7692 wpa_s = wpas_ctrl_vendor_elem_iface(wpa_s, frame);
7693
7694 pos = os_strchr(pos, ' ');
7695 if (pos == NULL)
7696 return -1;
7697 pos++;
7698
7699 len = os_strlen(pos);
7700 if (len == 0)
7701 return 0;
7702 if (len & 1)
7703 return -1;
7704 len /= 2;
7705
7706 buf = wpabuf_alloc(len);
7707 if (buf == NULL)
7708 return -1;
7709
7710 if (hexstr2bin(pos, wpabuf_put(buf, len), len) < 0) {
7711 wpabuf_free(buf);
7712 return -1;
7713 }
7714
7715 if (ieee802_11_parse_elems(wpabuf_head_u8(buf), len, &elems, 0) ==
7716 ParseFailed) {
7717 wpabuf_free(buf);
7718 return -1;
7719 }
7720
7721 if (wpa_s->vendor_elem[frame] == NULL) {
7722 wpa_s->vendor_elem[frame] = buf;
7723 wpas_ctrl_vendor_elem_update(wpa_s);
7724 return 0;
7725 }
7726
7727 if (wpabuf_resize(&wpa_s->vendor_elem[frame], len) < 0) {
7728 wpabuf_free(buf);
7729 return -1;
7730 }
7731
7732 wpabuf_put_buf(wpa_s->vendor_elem[frame], buf);
7733 wpabuf_free(buf);
7734 wpas_ctrl_vendor_elem_update(wpa_s);
7735
7736 return 0;
7737}
7738
7739
7740static int wpas_ctrl_vendor_elem_get(struct wpa_supplicant *wpa_s, char *cmd,
7741 char *buf, size_t buflen)
7742{
7743 int frame = atoi(cmd);
7744
7745 if (frame < 0 || frame >= NUM_VENDOR_ELEM_FRAMES)
7746 return -1;
7747 wpa_s = wpas_ctrl_vendor_elem_iface(wpa_s, frame);
7748
7749 if (wpa_s->vendor_elem[frame] == NULL)
7750 return 0;
7751
7752 return wpa_snprintf_hex(buf, buflen,
7753 wpabuf_head_u8(wpa_s->vendor_elem[frame]),
7754 wpabuf_len(wpa_s->vendor_elem[frame]));
7755}
7756
7757
7758static int wpas_ctrl_vendor_elem_remove(struct wpa_supplicant *wpa_s, char *cmd)
7759{
7760 char *pos = cmd;
7761 int frame;
7762 size_t len;
7763 u8 *buf;
7764 struct ieee802_11_elems elems;
7765 u8 *ie, *end;
7766
7767 frame = atoi(pos);
7768 if (frame < 0 || frame >= NUM_VENDOR_ELEM_FRAMES)
7769 return -1;
7770 wpa_s = wpas_ctrl_vendor_elem_iface(wpa_s, frame);
7771
7772 pos = os_strchr(pos, ' ');
7773 if (pos == NULL)
7774 return -1;
7775 pos++;
7776
7777 if (*pos == '*') {
7778 wpabuf_free(wpa_s->vendor_elem[frame]);
7779 wpa_s->vendor_elem[frame] = NULL;
7780 wpas_ctrl_vendor_elem_update(wpa_s);
7781 return 0;
7782 }
7783
7784 if (wpa_s->vendor_elem[frame] == NULL)
7785 return -1;
7786
7787 len = os_strlen(pos);
7788 if (len == 0)
7789 return 0;
7790 if (len & 1)
7791 return -1;
7792 len /= 2;
7793
7794 buf = os_malloc(len);
7795 if (buf == NULL)
7796 return -1;
7797
7798 if (hexstr2bin(pos, buf, len) < 0) {
7799 os_free(buf);
7800 return -1;
7801 }
7802
7803 if (ieee802_11_parse_elems(buf, len, &elems, 0) == ParseFailed) {
7804 os_free(buf);
7805 return -1;
7806 }
7807
7808 ie = wpabuf_mhead_u8(wpa_s->vendor_elem[frame]);
7809 end = ie + wpabuf_len(wpa_s->vendor_elem[frame]);
7810
7811 for (; ie + 1 < end; ie += 2 + ie[1]) {
7812 if (ie + len > end)
7813 break;
7814 if (os_memcmp(ie, buf, len) != 0)
7815 continue;
7816
7817 if (wpabuf_len(wpa_s->vendor_elem[frame]) == len) {
7818 wpabuf_free(wpa_s->vendor_elem[frame]);
7819 wpa_s->vendor_elem[frame] = NULL;
7820 } else {
7821 os_memmove(ie, ie + len,
45d85015 7822 end - (ie + len));
86bd36f0
JM		 7823 wpa_s->vendor_elem[frame]->used -= len;
7824 }
7825 os_free(buf);
7826 wpas_ctrl_vendor_elem_update(wpa_s);
7827 return 0;
7828 }
7829
7830 os_free(buf);
7831
7832 return -1;
7833}
7834
7835
f4b8bfae
AK		 7836static void wpas_ctrl_neighbor_rep_cb(void *ctx, struct wpabuf *neighbor_rep)
7837{
7838 struct wpa_supplicant *wpa_s = ctx;
7839
7840 if (neighbor_rep) {
7841 wpa_msg_ctrl(wpa_s, MSG_INFO, RRM_EVENT_NEIGHBOR_REP_RXED
7842 "length=%u",
7843 (unsigned int) wpabuf_len(neighbor_rep));
7844 wpabuf_free(neighbor_rep);
7845 } else {
7846 wpa_msg_ctrl(wpa_s, MSG_INFO, RRM_EVENT_NEIGHBOR_REP_FAILED);
7847 }
7848}
7849
7850
4c4b2305
AK		 7851static int wpas_ctrl_iface_send_neigbor_rep(struct wpa_supplicant *wpa_s,
7852 char *cmd)
f4b8bfae 7853{
4c4b2305
AK		 7854 struct wpa_ssid ssid;
7855 struct wpa_ssid *ssid_p = NULL;
7856 int ret = 0;
7857
7858 if (os_strncmp(cmd, " ssid=", 6) == 0) {
7859 ssid.ssid_len = os_strlen(cmd + 6);
d9d1b952 7860 if (ssid.ssid_len > SSID_MAX_LEN)
4c4b2305
AK		 7861 return -1;
7862 ssid.ssid = (u8 *) (cmd + 6);
7863 ssid_p = &ssid;
7864 }
7865
7866 ret = wpas_rrm_send_neighbor_rep_request(wpa_s, ssid_p,
7867 wpas_ctrl_neighbor_rep_cb,
7868 wpa_s);
7869
7870 return ret;
f4b8bfae
AK		 7871}
7872
7873
65d9a5e2
JM		 7874static int wpas_ctrl_iface_erp_flush(struct wpa_supplicant *wpa_s)
7875{
7876 eapol_sm_erp_flush(wpa_s->eapol);
7877 return 0;
7878}
7879
7880
fb375883
IP		 7881static int wpas_ctrl_iface_mac_rand_scan(struct wpa_supplicant *wpa_s,
7882 char *cmd)
7883{
7884 char *token, *context = NULL;
7885 unsigned int enable = ~0, type = 0;
7886 u8 _addr[ETH_ALEN], _mask[ETH_ALEN];
7887 u8 *addr = NULL, *mask = NULL;
7888
7889 while ((token = str_token(cmd, " ", &context))) {
7890 if (os_strcasecmp(token, "scan") == 0) {
7891 type |= MAC_ADDR_RAND_SCAN;
7892 } else if (os_strcasecmp(token, "sched") == 0) {
7893 type |= MAC_ADDR_RAND_SCHED_SCAN;
7894 } else if (os_strcasecmp(token, "pno") == 0) {
7895 type |= MAC_ADDR_RAND_PNO;
7896 } else if (os_strcasecmp(token, "all") == 0) {
7897 type = wpa_s->mac_addr_rand_supported;
7898 } else if (os_strncasecmp(token, "enable=", 7) == 0) {
7899 enable = atoi(token + 7);
7900 } else if (os_strncasecmp(token, "addr=", 5) == 0) {
7901 addr = _addr;
7902 if (hwaddr_aton(token + 5, addr)) {
7903 wpa_printf(MSG_INFO,
7904 "CTRL: Invalid MAC address: %s",
7905 token);
7906 return -1;
7907 }
7908 } else if (os_strncasecmp(token, "mask=", 5) == 0) {
7909 mask = _mask;
7910 if (hwaddr_aton(token + 5, mask)) {
7911 wpa_printf(MSG_INFO,
7912 "CTRL: Invalid MAC address mask: %s",
7913 token);
7914 return -1;
7915 }
7916 } else {
7917 wpa_printf(MSG_INFO,
7918 "CTRL: Invalid MAC_RAND_SCAN parameter: %s",
7919 token);
7920 return -1;
7921 }
7922 }
7923
7924 if (!type) {
7925 wpa_printf(MSG_INFO, "CTRL: MAC_RAND_SCAN no type specified");
7926 return -1;
7927 }
7928
7929 if ((wpa_s->mac_addr_rand_supported & type) != type) {
7930 wpa_printf(MSG_INFO,
7931 "CTRL: MAC_RAND_SCAN types=%u != supported=%u",
7932 type, wpa_s->mac_addr_rand_supported);
7933 return -1;
7934 }
7935
7936 if (enable > 1) {
7937 wpa_printf(MSG_INFO,
7938 "CTRL: MAC_RAND_SCAN enable=<0/1> not specified");
7939 return -1;
7940 }
7941
7942 if (!enable) {
7943 wpas_mac_addr_rand_scan_clear(wpa_s, type);
7944 if (wpa_s->pno) {
7945 if (type & MAC_ADDR_RAND_PNO) {
7946 wpas_stop_pno(wpa_s);
7947 wpas_start_pno(wpa_s);
7948 }
7949 } else if (wpa_s->sched_scanning &&
7950 (type & MAC_ADDR_RAND_SCHED_SCAN)) {
7951 /* simulate timeout to restart the sched scan */
7952 wpa_s->sched_scan_timed_out = 1;
7953 wpa_s->prev_sched_ssid = NULL;
7954 wpa_supplicant_cancel_sched_scan(wpa_s);
7955 }
7956 return 0;
7957 }
7958
7959 if ((addr && !mask) || (!addr && mask)) {
7960 wpa_printf(MSG_INFO,
7961 "CTRL: MAC_RAND_SCAN invalid addr/mask combination");
7962 return -1;
7963 }
7964
7965 if (addr && mask && (!(mask[0] & 0x01) || (addr[0] & 0x01))) {
7966 wpa_printf(MSG_INFO,
7967 "CTRL: MAC_RAND_SCAN cannot allow multicast address");
7968 return -1;
7969 }
7970
7971 if (type & MAC_ADDR_RAND_SCAN) {
7972 wpas_mac_addr_rand_scan_set(wpa_s, MAC_ADDR_RAND_SCAN,
7973 addr, mask);
7974 }
7975
7976 if (type & MAC_ADDR_RAND_SCHED_SCAN) {
7977 wpas_mac_addr_rand_scan_set(wpa_s, MAC_ADDR_RAND_SCHED_SCAN,
7978 addr, mask);
7979
7980 if (wpa_s->sched_scanning && !wpa_s->pno) {
7981 /* simulate timeout to restart the sched scan */
7982 wpa_s->sched_scan_timed_out = 1;
7983 wpa_s->prev_sched_ssid = NULL;
7984 wpa_supplicant_cancel_sched_scan(wpa_s);
7985 }
7986 }
7987
7988 if (type & MAC_ADDR_RAND_PNO) {
7989 wpas_mac_addr_rand_scan_set(wpa_s, MAC_ADDR_RAND_PNO,
7990 addr, mask);
7991 if (wpa_s->pno) {
7992 wpas_stop_pno(wpa_s);
7993 wpas_start_pno(wpa_s);
7994 }
7995 }
7996
7997 return 0;
7998}
7999
8000
6fc6879b
JM		 8001char * wpa_supplicant_ctrl_iface_process(struct wpa_supplicant *wpa_s,
8002 char *buf, size_t *resp_len)
8003{
8004 char *reply;
b563b388 8005 const int reply_size = 4096;
6fc6879b
JM		 8006 int reply_len;
8007
8008 if (os_strncmp(buf, WPA_CTRL_RSP, os_strlen(WPA_CTRL_RSP)) == 0 ||
d31b5ac7
JM		 8009 os_strncmp(buf, "SET_NETWORK ", 12) == 0) {
8010 if (wpa_debug_show_keys)
8011 wpa_dbg(wpa_s, MSG_DEBUG,
8012 "Control interface command '%s'", buf);
8013 else
8014 wpa_dbg(wpa_s, MSG_DEBUG,
8015 "Control interface command '%s [REMOVED]'",
8016 os_strncmp(buf, WPA_CTRL_RSP,
8017 os_strlen(WPA_CTRL_RSP)) == 0 ?
8018 WPA_CTRL_RSP : "SET_NETWORK");
8019 } else if (os_strncmp(buf, "WPS_NFC_TAG_READ", 16) == 0 ||
679f2e7c 8020 os_strncmp(buf, "NFC_REPORT_HANDOVER", 19) == 0) {
6fc6879b
JM		 8021 wpa_hexdump_ascii_key(MSG_DEBUG, "RX ctrl_iface",
8022 (const u8 *) buf, os_strlen(buf));
8023 } else {
235f69fc
JM		 8024 int level = MSG_DEBUG;
8025 if (os_strcmp(buf, "PING") == 0)
8026 level = MSG_EXCESSIVE;
b470b2bf 8027 wpa_dbg(wpa_s, level, "Control interface command '%s'", buf);
6fc6879b
JM		 8028 }
8029
8030 reply = os_malloc(reply_size);
8031 if (reply == NULL) {
8032 *resp_len = 1;
8033 return NULL;
8034 }
8035
8036 os_memcpy(reply, "OK\n", 3);
8037 reply_len = 3;
8038
8039 if (os_strcmp(buf, "PING") == 0) {
8040 os_memcpy(reply, "PONG\n", 5);
8041 reply_len = 5;
0eed2a8d
JD		 8042 } else if (os_strcmp(buf, "IFNAME") == 0) {
8043 reply_len = os_strlen(wpa_s->ifname);
8044 os_memcpy(reply, wpa_s->ifname, reply_len);
ac6912b5
BG		 8045 } else if (os_strncmp(buf, "RELOG", 5) == 0) {
8046 if (wpa_debug_reopen_file() < 0)
8047 reply_len = -1;
77895cd9
JM		 8048 } else if (os_strncmp(buf, "NOTE ", 5) == 0) {
8049 wpa_printf(MSG_INFO, "NOTE: %s", buf + 5);
6fc6879b
JM		 8050 } else if (os_strcmp(buf, "MIB") == 0) {
8051 reply_len = wpa_sm_get_mib(wpa_s->wpa, reply, reply_size);
8052 if (reply_len >= 0) {
5ac73acf
JM		 8053 reply_len += eapol_sm_get_mib(wpa_s->eapol,
8054 reply + reply_len,
8055 reply_size - reply_len);
6fc6879b
JM		 8056 }
8057 } else if (os_strncmp(buf, "STATUS", 6) == 0) {
8058 reply_len = wpa_supplicant_ctrl_iface_status(
8059 wpa_s, buf + 6, reply, reply_size);
8060 } else if (os_strcmp(buf, "PMKSA") == 0) {
540264a7
JM		 8061 reply_len = wpa_sm_pmksa_cache_list(wpa_s->wpa, reply,
8062 reply_size);
79e2b1cc
AK		 8063 } else if (os_strcmp(buf, "PMKSA_FLUSH") == 0) {
8064 wpa_sm_pmksa_cache_flush(wpa_s->wpa, NULL);
6fc6879b
JM		 8065 } else if (os_strncmp(buf, "SET ", 4) == 0) {
8066 if (wpa_supplicant_ctrl_iface_set(wpa_s, buf + 4))
8067 reply_len = -1;
10263dc2
OO		 8068 } else if (os_strncmp(buf, "DUMP", 4) == 0) {
8069 reply_len = wpa_config_dump_values(wpa_s->conf,
8070 reply, reply_size);
acec8d32
JM		 8071 } else if (os_strncmp(buf, "GET ", 4) == 0) {
8072 reply_len = wpa_supplicant_ctrl_iface_get(wpa_s, buf + 4,
8073 reply, reply_size);
6fc6879b
JM		 8074 } else if (os_strcmp(buf, "LOGON") == 0) {
8075 eapol_sm_notify_logoff(wpa_s->eapol, FALSE);
8076 } else if (os_strcmp(buf, "LOGOFF") == 0) {
8077 eapol_sm_notify_logoff(wpa_s->eapol, TRUE);
8078 } else if (os_strcmp(buf, "REASSOCIATE") == 0) {
8401a6b0
JM		 8079 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED)
8080 reply_len = -1;
9796a86c
JM		 8081 else
8082 wpas_request_connection(wpa_s);
0f44ec8e
PQ		 8083 } else if (os_strcmp(buf, "REATTACH") == 0) {
8084 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED ||
8085 !wpa_s->current_ssid)
8086 reply_len = -1;
8087 else {
8088 wpa_s->reattach = 1;
8089 wpas_request_connection(wpa_s);
8090 }
6fc6879b 8091 } else if (os_strcmp(buf, "RECONNECT") == 0) {
8401a6b0
JM		 8092 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED)
8093 reply_len = -1;
9796a86c
JM		 8094 else if (wpa_s->disconnected)
8095 wpas_request_connection(wpa_s);
ec717917 8096#ifdef IEEE8021X_EAPOL
6fc6879b
JM		 8097 } else if (os_strncmp(buf, "PREAUTH ", 8) == 0) {
8098 if (wpa_supplicant_ctrl_iface_preauth(wpa_s, buf + 8))
8099 reply_len = -1;
ec717917 8100#endif /* IEEE8021X_EAPOL */
6fc6879b
JM		 8101#ifdef CONFIG_PEERKEY
8102 } else if (os_strncmp(buf, "STKSTART ", 9) == 0) {
8103 if (wpa_supplicant_ctrl_iface_stkstart(wpa_s, buf + 9))
8104 reply_len = -1;
8105#endif /* CONFIG_PEERKEY */
8106#ifdef CONFIG_IEEE80211R
8107 } else if (os_strncmp(buf, "FT_DS ", 6) == 0) {
8108 if (wpa_supplicant_ctrl_iface_ft_ds(wpa_s, buf + 6))
8109 reply_len = -1;
8110#endif /* CONFIG_IEEE80211R */
fcc60db4
JM		 8111#ifdef CONFIG_WPS
8112 } else if (os_strcmp(buf, "WPS_PBC") == 0) {
3152ff42
CWY		 8113 int res = wpa_supplicant_ctrl_iface_wps_pbc(wpa_s, NULL);
8114 if (res == -2) {
8115 os_memcpy(reply, "FAIL-PBC-OVERLAP\n", 17);
8116 reply_len = 17;
8117 } else if (res)
fcc60db4
JM		 8118 reply_len = -1;
8119 } else if (os_strncmp(buf, "WPS_PBC ", 8) == 0) {
3152ff42
CWY		 8120 int res = wpa_supplicant_ctrl_iface_wps_pbc(wpa_s, buf + 8);
8121 if (res == -2) {
8122 os_memcpy(reply, "FAIL-PBC-OVERLAP\n", 17);
8123 reply_len = 17;
8124 } else if (res)
fcc60db4
JM		 8125 reply_len = -1;
8126 } else if (os_strncmp(buf, "WPS_PIN ", 8) == 0) {
8127 reply_len = wpa_supplicant_ctrl_iface_wps_pin(wpa_s, buf + 8,
8128 reply,
8129 reply_size);
3981cb3c
JM		 8130 } else if (os_strncmp(buf, "WPS_CHECK_PIN ", 14) == 0) {
8131 reply_len = wpa_supplicant_ctrl_iface_wps_check_pin(
8132 wpa_s, buf + 14, reply, reply_size);
2f9929ff
AC		 8133 } else if (os_strcmp(buf, "WPS_CANCEL") == 0) {
8134 if (wpas_wps_cancel(wpa_s))
8135 reply_len = -1;
71892384 8136#ifdef CONFIG_WPS_NFC
3f2c8ba6
JM		 8137 } else if (os_strcmp(buf, "WPS_NFC") == 0) {
8138 if (wpa_supplicant_ctrl_iface_wps_nfc(wpa_s, NULL))
8139 reply_len = -1;
8140 } else if (os_strncmp(buf, "WPS_NFC ", 8) == 0) {
8141 if (wpa_supplicant_ctrl_iface_wps_nfc(wpa_s, buf + 8))
8142 reply_len = -1;
bbf41865
JM		 8143 } else if (os_strncmp(buf, "WPS_NFC_CONFIG_TOKEN ", 21) == 0) {
8144 reply_len = wpa_supplicant_ctrl_iface_wps_nfc_config_token(
8145 wpa_s, buf + 21, reply, reply_size);
3f2c8ba6
JM		 8146 } else if (os_strncmp(buf, "WPS_NFC_TOKEN ", 14) == 0) {
8147 reply_len = wpa_supplicant_ctrl_iface_wps_nfc_token(
8148 wpa_s, buf + 14, reply, reply_size);
d7645d23
JM		 8149 } else if (os_strncmp(buf, "WPS_NFC_TAG_READ ", 17) == 0) {
8150 if (wpa_supplicant_ctrl_iface_wps_nfc_tag_read(wpa_s,
8151 buf + 17))
8152 reply_len = -1;
e65552dd
JM		 8153 } else if (os_strncmp(buf, "NFC_GET_HANDOVER_REQ ", 21) == 0) {
8154 reply_len = wpas_ctrl_nfc_get_handover_req(
8155 wpa_s, buf + 21, reply, reply_size);
8156 } else if (os_strncmp(buf, "NFC_GET_HANDOVER_SEL ", 21) == 0) {
8157 reply_len = wpas_ctrl_nfc_get_handover_sel(
8158 wpa_s, buf + 21, reply, reply_size);
e4758827
JM		 8159 } else if (os_strncmp(buf, "NFC_REPORT_HANDOVER ", 20) == 0) {
8160 if (wpas_ctrl_nfc_report_handover(wpa_s, buf + 20))
8161 reply_len = -1;
71892384 8162#endif /* CONFIG_WPS_NFC */
fcc60db4
JM		 8163 } else if (os_strncmp(buf, "WPS_REG ", 8) == 0) {
8164 if (wpa_supplicant_ctrl_iface_wps_reg(wpa_s, buf + 8))
8165 reply_len = -1;
70d84f11
JM		 8166#ifdef CONFIG_AP
8167 } else if (os_strncmp(buf, "WPS_AP_PIN ", 11) == 0) {
8168 reply_len = wpa_supplicant_ctrl_iface_wps_ap_pin(
8169 wpa_s, buf + 11, reply, reply_size);
8170#endif /* CONFIG_AP */
72df2f5f 8171#ifdef CONFIG_WPS_ER
e9bcfebf 8172 } else if (os_strcmp(buf, "WPS_ER_START") == 0) {
08486685
JM		 8173 if (wpas_wps_er_start(wpa_s, NULL))
8174 reply_len = -1;
8175 } else if (os_strncmp(buf, "WPS_ER_START ", 13) == 0) {
8176 if (wpas_wps_er_start(wpa_s, buf + 13))
e9bcfebf
JM		 8177 reply_len = -1;
8178 } else if (os_strcmp(buf, "WPS_ER_STOP") == 0) {
f77cedc1 8179 wpas_wps_er_stop(wpa_s);
72df2f5f
JM		 8180 } else if (os_strncmp(buf, "WPS_ER_PIN ", 11) == 0) {
8181 if (wpa_supplicant_ctrl_iface_wps_er_pin(wpa_s, buf + 11))
8182 reply_len = -1;
564cd7fa 8183 } else if (os_strncmp(buf, "WPS_ER_PBC ", 11) == 0) {
ed159ad4
JM		 8184 int ret = wpas_wps_er_pbc(wpa_s, buf + 11);
8185 if (ret == -2) {
8186 os_memcpy(reply, "FAIL-PBC-OVERLAP\n", 17);
8187 reply_len = 17;
8188 } else if (ret == -3) {
8189 os_memcpy(reply, "FAIL-UNKNOWN-UUID\n", 18);
8190 reply_len = 18;
8191 } else if (ret == -4) {
8192 os_memcpy(reply, "FAIL-NO-AP-SETTINGS\n", 20);
8193 reply_len = 20;
8194 } else if (ret)
564cd7fa 8195 reply_len = -1;
e64dcfd5
JM		 8196 } else if (os_strncmp(buf, "WPS_ER_LEARN ", 13) == 0) {
8197 if (wpa_supplicant_ctrl_iface_wps_er_learn(wpa_s, buf + 13))
8198 reply_len = -1;
ef10f473
JM		 8199 } else if (os_strncmp(buf, "WPS_ER_SET_CONFIG ", 18) == 0) {
8200 if (wpa_supplicant_ctrl_iface_wps_er_set_config(wpa_s,
8201 buf + 18))
8202 reply_len = -1;
7d6640a6
JM		 8203 } else if (os_strncmp(buf, "WPS_ER_CONFIG ", 14) == 0) {
8204 if (wpa_supplicant_ctrl_iface_wps_er_config(wpa_s, buf + 14))
8205 reply_len = -1;
1cea09a9
JM		 8206#ifdef CONFIG_WPS_NFC
8207 } else if (os_strncmp(buf, "WPS_ER_NFC_CONFIG_TOKEN ", 24) == 0) {
8208 reply_len = wpa_supplicant_ctrl_iface_wps_er_nfc_config_token(
8209 wpa_s, buf + 24, reply, reply_size);
8210#endif /* CONFIG_WPS_NFC */
72df2f5f 8211#endif /* CONFIG_WPS_ER */
fcc60db4 8212#endif /* CONFIG_WPS */
11ef8d35
JM		 8213#ifdef CONFIG_IBSS_RSN
8214 } else if (os_strncmp(buf, "IBSS_RSN ", 9) == 0) {
8215 if (wpa_supplicant_ctrl_iface_ibss_rsn(wpa_s, buf + 9))
8216 reply_len = -1;
8217#endif /* CONFIG_IBSS_RSN */
603a3f34 8218#ifdef CONFIG_MESH
5b78493f
MH		 8219 } else if (os_strncmp(buf, "MESH_INTERFACE_ADD ", 19) == 0) {
8220 reply_len = wpa_supplicant_ctrl_iface_mesh_interface_add(
8221 wpa_s, buf + 19, reply, reply_size);
8222 } else if (os_strcmp(buf, "MESH_INTERFACE_ADD") == 0) {
8223 reply_len = wpa_supplicant_ctrl_iface_mesh_interface_add(
8224 wpa_s, "", reply, reply_size);
603a3f34
JL		 8225 } else if (os_strncmp(buf, "MESH_GROUP_ADD ", 15) == 0) {
8226 if (wpa_supplicant_ctrl_iface_mesh_group_add(wpa_s, buf + 15))
8227 reply_len = -1;
8228 } else if (os_strncmp(buf, "MESH_GROUP_REMOVE ", 18) == 0) {
8229 if (wpa_supplicant_ctrl_iface_mesh_group_remove(wpa_s,
8230 buf + 18))
8231 reply_len = -1;
8232#endif /* CONFIG_MESH */
b563b388
JM		 8233#ifdef CONFIG_P2P
8234 } else if (os_strncmp(buf, "P2P_FIND ", 9) == 0) {
51775096 8235 if (p2p_ctrl_find(wpa_s, buf + 8))
b563b388
JM		 8236 reply_len = -1;
8237 } else if (os_strcmp(buf, "P2P_FIND") == 0) {
8238 if (p2p_ctrl_find(wpa_s, ""))
8239 reply_len = -1;
8240 } else if (os_strcmp(buf, "P2P_STOP_FIND") == 0) {
8241 wpas_p2p_stop_find(wpa_s);
f309c18e
KV		 8242 } else if (os_strncmp(buf, "P2P_ASP_PROVISION ", 18) == 0) {
8243 if (p2p_ctrl_asp_provision(wpa_s, buf + 18))
8244 reply_len = -1;
8245 } else if (os_strncmp(buf, "P2P_ASP_PROVISION_RESP ", 23) == 0) {
8246 if (p2p_ctrl_asp_provision_resp(wpa_s, buf + 23))
8247 reply_len = -1;
b563b388
JM		 8248 } else if (os_strncmp(buf, "P2P_CONNECT ", 12) == 0) {
8249 reply_len = p2p_ctrl_connect(wpa_s, buf + 12, reply,
8250 reply_size);
8251 } else if (os_strncmp(buf, "P2P_LISTEN ", 11) == 0) {
8252 if (p2p_ctrl_listen(wpa_s, buf + 11))
8253 reply_len = -1;
8254 } else if (os_strcmp(buf, "P2P_LISTEN") == 0) {
8255 if (p2p_ctrl_listen(wpa_s, ""))
8256 reply_len = -1;
8257 } else if (os_strncmp(buf, "P2P_GROUP_REMOVE ", 17) == 0) {
8258 if (wpas_p2p_group_remove(wpa_s, buf + 17))
8259 reply_len = -1;
8260 } else if (os_strcmp(buf, "P2P_GROUP_ADD") == 0) {
38dcc86c 8261 if (p2p_ctrl_group_add(wpa_s, ""))
b563b388
JM		 8262 reply_len = -1;
8263 } else if (os_strncmp(buf, "P2P_GROUP_ADD ", 14) == 0) {
8264 if (p2p_ctrl_group_add(wpa_s, buf + 14))
8265 reply_len = -1;
8266 } else if (os_strncmp(buf, "P2P_PROV_DISC ", 14) == 0) {
8267 if (p2p_ctrl_prov_disc(wpa_s, buf + 14))
8268 reply_len = -1;
8269 } else if (os_strcmp(buf, "P2P_GET_PASSPHRASE") == 0) {
8270 reply_len = p2p_get_passphrase(wpa_s, reply, reply_size);
8271 } else if (os_strncmp(buf, "P2P_SERV_DISC_REQ ", 18) == 0) {
8272 reply_len = p2p_ctrl_serv_disc_req(wpa_s, buf + 18, reply,
8273 reply_size);
8274 } else if (os_strncmp(buf, "P2P_SERV_DISC_CANCEL_REQ ", 25) == 0) {
8275 if (p2p_ctrl_serv_disc_cancel_req(wpa_s, buf + 25) < 0)
8276 reply_len = -1;
8277 } else if (os_strncmp(buf, "P2P_SERV_DISC_RESP ", 19) == 0) {
8278 if (p2p_ctrl_serv_disc_resp(wpa_s, buf + 19) < 0)
8279 reply_len = -1;
8280 } else if (os_strcmp(buf, "P2P_SERVICE_UPDATE") == 0) {
8281 wpas_p2p_sd_service_update(wpa_s);
8282 } else if (os_strncmp(buf, "P2P_SERV_DISC_EXTERNAL ", 23) == 0) {
8283 if (p2p_ctrl_serv_disc_external(wpa_s, buf + 23) < 0)
8284 reply_len = -1;
8285 } else if (os_strcmp(buf, "P2P_SERVICE_FLUSH") == 0) {
8286 wpas_p2p_service_flush(wpa_s);
8287 } else if (os_strncmp(buf, "P2P_SERVICE_ADD ", 16) == 0) {
8288 if (p2p_ctrl_service_add(wpa_s, buf + 16) < 0)
8289 reply_len = -1;
8290 } else if (os_strncmp(buf, "P2P_SERVICE_DEL ", 16) == 0) {
8291 if (p2p_ctrl_service_del(wpa_s, buf + 16) < 0)
8292 reply_len = -1;
ae9d45f3
KV		 8293 } else if (os_strncmp(buf, "P2P_SERVICE_REP ", 16) == 0) {
8294 if (p2p_ctrl_service_replace(wpa_s, buf + 16) < 0)
8295 reply_len = -1;
b563b388
JM		 8296 } else if (os_strncmp(buf, "P2P_REJECT ", 11) == 0) {
8297 if (p2p_ctrl_reject(wpa_s, buf + 11) < 0)
8298 reply_len = -1;
8299 } else if (os_strncmp(buf, "P2P_INVITE ", 11) == 0) {
8300 if (p2p_ctrl_invite(wpa_s, buf + 11) < 0)
8301 reply_len = -1;
8302 } else if (os_strncmp(buf, "P2P_PEER ", 9) == 0) {
8303 reply_len = p2p_ctrl_peer(wpa_s, buf + 9, reply,
8304 reply_size);
8305 } else if (os_strncmp(buf, "P2P_SET ", 8) == 0) {
8306 if (p2p_ctrl_set(wpa_s, buf + 8) < 0)
8307 reply_len = -1;
8308 } else if (os_strcmp(buf, "P2P_FLUSH") == 0) {
acb54643 8309 p2p_ctrl_flush(wpa_s);
9d562b79
SS		 8310 } else if (os_strncmp(buf, "P2P_UNAUTHORIZE ", 16) == 0) {
8311 if (wpas_p2p_unauthorize(wpa_s, buf + 16) < 0)
8312 reply_len = -1;
59eba7a2
JM		 8313 } else if (os_strcmp(buf, "P2P_CANCEL") == 0) {
8314 if (wpas_p2p_cancel(wpa_s))
8315 reply_len = -1;
b563b388
JM		 8316 } else if (os_strncmp(buf, "P2P_PRESENCE_REQ ", 17) == 0) {
8317 if (p2p_ctrl_presence_req(wpa_s, buf + 17) < 0)
8318 reply_len = -1;
8319 } else if (os_strcmp(buf, "P2P_PRESENCE_REQ") == 0) {
8320 if (p2p_ctrl_presence_req(wpa_s, "") < 0)
8321 reply_len = -1;
8322 } else if (os_strncmp(buf, "P2P_EXT_LISTEN ", 15) == 0) {
8323 if (p2p_ctrl_ext_listen(wpa_s, buf + 15) < 0)
8324 reply_len = -1;
8325 } else if (os_strcmp(buf, "P2P_EXT_LISTEN") == 0) {
8326 if (p2p_ctrl_ext_listen(wpa_s, "") < 0)
8327 reply_len = -1;
f2c56602
JM		 8328 } else if (os_strncmp(buf, "P2P_REMOVE_CLIENT ", 18) == 0) {
8329 if (p2p_ctrl_remove_client(wpa_s, buf + 18) < 0)
8330 reply_len = -1;
b563b388 8331#endif /* CONFIG_P2P */
9675ce35
JM		 8332#ifdef CONFIG_WIFI_DISPLAY
8333 } else if (os_strncmp(buf, "WFD_SUBELEM_SET ", 16) == 0) {
8334 if (wifi_display_subelem_set(wpa_s->global, buf + 16) < 0)
8335 reply_len = -1;
8336 } else if (os_strncmp(buf, "WFD_SUBELEM_GET ", 16) == 0) {
8337 reply_len = wifi_display_subelem_get(wpa_s->global, buf + 16,
8338 reply, reply_size);
8339#endif /* CONFIG_WIFI_DISPLAY */
afc064fe
JM		 8340#ifdef CONFIG_INTERWORKING
8341 } else if (os_strcmp(buf, "FETCH_ANQP") == 0) {
8342 if (interworking_fetch_anqp(wpa_s) < 0)
8343 reply_len = -1;
8344 } else if (os_strcmp(buf, "STOP_FETCH_ANQP") == 0) {
8345 interworking_stop_fetch_anqp(wpa_s);
356d1488
JM		 8346 } else if (os_strcmp(buf, "INTERWORKING_SELECT") == 0) {
8347 if (ctrl_interworking_select(wpa_s, NULL) < 0)
8348 reply_len = -1;
8349 } else if (os_strncmp(buf, "INTERWORKING_SELECT ", 20) == 0) {
8350 if (ctrl_interworking_select(wpa_s, buf + 20) < 0)
b02fe7ff
JM		 8351 reply_len = -1;
8352 } else if (os_strncmp(buf, "INTERWORKING_CONNECT ", 21) == 0) {
f91a512f 8353 if (ctrl_interworking_connect(wpa_s, buf + 21, 0) < 0)
b02fe7ff 8354 reply_len = -1;
f91a512f
JM		 8355 } else if (os_strncmp(buf, "INTERWORKING_ADD_NETWORK ", 25) == 0) {
8356 int id;
8357
8358 id = ctrl_interworking_connect(wpa_s, buf + 25, 1);
8359 if (id < 0)
8360 reply_len = -1;
8361 else {
8362 reply_len = os_snprintf(reply, reply_size, "%d\n", id);
8363 if (os_snprintf_error(reply_size, reply_len))
8364 reply_len = -1;
8365 }
afc064fe
JM		 8366 } else if (os_strncmp(buf, "ANQP_GET ", 9) == 0) {
8367 if (get_anqp(wpa_s, buf + 9) < 0)
8368 reply_len = -1;
b1f12296
JM		 8369 } else if (os_strncmp(buf, "GAS_REQUEST ", 12) == 0) {
8370 if (gas_request(wpa_s, buf + 12) < 0)
8371 reply_len = -1;
8372 } else if (os_strncmp(buf, "GAS_RESPONSE_GET ", 17) == 0) {
8373 reply_len = gas_response_get(wpa_s, buf + 17, reply,
8374 reply_size);
afc064fe 8375#endif /* CONFIG_INTERWORKING */
a8918e86
JK		 8376#ifdef CONFIG_HS20
8377 } else if (os_strncmp(buf, "HS20_ANQP_GET ", 14) == 0) {
8378 if (get_hs20_anqp(wpa_s, buf + 14) < 0)
8379 reply_len = -1;
8380 } else if (os_strncmp(buf, "HS20_GET_NAI_HOME_REALM_LIST ", 29) == 0) {
8381 if (hs20_get_nai_home_realm_list(wpa_s, buf + 29) < 0)
8382 reply_len = -1;
184e110c
JM		 8383 } else if (os_strncmp(buf, "HS20_ICON_REQUEST ", 18) == 0) {
8384 if (hs20_icon_request(wpa_s, buf + 18) < 0)
8385 reply_len = -1;
b572df86
JM		 8386 } else if (os_strcmp(buf, "FETCH_OSU") == 0) {
8387 if (hs20_fetch_osu(wpa_s) < 0)
8388 reply_len = -1;
8389 } else if (os_strcmp(buf, "CANCEL_FETCH_OSU") == 0) {
8390 hs20_cancel_fetch_osu(wpa_s);
a8918e86 8391#endif /* CONFIG_HS20 */
6fc6879b
JM		 8392 } else if (os_strncmp(buf, WPA_CTRL_RSP, os_strlen(WPA_CTRL_RSP)) == 0)
8393 {
8394 if (wpa_supplicant_ctrl_iface_ctrl_rsp(
8395 wpa_s, buf + os_strlen(WPA_CTRL_RSP)))
8396 reply_len = -1;
bceb8431
JM		 8397 else {
8398 /*
8399 * Notify response from timeout to allow the control
8400 * interface response to be sent first.
8401 */
8402 eloop_register_timeout(0, 0, wpas_ctrl_eapol_response,
8403 wpa_s, NULL);
8404 }
6fc6879b
JM		 8405 } else if (os_strcmp(buf, "RECONFIGURE") == 0) {
8406 if (wpa_supplicant_reload_configuration(wpa_s))
8407 reply_len = -1;
8408 } else if (os_strcmp(buf, "TERMINATE") == 0) {
1a1bf008 8409 wpa_supplicant_terminate_proc(wpa_s->global);
6fc6879b
JM		 8410 } else if (os_strncmp(buf, "BSSID ", 6) == 0) {
8411 if (wpa_supplicant_ctrl_iface_bssid(wpa_s, buf + 6))
8412 reply_len = -1;
9aa10e2b
DS		 8413 } else if (os_strncmp(buf, "BLACKLIST", 9) == 0) {
8414 reply_len = wpa_supplicant_ctrl_iface_blacklist(
8415 wpa_s, buf + 9, reply, reply_size);
0597a5b5
DS		 8416 } else if (os_strncmp(buf, "LOG_LEVEL", 9) == 0) {
8417 reply_len = wpa_supplicant_ctrl_iface_log_level(
8418 wpa_s, buf + 9, reply, reply_size);
90903a77
VD		 8419 } else if (os_strncmp(buf, "LIST_NETWORKS ", 14) == 0) {
8420 reply_len = wpa_supplicant_ctrl_iface_list_networks(
8421 wpa_s, buf + 14, reply, reply_size);
6fc6879b
JM		 8422 } else if (os_strcmp(buf, "LIST_NETWORKS") == 0) {
8423 reply_len = wpa_supplicant_ctrl_iface_list_networks(
90903a77 8424 wpa_s, NULL, reply, reply_size);
6fc6879b 8425 } else if (os_strcmp(buf, "DISCONNECT") == 0) {
83df8149
JM		 8426#ifdef CONFIG_SME
8427 wpa_s->sme.prev_bssid_set = 0;
8428#endif /* CONFIG_SME */
6fc6879b
JM		 8429 wpa_s->reassociate = 0;
8430 wpa_s->disconnected = 1;
6ad9c911 8431 wpa_supplicant_cancel_sched_scan(wpa_s);
d7ded758 8432 wpa_supplicant_cancel_scan(wpa_s);
cf4783e3
JM		 8433 wpa_supplicant_deauthenticate(wpa_s,
8434 WLAN_REASON_DEAUTH_LEAVING);
9bd566a3 8435 eloop_cancel_timeout(wpas_network_reenabled, wpa_s, NULL);
fee52342
JM		 8436 } else if (os_strcmp(buf, "SCAN") == 0) {
8437 wpas_ctrl_scan(wpa_s, NULL, reply, reply_size, &reply_len);
8438 } else if (os_strncmp(buf, "SCAN ", 5) == 0) {
8439 wpas_ctrl_scan(wpa_s, buf + 5, reply, reply_size, &reply_len);
6fc6879b
JM		 8440 } else if (os_strcmp(buf, "SCAN_RESULTS") == 0) {
8441 reply_len = wpa_supplicant_ctrl_iface_scan_results(
8442 wpa_s, reply, reply_size);
8443 } else if (os_strncmp(buf, "SELECT_NETWORK ", 15) == 0) {
8444 if (wpa_supplicant_ctrl_iface_select_network(wpa_s, buf + 15))
8445 reply_len = -1;
8446 } else if (os_strncmp(buf, "ENABLE_NETWORK ", 15) == 0) {
8447 if (wpa_supplicant_ctrl_iface_enable_network(wpa_s, buf + 15))
8448 reply_len = -1;
8449 } else if (os_strncmp(buf, "DISABLE_NETWORK ", 16) == 0) {
8450 if (wpa_supplicant_ctrl_iface_disable_network(wpa_s, buf + 16))
8451 reply_len = -1;
8452 } else if (os_strcmp(buf, "ADD_NETWORK") == 0) {
8453 reply_len = wpa_supplicant_ctrl_iface_add_network(
8454 wpa_s, reply, reply_size);
8455 } else if (os_strncmp(buf, "REMOVE_NETWORK ", 15) == 0) {
8456 if (wpa_supplicant_ctrl_iface_remove_network(wpa_s, buf + 15))
8457 reply_len = -1;
8458 } else if (os_strncmp(buf, "SET_NETWORK ", 12) == 0) {
8459 if (wpa_supplicant_ctrl_iface_set_network(wpa_s, buf + 12))
8460 reply_len = -1;
8461 } else if (os_strncmp(buf, "GET_NETWORK ", 12) == 0) {
8462 reply_len = wpa_supplicant_ctrl_iface_get_network(
8463 wpa_s, buf + 12, reply, reply_size);
1c330a2f 8464 } else if (os_strncmp(buf, "DUP_NETWORK ", 12) == 0) {
daae4995
AN		 8465 if (wpa_supplicant_ctrl_iface_dup_network(wpa_s, buf + 12,
8466 wpa_s))
1c330a2f 8467 reply_len = -1;
d94c9ee6
JM		 8468 } else if (os_strcmp(buf, "LIST_CREDS") == 0) {
8469 reply_len = wpa_supplicant_ctrl_iface_list_creds(
8470 wpa_s, reply, reply_size);
8471 } else if (os_strcmp(buf, "ADD_CRED") == 0) {
8472 reply_len = wpa_supplicant_ctrl_iface_add_cred(
8473 wpa_s, reply, reply_size);
8474 } else if (os_strncmp(buf, "REMOVE_CRED ", 12) == 0) {
8475 if (wpa_supplicant_ctrl_iface_remove_cred(wpa_s, buf + 12))
8476 reply_len = -1;
8477 } else if (os_strncmp(buf, "SET_CRED ", 9) == 0) {
8478 if (wpa_supplicant_ctrl_iface_set_cred(wpa_s, buf + 9))
8479 reply_len = -1;
c880ab87
JM		 8480 } else if (os_strncmp(buf, "GET_CRED ", 9) == 0) {
8481 reply_len = wpa_supplicant_ctrl_iface_get_cred(wpa_s, buf + 9,
8482 reply,
8483 reply_size);
6fc6879b
JM		 8484#ifndef CONFIG_NO_CONFIG_WRITE
8485 } else if (os_strcmp(buf, "SAVE_CONFIG") == 0) {
8486 if (wpa_supplicant_ctrl_iface_save_config(wpa_s))
8487 reply_len = -1;
8488#endif /* CONFIG_NO_CONFIG_WRITE */
8489 } else if (os_strncmp(buf, "GET_CAPABILITY ", 15) == 0) {
8490 reply_len = wpa_supplicant_ctrl_iface_get_capability(
8491 wpa_s, buf + 15, reply, reply_size);
8492 } else if (os_strncmp(buf, "AP_SCAN ", 8) == 0) {
8493 if (wpa_supplicant_ctrl_iface_ap_scan(wpa_s, buf + 8))
8494 reply_len = -1;
67b9bd08
DS		 8495 } else if (os_strncmp(buf, "SCAN_INTERVAL ", 14) == 0) {
8496 if (wpa_supplicant_ctrl_iface_scan_interval(wpa_s, buf + 14))
8497 reply_len = -1;
4b4a8ae5
JM		 8498 } else if (os_strcmp(buf, "INTERFACE_LIST") == 0) {
8499 reply_len = wpa_supplicant_global_iface_list(
8500 wpa_s->global, reply, reply_size);
6fc6879b
JM		 8501 } else if (os_strcmp(buf, "INTERFACES") == 0) {
8502 reply_len = wpa_supplicant_global_iface_interfaces(
8503 wpa_s->global, reply, reply_size);
8504 } else if (os_strncmp(buf, "BSS ", 4) == 0) {
8505 reply_len = wpa_supplicant_ctrl_iface_bss(
8506 wpa_s, buf + 4, reply, reply_size);
e653b622
JM		 8507#ifdef CONFIG_AP
8508 } else if (os_strcmp(buf, "STA-FIRST") == 0) {
8509 reply_len = ap_ctrl_iface_sta_first(wpa_s, reply, reply_size);
8510 } else if (os_strncmp(buf, "STA ", 4) == 0) {
8511 reply_len = ap_ctrl_iface_sta(wpa_s, buf + 4, reply,
8512 reply_size);
8513 } else if (os_strncmp(buf, "STA-NEXT ", 9) == 0) {
8514 reply_len = ap_ctrl_iface_sta_next(wpa_s, buf + 9, reply,
8515 reply_size);
e60b2951
JJ		 8516 } else if (os_strncmp(buf, "DEAUTHENTICATE ", 15) == 0) {
8517 if (ap_ctrl_iface_sta_deauthenticate(wpa_s, buf + 15))
8518 reply_len = -1;
8519 } else if (os_strncmp(buf, "DISASSOCIATE ", 13) == 0) {
8520 if (ap_ctrl_iface_sta_disassociate(wpa_s, buf + 13))
8521 reply_len = -1;
334bf36a
AO		 8522 } else if (os_strncmp(buf, "CHAN_SWITCH ", 12) == 0) {
8523 if (ap_ctrl_iface_chanswitch(wpa_s, buf + 12))
8524 reply_len = -1;
99650cad
JM		 8525 } else if (os_strcmp(buf, "STOP_AP") == 0) {
8526 if (wpas_ap_stop_ap(wpa_s))
8527 reply_len = -1;
e653b622 8528#endif /* CONFIG_AP */
207ef3fb
JM		 8529 } else if (os_strcmp(buf, "SUSPEND") == 0) {
8530 wpas_notify_suspend(wpa_s->global);
8531 } else if (os_strcmp(buf, "RESUME") == 0) {
8532 wpas_notify_resume(wpa_s->global);
9ff4de6d 8533#ifdef CONFIG_TESTING_OPTIONS
32d5295f
JM		 8534 } else if (os_strcmp(buf, "DROP_SA") == 0) {
8535 wpa_supplicant_ctrl_iface_drop_sa(wpa_s);
9ff4de6d 8536#endif /* CONFIG_TESTING_OPTIONS */
86d4f806
JM		 8537 } else if (os_strncmp(buf, "ROAM ", 5) == 0) {
8538 if (wpa_supplicant_ctrl_iface_roam(wpa_s, buf + 5))
8539 reply_len = -1;
0d0a8ca1 8540 } else if (os_strncmp(buf, "STA_AUTOCONNECT ", 16) == 0) {
5407c69d 8541 wpa_s->auto_reconnect_disabled = atoi(buf + 16) == 0;
78633c37
SL		 8542 } else if (os_strncmp(buf, "BSS_EXPIRE_AGE ", 15) == 0) {
8543 if (wpa_supplicant_ctrl_iface_bss_expire_age(wpa_s, buf + 15))
8544 reply_len = -1;
8545 } else if (os_strncmp(buf, "BSS_EXPIRE_COUNT ", 17) == 0) {
8546 if (wpa_supplicant_ctrl_iface_bss_expire_count(wpa_s,
8547 buf + 17))
8548 reply_len = -1;
39ee845f 8549 } else if (os_strncmp(buf, "BSS_FLUSH ", 10) == 0) {
a1144000 8550 wpa_supplicant_ctrl_iface_bss_flush(wpa_s, buf + 10);
281ff0aa
GP		 8551#ifdef CONFIG_TDLS
8552 } else if (os_strncmp(buf, "TDLS_DISCOVER ", 14) == 0) {
8553 if (wpa_supplicant_ctrl_iface_tdls_discover(wpa_s, buf + 14))
8554 reply_len = -1;
8555 } else if (os_strncmp(buf, "TDLS_SETUP ", 11) == 0) {
8556 if (wpa_supplicant_ctrl_iface_tdls_setup(wpa_s, buf + 11))
8557 reply_len = -1;
8558 } else if (os_strncmp(buf, "TDLS_TEARDOWN ", 14) == 0) {
8559 if (wpa_supplicant_ctrl_iface_tdls_teardown(wpa_s, buf + 14))
8560 reply_len = -1;
6b90deae
AN		 8561 } else if (os_strncmp(buf, "TDLS_CHAN_SWITCH ", 17) == 0) {
8562 if (wpa_supplicant_ctrl_iface_tdls_chan_switch(wpa_s,
8563 buf + 17))
8564 reply_len = -1;
8565 } else if (os_strncmp(buf, "TDLS_CANCEL_CHAN_SWITCH ", 24) == 0) {
8566 if (wpa_supplicant_ctrl_iface_tdls_cancel_chan_switch(wpa_s,
8567 buf + 24))
8568 reply_len = -1;
4504621f
OG		 8569 } else if (os_strncmp(buf, "TDLS_LINK_STATUS ", 17) == 0) {
8570 reply_len = wpa_supplicant_ctrl_iface_tdls_link_status(
8571 wpa_s, buf + 17, reply, reply_size);
281ff0aa 8572#endif /* CONFIG_TDLS */
8506ea6f
MB		 8573 } else if (os_strcmp(buf, "WMM_AC_STATUS") == 0) {
8574 reply_len = wpas_wmm_ac_status(wpa_s, reply, reply_size);
eb2f2088
MB		 8575 } else if (os_strncmp(buf, "WMM_AC_ADDTS ", 13) == 0) {
8576 if (wmm_ac_ctrl_addts(wpa_s, buf + 13))
8577 reply_len = -1;
8578 } else if (os_strncmp(buf, "WMM_AC_DELTS ", 13) == 0) {
8579 if (wmm_ac_ctrl_delts(wpa_s, buf + 13))
8580 reply_len = -1;
60b24b0d
DS		 8581 } else if (os_strncmp(buf, "SIGNAL_POLL", 11) == 0) {
8582 reply_len = wpa_supplicant_signal_poll(wpa_s, reply,
8583 reply_size);
dc7785f8
YZ		 8584 } else if (os_strncmp(buf, "PKTCNT_POLL", 11) == 0) {
8585 reply_len = wpa_supplicant_pktcnt_poll(wpa_s, reply,
8586 reply_size);
bc5d330a
TB		 8587#ifdef CONFIG_AUTOSCAN
8588 } else if (os_strncmp(buf, "AUTOSCAN ", 9) == 0) {
8589 if (wpa_supplicant_ctrl_iface_autoscan(wpa_s, buf + 9))
8590 reply_len = -1;
8591#endif /* CONFIG_AUTOSCAN */
5e2c3490
JM		 8592#ifdef ANDROID
8593 } else if (os_strncmp(buf, "DRIVER ", 7) == 0) {
8594 reply_len = wpa_supplicant_driver_cmd(wpa_s, buf + 7, reply,
8595 reply_size);
8596#endif /* ANDROID */
adef8948
BL		 8597 } else if (os_strncmp(buf, "VENDOR ", 7) == 0) {
8598 reply_len = wpa_supplicant_vendor_cmd(wpa_s, buf + 7, reply,
8599 reply_size);
9482426e 8600 } else if (os_strcmp(buf, "REAUTHENTICATE") == 0) {
f5f37d3a 8601 pmksa_cache_clear_current(wpa_s->wpa);
9482426e 8602 eapol_sm_request_reauth(wpa_s->eapol);
e9199e31
JM		 8603#ifdef CONFIG_WNM
8604 } else if (os_strncmp(buf, "WNM_SLEEP ", 10) == 0) {
8605 if (wpas_ctrl_iface_wnm_sleep(wpa_s, buf + 10))
8606 reply_len = -1;
07565ab0
MG		 8607 } else if (os_strncmp(buf, "WNM_BSS_QUERY ", 14) == 0) {
8608 if (wpas_ctrl_iface_wnm_bss_query(wpa_s, buf + 14))
65bcd0a9 8609 reply_len = -1;
e9199e31 8610#endif /* CONFIG_WNM */
acb54643
JM		 8611 } else if (os_strcmp(buf, "FLUSH") == 0) {
8612 wpa_supplicant_ctrl_iface_flush(wpa_s);
1f965e62
JM		 8613 } else if (os_strncmp(buf, "RADIO_WORK ", 11) == 0) {
8614 reply_len = wpas_ctrl_radio_work(wpa_s, buf + 11, reply,
8615 reply_size);
60b893df
JM		 8616#ifdef CONFIG_TESTING_OPTIONS
8617 } else if (os_strncmp(buf, "MGMT_TX ", 8) == 0) {
8618 if (wpas_ctrl_iface_mgmt_tx(wpa_s, buf + 8) < 0)
8619 reply_len = -1;
8620 } else if (os_strcmp(buf, "MGMT_TX_DONE") == 0) {
8621 wpas_ctrl_iface_mgmt_tx_done(wpa_s);
ad12f2f4
JM		 8622 } else if (os_strncmp(buf, "DRIVER_EVENT ", 13) == 0) {
8623 if (wpas_ctrl_iface_driver_event(wpa_s, buf + 13) < 0)
8624 reply_len = -1;
9d4ff04a
JM		 8625 } else if (os_strncmp(buf, "EAPOL_RX ", 9) == 0) {
8626 if (wpas_ctrl_iface_eapol_rx(wpa_s, buf + 9) < 0)
8627 reply_len = -1;
4a6cc862
JM		 8628 } else if (os_strncmp(buf, "DATA_TEST_CONFIG ", 17) == 0) {
8629 if (wpas_ctrl_iface_data_test_config(wpa_s, buf + 17) < 0)
8630 reply_len = -1;
8631 } else if (os_strncmp(buf, "DATA_TEST_TX ", 13) == 0) {
8632 if (wpas_ctrl_iface_data_test_tx(wpa_s, buf + 13) < 0)
8633 reply_len = -1;
fc0ef7c0
JM		 8634 } else if (os_strncmp(buf, "DATA_TEST_FRAME ", 16) == 0) {
8635 if (wpas_ctrl_iface_data_test_frame(wpa_s, buf + 16) < 0)
8636 reply_len = -1;
a156ffda
JM		 8637 } else if (os_strncmp(buf, "TEST_ALLOC_FAIL ", 16) == 0) {
8638 if (wpas_ctrl_test_alloc_fail(wpa_s, buf + 16) < 0)
8639 reply_len = -1;
8640 } else if (os_strcmp(buf, "GET_ALLOC_FAIL") == 0) {
8641 reply_len = wpas_ctrl_get_alloc_fail(wpa_s, reply, reply_size);
2da52565
JM		 8642 } else if (os_strncmp(buf, "TEST_FAIL ", 10) == 0) {
8643 if (wpas_ctrl_test_fail(wpa_s, buf + 10) < 0)
8644 reply_len = -1;
8645 } else if (os_strcmp(buf, "GET_FAIL") == 0) {
8646 reply_len = wpas_ctrl_get_fail(wpa_s, reply, reply_size);
60b893df 8647#endif /* CONFIG_TESTING_OPTIONS */
86bd36f0
JM		 8648 } else if (os_strncmp(buf, "VENDOR_ELEM_ADD ", 16) == 0) {
8649 if (wpas_ctrl_vendor_elem_add(wpa_s, buf + 16) < 0)
8650 reply_len = -1;
8651 } else if (os_strncmp(buf, "VENDOR_ELEM_GET ", 16) == 0) {
8652 reply_len = wpas_ctrl_vendor_elem_get(wpa_s, buf + 16, reply,
8653 reply_size);
8654 } else if (os_strncmp(buf, "VENDOR_ELEM_REMOVE ", 19) == 0) {
8655 if (wpas_ctrl_vendor_elem_remove(wpa_s, buf + 19) < 0)
8656 reply_len = -1;
f4b8bfae 8657 } else if (os_strncmp(buf, "NEIGHBOR_REP_REQUEST", 20) == 0) {
4c4b2305 8658 if (wpas_ctrl_iface_send_neigbor_rep(wpa_s, buf + 20))
f4b8bfae 8659 reply_len = -1;
65d9a5e2
JM		 8660 } else if (os_strcmp(buf, "ERP_FLUSH") == 0) {
8661 wpas_ctrl_iface_erp_flush(wpa_s);
fb375883
IP		 8662 } else if (os_strncmp(buf, "MAC_RAND_SCAN ", 14) == 0) {
8663 if (wpas_ctrl_iface_mac_rand_scan(wpa_s, buf + 14))
8664 reply_len = -1;
6fc6879b
JM		 8665 } else {
8666 os_memcpy(reply, "UNKNOWN COMMAND\n", 16);
8667 reply_len = 16;
8668 }
8669
8670 if (reply_len < 0) {
8671 os_memcpy(reply, "FAIL\n", 5);
8672 reply_len = 5;
8673 }
8674
6fc6879b
JM		 8675 *resp_len = reply_len;
8676 return reply;
8677}
8678
8679
8680static int wpa_supplicant_global_iface_add(struct wpa_global *global,
8681 char *cmd)
8682{
8683 struct wpa_interface iface;
efa232f9
JJ		 8684 char *pos, *extra;
8685 struct wpa_supplicant *wpa_s;
8686 unsigned int create_iface = 0;
8687 u8 mac_addr[ETH_ALEN];
6fc6879b
JM		 8688
8689 /*
8690 * <ifname>TAB<confname>TAB<driver>TAB<ctrl_interface>TAB<driver_param>
efa232f9 8691 * TAB<bridge_ifname>[TAB<create>]
6fc6879b
JM		 8692 */
8693 wpa_printf(MSG_DEBUG, "CTRL_IFACE GLOBAL INTERFACE_ADD '%s'", cmd);
8694
8695 os_memset(&iface, 0, sizeof(iface));
8696
8697 do {
8698 iface.ifname = pos = cmd;
8699 pos = os_strchr(pos, '\t');
8700 if (pos)
8701 *pos++ = '\0';
8702 if (iface.ifname[0] == '\0')
8703 return -1;
8704 if (pos == NULL)
8705 break;
8706
8707 iface.confname = pos;
8708 pos = os_strchr(pos, '\t');
8709 if (pos)
8710 *pos++ = '\0';
8711 if (iface.confname[0] == '\0')
8712 iface.confname = NULL;
8713 if (pos == NULL)
8714 break;
8715
8716 iface.driver = pos;
8717 pos = os_strchr(pos, '\t');
8718 if (pos)
8719 *pos++ = '\0';
8720 if (iface.driver[0] == '\0')
8721 iface.driver = NULL;
8722 if (pos == NULL)
8723 break;
8724
8725 iface.ctrl_interface = pos;
8726 pos = os_strchr(pos, '\t');
8727 if (pos)
8728 *pos++ = '\0';
8729 if (iface.ctrl_interface[0] == '\0')
8730 iface.ctrl_interface = NULL;
8731 if (pos == NULL)
8732 break;
8733
8734 iface.driver_param = pos;
8735 pos = os_strchr(pos, '\t');
8736 if (pos)
8737 *pos++ = '\0';
8738 if (iface.driver_param[0] == '\0')
8739 iface.driver_param = NULL;
8740 if (pos == NULL)
8741 break;
8742
8743 iface.bridge_ifname = pos;
8744 pos = os_strchr(pos, '\t');
8745 if (pos)
8746 *pos++ = '\0';
8747 if (iface.bridge_ifname[0] == '\0')
8748 iface.bridge_ifname = NULL;
8749 if (pos == NULL)
8750 break;
efa232f9
JJ		 8751
8752 extra = pos;
8753 pos = os_strchr(pos, '\t');
8754 if (pos)
8755 *pos++ = '\0';
da3db681
BG		 8756 if (!extra[0])
8757 break;
8758
efa232f9
JJ		 8759 if (os_strcmp(extra, "create") == 0)
8760 create_iface = 1;
da3db681
BG		 8761 else {
8762 wpa_printf(MSG_DEBUG,
8763 "INTERFACE_ADD unsupported extra parameter: '%s'",
8764 extra);
efa232f9 8765 return -1;
da3db681 8766 }
6fc6879b
JM		 8767 } while (0);
8768
efa232f9
JJ		 8769 if (create_iface) {
8770 wpa_printf(MSG_DEBUG, "CTRL_IFACE creating interface '%s'",
8771 iface.ifname);
8772 if (!global->ifaces)
8773 return -1;
8774 if (wpa_drv_if_add(global->ifaces, WPA_IF_STATION, iface.ifname,
8775 NULL, NULL, NULL, mac_addr, NULL) < 0) {
8776 wpa_printf(MSG_ERROR,
8777 "CTRL_IFACE interface creation failed");
8778 return -1;
8779 }
8780
8781 wpa_printf(MSG_DEBUG,
8782 "CTRL_IFACE interface '%s' created with MAC addr: "
8783 MACSTR, iface.ifname, MAC2STR(mac_addr));
8784 }
8785
6fc6879b 8786 if (wpa_supplicant_get_iface(global, iface.ifname))
efa232f9
JJ		 8787 goto fail;
8788
8789 wpa_s = wpa_supplicant_add_iface(global, &iface, NULL);
8790 if (!wpa_s)
8791 goto fail;
8792 wpa_s->added_vif = create_iface;
8793 return 0;
6fc6879b 8794
efa232f9
JJ		 8795fail:
8796 if (create_iface)
8797 wpa_drv_if_remove(global->ifaces, WPA_IF_STATION, iface.ifname);
8798 return -1;
6fc6879b
JM		 8799}
8800
8801
8802static int wpa_supplicant_global_iface_remove(struct wpa_global *global,
8803 char *cmd)
8804{
8805 struct wpa_supplicant *wpa_s;
efa232f9
JJ		 8806 int ret;
8807 unsigned int delete_iface;
6fc6879b
JM		 8808
8809 wpa_printf(MSG_DEBUG, "CTRL_IFACE GLOBAL INTERFACE_REMOVE '%s'", cmd);
8810
8811 wpa_s = wpa_supplicant_get_iface(global, cmd);
8812 if (wpa_s == NULL)
8813 return -1;
efa232f9
JJ		 8814 delete_iface = wpa_s->added_vif;
8815 ret = wpa_supplicant_remove_iface(global, wpa_s, 0);
8816 if (!ret && delete_iface) {
8817 wpa_printf(MSG_DEBUG, "CTRL_IFACE deleting the interface '%s'",
8818 cmd);
8819 ret = wpa_drv_if_remove(global->ifaces, WPA_IF_STATION, cmd);
8820 }
8821 return ret;
6fc6879b
JM		 8822}
8823
8824
4b4a8ae5
JM		 8825static void wpa_free_iface_info(struct wpa_interface_info *iface)
8826{
8827 struct wpa_interface_info *prev;
8828
8829 while (iface) {
8830 prev = iface;
8831 iface = iface->next;
8832
8833 os_free(prev->ifname);
8834 os_free(prev->desc);
8835 os_free(prev);
8836 }
8837}
8838
8839
8840static int wpa_supplicant_global_iface_list(struct wpa_global *global,
8841 char *buf, int len)
8842{
8843 int i, res;
8844 struct wpa_interface_info *iface = NULL, *last = NULL, *tmp;
8845 char *pos, *end;
8846
c5121837 8847 for (i = 0; wpa_drivers[i]; i++) {
8b423edb 8848 const struct wpa_driver_ops *drv = wpa_drivers[i];
4b4a8ae5
JM		 8849 if (drv->get_interfaces == NULL)
8850 continue;
5fbc1f27 8851 tmp = drv->get_interfaces(global->drv_priv[i]);
4b4a8ae5
JM		 8852 if (tmp == NULL)
8853 continue;
8854
8855 if (last == NULL)
8856 iface = last = tmp;
8857 else
8858 last->next = tmp;
8859 while (last->next)
8860 last = last->next;
8861 }
8862
8863 pos = buf;
8864 end = buf + len;
8865 for (tmp = iface; tmp; tmp = tmp->next) {
8866 res = os_snprintf(pos, end - pos, "%s\t%s\t%s\n",
8867 tmp->drv_name, tmp->ifname,
8868 tmp->desc ? tmp->desc : "");
d85e1fc8 8869 if (os_snprintf_error(end - pos, res)) {
4b4a8ae5
JM		 8870 *pos = '\0';
8871 break;
8872 }
8873 pos += res;
8874 }
8875
8876 wpa_free_iface_info(iface);
8877
8878 return pos - buf;
8879}
8880
8881
6fc6879b
JM		 8882static int wpa_supplicant_global_iface_interfaces(struct wpa_global *global,
8883 char *buf, int len)
8884{
8885 int res;
8886 char *pos, *end;
8887 struct wpa_supplicant *wpa_s;
8888
8889 wpa_s = global->ifaces;
8890 pos = buf;
8891 end = buf + len;
8892
8893 while (wpa_s) {
8894 res = os_snprintf(pos, end - pos, "%s\n", wpa_s->ifname);
d85e1fc8 8895 if (os_snprintf_error(end - pos, res)) {
6fc6879b
JM		 8896 *pos = '\0';
8897 break;
8898 }
8899 pos += res;
8900 wpa_s = wpa_s->next;
8901 }
8902 return pos - buf;
8903}
8904
8905
cf3bebf2
JM		 8906static char * wpas_global_ctrl_iface_ifname(struct wpa_global *global,
8907 const char *ifname,
8908 char *cmd, size_t *resp_len)
8909{
8910 struct wpa_supplicant *wpa_s;
8911
8912 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
8913 if (os_strcmp(ifname, wpa_s->ifname) == 0)
8914 break;
8915 }
8916
8917 if (wpa_s == NULL) {
8918 char *resp = os_strdup("FAIL-NO-IFNAME-MATCH\n");
8919 if (resp)
8920 *resp_len = os_strlen(resp);
8921 else
8922 *resp_len = 1;
8923 return resp;
8924 }
8925
8926 return wpa_supplicant_ctrl_iface_process(wpa_s, cmd, resp_len);
8927}
8928
8929
576bce9c
JM		 8930static char * wpas_global_ctrl_iface_redir_p2p(struct wpa_global *global,
8931 char *buf, size_t *resp_len)
8932{
8933#ifdef CONFIG_P2P
8934 static const char * cmd[] = {
443427e4 8935 "LIST_NETWORKS",
576bce9c
JM		 8936 "P2P_FIND",
8937 "P2P_STOP_FIND",
8938 "P2P_LISTEN",
8939 "P2P_GROUP_ADD",
8940 "P2P_GET_PASSPHRASE",
8941 "P2P_SERVICE_UPDATE",
8942 "P2P_SERVICE_FLUSH",
8943 "P2P_FLUSH",
8944 "P2P_CANCEL",
8945 "P2P_PRESENCE_REQ",
8946 "P2P_EXT_LISTEN",
8947 NULL
8948 };
8949 static const char * prefix[] = {
443427e4
DS		 8950#ifdef ANDROID
8951 "DRIVER ",
8952#endif /* ANDROID */
8953 "GET_NETWORK ",
8954 "REMOVE_NETWORK ",
576bce9c
JM		 8955 "P2P_FIND ",
8956 "P2P_CONNECT ",
8957 "P2P_LISTEN ",
8958 "P2P_GROUP_REMOVE ",
8959 "P2P_GROUP_ADD ",
8960 "P2P_PROV_DISC ",
8961 "P2P_SERV_DISC_REQ ",
8962 "P2P_SERV_DISC_CANCEL_REQ ",
8963 "P2P_SERV_DISC_RESP ",
8964 "P2P_SERV_DISC_EXTERNAL ",
8965 "P2P_SERVICE_ADD ",
8966 "P2P_SERVICE_DEL ",
87d5ef5a 8967 "P2P_SERVICE_REP ",
576bce9c
JM		 8968 "P2P_REJECT ",
8969 "P2P_INVITE ",
8970 "P2P_PEER ",
8971 "P2P_SET ",
8972 "P2P_UNAUTHORIZE ",
8973 "P2P_PRESENCE_REQ ",
8974 "P2P_EXT_LISTEN ",
f2c56602 8975 "P2P_REMOVE_CLIENT ",
8ad8bc5c
DS		 8976 "WPS_NFC_TOKEN ",
8977 "WPS_NFC_TAG_READ ",
f3ff9487
AM		 8978 "NFC_GET_HANDOVER_SEL ",
8979 "NFC_GET_HANDOVER_REQ ",
8980 "NFC_REPORT_HANDOVER ",
87d5ef5a
KV		 8981 "P2P_ASP_PROVISION ",
8982 "P2P_ASP_PROVISION_RESP ",
576bce9c
JM		 8983 NULL
8984 };
8985 int found = 0;
8986 int i;
8987
8988 if (global->p2p_init_wpa_s == NULL)
8989 return NULL;
8990
8991 for (i = 0; !found && cmd[i]; i++) {
8992 if (os_strcmp(buf, cmd[i]) == 0)
8993 found = 1;
8994 }
8995
8996 for (i = 0; !found && prefix[i]; i++) {
8997 if (os_strncmp(buf, prefix[i], os_strlen(prefix[i])) == 0)
8998 found = 1;
8999 }
9000
9001 if (found)
9002 return wpa_supplicant_ctrl_iface_process(global->p2p_init_wpa_s,
9003 buf, resp_len);
9004#endif /* CONFIG_P2P */
9005 return NULL;
9006}
9007
9008
9009static char * wpas_global_ctrl_iface_redir_wfd(struct wpa_global *global,
9010 char *buf, size_t *resp_len)
9011{
9012#ifdef CONFIG_WIFI_DISPLAY
9013 if (global->p2p_init_wpa_s == NULL)
9014 return NULL;
9015 if (os_strncmp(buf, "WFD_SUBELEM_SET ", 16) == 0 ||
9016 os_strncmp(buf, "WFD_SUBELEM_GET ", 16) == 0)
9017 return wpa_supplicant_ctrl_iface_process(global->p2p_init_wpa_s,
9018 buf, resp_len);
9019#endif /* CONFIG_WIFI_DISPLAY */
9020 return NULL;
9021}
9022
9023
9024static char * wpas_global_ctrl_iface_redir(struct wpa_global *global,
9025 char *buf, size_t *resp_len)
9026{
9027 char *ret;
9028
9029 ret = wpas_global_ctrl_iface_redir_p2p(global, buf, resp_len);
9030 if (ret)
9031 return ret;
9032
9033 ret = wpas_global_ctrl_iface_redir_wfd(global, buf, resp_len);
9034 if (ret)
9035 return ret;
9036
9037 return NULL;
9038}
9039
9040
1b9b31c1
JM		 9041static int wpas_global_ctrl_iface_set(struct wpa_global *global, char *cmd)
9042{
9043 char *value;
9044
9045 value = os_strchr(cmd, ' ');
9046 if (value == NULL)
9047 return -1;
9048 *value++ = '\0';
9049
9050 wpa_printf(MSG_DEBUG, "GLOBAL_CTRL_IFACE SET '%s'='%s'", cmd, value);
9051
9052#ifdef CONFIG_WIFI_DISPLAY
9053 if (os_strcasecmp(cmd, "wifi_display") == 0) {
9054 wifi_display_enable(global, !!atoi(value));
9055 return 0;
9056 }
9057#endif /* CONFIG_WIFI_DISPLAY */
9058
a7ca6dac
JM		 9059 /* Restore cmd to its original value to allow redirection */
9060 value[-1] = ' ';
9061
1b9b31c1
JM		 9062 return -1;
9063}
9064
9065
daae4995
AN		 9066static int wpas_global_ctrl_iface_dup_network(struct wpa_global *global,
9067 char *cmd)
9068{
9069 struct wpa_supplicant *wpa_s[2]; /* src, dst */
9070 char *p;
9071 unsigned int i;
9072
9073 /* cmd: "<src ifname> <dst ifname> <src network id> <dst network id>
9074 * <variable name> */
9075
9076 for (i = 0; i < ARRAY_SIZE(wpa_s) ; i++) {
9077 p = os_strchr(cmd, ' ');
9078 if (p == NULL)
9079 return -1;
9080 *p = '\0';
9081
9082 wpa_s[i] = global->ifaces;
9083 for (; wpa_s[i]; wpa_s[i] = wpa_s[i]->next) {
9084 if (os_strcmp(cmd, wpa_s[i]->ifname) == 0)
9085 break;
9086 }
9087
9088 if (!wpa_s[i]) {
9089 wpa_printf(MSG_DEBUG,
9090 "CTRL_IFACE: Could not find iface=%s", cmd);
9091 return -1;
9092 }
9093
9094 cmd = p + 1;
9095 }
9096
9097 return wpa_supplicant_ctrl_iface_dup_network(wpa_s[0], cmd, wpa_s[1]);
9098}
9099
9100
42868f14
JM		 9101#ifndef CONFIG_NO_CONFIG_WRITE
9102static int wpas_global_ctrl_iface_save_config(struct wpa_global *global)
9103{
d6b818ef 9104 int ret = 0, saved = 0;
42868f14
JM		 9105 struct wpa_supplicant *wpa_s;
9106
9107 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
9108 if (!wpa_s->conf->update_config) {
9109 wpa_dbg(wpa_s, MSG_DEBUG, "CTRL_IFACE: SAVE_CONFIG - Not allowed to update configuration (update_config=0)");
9110 continue;
9111 }
9112
9113 if (wpa_config_write(wpa_s->confname, wpa_s->conf)) {
9114 wpa_dbg(wpa_s, MSG_DEBUG, "CTRL_IFACE: SAVE_CONFIG - Failed to update configuration");
9115 ret = 1;
9116 } else {
9117 wpa_dbg(wpa_s, MSG_DEBUG, "CTRL_IFACE: SAVE_CONFIG - Configuration updated");
d6b818ef 9118 saved++;
42868f14
JM		 9119 }
9120 }
9121
d6b818ef
JM		 9122 if (!saved && !ret) {
9123 wpa_dbg(wpa_s, MSG_DEBUG,
9124 "CTRL_IFACE: SAVE_CONFIG - No configuration files could be updated");
9125 ret = 1;
9126 }
9127
42868f14
JM		 9128 return ret;
9129}
9130#endif /* CONFIG_NO_CONFIG_WRITE */
9131
9132
ae8c27f7
JM		 9133static int wpas_global_ctrl_iface_status(struct wpa_global *global,
9134 char *buf, size_t buflen)
9135{
9136 char *pos, *end;
9137 int ret;
9138 struct wpa_supplicant *wpa_s;
9139
9140 pos = buf;
9141 end = buf + buflen;
9142
9143#ifdef CONFIG_P2P
4c559019 9144 if (global->p2p && !global->p2p_disabled) {
ae8c27f7 9145 ret = os_snprintf(pos, end - pos, "p2p_device_address=" MACSTR
4c559019
JM		 9146 "\n"
9147 "p2p_state=%s\n",
9148 MAC2STR(global->p2p_dev_addr),
9149 p2p_get_state_txt(global->p2p));
d85e1fc8 9150 if (os_snprintf_error(end - pos, ret))
4c559019
JM		 9151 return pos - buf;
9152 pos += ret;
9153 } else if (global->p2p) {
9154 ret = os_snprintf(pos, end - pos, "p2p_state=DISABLED\n");
d85e1fc8 9155 if (os_snprintf_error(end - pos, ret))
ae8c27f7
JM		 9156 return pos - buf;
9157 pos += ret;
9158 }
9159#endif /* CONFIG_P2P */
9160
9161#ifdef CONFIG_WIFI_DISPLAY
9162 ret = os_snprintf(pos, end - pos, "wifi_display=%d\n",
9163 !!global->wifi_display);
d85e1fc8 9164 if (os_snprintf_error(end - pos, ret))
ae8c27f7
JM		 9165 return pos - buf;
9166 pos += ret;
9167#endif /* CONFIG_WIFI_DISPLAY */
9168
9169 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
9170 ret = os_snprintf(pos, end - pos, "ifname=%s\n"
9171 "address=" MACSTR "\n",
9172 wpa_s->ifname, MAC2STR(wpa_s->own_addr));
d85e1fc8 9173 if (os_snprintf_error(end - pos, ret))
ae8c27f7
JM		 9174 return pos - buf;
9175 pos += ret;
9176 }
9177
9178 return pos - buf;
9179}
9180
9181
3794af2d
AN		 9182#ifdef CONFIG_FST
9183
9184static int wpas_global_ctrl_iface_fst_attach(struct wpa_global *global,
9185 char *cmd, char *buf,
9186 size_t reply_size)
9187{
9188 char ifname[IFNAMSIZ + 1];
9189 struct fst_iface_cfg cfg;
9190 struct wpa_supplicant *wpa_s;
9191 struct fst_wpa_obj iface_obj;
9192
9193 if (!fst_parse_attach_command(cmd, ifname, sizeof(ifname), &cfg)) {
9194 wpa_s = wpa_supplicant_get_iface(global, ifname);
9195 if (wpa_s) {
9196 fst_wpa_supplicant_fill_iface_obj(wpa_s, &iface_obj);
9197 wpa_s->fst = fst_attach(ifname, wpa_s->own_addr,
9198 &iface_obj, &cfg);
9199 if (wpa_s->fst)
9200 return os_snprintf(buf, reply_size, "OK\n");
9201 }
9202 }
9203
9204 return -1;
9205}
9206
9207
9208static int wpas_global_ctrl_iface_fst_detach(struct wpa_global *global,
9209 char *cmd, char *buf,
9210 size_t reply_size)
9211{
9212 char ifname[IFNAMSIZ + 1];
9213 struct wpa_supplicant *wpa_s;
9214
9215 if (!fst_parse_detach_command(cmd, ifname, sizeof(ifname))) {
9216 wpa_s = wpa_supplicant_get_iface(global, ifname);
9217 if (wpa_s) {
9218 if (!fst_iface_detach(ifname)) {
9219 wpa_s->fst = NULL;
9220 return os_snprintf(buf, reply_size, "OK\n");
9221 }
9222 }
9223 }
9224
9225 return -1;
9226}
9227
9228#endif /* CONFIG_FST */
9229
9230
6fc6879b
JM		 9231char * wpa_supplicant_global_ctrl_iface_process(struct wpa_global *global,
9232 char *buf, size_t *resp_len)
9233{
9234 char *reply;
9235 const int reply_size = 2048;
9236 int reply_len;
f4a0a82c 9237 int level = MSG_DEBUG;
6fc6879b 9238
cf3bebf2
JM		 9239 if (os_strncmp(buf, "IFNAME=", 7) == 0) {
9240 char *pos = os_strchr(buf + 7, ' ');
9241 if (pos) {
9242 *pos++ = '\0';
9243 return wpas_global_ctrl_iface_ifname(global,
9244 buf + 7, pos,
9245 resp_len);
9246 }
9247 }
9248
576bce9c
JM		 9249 reply = wpas_global_ctrl_iface_redir(global, buf, resp_len);
9250 if (reply)
9251 return reply;
9252
f4a0a82c
JM		 9253 if (os_strcmp(buf, "PING") == 0)
9254 level = MSG_EXCESSIVE;
9255 wpa_hexdump_ascii(level, "RX global ctrl_iface",
6fc6879b
JM		 9256 (const u8 *) buf, os_strlen(buf));
9257
9258 reply = os_malloc(reply_size);
9259 if (reply == NULL) {
9260 *resp_len = 1;
9261 return NULL;
9262 }
9263
9264 os_memcpy(reply, "OK\n", 3);
9265 reply_len = 3;
9266
9267 if (os_strcmp(buf, "PING") == 0) {
9268 os_memcpy(reply, "PONG\n", 5);
9269 reply_len = 5;
9270 } else if (os_strncmp(buf, "INTERFACE_ADD ", 14) == 0) {
9271 if (wpa_supplicant_global_iface_add(global, buf + 14))
9272 reply_len = -1;
9273 } else if (os_strncmp(buf, "INTERFACE_REMOVE ", 17) == 0) {
9274 if (wpa_supplicant_global_iface_remove(global, buf + 17))
9275 reply_len = -1;
4b4a8ae5
JM		 9276 } else if (os_strcmp(buf, "INTERFACE_LIST") == 0) {
9277 reply_len = wpa_supplicant_global_iface_list(
9278 global, reply, reply_size);
6fc6879b
JM		 9279 } else if (os_strcmp(buf, "INTERFACES") == 0) {
9280 reply_len = wpa_supplicant_global_iface_interfaces(
9281 global, reply, reply_size);
3794af2d
AN		 9282#ifdef CONFIG_FST
9283 } else if (os_strncmp(buf, "FST-ATTACH ", 11) == 0) {
9284 reply_len = wpas_global_ctrl_iface_fst_attach(global, buf + 11,
9285 reply,
9286 reply_size);
9287 } else if (os_strncmp(buf, "FST-DETACH ", 11) == 0) {
9288 reply_len = wpas_global_ctrl_iface_fst_detach(global, buf + 11,
9289 reply,
9290 reply_size);
9291 } else if (os_strncmp(buf, "FST-MANAGER ", 12) == 0) {
9292 reply_len = fst_ctrl_iface_receive(buf + 12, reply, reply_size);
9293#endif /* CONFIG_FST */
6fc6879b 9294 } else if (os_strcmp(buf, "TERMINATE") == 0) {
1a1bf008 9295 wpa_supplicant_terminate_proc(global);
207ef3fb
JM		 9296 } else if (os_strcmp(buf, "SUSPEND") == 0) {
9297 wpas_notify_suspend(global);
9298 } else if (os_strcmp(buf, "RESUME") == 0) {
9299 wpas_notify_resume(global);
1b9b31c1 9300 } else if (os_strncmp(buf, "SET ", 4) == 0) {
a7ca6dac
JM		 9301 if (wpas_global_ctrl_iface_set(global, buf + 4)) {
9302#ifdef CONFIG_P2P
9303 if (global->p2p_init_wpa_s) {
9304 os_free(reply);
9305 /* Check if P2P redirection would work for this
9306 * command. */
9307 return wpa_supplicant_ctrl_iface_process(
9308 global->p2p_init_wpa_s,
9309 buf, resp_len);
9310 }
9311#endif /* CONFIG_P2P */
1b9b31c1 9312 reply_len = -1;
a7ca6dac 9313 }
daae4995
AN		 9314 } else if (os_strncmp(buf, "DUP_NETWORK ", 12) == 0) {
9315 if (wpas_global_ctrl_iface_dup_network(global, buf + 12))
9316 reply_len = -1;
42868f14
JM		 9317#ifndef CONFIG_NO_CONFIG_WRITE
9318 } else if (os_strcmp(buf, "SAVE_CONFIG") == 0) {
9319 if (wpas_global_ctrl_iface_save_config(global))
9320 reply_len = -1;
9321#endif /* CONFIG_NO_CONFIG_WRITE */
ae8c27f7
JM		 9322 } else if (os_strcmp(buf, "STATUS") == 0) {
9323 reply_len = wpas_global_ctrl_iface_status(global, reply,
9324 reply_size);
ea449b5b
JM		 9325#ifdef CONFIG_MODULE_TESTS
9326 } else if (os_strcmp(buf, "MODULE_TESTS") == 0) {
9327 int wpas_module_tests(void);
9328 if (wpas_module_tests() < 0)
9329 reply_len = -1;
9330#endif /* CONFIG_MODULE_TESTS */
5f797376
JM		 9331 } else if (os_strncmp(buf, "RELOG", 5) == 0) {
9332 if (wpa_debug_reopen_file() < 0)
9333 reply_len = -1;
6fc6879b
JM		 9334 } else {
9335 os_memcpy(reply, "UNKNOWN COMMAND\n", 16);
9336 reply_len = 16;
9337 }
9338
9339 if (reply_len < 0) {
9340 os_memcpy(reply, "FAIL\n", 5);
9341 reply_len = 5;
9342 }
9343
9344 *resp_len = reply_len;
9345 return reply;
9346}
Unnamed repository; edit this file 'description' to name the repository.