Branch data Line data Source code
1 : : /*
2 : : * WPA Supplicant / Control interface (shared code for all backends)
3 : : * Copyright (c) 2004-2013, Jouni Malinen <j@w1.fi>
4 : : *
5 : : * This software may be distributed under the terms of the BSD license.
6 : : * See README for more details.
7 : : */
8 : :
9 : : #include "utils/includes.h"
10 : :
11 : : #include "utils/common.h"
12 : : #include "utils/eloop.h"
13 : : #include "utils/uuid.h"
14 : : #include "common/version.h"
15 : : #include "common/ieee802_11_defs.h"
16 : : #include "common/ieee802_11_common.h"
17 : : #include "common/wpa_ctrl.h"
18 : : #include "eap_peer/eap.h"
19 : : #include "eapol_supp/eapol_supp_sm.h"
20 : : #include "rsn_supp/wpa.h"
21 : : #include "rsn_supp/preauth.h"
22 : : #include "rsn_supp/pmksa_cache.h"
23 : : #include "l2_packet/l2_packet.h"
24 : : #include "wps/wps.h"
25 : : #include "config.h"
26 : : #include "wpa_supplicant_i.h"
27 : : #include "driver_i.h"
28 : : #include "wps_supplicant.h"
29 : : #include "ibss_rsn.h"
30 : : #include "ap.h"
31 : : #include "p2p_supplicant.h"
32 : : #include "p2p/p2p.h"
33 : : #include "hs20_supplicant.h"
34 : : #include "wifi_display.h"
35 : : #include "notify.h"
36 : : #include "bss.h"
37 : : #include "scan.h"
38 : : #include "ctrl_iface.h"
39 : : #include "interworking.h"
40 : : #include "blacklist.h"
41 : : #include "autoscan.h"
42 : : #include "wnm_sta.h"
43 : :
44 : : static int wpa_supplicant_global_iface_list(struct wpa_global *global,
45 : : char *buf, int len);
46 : : static int wpa_supplicant_global_iface_interfaces(struct wpa_global *global,
47 : : char *buf, int len);
48 : :
49 : :
50 : 0 : static int pno_start(struct wpa_supplicant *wpa_s)
51 : : {
52 : : int ret, interval;
53 : : size_t i, num_ssid;
54 : : struct wpa_ssid *ssid;
55 : : struct wpa_driver_scan_params params;
56 : :
57 [ # # ]: 0 : if (wpa_s->pno)
58 : 0 : return 0;
59 : :
60 [ # # ][ # # ]: 0 : if ((wpa_s->wpa_state > WPA_SCANNING) &&
61 : 0 : (wpa_s->wpa_state <= WPA_COMPLETED)) {
62 : 0 : wpa_printf(MSG_ERROR, "PNO: In assoc process");
63 : 0 : return -EAGAIN;
64 : : }
65 : :
66 [ # # ]: 0 : if (wpa_s->wpa_state == WPA_SCANNING) {
67 : 0 : wpa_supplicant_cancel_sched_scan(wpa_s);
68 : 0 : wpa_supplicant_cancel_scan(wpa_s);
69 : : }
70 : :
71 : 0 : os_memset(¶ms, 0, sizeof(params));
72 : :
73 : 0 : num_ssid = 0;
74 : 0 : ssid = wpa_s->conf->ssid;
75 [ # # ]: 0 : while (ssid) {
76 [ # # ]: 0 : if (!wpas_network_disabled(wpa_s, ssid))
77 : 0 : num_ssid++;
78 : 0 : ssid = ssid->next;
79 : : }
80 [ # # ]: 0 : if (num_ssid > WPAS_MAX_SCAN_SSIDS) {
81 : 0 : wpa_printf(MSG_DEBUG, "PNO: Use only the first %u SSIDs from "
82 : : "%u", WPAS_MAX_SCAN_SSIDS, (unsigned int) num_ssid);
83 : 0 : num_ssid = WPAS_MAX_SCAN_SSIDS;
84 : : }
85 : :
86 [ # # ]: 0 : if (num_ssid == 0) {
87 : 0 : wpa_printf(MSG_DEBUG, "PNO: No configured SSIDs");
88 : 0 : return -1;
89 : : }
90 : :
91 : 0 : params.filter_ssids = os_malloc(sizeof(struct wpa_driver_scan_filter) *
92 : : num_ssid);
93 [ # # ]: 0 : if (params.filter_ssids == NULL)
94 : 0 : return -1;
95 : 0 : i = 0;
96 : 0 : ssid = wpa_s->conf->ssid;
97 [ # # ]: 0 : while (ssid) {
98 [ # # ]: 0 : if (!wpas_network_disabled(wpa_s, ssid)) {
99 : 0 : params.ssids[i].ssid = ssid->ssid;
100 : 0 : params.ssids[i].ssid_len = ssid->ssid_len;
101 : 0 : params.num_ssids++;
102 : 0 : os_memcpy(params.filter_ssids[i].ssid, ssid->ssid,
103 : : ssid->ssid_len);
104 : 0 : params.filter_ssids[i].ssid_len = ssid->ssid_len;
105 : 0 : params.num_filter_ssids++;
106 : 0 : i++;
107 [ # # ]: 0 : if (i == num_ssid)
108 : 0 : break;
109 : : }
110 : 0 : ssid = ssid->next;
111 : : }
112 : :
113 [ # # ]: 0 : if (wpa_s->conf->filter_rssi)
114 : 0 : params.filter_rssi = wpa_s->conf->filter_rssi;
115 : :
116 [ # # ]: 0 : interval = wpa_s->conf->sched_scan_interval ?
117 : 0 : wpa_s->conf->sched_scan_interval : 10;
118 : :
119 : 0 : ret = wpa_supplicant_start_sched_scan(wpa_s, ¶ms, interval);
120 : 0 : os_free(params.filter_ssids);
121 [ # # ]: 0 : if (ret == 0)
122 : 0 : wpa_s->pno = 1;
123 : 0 : return ret;
124 : : }
125 : :
126 : :
127 : 0 : static int pno_stop(struct wpa_supplicant *wpa_s)
128 : : {
129 : 0 : int ret = 0;
130 : :
131 [ # # ]: 0 : if (wpa_s->pno) {
132 : 0 : wpa_s->pno = 0;
133 : 0 : ret = wpa_supplicant_stop_sched_scan(wpa_s);
134 : : }
135 : :
136 [ # # ]: 0 : if (wpa_s->wpa_state == WPA_SCANNING)
137 : 0 : wpa_supplicant_req_scan(wpa_s, 0, 0);
138 : :
139 : 0 : return ret;
140 : : }
141 : :
142 : :
143 : 0 : static int set_bssid_filter(struct wpa_supplicant *wpa_s, char *val)
144 : : {
145 : : char *pos;
146 : 0 : u8 addr[ETH_ALEN], *filter = NULL, *n;
147 : 0 : size_t count = 0;
148 : :
149 : 0 : pos = val;
150 [ # # ]: 0 : while (pos) {
151 [ # # ]: 0 : if (*pos == '\0')
152 : 0 : break;
153 [ # # ]: 0 : if (hwaddr_aton(pos, addr)) {
154 : 0 : os_free(filter);
155 : 0 : return -1;
156 : : }
157 : 0 : n = os_realloc_array(filter, count + 1, ETH_ALEN);
158 [ # # ]: 0 : if (n == NULL) {
159 : 0 : os_free(filter);
160 : 0 : return -1;
161 : : }
162 : 0 : filter = n;
163 : 0 : os_memcpy(filter + count * ETH_ALEN, addr, ETH_ALEN);
164 : 0 : count++;
165 : :
166 : 0 : pos = os_strchr(pos, ' ');
167 [ # # ]: 0 : if (pos)
168 : 0 : pos++;
169 : : }
170 : :
171 : 0 : wpa_hexdump(MSG_DEBUG, "bssid_filter", filter, count * ETH_ALEN);
172 : 0 : os_free(wpa_s->bssid_filter);
173 : 0 : wpa_s->bssid_filter = filter;
174 : 0 : wpa_s->bssid_filter_count = count;
175 : :
176 : 0 : return 0;
177 : : }
178 : :
179 : :
180 : 4 : static int set_disallow_aps(struct wpa_supplicant *wpa_s, char *val)
181 : : {
182 : : char *pos;
183 : 4 : u8 addr[ETH_ALEN], *bssid = NULL, *n;
184 : 4 : struct wpa_ssid_value *ssid = NULL, *ns;
185 : 4 : size_t count = 0, ssid_count = 0;
186 : : struct wpa_ssid *c;
187 : :
188 : : /*
189 : : * disallow_list ::= <ssid_spec> | <bssid_spec> | <disallow_list> | ""
190 : : * SSID_SPEC ::= ssid <SSID_HEX>
191 : : * BSSID_SPEC ::= bssid <BSSID_HEX>
192 : : */
193 : :
194 : 4 : pos = val;
195 [ + + ]: 7 : while (pos) {
196 [ + + ]: 4 : if (*pos == '\0')
197 : 1 : break;
198 [ + + ]: 3 : if (os_strncmp(pos, "bssid ", 6) == 0) {
199 : : int res;
200 : 2 : pos += 6;
201 : 2 : res = hwaddr_aton2(pos, addr);
202 [ - + ]: 2 : if (res < 0) {
203 : 0 : os_free(ssid);
204 : 0 : os_free(bssid);
205 : 0 : wpa_printf(MSG_DEBUG, "Invalid disallow_aps "
206 : : "BSSID value '%s'", pos);
207 : 0 : return -1;
208 : : }
209 : 2 : pos += res;
210 : 2 : n = os_realloc_array(bssid, count + 1, ETH_ALEN);
211 [ - + ]: 2 : if (n == NULL) {
212 : 0 : os_free(ssid);
213 : 0 : os_free(bssid);
214 : 0 : return -1;
215 : : }
216 : 2 : bssid = n;
217 : 2 : os_memcpy(bssid + count * ETH_ALEN, addr, ETH_ALEN);
218 : 2 : count++;
219 [ + - ]: 1 : } else if (os_strncmp(pos, "ssid ", 5) == 0) {
220 : : char *end;
221 : 1 : pos += 5;
222 : :
223 : 1 : end = pos;
224 [ + + ]: 19 : while (*end) {
225 [ + - ][ + - ]: 18 : if (*end == '\0' || *end == ' ')
226 : : break;
227 : 18 : end++;
228 : : }
229 : :
230 : 1 : ns = os_realloc_array(ssid, ssid_count + 1,
231 : : sizeof(struct wpa_ssid_value));
232 [ - + ]: 1 : if (ns == NULL) {
233 : 0 : os_free(ssid);
234 : 0 : os_free(bssid);
235 : 0 : return -1;
236 : : }
237 : 1 : ssid = ns;
238 : :
239 [ + - ]: 2 : if ((end - pos) & 0x01 || end - pos > 2 * 32 ||
[ + - - + ]
240 : 1 : hexstr2bin(pos, ssid[ssid_count].ssid,
241 : 1 : (end - pos) / 2) < 0) {
242 : 0 : os_free(ssid);
243 : 0 : os_free(bssid);
244 : 0 : wpa_printf(MSG_DEBUG, "Invalid disallow_aps "
245 : : "SSID value '%s'", pos);
246 : 0 : return -1;
247 : : }
248 : 1 : ssid[ssid_count].ssid_len = (end - pos) / 2;
249 : 1 : wpa_hexdump_ascii(MSG_DEBUG, "disallow_aps SSID",
250 : 1 : ssid[ssid_count].ssid,
251 : 1 : ssid[ssid_count].ssid_len);
252 : 1 : ssid_count++;
253 : 1 : pos = end;
254 : : } else {
255 : 0 : wpa_printf(MSG_DEBUG, "Unexpected disallow_aps value "
256 : : "'%s'", pos);
257 : 0 : os_free(ssid);
258 : 0 : os_free(bssid);
259 : 0 : return -1;
260 : : }
261 : :
262 : 3 : pos = os_strchr(pos, ' ');
263 [ - + ]: 3 : if (pos)
264 : 0 : pos++;
265 : : }
266 : :
267 : 4 : wpa_hexdump(MSG_DEBUG, "disallow_aps_bssid", bssid, count * ETH_ALEN);
268 : 4 : os_free(wpa_s->disallow_aps_bssid);
269 : 4 : wpa_s->disallow_aps_bssid = bssid;
270 : 4 : wpa_s->disallow_aps_bssid_count = count;
271 : :
272 : 4 : wpa_printf(MSG_DEBUG, "disallow_aps_ssid_count %d", (int) ssid_count);
273 : 4 : os_free(wpa_s->disallow_aps_ssid);
274 : 4 : wpa_s->disallow_aps_ssid = ssid;
275 : 4 : wpa_s->disallow_aps_ssid_count = ssid_count;
276 : :
277 [ - + ][ # # ]: 4 : if (!wpa_s->current_ssid || wpa_s->wpa_state < WPA_AUTHENTICATING)
278 : 4 : return 0;
279 : :
280 : 0 : c = wpa_s->current_ssid;
281 [ # # ][ # # ]: 0 : if (c->mode != WPAS_MODE_INFRA && c->mode != WPAS_MODE_IBSS)
282 : 0 : return 0;
283 : :
284 [ # # # # ]: 0 : if (!disallowed_bssid(wpa_s, wpa_s->bssid) &&
285 : 0 : !disallowed_ssid(wpa_s, c->ssid, c->ssid_len))
286 : 0 : return 0;
287 : :
288 : 0 : wpa_printf(MSG_DEBUG, "Disconnect and try to find another network "
289 : : "because current AP was marked disallowed");
290 : :
291 : : #ifdef CONFIG_SME
292 : 0 : wpa_s->sme.prev_bssid_set = 0;
293 : : #endif /* CONFIG_SME */
294 : 0 : wpa_s->reassociate = 1;
295 : 0 : wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
296 : 0 : wpa_supplicant_req_scan(wpa_s, 0, 0);
297 : :
298 : 4 : return 0;
299 : : }
300 : :
301 : :
302 : 5227 : static int wpa_supplicant_ctrl_iface_set(struct wpa_supplicant *wpa_s,
303 : : char *cmd)
304 : : {
305 : : char *value;
306 : 5227 : int ret = 0;
307 : :
308 : 5227 : value = os_strchr(cmd, ' ');
309 [ - + ]: 5227 : if (value == NULL)
310 : 0 : return -1;
311 : 5227 : *value++ = '\0';
312 : :
313 : 5227 : wpa_printf(MSG_DEBUG, "CTRL_IFACE SET '%s'='%s'", cmd, value);
314 [ - + ]: 5227 : if (os_strcasecmp(cmd, "EAPOL::heldPeriod") == 0) {
315 : 0 : eapol_sm_configure(wpa_s->eapol,
316 : : atoi(value), -1, -1, -1);
317 [ - + ]: 5227 : } else if (os_strcasecmp(cmd, "EAPOL::authPeriod") == 0) {
318 : 0 : eapol_sm_configure(wpa_s->eapol,
319 : : -1, atoi(value), -1, -1);
320 [ - + ]: 5227 : } else if (os_strcasecmp(cmd, "EAPOL::startPeriod") == 0) {
321 : 0 : eapol_sm_configure(wpa_s->eapol,
322 : : -1, -1, atoi(value), -1);
323 [ - + ]: 5227 : } else if (os_strcasecmp(cmd, "EAPOL::maxStart") == 0) {
324 : 0 : eapol_sm_configure(wpa_s->eapol,
325 : : -1, -1, -1, atoi(value));
326 [ + + ]: 5227 : } else if (os_strcasecmp(cmd, "dot11RSNAConfigPMKLifetime") == 0) {
327 [ - + ]: 1 : if (wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
328 : 1 : atoi(value)))
329 : 0 : ret = -1;
330 [ - + ]: 5226 : } else if (os_strcasecmp(cmd, "dot11RSNAConfigPMKReauthThreshold") ==
331 : : 0) {
332 [ # # ]: 0 : if (wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
333 : 0 : atoi(value)))
334 : 0 : ret = -1;
335 [ - + ]: 5226 : } else if (os_strcasecmp(cmd, "dot11RSNAConfigSATimeout") == 0) {
336 [ # # ]: 0 : if (wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT, atoi(value)))
337 : 0 : ret = -1;
338 [ + + ]: 5226 : } else if (os_strcasecmp(cmd, "wps_fragment_size") == 0) {
339 : 1 : wpa_s->wps_fragment_size = atoi(value);
340 : : #ifdef CONFIG_WPS_TESTING
341 [ + + ]: 5225 : } else if (os_strcasecmp(cmd, "wps_version_number") == 0) {
342 : : long int val;
343 : 2 : val = strtol(value, NULL, 0);
344 [ + - ][ - + ]: 2 : if (val < 0 || val > 0xff) {
345 : 0 : ret = -1;
346 : 0 : wpa_printf(MSG_DEBUG, "WPS: Invalid "
347 : : "wps_version_number %ld", val);
348 : : } else {
349 : 2 : wps_version_number = val;
350 : 2 : wpa_printf(MSG_DEBUG, "WPS: Testing - force WPS "
351 : : "version %u.%u",
352 : 2 : (wps_version_number & 0xf0) >> 4,
353 : : wps_version_number & 0x0f);
354 : : }
355 [ - + ]: 5223 : } else if (os_strcasecmp(cmd, "wps_testing_dummy_cred") == 0) {
356 : 0 : wps_testing_dummy_cred = atoi(value);
357 : 0 : wpa_printf(MSG_DEBUG, "WPS: Testing - dummy_cred=%d",
358 : : wps_testing_dummy_cred);
359 : : #endif /* CONFIG_WPS_TESTING */
360 [ - + ]: 5223 : } else if (os_strcasecmp(cmd, "ampdu") == 0) {
361 [ # # ]: 0 : if (wpa_drv_ampdu(wpa_s, atoi(value)) < 0)
362 : 0 : ret = -1;
363 : : #ifdef CONFIG_TDLS
364 : : #ifdef CONFIG_TDLS_TESTING
365 [ + + ]: 5223 : } else if (os_strcasecmp(cmd, "tdls_testing") == 0) {
366 : : extern unsigned int tdls_testing;
367 : 8 : tdls_testing = strtol(value, NULL, 0);
368 : 8 : wpa_printf(MSG_DEBUG, "TDLS: tdls_testing=0x%x", tdls_testing);
369 : : #endif /* CONFIG_TDLS_TESTING */
370 [ - + ]: 5215 : } else if (os_strcasecmp(cmd, "tdls_disabled") == 0) {
371 : 0 : int disabled = atoi(value);
372 : 0 : wpa_printf(MSG_DEBUG, "TDLS: tdls_disabled=%d", disabled);
373 [ # # ]: 0 : if (disabled) {
374 [ # # ]: 0 : if (wpa_drv_tdls_oper(wpa_s, TDLS_DISABLE, NULL) < 0)
375 : 0 : ret = -1;
376 [ # # ]: 0 : } else if (wpa_drv_tdls_oper(wpa_s, TDLS_ENABLE, NULL) < 0)
377 : 0 : ret = -1;
378 : 0 : wpa_tdls_enable(wpa_s->wpa, !disabled);
379 : : #endif /* CONFIG_TDLS */
380 [ - + ]: 5215 : } else if (os_strcasecmp(cmd, "pno") == 0) {
381 [ # # ]: 0 : if (atoi(value))
382 : 0 : ret = pno_start(wpa_s);
383 : : else
384 : 0 : ret = pno_stop(wpa_s);
385 [ - + ]: 5215 : } else if (os_strcasecmp(cmd, "radio_disabled") == 0) {
386 : 0 : int disabled = atoi(value);
387 [ # # ]: 0 : if (wpa_drv_radio_disable(wpa_s, disabled) < 0)
388 : 0 : ret = -1;
389 [ # # ]: 0 : else if (disabled)
390 : 0 : wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
391 [ - + ]: 5215 : } else if (os_strcasecmp(cmd, "uapsd") == 0) {
392 [ # # ]: 0 : if (os_strcmp(value, "disable") == 0)
393 : 0 : wpa_s->set_sta_uapsd = 0;
394 : : else {
395 : : int be, bk, vi, vo;
396 : : char *pos;
397 : : /* format: BE,BK,VI,VO;max SP Length */
398 : 0 : be = atoi(value);
399 : 0 : pos = os_strchr(value, ',');
400 [ # # ]: 0 : if (pos == NULL)
401 : 0 : return -1;
402 : 0 : pos++;
403 : 0 : bk = atoi(pos);
404 : 0 : pos = os_strchr(pos, ',');
405 [ # # ]: 0 : if (pos == NULL)
406 : 0 : return -1;
407 : 0 : pos++;
408 : 0 : vi = atoi(pos);
409 : 0 : pos = os_strchr(pos, ',');
410 [ # # ]: 0 : if (pos == NULL)
411 : 0 : return -1;
412 : 0 : pos++;
413 : 0 : vo = atoi(pos);
414 : : /* ignore max SP Length for now */
415 : :
416 : 0 : wpa_s->set_sta_uapsd = 1;
417 : 0 : wpa_s->sta_uapsd = 0;
418 [ # # ]: 0 : if (be)
419 : 0 : wpa_s->sta_uapsd |= BIT(0);
420 [ # # ]: 0 : if (bk)
421 : 0 : wpa_s->sta_uapsd |= BIT(1);
422 [ # # ]: 0 : if (vi)
423 : 0 : wpa_s->sta_uapsd |= BIT(2);
424 [ # # ]: 0 : if (vo)
425 : 0 : wpa_s->sta_uapsd |= BIT(3);
426 : : }
427 [ - + ]: 5215 : } else if (os_strcasecmp(cmd, "ps") == 0) {
428 : 0 : ret = wpa_drv_set_p2p_powersave(wpa_s, atoi(value), -1, -1);
429 : : #ifdef CONFIG_WIFI_DISPLAY
430 [ + + ]: 5215 : } else if (os_strcasecmp(cmd, "wifi_display") == 0) {
431 : 3 : wifi_display_enable(wpa_s->global, !!atoi(value));
432 : : #endif /* CONFIG_WIFI_DISPLAY */
433 [ - + ]: 5212 : } else if (os_strcasecmp(cmd, "bssid_filter") == 0) {
434 : 0 : ret = set_bssid_filter(wpa_s, value);
435 [ + + ]: 5212 : } else if (os_strcasecmp(cmd, "disallow_aps") == 0) {
436 : 4 : ret = set_disallow_aps(wpa_s, value);
437 [ - + ]: 5208 : } else if (os_strcasecmp(cmd, "no_keep_alive") == 0) {
438 : 0 : wpa_s->no_keep_alive = !!atoi(value);
439 : : } else {
440 : 5208 : value[-1] = '=';
441 : 5208 : ret = wpa_config_process_global(wpa_s->conf, cmd, -1);
442 [ + - ]: 5208 : if (ret == 0)
443 : 5208 : wpa_supplicant_update_config(wpa_s);
444 : : }
445 : :
446 : 5227 : return ret;
447 : : }
448 : :
449 : :
450 : 0 : static int wpa_supplicant_ctrl_iface_get(struct wpa_supplicant *wpa_s,
451 : : char *cmd, char *buf, size_t buflen)
452 : : {
453 : 0 : int res = -1;
454 : :
455 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE GET '%s'", cmd);
456 : :
457 [ # # ]: 0 : if (os_strcmp(cmd, "version") == 0) {
458 : 0 : res = os_snprintf(buf, buflen, "%s", VERSION_STR);
459 [ # # ]: 0 : } else if (os_strcasecmp(cmd, "country") == 0) {
460 [ # # ][ # # ]: 0 : if (wpa_s->conf->country[0] && wpa_s->conf->country[1])
461 : 0 : res = os_snprintf(buf, buflen, "%c%c",
462 : 0 : wpa_s->conf->country[0],
463 : 0 : wpa_s->conf->country[1]);
464 : : #ifdef CONFIG_WIFI_DISPLAY
465 [ # # ]: 0 : } else if (os_strcasecmp(cmd, "wifi_display") == 0) {
466 : 0 : res = os_snprintf(buf, buflen, "%d",
467 : 0 : wpa_s->global->wifi_display);
468 [ # # ][ # # ]: 0 : if (res < 0 || (unsigned int) res >= buflen)
469 : 0 : return -1;
470 : 0 : return res;
471 : : #endif /* CONFIG_WIFI_DISPLAY */
472 : : #ifdef CONFIG_TESTING_GET_GTK
473 : : } else if (os_strcmp(cmd, "gtk") == 0) {
474 : : if (wpa_s->last_gtk_len == 0)
475 : : return -1;
476 : : res = wpa_snprintf_hex(buf, buflen, wpa_s->last_gtk,
477 : : wpa_s->last_gtk_len);
478 : : return res;
479 : : #endif /* CONFIG_TESTING_GET_GTK */
480 : : }
481 : :
482 [ # # ][ # # ]: 0 : if (res < 0 || (unsigned int) res >= buflen)
483 : 0 : return -1;
484 : 0 : return res;
485 : : }
486 : :
487 : :
488 : : #ifdef IEEE8021X_EAPOL
489 : 0 : static int wpa_supplicant_ctrl_iface_preauth(struct wpa_supplicant *wpa_s,
490 : : char *addr)
491 : : {
492 : : u8 bssid[ETH_ALEN];
493 : 0 : struct wpa_ssid *ssid = wpa_s->current_ssid;
494 : :
495 [ # # ]: 0 : if (hwaddr_aton(addr, bssid)) {
496 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE PREAUTH: invalid address "
497 : : "'%s'", addr);
498 : 0 : return -1;
499 : : }
500 : :
501 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE PREAUTH " MACSTR, MAC2STR(bssid));
502 : 0 : rsn_preauth_deinit(wpa_s->wpa);
503 [ # # ][ # # ]: 0 : if (rsn_preauth_init(wpa_s->wpa, bssid, ssid ? &ssid->eap : NULL))
504 : 0 : return -1;
505 : :
506 : 0 : return 0;
507 : : }
508 : : #endif /* IEEE8021X_EAPOL */
509 : :
510 : :
511 : : #ifdef CONFIG_PEERKEY
512 : : /* MLME-STKSTART.request(peer) */
513 : 1 : static int wpa_supplicant_ctrl_iface_stkstart(
514 : : struct wpa_supplicant *wpa_s, char *addr)
515 : : {
516 : : u8 peer[ETH_ALEN];
517 : :
518 [ - + ]: 1 : if (hwaddr_aton(addr, peer)) {
519 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE STKSTART: invalid "
520 : : "address '%s'", addr);
521 : 0 : return -1;
522 : : }
523 : :
524 : 1 : wpa_printf(MSG_DEBUG, "CTRL_IFACE STKSTART " MACSTR,
525 : 6 : MAC2STR(peer));
526 : :
527 : 1 : return wpa_sm_stkstart(wpa_s->wpa, peer);
528 : : }
529 : : #endif /* CONFIG_PEERKEY */
530 : :
531 : :
532 : : #ifdef CONFIG_TDLS
533 : :
534 : 0 : static int wpa_supplicant_ctrl_iface_tdls_discover(
535 : : struct wpa_supplicant *wpa_s, char *addr)
536 : : {
537 : : u8 peer[ETH_ALEN];
538 : : int ret;
539 : :
540 [ # # ]: 0 : if (hwaddr_aton(addr, peer)) {
541 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE TDLS_DISCOVER: invalid "
542 : : "address '%s'", addr);
543 : 0 : return -1;
544 : : }
545 : :
546 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE TDLS_DISCOVER " MACSTR,
547 : 0 : MAC2STR(peer));
548 : :
549 [ # # ]: 0 : if (wpa_tdls_is_external_setup(wpa_s->wpa))
550 : 0 : ret = wpa_tdls_send_discovery_request(wpa_s->wpa, peer);
551 : : else
552 : 0 : ret = wpa_drv_tdls_oper(wpa_s, TDLS_DISCOVERY_REQ, peer);
553 : :
554 : 0 : return ret;
555 : : }
556 : :
557 : :
558 : 21 : static int wpa_supplicant_ctrl_iface_tdls_setup(
559 : : struct wpa_supplicant *wpa_s, char *addr)
560 : : {
561 : : u8 peer[ETH_ALEN];
562 : : int ret;
563 : :
564 [ - + ]: 21 : if (hwaddr_aton(addr, peer)) {
565 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE TDLS_SETUP: invalid "
566 : : "address '%s'", addr);
567 : 0 : return -1;
568 : : }
569 : :
570 : 21 : wpa_printf(MSG_DEBUG, "CTRL_IFACE TDLS_SETUP " MACSTR,
571 : 126 : MAC2STR(peer));
572 : :
573 [ - + # # ]: 21 : if ((wpa_s->conf->tdls_external_control) &&
574 : 0 : wpa_tdls_is_external_setup(wpa_s->wpa))
575 : 0 : return wpa_drv_tdls_oper(wpa_s, TDLS_SETUP, peer);
576 : :
577 : 21 : wpa_tdls_remove(wpa_s->wpa, peer);
578 : :
579 [ + - ]: 21 : if (wpa_tdls_is_external_setup(wpa_s->wpa))
580 : 21 : ret = wpa_tdls_start(wpa_s->wpa, peer);
581 : : else
582 : 0 : ret = wpa_drv_tdls_oper(wpa_s, TDLS_SETUP, peer);
583 : :
584 : 21 : return ret;
585 : : }
586 : :
587 : :
588 : 8 : static int wpa_supplicant_ctrl_iface_tdls_teardown(
589 : : struct wpa_supplicant *wpa_s, char *addr)
590 : : {
591 : : u8 peer[ETH_ALEN];
592 : : int ret;
593 : :
594 [ - + ]: 8 : if (hwaddr_aton(addr, peer)) {
595 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE TDLS_TEARDOWN: invalid "
596 : : "address '%s'", addr);
597 : 0 : return -1;
598 : : }
599 : :
600 : 8 : wpa_printf(MSG_DEBUG, "CTRL_IFACE TDLS_TEARDOWN " MACSTR,
601 : 48 : MAC2STR(peer));
602 : :
603 [ - + # # ]: 8 : if ((wpa_s->conf->tdls_external_control) &&
604 : 0 : wpa_tdls_is_external_setup(wpa_s->wpa))
605 : 0 : return wpa_drv_tdls_oper(wpa_s, TDLS_TEARDOWN, peer);
606 : :
607 [ + - ]: 8 : if (wpa_tdls_is_external_setup(wpa_s->wpa))
608 : 8 : ret = wpa_tdls_teardown_link(
609 : : wpa_s->wpa, peer,
610 : : WLAN_REASON_TDLS_TEARDOWN_UNSPECIFIED);
611 : : else
612 : 0 : ret = wpa_drv_tdls_oper(wpa_s, TDLS_TEARDOWN, peer);
613 : :
614 : 8 : return ret;
615 : : }
616 : :
617 : : #endif /* CONFIG_TDLS */
618 : :
619 : :
620 : : #ifdef CONFIG_IEEE80211R
621 : 6 : static int wpa_supplicant_ctrl_iface_ft_ds(
622 : : struct wpa_supplicant *wpa_s, char *addr)
623 : : {
624 : : u8 target_ap[ETH_ALEN];
625 : : struct wpa_bss *bss;
626 : : const u8 *mdie;
627 : :
628 [ - + ]: 6 : if (hwaddr_aton(addr, target_ap)) {
629 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE FT_DS: invalid "
630 : : "address '%s'", addr);
631 : 0 : return -1;
632 : : }
633 : :
634 : 6 : wpa_printf(MSG_DEBUG, "CTRL_IFACE FT_DS " MACSTR, MAC2STR(target_ap));
635 : :
636 : 6 : bss = wpa_bss_get_bssid(wpa_s, target_ap);
637 [ + - ]: 6 : if (bss)
638 : 6 : mdie = wpa_bss_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN);
639 : : else
640 : 0 : mdie = NULL;
641 : :
642 : 6 : return wpa_ft_start_over_ds(wpa_s->wpa, target_ap, mdie);
643 : : }
644 : : #endif /* CONFIG_IEEE80211R */
645 : :
646 : :
647 : : #ifdef CONFIG_WPS
648 : 14 : static int wpa_supplicant_ctrl_iface_wps_pbc(struct wpa_supplicant *wpa_s,
649 : : char *cmd)
650 : : {
651 : 14 : u8 bssid[ETH_ALEN], *_bssid = bssid;
652 : : #ifdef CONFIG_P2P
653 : : u8 p2p_dev_addr[ETH_ALEN];
654 : : #endif /* CONFIG_P2P */
655 : : #ifdef CONFIG_AP
656 : 14 : u8 *_p2p_dev_addr = NULL;
657 : : #endif /* CONFIG_AP */
658 : :
659 [ - + ][ # # ]: 14 : if (cmd == NULL || os_strcmp(cmd, "any") == 0) {
660 : 14 : _bssid = NULL;
661 : : #ifdef CONFIG_P2P
662 [ # # ]: 0 : } else if (os_strncmp(cmd, "p2p_dev_addr=", 13) == 0) {
663 [ # # ]: 0 : if (hwaddr_aton(cmd + 13, p2p_dev_addr)) {
664 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE WPS_PBC: invalid "
665 : : "P2P Device Address '%s'",
666 : : cmd + 13);
667 : 0 : return -1;
668 : : }
669 : 0 : _p2p_dev_addr = p2p_dev_addr;
670 : : #endif /* CONFIG_P2P */
671 [ # # ]: 0 : } else if (hwaddr_aton(cmd, bssid)) {
672 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE WPS_PBC: invalid BSSID '%s'",
673 : : cmd);
674 : 0 : return -1;
675 : : }
676 : :
677 : : #ifdef CONFIG_AP
678 [ + + ]: 14 : if (wpa_s->ap_iface)
679 : 1 : return wpa_supplicant_ap_wps_pbc(wpa_s, _bssid, _p2p_dev_addr);
680 : : #endif /* CONFIG_AP */
681 : :
682 : 14 : return wpas_wps_start_pbc(wpa_s, _bssid, 0);
683 : : }
684 : :
685 : :
686 : 29 : static int wpa_supplicant_ctrl_iface_wps_pin(struct wpa_supplicant *wpa_s,
687 : : char *cmd, char *buf,
688 : : size_t buflen)
689 : : {
690 : 29 : u8 bssid[ETH_ALEN], *_bssid = bssid;
691 : : char *pin;
692 : : int ret;
693 : :
694 : 29 : pin = os_strchr(cmd, ' ');
695 [ + - ]: 29 : if (pin)
696 : 29 : *pin++ = '\0';
697 : :
698 [ + - ]: 29 : if (os_strcmp(cmd, "any") == 0)
699 : 29 : _bssid = NULL;
700 [ # # ]: 0 : else if (os_strcmp(cmd, "get") == 0) {
701 : 0 : ret = wps_generate_pin();
702 : 0 : goto done;
703 [ # # ]: 0 : } else if (hwaddr_aton(cmd, bssid)) {
704 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE WPS_PIN: invalid BSSID '%s'",
705 : : cmd);
706 : 0 : return -1;
707 : : }
708 : :
709 : : #ifdef CONFIG_AP
710 [ + + ]: 29 : if (wpa_s->ap_iface) {
711 : 19 : int timeout = 0;
712 : : char *pos;
713 : :
714 [ + - ]: 19 : if (pin) {
715 : 19 : pos = os_strchr(pin, ' ');
716 [ - + ]: 19 : if (pos) {
717 : 0 : *pos++ = '\0';
718 : 0 : timeout = atoi(pos);
719 : : }
720 : : }
721 : :
722 : 19 : return wpa_supplicant_ap_wps_pin(wpa_s, _bssid, pin,
723 : : buf, buflen, timeout);
724 : : }
725 : : #endif /* CONFIG_AP */
726 : :
727 [ + - ]: 10 : if (pin) {
728 : 10 : ret = wpas_wps_start_pin(wpa_s, _bssid, pin, 0,
729 : : DEV_PW_DEFAULT);
730 [ - + ]: 10 : if (ret < 0)
731 : 0 : return -1;
732 : 10 : ret = os_snprintf(buf, buflen, "%s", pin);
733 [ + - ][ - + ]: 10 : if (ret < 0 || (size_t) ret >= buflen)
734 : 0 : return -1;
735 : 10 : return ret;
736 : : }
737 : :
738 : 0 : ret = wpas_wps_start_pin(wpa_s, _bssid, NULL, 0, DEV_PW_DEFAULT);
739 [ # # ]: 0 : if (ret < 0)
740 : 0 : return -1;
741 : :
742 : : done:
743 : : /* Return the generated PIN */
744 : 0 : ret = os_snprintf(buf, buflen, "%08d", ret);
745 [ # # ][ # # ]: 0 : if (ret < 0 || (size_t) ret >= buflen)
746 : 0 : return -1;
747 : 29 : return ret;
748 : : }
749 : :
750 : :
751 : 5 : static int wpa_supplicant_ctrl_iface_wps_check_pin(
752 : : struct wpa_supplicant *wpa_s, char *cmd, char *buf, size_t buflen)
753 : : {
754 : : char pin[9];
755 : : size_t len;
756 : : char *pos;
757 : : int ret;
758 : :
759 : 5 : wpa_hexdump_ascii_key(MSG_DEBUG, "WPS_CHECK_PIN",
760 : : (u8 *) cmd, os_strlen(cmd));
761 [ + + ]: 51 : for (pos = cmd, len = 0; *pos != '\0'; pos++) {
762 [ + + ][ + + ]: 46 : if (*pos < '0' || *pos > '9')
763 : 6 : continue;
764 : 40 : pin[len++] = *pos;
765 [ - + ]: 40 : if (len == 9) {
766 : 0 : wpa_printf(MSG_DEBUG, "WPS: Too long PIN");
767 : 0 : return -1;
768 : : }
769 : : }
770 [ + - ][ - + ]: 5 : if (len != 4 && len != 8) {
771 : 0 : wpa_printf(MSG_DEBUG, "WPS: Invalid PIN length %d", (int) len);
772 : 0 : return -1;
773 : : }
774 : 5 : pin[len] = '\0';
775 : :
776 [ + - ]: 5 : if (len == 8) {
777 : : unsigned int pin_val;
778 : 5 : pin_val = atoi(pin);
779 [ + + ]: 5 : if (!wps_pin_valid(pin_val)) {
780 : 1 : wpa_printf(MSG_DEBUG, "WPS: Invalid checksum digit");
781 : 1 : ret = os_snprintf(buf, buflen, "FAIL-CHECKSUM\n");
782 [ + - ][ - + ]: 1 : if (ret < 0 || (size_t) ret >= buflen)
783 : 0 : return -1;
784 : 1 : return ret;
785 : : }
786 : : }
787 : :
788 : 4 : ret = os_snprintf(buf, buflen, "%s", pin);
789 [ + - ][ - + ]: 4 : if (ret < 0 || (size_t) ret >= buflen)
790 : 0 : return -1;
791 : :
792 : 5 : return ret;
793 : : }
794 : :
795 : :
796 : : #ifdef CONFIG_WPS_NFC
797 : :
798 : 2 : static int wpa_supplicant_ctrl_iface_wps_nfc(struct wpa_supplicant *wpa_s,
799 : : char *cmd)
800 : : {
801 : 2 : u8 bssid[ETH_ALEN], *_bssid = bssid;
802 : :
803 [ - + ][ # # ]: 2 : if (cmd == NULL || cmd[0] == '\0')
804 : 2 : _bssid = NULL;
805 [ # # ]: 0 : else if (hwaddr_aton(cmd, bssid))
806 : 0 : return -1;
807 : :
808 : 2 : return wpas_wps_start_nfc(wpa_s, _bssid);
809 : : }
810 : :
811 : :
812 : 0 : static int wpa_supplicant_ctrl_iface_wps_nfc_config_token(
813 : : struct wpa_supplicant *wpa_s, char *cmd, char *reply, size_t max_len)
814 : : {
815 : : int ndef;
816 : : struct wpabuf *buf;
817 : : int res;
818 : : char *pos;
819 : :
820 : 0 : pos = os_strchr(cmd, ' ');
821 [ # # ]: 0 : if (pos)
822 : 0 : *pos++ = '\0';
823 [ # # ]: 0 : if (os_strcmp(cmd, "WPS") == 0)
824 : 0 : ndef = 0;
825 [ # # ]: 0 : else if (os_strcmp(cmd, "NDEF") == 0)
826 : 0 : ndef = 1;
827 : : else
828 : 0 : return -1;
829 : :
830 : 0 : buf = wpas_wps_nfc_config_token(wpa_s, ndef, pos);
831 [ # # ]: 0 : if (buf == NULL)
832 : 0 : return -1;
833 : :
834 : 0 : res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf),
835 : : wpabuf_len(buf));
836 : 0 : reply[res++] = '\n';
837 : 0 : reply[res] = '\0';
838 : :
839 : 0 : wpabuf_free(buf);
840 : :
841 : 0 : return res;
842 : : }
843 : :
844 : :
845 : 2 : static int wpa_supplicant_ctrl_iface_wps_nfc_token(
846 : : struct wpa_supplicant *wpa_s, char *cmd, char *reply, size_t max_len)
847 : : {
848 : : int ndef;
849 : : struct wpabuf *buf;
850 : : int res;
851 : :
852 [ - + ]: 2 : if (os_strcmp(cmd, "WPS") == 0)
853 : 0 : ndef = 0;
854 [ + - ]: 2 : else if (os_strcmp(cmd, "NDEF") == 0)
855 : 2 : ndef = 1;
856 : : else
857 : 0 : return -1;
858 : :
859 : 2 : buf = wpas_wps_nfc_token(wpa_s, ndef);
860 [ - + ]: 2 : if (buf == NULL)
861 : 0 : return -1;
862 : :
863 : 2 : res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf),
864 : : wpabuf_len(buf));
865 : 2 : reply[res++] = '\n';
866 : 2 : reply[res] = '\0';
867 : :
868 : 2 : wpabuf_free(buf);
869 : :
870 : 2 : return res;
871 : : }
872 : :
873 : :
874 : 3 : static int wpa_supplicant_ctrl_iface_wps_nfc_tag_read(
875 : : struct wpa_supplicant *wpa_s, char *pos)
876 : : {
877 : : size_t len;
878 : : struct wpabuf *buf;
879 : : int ret;
880 : :
881 : 3 : len = os_strlen(pos);
882 [ - + ]: 3 : if (len & 0x01)
883 : 0 : return -1;
884 : 3 : len /= 2;
885 : :
886 : 3 : buf = wpabuf_alloc(len);
887 [ - + ]: 3 : if (buf == NULL)
888 : 0 : return -1;
889 [ - + ]: 3 : if (hexstr2bin(pos, wpabuf_put(buf, len), len) < 0) {
890 : 0 : wpabuf_free(buf);
891 : 0 : return -1;
892 : : }
893 : :
894 : 3 : ret = wpas_wps_nfc_tag_read(wpa_s, buf);
895 : 3 : wpabuf_free(buf);
896 : :
897 : 3 : return ret;
898 : : }
899 : :
900 : :
901 : 1 : static int wpas_ctrl_nfc_get_handover_req_wps(struct wpa_supplicant *wpa_s,
902 : : char *reply, size_t max_len,
903 : : int cr)
904 : : {
905 : : struct wpabuf *buf;
906 : : int res;
907 : :
908 : 1 : buf = wpas_wps_nfc_handover_req(wpa_s, cr);
909 [ - + ]: 1 : if (buf == NULL)
910 : 0 : return -1;
911 : :
912 : 1 : res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf),
913 : : wpabuf_len(buf));
914 : 1 : reply[res++] = '\n';
915 : 1 : reply[res] = '\0';
916 : :
917 : 1 : wpabuf_free(buf);
918 : :
919 : 1 : return res;
920 : : }
921 : :
922 : :
923 : 1 : static int wpas_ctrl_nfc_get_handover_req(struct wpa_supplicant *wpa_s,
924 : : char *cmd, char *reply,
925 : : size_t max_len)
926 : : {
927 : : char *pos;
928 : :
929 : 1 : pos = os_strchr(cmd, ' ');
930 [ - + ]: 1 : if (pos == NULL)
931 : 0 : return -1;
932 : 1 : *pos++ = '\0';
933 : :
934 [ - + ]: 1 : if (os_strcmp(cmd, "NDEF") != 0)
935 : 0 : return -1;
936 : :
937 [ + - ][ + - ]: 1 : if (os_strcmp(pos, "WPS") == 0 || os_strcmp(pos, "WPS-CR") == 0) {
938 : 1 : return wpas_ctrl_nfc_get_handover_req_wps(
939 : 1 : wpa_s, reply, max_len, os_strcmp(pos, "WPS-CR") == 0);
940 : : }
941 : :
942 : 1 : return -1;
943 : : }
944 : :
945 : :
946 : 0 : static int wpas_ctrl_nfc_get_handover_sel_wps(struct wpa_supplicant *wpa_s,
947 : : char *reply, size_t max_len,
948 : : int ndef, int cr, char *uuid)
949 : : {
950 : : struct wpabuf *buf;
951 : : int res;
952 : :
953 : 0 : buf = wpas_wps_nfc_handover_sel(wpa_s, ndef, cr, uuid);
954 [ # # ]: 0 : if (buf == NULL)
955 : 0 : return -1;
956 : :
957 : 0 : res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf),
958 : : wpabuf_len(buf));
959 : 0 : reply[res++] = '\n';
960 : 0 : reply[res] = '\0';
961 : :
962 : 0 : wpabuf_free(buf);
963 : :
964 : 0 : return res;
965 : : }
966 : :
967 : :
968 : 0 : static int wpas_ctrl_nfc_get_handover_sel(struct wpa_supplicant *wpa_s,
969 : : char *cmd, char *reply,
970 : : size_t max_len)
971 : : {
972 : : char *pos, *pos2;
973 : : int ndef;
974 : :
975 : 0 : pos = os_strchr(cmd, ' ');
976 [ # # ]: 0 : if (pos == NULL)
977 : 0 : return -1;
978 : 0 : *pos++ = '\0';
979 : :
980 [ # # ]: 0 : if (os_strcmp(cmd, "WPS") == 0)
981 : 0 : ndef = 0;
982 [ # # ]: 0 : else if (os_strcmp(cmd, "NDEF") == 0)
983 : 0 : ndef = 1;
984 : : else
985 : 0 : return -1;
986 : :
987 : 0 : pos2 = os_strchr(pos, ' ');
988 [ # # ]: 0 : if (pos2)
989 : 0 : *pos2++ = '\0';
990 [ # # ][ # # ]: 0 : if (os_strcmp(pos, "WPS") == 0 || os_strcmp(pos, "WPS-CR") == 0) {
991 : 0 : return wpas_ctrl_nfc_get_handover_sel_wps(
992 : : wpa_s, reply, max_len, ndef,
993 : 0 : os_strcmp(pos, "WPS-CR") == 0, pos2);
994 : : }
995 : :
996 : 0 : return -1;
997 : : }
998 : :
999 : :
1000 : 0 : static int wpas_ctrl_nfc_rx_handover_req(struct wpa_supplicant *wpa_s,
1001 : : char *cmd, char *reply,
1002 : : size_t max_len)
1003 : : {
1004 : : size_t len;
1005 : : struct wpabuf *buf;
1006 : : int ret;
1007 : :
1008 : 0 : len = os_strlen(cmd);
1009 [ # # ]: 0 : if (len & 0x01)
1010 : 0 : return -1;
1011 : 0 : len /= 2;
1012 : :
1013 : 0 : buf = wpabuf_alloc(len);
1014 [ # # ]: 0 : if (buf == NULL)
1015 : 0 : return -1;
1016 [ # # ]: 0 : if (hexstr2bin(cmd, wpabuf_put(buf, len), len) < 0) {
1017 : 0 : wpabuf_free(buf);
1018 : 0 : return -1;
1019 : : }
1020 : :
1021 : 0 : ret = wpas_wps_nfc_rx_handover_req(wpa_s, buf);
1022 : 0 : wpabuf_free(buf);
1023 : :
1024 : 0 : return ret;
1025 : : }
1026 : :
1027 : :
1028 : 0 : static int wpas_ctrl_nfc_rx_handover_sel(struct wpa_supplicant *wpa_s,
1029 : : char *cmd)
1030 : : {
1031 : : size_t len;
1032 : : struct wpabuf *buf;
1033 : : int ret;
1034 : :
1035 : 0 : len = os_strlen(cmd);
1036 [ # # ]: 0 : if (len & 0x01)
1037 : 0 : return -1;
1038 : 0 : len /= 2;
1039 : :
1040 : 0 : buf = wpabuf_alloc(len);
1041 [ # # ]: 0 : if (buf == NULL)
1042 : 0 : return -1;
1043 [ # # ]: 0 : if (hexstr2bin(cmd, wpabuf_put(buf, len), len) < 0) {
1044 : 0 : wpabuf_free(buf);
1045 : 0 : return -1;
1046 : : }
1047 : :
1048 : 0 : ret = wpas_wps_nfc_rx_handover_sel(wpa_s, buf);
1049 : 0 : wpabuf_free(buf);
1050 : :
1051 : 0 : return ret;
1052 : : }
1053 : :
1054 : :
1055 : 1 : static int wpas_ctrl_nfc_report_handover(struct wpa_supplicant *wpa_s,
1056 : : char *cmd)
1057 : : {
1058 : : size_t len;
1059 : : struct wpabuf *req, *sel;
1060 : : int ret;
1061 : : char *pos, *role, *type, *pos2;
1062 : :
1063 : 1 : role = cmd;
1064 : 1 : pos = os_strchr(role, ' ');
1065 [ - + ]: 1 : if (pos == NULL)
1066 : 0 : return -1;
1067 : 1 : *pos++ = '\0';
1068 : :
1069 : 1 : type = pos;
1070 : 1 : pos = os_strchr(type, ' ');
1071 [ - + ]: 1 : if (pos == NULL)
1072 : 0 : return -1;
1073 : 1 : *pos++ = '\0';
1074 : :
1075 : 1 : pos2 = os_strchr(pos, ' ');
1076 [ - + ]: 1 : if (pos2 == NULL)
1077 : 0 : return -1;
1078 : 1 : *pos2++ = '\0';
1079 : :
1080 : 1 : len = os_strlen(pos);
1081 [ - + ]: 1 : if (len & 0x01)
1082 : 0 : return -1;
1083 : 1 : len /= 2;
1084 : :
1085 : 1 : req = wpabuf_alloc(len);
1086 [ - + ]: 1 : if (req == NULL)
1087 : 0 : return -1;
1088 [ - + ]: 1 : if (hexstr2bin(pos, wpabuf_put(req, len), len) < 0) {
1089 : 0 : wpabuf_free(req);
1090 : 0 : return -1;
1091 : : }
1092 : :
1093 : 1 : len = os_strlen(pos2);
1094 [ - + ]: 1 : if (len & 0x01) {
1095 : 0 : wpabuf_free(req);
1096 : 0 : return -1;
1097 : : }
1098 : 1 : len /= 2;
1099 : :
1100 : 1 : sel = wpabuf_alloc(len);
1101 [ - + ]: 1 : if (sel == NULL) {
1102 : 0 : wpabuf_free(req);
1103 : 0 : return -1;
1104 : : }
1105 [ - + ]: 1 : if (hexstr2bin(pos2, wpabuf_put(sel, len), len) < 0) {
1106 : 0 : wpabuf_free(req);
1107 : 0 : wpabuf_free(sel);
1108 : 0 : return -1;
1109 : : }
1110 : :
1111 [ + - ][ + - ]: 1 : if (os_strcmp(role, "INIT") == 0 && os_strcmp(type, "WPS") == 0) {
1112 : 1 : ret = wpas_wps_nfc_report_handover(wpa_s, req, sel);
1113 : : } else {
1114 : 0 : wpa_printf(MSG_DEBUG, "NFC: Unsupported connection handover "
1115 : : "reported: role=%s type=%s", role, type);
1116 : 0 : ret = -1;
1117 : : }
1118 : 1 : wpabuf_free(req);
1119 : 1 : wpabuf_free(sel);
1120 : :
1121 : 1 : return ret;
1122 : : }
1123 : :
1124 : : #endif /* CONFIG_WPS_NFC */
1125 : :
1126 : :
1127 : 16 : static int wpa_supplicant_ctrl_iface_wps_reg(struct wpa_supplicant *wpa_s,
1128 : : char *cmd)
1129 : : {
1130 : : u8 bssid[ETH_ALEN];
1131 : : char *pin;
1132 : : char *new_ssid;
1133 : : char *new_auth;
1134 : : char *new_encr;
1135 : : char *new_key;
1136 : : struct wps_new_ap_settings ap;
1137 : :
1138 : 16 : pin = os_strchr(cmd, ' ');
1139 [ - + ]: 16 : if (pin == NULL)
1140 : 0 : return -1;
1141 : 16 : *pin++ = '\0';
1142 : :
1143 [ - + ]: 16 : if (hwaddr_aton(cmd, bssid)) {
1144 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE WPS_REG: invalid BSSID '%s'",
1145 : : cmd);
1146 : 0 : return -1;
1147 : : }
1148 : :
1149 : 16 : new_ssid = os_strchr(pin, ' ');
1150 [ + + ]: 16 : if (new_ssid == NULL)
1151 : 7 : return wpas_wps_start_reg(wpa_s, bssid, pin, NULL);
1152 : 9 : *new_ssid++ = '\0';
1153 : :
1154 : 9 : new_auth = os_strchr(new_ssid, ' ');
1155 [ - + ]: 9 : if (new_auth == NULL)
1156 : 0 : return -1;
1157 : 9 : *new_auth++ = '\0';
1158 : :
1159 : 9 : new_encr = os_strchr(new_auth, ' ');
1160 [ - + ]: 9 : if (new_encr == NULL)
1161 : 0 : return -1;
1162 : 9 : *new_encr++ = '\0';
1163 : :
1164 : 9 : new_key = os_strchr(new_encr, ' ');
1165 [ - + ]: 9 : if (new_key == NULL)
1166 : 0 : return -1;
1167 : 9 : *new_key++ = '\0';
1168 : :
1169 : 9 : os_memset(&ap, 0, sizeof(ap));
1170 : 9 : ap.ssid_hex = new_ssid;
1171 : 9 : ap.auth = new_auth;
1172 : 9 : ap.encr = new_encr;
1173 : 9 : ap.key_hex = new_key;
1174 : 16 : return wpas_wps_start_reg(wpa_s, bssid, pin, &ap);
1175 : : }
1176 : :
1177 : :
1178 : : #ifdef CONFIG_AP
1179 : 0 : static int wpa_supplicant_ctrl_iface_wps_ap_pin(struct wpa_supplicant *wpa_s,
1180 : : char *cmd, char *buf,
1181 : : size_t buflen)
1182 : : {
1183 : 0 : int timeout = 300;
1184 : : char *pos;
1185 : : const char *pin_txt;
1186 : :
1187 [ # # ]: 0 : if (!wpa_s->ap_iface)
1188 : 0 : return -1;
1189 : :
1190 : 0 : pos = os_strchr(cmd, ' ');
1191 [ # # ]: 0 : if (pos)
1192 : 0 : *pos++ = '\0';
1193 : :
1194 [ # # ]: 0 : if (os_strcmp(cmd, "disable") == 0) {
1195 : 0 : wpas_wps_ap_pin_disable(wpa_s);
1196 : 0 : return os_snprintf(buf, buflen, "OK\n");
1197 : : }
1198 : :
1199 [ # # ]: 0 : if (os_strcmp(cmd, "random") == 0) {
1200 [ # # ]: 0 : if (pos)
1201 : 0 : timeout = atoi(pos);
1202 : 0 : pin_txt = wpas_wps_ap_pin_random(wpa_s, timeout);
1203 [ # # ]: 0 : if (pin_txt == NULL)
1204 : 0 : return -1;
1205 : 0 : return os_snprintf(buf, buflen, "%s", pin_txt);
1206 : : }
1207 : :
1208 [ # # ]: 0 : if (os_strcmp(cmd, "get") == 0) {
1209 : 0 : pin_txt = wpas_wps_ap_pin_get(wpa_s);
1210 [ # # ]: 0 : if (pin_txt == NULL)
1211 : 0 : return -1;
1212 : 0 : return os_snprintf(buf, buflen, "%s", pin_txt);
1213 : : }
1214 : :
1215 [ # # ]: 0 : if (os_strcmp(cmd, "set") == 0) {
1216 : : char *pin;
1217 [ # # ]: 0 : if (pos == NULL)
1218 : 0 : return -1;
1219 : 0 : pin = pos;
1220 : 0 : pos = os_strchr(pos, ' ');
1221 [ # # ]: 0 : if (pos) {
1222 : 0 : *pos++ = '\0';
1223 : 0 : timeout = atoi(pos);
1224 : : }
1225 [ # # ]: 0 : if (os_strlen(pin) > buflen)
1226 : 0 : return -1;
1227 [ # # ]: 0 : if (wpas_wps_ap_pin_set(wpa_s, pin, timeout) < 0)
1228 : 0 : return -1;
1229 : 0 : return os_snprintf(buf, buflen, "%s", pin);
1230 : : }
1231 : :
1232 : 0 : return -1;
1233 : : }
1234 : : #endif /* CONFIG_AP */
1235 : :
1236 : :
1237 : : #ifdef CONFIG_WPS_ER
1238 : 2 : static int wpa_supplicant_ctrl_iface_wps_er_pin(struct wpa_supplicant *wpa_s,
1239 : : char *cmd)
1240 : : {
1241 : 2 : char *uuid = cmd, *pin, *pos;
1242 : 2 : u8 addr_buf[ETH_ALEN], *addr = NULL;
1243 : 2 : pin = os_strchr(uuid, ' ');
1244 [ - + ]: 2 : if (pin == NULL)
1245 : 0 : return -1;
1246 : 2 : *pin++ = '\0';
1247 : 2 : pos = os_strchr(pin, ' ');
1248 [ + - ]: 2 : if (pos) {
1249 : 2 : *pos++ = '\0';
1250 [ + - ]: 2 : if (hwaddr_aton(pos, addr_buf) == 0)
1251 : 2 : addr = addr_buf;
1252 : : }
1253 : 2 : return wpas_wps_er_add_pin(wpa_s, addr, uuid, pin);
1254 : : }
1255 : :
1256 : :
1257 : 1 : static int wpa_supplicant_ctrl_iface_wps_er_learn(struct wpa_supplicant *wpa_s,
1258 : : char *cmd)
1259 : : {
1260 : 1 : char *uuid = cmd, *pin;
1261 : 1 : pin = os_strchr(uuid, ' ');
1262 [ - + ]: 1 : if (pin == NULL)
1263 : 0 : return -1;
1264 : 1 : *pin++ = '\0';
1265 : 1 : return wpas_wps_er_learn(wpa_s, uuid, pin);
1266 : : }
1267 : :
1268 : :
1269 : 2 : static int wpa_supplicant_ctrl_iface_wps_er_set_config(
1270 : : struct wpa_supplicant *wpa_s, char *cmd)
1271 : : {
1272 : 2 : char *uuid = cmd, *id;
1273 : 2 : id = os_strchr(uuid, ' ');
1274 [ - + ]: 2 : if (id == NULL)
1275 : 0 : return -1;
1276 : 2 : *id++ = '\0';
1277 : 2 : return wpas_wps_er_set_config(wpa_s, uuid, atoi(id));
1278 : : }
1279 : :
1280 : :
1281 : 1 : static int wpa_supplicant_ctrl_iface_wps_er_config(
1282 : : struct wpa_supplicant *wpa_s, char *cmd)
1283 : : {
1284 : : char *pin;
1285 : : char *new_ssid;
1286 : : char *new_auth;
1287 : : char *new_encr;
1288 : : char *new_key;
1289 : : struct wps_new_ap_settings ap;
1290 : :
1291 : 1 : pin = os_strchr(cmd, ' ');
1292 [ - + ]: 1 : if (pin == NULL)
1293 : 0 : return -1;
1294 : 1 : *pin++ = '\0';
1295 : :
1296 : 1 : new_ssid = os_strchr(pin, ' ');
1297 [ - + ]: 1 : if (new_ssid == NULL)
1298 : 0 : return -1;
1299 : 1 : *new_ssid++ = '\0';
1300 : :
1301 : 1 : new_auth = os_strchr(new_ssid, ' ');
1302 [ - + ]: 1 : if (new_auth == NULL)
1303 : 0 : return -1;
1304 : 1 : *new_auth++ = '\0';
1305 : :
1306 : 1 : new_encr = os_strchr(new_auth, ' ');
1307 [ - + ]: 1 : if (new_encr == NULL)
1308 : 0 : return -1;
1309 : 1 : *new_encr++ = '\0';
1310 : :
1311 : 1 : new_key = os_strchr(new_encr, ' ');
1312 [ - + ]: 1 : if (new_key == NULL)
1313 : 0 : return -1;
1314 : 1 : *new_key++ = '\0';
1315 : :
1316 : 1 : os_memset(&ap, 0, sizeof(ap));
1317 : 1 : ap.ssid_hex = new_ssid;
1318 : 1 : ap.auth = new_auth;
1319 : 1 : ap.encr = new_encr;
1320 : 1 : ap.key_hex = new_key;
1321 : 1 : return wpas_wps_er_config(wpa_s, cmd, pin, &ap);
1322 : : }
1323 : :
1324 : :
1325 : : #ifdef CONFIG_WPS_NFC
1326 : 0 : static int wpa_supplicant_ctrl_iface_wps_er_nfc_config_token(
1327 : : struct wpa_supplicant *wpa_s, char *cmd, char *reply, size_t max_len)
1328 : : {
1329 : : int ndef;
1330 : : struct wpabuf *buf;
1331 : : int res;
1332 : : char *uuid;
1333 : :
1334 : 0 : uuid = os_strchr(cmd, ' ');
1335 [ # # ]: 0 : if (uuid == NULL)
1336 : 0 : return -1;
1337 : 0 : *uuid++ = '\0';
1338 : :
1339 [ # # ]: 0 : if (os_strcmp(cmd, "WPS") == 0)
1340 : 0 : ndef = 0;
1341 [ # # ]: 0 : else if (os_strcmp(cmd, "NDEF") == 0)
1342 : 0 : ndef = 1;
1343 : : else
1344 : 0 : return -1;
1345 : :
1346 : 0 : buf = wpas_wps_er_nfc_config_token(wpa_s, ndef, uuid);
1347 [ # # ]: 0 : if (buf == NULL)
1348 : 0 : return -1;
1349 : :
1350 : 0 : res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf),
1351 : : wpabuf_len(buf));
1352 : 0 : reply[res++] = '\n';
1353 : 0 : reply[res] = '\0';
1354 : :
1355 : 0 : wpabuf_free(buf);
1356 : :
1357 : 0 : return res;
1358 : : }
1359 : : #endif /* CONFIG_WPS_NFC */
1360 : : #endif /* CONFIG_WPS_ER */
1361 : :
1362 : : #endif /* CONFIG_WPS */
1363 : :
1364 : :
1365 : : #ifdef CONFIG_IBSS_RSN
1366 : 0 : static int wpa_supplicant_ctrl_iface_ibss_rsn(
1367 : : struct wpa_supplicant *wpa_s, char *addr)
1368 : : {
1369 : : u8 peer[ETH_ALEN];
1370 : :
1371 [ # # ]: 0 : if (hwaddr_aton(addr, peer)) {
1372 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE IBSS_RSN: invalid "
1373 : : "address '%s'", addr);
1374 : 0 : return -1;
1375 : : }
1376 : :
1377 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE IBSS_RSN " MACSTR,
1378 : 0 : MAC2STR(peer));
1379 : :
1380 : 0 : return ibss_rsn_start(wpa_s->ibss_rsn, peer);
1381 : : }
1382 : : #endif /* CONFIG_IBSS_RSN */
1383 : :
1384 : :
1385 : 9 : static int wpa_supplicant_ctrl_iface_ctrl_rsp(struct wpa_supplicant *wpa_s,
1386 : : char *rsp)
1387 : : {
1388 : : #ifdef IEEE8021X_EAPOL
1389 : : char *pos, *id_pos;
1390 : : int id;
1391 : : struct wpa_ssid *ssid;
1392 : :
1393 : 9 : pos = os_strchr(rsp, '-');
1394 [ - + ]: 9 : if (pos == NULL)
1395 : 0 : return -1;
1396 : 9 : *pos++ = '\0';
1397 : 9 : id_pos = pos;
1398 : 9 : pos = os_strchr(pos, ':');
1399 [ - + ]: 9 : if (pos == NULL)
1400 : 0 : return -1;
1401 : 9 : *pos++ = '\0';
1402 : 9 : id = atoi(id_pos);
1403 : 9 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: field=%s id=%d", rsp, id);
1404 : 9 : wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: value",
1405 : : (u8 *) pos, os_strlen(pos));
1406 : :
1407 : 9 : ssid = wpa_config_get_network(wpa_s->conf, id);
1408 [ - + ]: 9 : if (ssid == NULL) {
1409 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find SSID id=%d "
1410 : : "to update", id);
1411 : 0 : return -1;
1412 : : }
1413 : :
1414 : 9 : return wpa_supplicant_ctrl_iface_ctrl_rsp_handle(wpa_s, ssid, rsp,
1415 : : pos);
1416 : : #else /* IEEE8021X_EAPOL */
1417 : : wpa_printf(MSG_DEBUG, "CTRL_IFACE: 802.1X not included");
1418 : : return -1;
1419 : : #endif /* IEEE8021X_EAPOL */
1420 : : }
1421 : :
1422 : :
1423 : 1165 : static int wpa_supplicant_ctrl_iface_status(struct wpa_supplicant *wpa_s,
1424 : : const char *params,
1425 : : char *buf, size_t buflen)
1426 : : {
1427 : : char *pos, *end, tmp[30];
1428 : : int res, verbose, wps, ret;
1429 : :
1430 [ + + ]: 1165 : if (os_strcmp(params, "-DRIVER") == 0)
1431 : 735 : return wpa_drv_status(wpa_s, buf, buflen);
1432 : 430 : verbose = os_strcmp(params, "-VERBOSE") == 0;
1433 : 430 : wps = os_strcmp(params, "-WPS") == 0;
1434 : 430 : pos = buf;
1435 : 430 : end = buf + buflen;
1436 [ + + ]: 430 : if (wpa_s->wpa_state >= WPA_ASSOCIATED) {
1437 : 302 : struct wpa_ssid *ssid = wpa_s->current_ssid;
1438 : 1812 : ret = os_snprintf(pos, end - pos, "bssid=" MACSTR "\n",
1439 : 1812 : MAC2STR(wpa_s->bssid));
1440 [ + - ][ - + ]: 302 : if (ret < 0 || ret >= end - pos)
1441 : 0 : return pos - buf;
1442 : 302 : pos += ret;
1443 [ + - ]: 302 : if (ssid) {
1444 : 302 : u8 *_ssid = ssid->ssid;
1445 : 302 : size_t ssid_len = ssid->ssid_len;
1446 : : u8 ssid_buf[MAX_SSID_LEN];
1447 [ - + ]: 302 : if (ssid_len == 0) {
1448 : 0 : int _res = wpa_drv_get_ssid(wpa_s, ssid_buf);
1449 [ # # ]: 0 : if (_res < 0)
1450 : 0 : ssid_len = 0;
1451 : : else
1452 : 0 : ssid_len = _res;
1453 : 0 : _ssid = ssid_buf;
1454 : : }
1455 : 302 : ret = os_snprintf(pos, end - pos, "ssid=%s\nid=%d\n",
1456 : : wpa_ssid_txt(_ssid, ssid_len),
1457 : : ssid->id);
1458 [ + - ][ - + ]: 302 : if (ret < 0 || ret >= end - pos)
1459 : 0 : return pos - buf;
1460 : 302 : pos += ret;
1461 : :
1462 [ - + ]: 302 : if (wps && ssid->passphrase &&
[ # # # # ]
1463 [ # # ]: 0 : wpa_key_mgmt_wpa_psk(ssid->key_mgmt) &&
1464 [ # # ]: 0 : (ssid->mode == WPAS_MODE_AP ||
1465 : 0 : ssid->mode == WPAS_MODE_P2P_GO)) {
1466 : 0 : ret = os_snprintf(pos, end - pos,
1467 : : "passphrase=%s\n",
1468 : : ssid->passphrase);
1469 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
1470 : 0 : return pos - buf;
1471 : 0 : pos += ret;
1472 : : }
1473 [ - + ]: 302 : if (ssid->id_str) {
1474 : 0 : ret = os_snprintf(pos, end - pos,
1475 : : "id_str=%s\n",
1476 : : ssid->id_str);
1477 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
1478 : 0 : return pos - buf;
1479 : 0 : pos += ret;
1480 : : }
1481 : :
1482 [ + + - + : 302 : switch (ssid->mode) {
- - ]
1483 : : case WPAS_MODE_INFRA:
1484 : 268 : ret = os_snprintf(pos, end - pos,
1485 : : "mode=station\n");
1486 : 268 : break;
1487 : : case WPAS_MODE_IBSS:
1488 : 12 : ret = os_snprintf(pos, end - pos,
1489 : : "mode=IBSS\n");
1490 : 12 : break;
1491 : : case WPAS_MODE_AP:
1492 : 0 : ret = os_snprintf(pos, end - pos,
1493 : : "mode=AP\n");
1494 : 0 : break;
1495 : : case WPAS_MODE_P2P_GO:
1496 : 22 : ret = os_snprintf(pos, end - pos,
1497 : : "mode=P2P GO\n");
1498 : 22 : break;
1499 : : case WPAS_MODE_P2P_GROUP_FORMATION:
1500 : 0 : ret = os_snprintf(pos, end - pos,
1501 : : "mode=P2P GO - group "
1502 : : "formation\n");
1503 : 0 : break;
1504 : : default:
1505 : 0 : ret = 0;
1506 : 0 : break;
1507 : : }
1508 [ + - ][ - + ]: 302 : if (ret < 0 || ret >= end - pos)
1509 : 0 : return pos - buf;
1510 : 302 : pos += ret;
1511 : : }
1512 : :
1513 : : #ifdef CONFIG_AP
1514 [ + + ]: 302 : if (wpa_s->ap_iface) {
1515 : 22 : pos += ap_ctrl_iface_wpa_get_status(wpa_s, pos,
1516 : 22 : end - pos,
1517 : : verbose);
1518 : : } else
1519 : : #endif /* CONFIG_AP */
1520 : 280 : pos += wpa_sm_get_status(wpa_s->wpa, pos, end - pos, verbose);
1521 : : }
1522 : : #ifdef CONFIG_SAE
1523 [ + + ][ + + ]: 430 : if (wpa_s->wpa_state >= WPA_ASSOCIATED &&
1524 : : #ifdef CONFIG_AP
1525 [ + + ]: 280 : !wpa_s->ap_iface &&
1526 : : #endif /* CONFIG_AP */
1527 : 280 : wpa_s->sme.sae.state == SAE_ACCEPTED) {
1528 : 16 : ret = os_snprintf(pos, end - pos, "sae_group=%d\n",
1529 : : wpa_s->sme.sae.group);
1530 [ + - ][ - + ]: 16 : if (ret < 0 || ret >= end - pos)
1531 : 0 : return pos - buf;
1532 : 16 : pos += ret;
1533 : : }
1534 : : #endif /* CONFIG_SAE */
1535 : 430 : ret = os_snprintf(pos, end - pos, "wpa_state=%s\n",
1536 : : wpa_supplicant_state_txt(wpa_s->wpa_state));
1537 [ + - ][ - + ]: 430 : if (ret < 0 || ret >= end - pos)
1538 : 0 : return pos - buf;
1539 : 430 : pos += ret;
1540 : :
1541 [ + - - + ]: 860 : if (wpa_s->l2 &&
1542 : 430 : l2_packet_get_ip_addr(wpa_s->l2, tmp, sizeof(tmp)) >= 0) {
1543 : 0 : ret = os_snprintf(pos, end - pos, "ip_address=%s\n", tmp);
1544 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
1545 : 0 : return pos - buf;
1546 : 0 : pos += ret;
1547 : : }
1548 : :
1549 : : #ifdef CONFIG_P2P
1550 [ + - ]: 430 : if (wpa_s->global->p2p) {
1551 : 2580 : ret = os_snprintf(pos, end - pos, "p2p_device_address=" MACSTR
1552 : 2580 : "\n", MAC2STR(wpa_s->global->p2p_dev_addr));
1553 [ + - ][ - + ]: 430 : if (ret < 0 || ret >= end - pos)
1554 : 0 : return pos - buf;
1555 : 430 : pos += ret;
1556 : : }
1557 : : #endif /* CONFIG_P2P */
1558 : :
1559 : 2580 : ret = os_snprintf(pos, end - pos, "address=" MACSTR "\n",
1560 : 2580 : MAC2STR(wpa_s->own_addr));
1561 [ + - ][ - + ]: 430 : if (ret < 0 || ret >= end - pos)
1562 : 0 : return pos - buf;
1563 : 430 : pos += ret;
1564 : :
1565 : : #ifdef CONFIG_HS20
1566 [ + + + + ]: 710 : if (wpa_s->current_bss &&
1567 [ + - ]: 295 : wpa_bss_get_vendor_ie(wpa_s->current_bss, HS20_IE_VENDOR_TYPE) &&
1568 [ + - ]: 15 : wpa_s->wpa_proto == WPA_PROTO_RSN &&
1569 : 15 : wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
1570 : 15 : ret = os_snprintf(pos, end - pos, "hs20=1\n");
1571 [ + - ][ - + ]: 15 : if (ret < 0 || ret >= end - pos)
1572 : 0 : return pos - buf;
1573 : 15 : pos += ret;
1574 : : }
1575 : :
1576 [ + + ]: 430 : if (wpa_s->current_ssid) {
1577 : : struct wpa_cred *cred;
1578 : : char *type;
1579 : :
1580 [ + + ]: 304 : for (cred = wpa_s->conf->cred; cred; cred = cred->next) {
1581 : : size_t i;
1582 : :
1583 [ - + ]: 15 : if (wpa_s->current_ssid->parent_cred != cred)
1584 : 0 : continue;
1585 : :
1586 [ + + ][ + + ]: 20 : for (i = 0; cred->domain && i < cred->num_domain; i++) {
1587 : 5 : ret = os_snprintf(pos, end - pos,
1588 : : "home_sp=%s\n",
1589 : 5 : cred->domain[i]);
1590 [ + - ][ - + ]: 5 : if (ret < 0 || ret >= end - pos)
1591 : 0 : return pos - buf;
1592 : 5 : pos += ret;
1593 : : }
1594 : :
1595 [ + - ][ - + ]: 15 : if (wpa_s->current_bss == NULL ||
1596 : 15 : wpa_s->current_bss->anqp == NULL)
1597 : 0 : res = -1;
1598 : : else
1599 : 15 : res = interworking_home_sp_cred(
1600 : : wpa_s, cred,
1601 : 15 : wpa_s->current_bss->anqp->domain_name);
1602 [ + + ]: 15 : if (res > 0)
1603 : 7 : type = "home";
1604 [ + + ]: 8 : else if (res == 0)
1605 : 2 : type = "roaming";
1606 : : else
1607 : 6 : type = "unknown";
1608 : :
1609 : 15 : ret = os_snprintf(pos, end - pos, "sp_type=%s\n", type);
1610 [ + - ][ - + ]: 15 : if (ret < 0 || ret >= end - pos)
1611 : 0 : return pos - buf;
1612 : 15 : pos += ret;
1613 : :
1614 : 15 : break;
1615 : : }
1616 : : }
1617 : : #endif /* CONFIG_HS20 */
1618 : :
1619 [ + + ][ - + ]: 430 : if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
1620 : 356 : wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1621 : 74 : res = eapol_sm_get_status(wpa_s->eapol, pos, end - pos,
1622 : : verbose);
1623 [ + - ]: 74 : if (res >= 0)
1624 : 74 : pos += res;
1625 : : }
1626 : :
1627 : 430 : res = rsn_preauth_get_status(wpa_s->wpa, pos, end - pos, verbose);
1628 [ + - ]: 430 : if (res >= 0)
1629 : 430 : pos += res;
1630 : :
1631 : : #ifdef CONFIG_WPS
1632 : : {
1633 : : char uuid_str[100];
1634 : 430 : uuid_bin2str(wpa_s->wps->uuid, uuid_str, sizeof(uuid_str));
1635 : 430 : ret = os_snprintf(pos, end - pos, "uuid=%s\n", uuid_str);
1636 [ + - ][ - + ]: 430 : if (ret < 0 || ret >= end - pos)
1637 : 0 : return pos - buf;
1638 : 430 : pos += ret;
1639 : : }
1640 : : #endif /* CONFIG_WPS */
1641 : :
1642 : : #ifdef ANDROID
1643 : : wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_STATE_CHANGE
1644 : : "id=%d state=%d BSSID=" MACSTR " SSID=%s",
1645 : : wpa_s->current_ssid ? wpa_s->current_ssid->id : -1,
1646 : : wpa_s->wpa_state,
1647 : : MAC2STR(wpa_s->bssid),
1648 : : wpa_s->current_ssid && wpa_s->current_ssid->ssid ?
1649 : : wpa_ssid_txt(wpa_s->current_ssid->ssid,
1650 : : wpa_s->current_ssid->ssid_len) : "");
1651 : : if (wpa_s->wpa_state == WPA_COMPLETED) {
1652 : : struct wpa_ssid *ssid = wpa_s->current_ssid;
1653 : : wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED
1654 : : "- connection to " MACSTR
1655 : : " completed %s [id=%d id_str=%s]",
1656 : : MAC2STR(wpa_s->bssid), "(auth)",
1657 : : ssid ? ssid->id : -1,
1658 : : ssid && ssid->id_str ? ssid->id_str : "");
1659 : : }
1660 : : #endif /* ANDROID */
1661 : :
1662 : 1165 : return pos - buf;
1663 : : }
1664 : :
1665 : :
1666 : 0 : static int wpa_supplicant_ctrl_iface_bssid(struct wpa_supplicant *wpa_s,
1667 : : char *cmd)
1668 : : {
1669 : : char *pos;
1670 : : int id;
1671 : : struct wpa_ssid *ssid;
1672 : : u8 bssid[ETH_ALEN];
1673 : :
1674 : : /* cmd: "<network id> <BSSID>" */
1675 : 0 : pos = os_strchr(cmd, ' ');
1676 [ # # ]: 0 : if (pos == NULL)
1677 : 0 : return -1;
1678 : 0 : *pos++ = '\0';
1679 : 0 : id = atoi(cmd);
1680 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: id=%d bssid='%s'", id, pos);
1681 [ # # ]: 0 : if (hwaddr_aton(pos, bssid)) {
1682 : 0 : wpa_printf(MSG_DEBUG ,"CTRL_IFACE: invalid BSSID '%s'", pos);
1683 : 0 : return -1;
1684 : : }
1685 : :
1686 : 0 : ssid = wpa_config_get_network(wpa_s->conf, id);
1687 [ # # ]: 0 : if (ssid == NULL) {
1688 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find SSID id=%d "
1689 : : "to update", id);
1690 : 0 : return -1;
1691 : : }
1692 : :
1693 : 0 : os_memcpy(ssid->bssid, bssid, ETH_ALEN);
1694 : 0 : ssid->bssid_set = !is_zero_ether_addr(bssid);
1695 : :
1696 : 0 : return 0;
1697 : : }
1698 : :
1699 : :
1700 : 0 : static int wpa_supplicant_ctrl_iface_blacklist(struct wpa_supplicant *wpa_s,
1701 : : char *cmd, char *buf,
1702 : : size_t buflen)
1703 : : {
1704 : : u8 bssid[ETH_ALEN];
1705 : : struct wpa_blacklist *e;
1706 : : char *pos, *end;
1707 : : int ret;
1708 : :
1709 : : /* cmd: "BLACKLIST [<BSSID>]" */
1710 [ # # ]: 0 : if (*cmd == '\0') {
1711 : 0 : pos = buf;
1712 : 0 : end = buf + buflen;
1713 : 0 : e = wpa_s->blacklist;
1714 [ # # ]: 0 : while (e) {
1715 : 0 : ret = os_snprintf(pos, end - pos, MACSTR "\n",
1716 : 0 : MAC2STR(e->bssid));
1717 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
1718 : 0 : return pos - buf;
1719 : 0 : pos += ret;
1720 : 0 : e = e->next;
1721 : : }
1722 : 0 : return pos - buf;
1723 : : }
1724 : :
1725 : 0 : cmd++;
1726 [ # # ]: 0 : if (os_strncmp(cmd, "clear", 5) == 0) {
1727 : 0 : wpa_blacklist_clear(wpa_s);
1728 : 0 : os_memcpy(buf, "OK\n", 3);
1729 : 0 : return 3;
1730 : : }
1731 : :
1732 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: BLACKLIST bssid='%s'", cmd);
1733 [ # # ]: 0 : if (hwaddr_aton(cmd, bssid)) {
1734 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: invalid BSSID '%s'", cmd);
1735 : 0 : return -1;
1736 : : }
1737 : :
1738 : : /*
1739 : : * Add the BSSID twice, so its count will be 2, causing it to be
1740 : : * skipped when processing scan results.
1741 : : */
1742 : 0 : ret = wpa_blacklist_add(wpa_s, bssid);
1743 [ # # ]: 0 : if (ret != 0)
1744 : 0 : return -1;
1745 : 0 : ret = wpa_blacklist_add(wpa_s, bssid);
1746 [ # # ]: 0 : if (ret != 0)
1747 : 0 : return -1;
1748 : 0 : os_memcpy(buf, "OK\n", 3);
1749 : 0 : return 3;
1750 : : }
1751 : :
1752 : :
1753 : 0 : static const char * debug_level_str(int level)
1754 : : {
1755 [ # # # # : 0 : switch (level) {
# # # ]
1756 : : case MSG_EXCESSIVE:
1757 : 0 : return "EXCESSIVE";
1758 : : case MSG_MSGDUMP:
1759 : 0 : return "MSGDUMP";
1760 : : case MSG_DEBUG:
1761 : 0 : return "DEBUG";
1762 : : case MSG_INFO:
1763 : 0 : return "INFO";
1764 : : case MSG_WARNING:
1765 : 0 : return "WARNING";
1766 : : case MSG_ERROR:
1767 : 0 : return "ERROR";
1768 : : default:
1769 : 0 : return "?";
1770 : : }
1771 : : }
1772 : :
1773 : :
1774 : 0 : static int str_to_debug_level(const char *s)
1775 : : {
1776 [ # # ]: 0 : if (os_strcasecmp(s, "EXCESSIVE") == 0)
1777 : 0 : return MSG_EXCESSIVE;
1778 [ # # ]: 0 : if (os_strcasecmp(s, "MSGDUMP") == 0)
1779 : 0 : return MSG_MSGDUMP;
1780 [ # # ]: 0 : if (os_strcasecmp(s, "DEBUG") == 0)
1781 : 0 : return MSG_DEBUG;
1782 [ # # ]: 0 : if (os_strcasecmp(s, "INFO") == 0)
1783 : 0 : return MSG_INFO;
1784 [ # # ]: 0 : if (os_strcasecmp(s, "WARNING") == 0)
1785 : 0 : return MSG_WARNING;
1786 [ # # ]: 0 : if (os_strcasecmp(s, "ERROR") == 0)
1787 : 0 : return MSG_ERROR;
1788 : 0 : return -1;
1789 : : }
1790 : :
1791 : :
1792 : 0 : static int wpa_supplicant_ctrl_iface_log_level(struct wpa_supplicant *wpa_s,
1793 : : char *cmd, char *buf,
1794 : : size_t buflen)
1795 : : {
1796 : : char *pos, *end, *stamp;
1797 : : int ret;
1798 : :
1799 [ # # ]: 0 : if (cmd == NULL) {
1800 : 0 : return -1;
1801 : : }
1802 : :
1803 : : /* cmd: "LOG_LEVEL [<level>]" */
1804 [ # # ]: 0 : if (*cmd == '\0') {
1805 : 0 : pos = buf;
1806 : 0 : end = buf + buflen;
1807 : 0 : ret = os_snprintf(pos, end - pos, "Current level: %s\n"
1808 : : "Timestamp: %d\n",
1809 : : debug_level_str(wpa_debug_level),
1810 : : wpa_debug_timestamp);
1811 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
1812 : 0 : ret = 0;
1813 : :
1814 : 0 : return ret;
1815 : : }
1816 : :
1817 [ # # ]: 0 : while (*cmd == ' ')
1818 : 0 : cmd++;
1819 : :
1820 : 0 : stamp = os_strchr(cmd, ' ');
1821 [ # # ]: 0 : if (stamp) {
1822 : 0 : *stamp++ = '\0';
1823 [ # # ]: 0 : while (*stamp == ' ') {
1824 : 0 : stamp++;
1825 : : }
1826 : : }
1827 : :
1828 [ # # ][ # # ]: 0 : if (cmd && os_strlen(cmd)) {
1829 : 0 : int level = str_to_debug_level(cmd);
1830 [ # # ]: 0 : if (level < 0)
1831 : 0 : return -1;
1832 : 0 : wpa_debug_level = level;
1833 : : }
1834 : :
1835 [ # # ][ # # ]: 0 : if (stamp && os_strlen(stamp))
1836 : 0 : wpa_debug_timestamp = atoi(stamp);
1837 : :
1838 : 0 : os_memcpy(buf, "OK\n", 3);
1839 : 0 : return 3;
1840 : : }
1841 : :
1842 : :
1843 : 2 : static int wpa_supplicant_ctrl_iface_list_networks(
1844 : : struct wpa_supplicant *wpa_s, char *buf, size_t buflen)
1845 : : {
1846 : : char *pos, *end;
1847 : : struct wpa_ssid *ssid;
1848 : : int ret;
1849 : :
1850 : 2 : pos = buf;
1851 : 2 : end = buf + buflen;
1852 : 2 : ret = os_snprintf(pos, end - pos,
1853 : : "network id / ssid / bssid / flags\n");
1854 [ + - ][ - + ]: 2 : if (ret < 0 || ret >= end - pos)
1855 : 0 : return pos - buf;
1856 : 2 : pos += ret;
1857 : :
1858 : 2 : ssid = wpa_s->conf->ssid;
1859 [ + + ]: 4 : while (ssid) {
1860 : 2 : ret = os_snprintf(pos, end - pos, "%d\t%s",
1861 : : ssid->id,
1862 : 2 : wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
1863 [ + - ][ - + ]: 2 : if (ret < 0 || ret >= end - pos)
1864 : 0 : return pos - buf;
1865 : 2 : pos += ret;
1866 [ - + ]: 2 : if (ssid->bssid_set) {
1867 : 0 : ret = os_snprintf(pos, end - pos, "\t" MACSTR,
1868 : 0 : MAC2STR(ssid->bssid));
1869 : : } else {
1870 : 2 : ret = os_snprintf(pos, end - pos, "\tany");
1871 : : }
1872 [ + - ][ - + ]: 2 : if (ret < 0 || ret >= end - pos)
1873 : 0 : return pos - buf;
1874 : 2 : pos += ret;
1875 [ - + ][ - + ]: 2 : ret = os_snprintf(pos, end - pos, "\t%s%s%s%s",
[ - + ][ + - ]
1876 : 2 : ssid == wpa_s->current_ssid ?
1877 : : "[CURRENT]" : "",
1878 : 2 : ssid->disabled ? "[DISABLED]" : "",
1879 : 2 : ssid->disabled_until.sec ?
1880 : : "[TEMP-DISABLED]" : "",
1881 : 2 : ssid->disabled == 2 ? "[P2P-PERSISTENT]" :
1882 : : "");
1883 [ + - ][ - + ]: 2 : if (ret < 0 || ret >= end - pos)
1884 : 0 : return pos - buf;
1885 : 2 : pos += ret;
1886 : 2 : ret = os_snprintf(pos, end - pos, "\n");
1887 [ + - ][ - + ]: 2 : if (ret < 0 || ret >= end - pos)
1888 : 0 : return pos - buf;
1889 : 2 : pos += ret;
1890 : :
1891 : 2 : ssid = ssid->next;
1892 : : }
1893 : :
1894 : 2 : return pos - buf;
1895 : : }
1896 : :
1897 : :
1898 : 25 : static char * wpa_supplicant_cipher_txt(char *pos, char *end, int cipher)
1899 : : {
1900 : : int ret;
1901 : 25 : ret = os_snprintf(pos, end - pos, "-");
1902 [ + - ][ - + ]: 25 : if (ret < 0 || ret >= end - pos)
1903 : 0 : return pos;
1904 : 25 : pos += ret;
1905 : 25 : ret = wpa_write_ciphers(pos, end, cipher, "+");
1906 [ - + ]: 25 : if (ret < 0)
1907 : 0 : return pos;
1908 : 25 : pos += ret;
1909 : 25 : return pos;
1910 : : }
1911 : :
1912 : :
1913 : 25 : static char * wpa_supplicant_ie_txt(char *pos, char *end, const char *proto,
1914 : : const u8 *ie, size_t ie_len)
1915 : : {
1916 : : struct wpa_ie_data data;
1917 : : int first, ret;
1918 : :
1919 : 25 : ret = os_snprintf(pos, end - pos, "[%s-", proto);
1920 [ + - ][ - + ]: 25 : if (ret < 0 || ret >= end - pos)
1921 : 0 : return pos;
1922 : 25 : pos += ret;
1923 : :
1924 [ - + ]: 25 : if (wpa_parse_wpa_ie(ie, ie_len, &data) < 0) {
1925 : 0 : ret = os_snprintf(pos, end - pos, "?]");
1926 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
1927 : 0 : return pos;
1928 : 0 : pos += ret;
1929 : 0 : return pos;
1930 : : }
1931 : :
1932 : 25 : first = 1;
1933 [ + + ]: 25 : if (data.key_mgmt & WPA_KEY_MGMT_IEEE8021X) {
1934 [ + - ]: 4 : ret = os_snprintf(pos, end - pos, "%sEAP", first ? "" : "+");
1935 [ + - ][ - + ]: 4 : if (ret < 0 || ret >= end - pos)
1936 : 0 : return pos;
1937 : 4 : pos += ret;
1938 : 4 : first = 0;
1939 : : }
1940 [ + + ]: 25 : if (data.key_mgmt & WPA_KEY_MGMT_PSK) {
1941 [ + - ]: 21 : ret = os_snprintf(pos, end - pos, "%sPSK", first ? "" : "+");
1942 [ + - ][ - + ]: 21 : if (ret < 0 || ret >= end - pos)
1943 : 0 : return pos;
1944 : 21 : pos += ret;
1945 : 21 : first = 0;
1946 : : }
1947 [ - + ]: 25 : if (data.key_mgmt & WPA_KEY_MGMT_WPA_NONE) {
1948 [ # # ]: 0 : ret = os_snprintf(pos, end - pos, "%sNone", first ? "" : "+");
1949 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
1950 : 0 : return pos;
1951 : 0 : pos += ret;
1952 : 0 : first = 0;
1953 : : }
1954 : : #ifdef CONFIG_IEEE80211R
1955 [ - + ]: 25 : if (data.key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X) {
1956 [ # # ]: 0 : ret = os_snprintf(pos, end - pos, "%sFT/EAP",
1957 : : first ? "" : "+");
1958 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
1959 : 0 : return pos;
1960 : 0 : pos += ret;
1961 : 0 : first = 0;
1962 : : }
1963 [ - + ]: 25 : if (data.key_mgmt & WPA_KEY_MGMT_FT_PSK) {
1964 [ # # ]: 0 : ret = os_snprintf(pos, end - pos, "%sFT/PSK",
1965 : : first ? "" : "+");
1966 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
1967 : 0 : return pos;
1968 : 0 : pos += ret;
1969 : 0 : first = 0;
1970 : : }
1971 : : #endif /* CONFIG_IEEE80211R */
1972 : : #ifdef CONFIG_IEEE80211W
1973 [ - + ]: 25 : if (data.key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA256) {
1974 [ # # ]: 0 : ret = os_snprintf(pos, end - pos, "%sEAP-SHA256",
1975 : : first ? "" : "+");
1976 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
1977 : 0 : return pos;
1978 : 0 : pos += ret;
1979 : 0 : first = 0;
1980 : : }
1981 [ - + ]: 25 : if (data.key_mgmt & WPA_KEY_MGMT_PSK_SHA256) {
1982 [ # # ]: 0 : ret = os_snprintf(pos, end - pos, "%sPSK-SHA256",
1983 : : first ? "" : "+");
1984 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
1985 : 0 : return pos;
1986 : 0 : pos += ret;
1987 : 0 : first = 0;
1988 : : }
1989 : : #endif /* CONFIG_IEEE80211W */
1990 : :
1991 : 25 : pos = wpa_supplicant_cipher_txt(pos, end, data.pairwise_cipher);
1992 : :
1993 [ - + ]: 25 : if (data.capabilities & WPA_CAPABILITY_PREAUTH) {
1994 : 0 : ret = os_snprintf(pos, end - pos, "-preauth");
1995 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
1996 : 0 : return pos;
1997 : 0 : pos += ret;
1998 : : }
1999 : :
2000 : 25 : ret = os_snprintf(pos, end - pos, "]");
2001 [ + - ][ - + ]: 25 : if (ret < 0 || ret >= end - pos)
2002 : 0 : return pos;
2003 : 25 : pos += ret;
2004 : :
2005 : 25 : return pos;
2006 : : }
2007 : :
2008 : :
2009 : : #ifdef CONFIG_WPS
2010 : 30 : static char * wpa_supplicant_wps_ie_txt_buf(struct wpa_supplicant *wpa_s,
2011 : : char *pos, char *end,
2012 : : struct wpabuf *wps_ie)
2013 : : {
2014 : : int ret;
2015 : : const char *txt;
2016 : :
2017 [ + + ]: 30 : if (wps_ie == NULL)
2018 : 11 : return pos;
2019 [ + + ]: 19 : if (wps_is_selected_pbc_registrar(wps_ie))
2020 : 3 : txt = "[WPS-PBC]";
2021 : : #ifdef CONFIG_WPS2
2022 [ + + ]: 16 : else if (wps_is_addr_authorized(wps_ie, wpa_s->own_addr, 0))
2023 : 7 : txt = "[WPS-AUTH]";
2024 : : #endif /* CONFIG_WPS2 */
2025 [ - + ]: 9 : else if (wps_is_selected_pin_registrar(wps_ie))
2026 : 0 : txt = "[WPS-PIN]";
2027 : : else
2028 : 9 : txt = "[WPS]";
2029 : :
2030 : 19 : ret = os_snprintf(pos, end - pos, "%s", txt);
2031 [ + - ][ + - ]: 19 : if (ret >= 0 && ret < end - pos)
2032 : 19 : pos += ret;
2033 : 19 : wpabuf_free(wps_ie);
2034 : 30 : return pos;
2035 : : }
2036 : : #endif /* CONFIG_WPS */
2037 : :
2038 : :
2039 : 30 : static char * wpa_supplicant_wps_ie_txt(struct wpa_supplicant *wpa_s,
2040 : : char *pos, char *end,
2041 : : const struct wpa_bss *bss)
2042 : : {
2043 : : #ifdef CONFIG_WPS
2044 : : struct wpabuf *wps_ie;
2045 : 30 : wps_ie = wpa_bss_get_vendor_ie_multi(bss, WPS_IE_VENDOR_TYPE);
2046 : 30 : return wpa_supplicant_wps_ie_txt_buf(wpa_s, pos, end, wps_ie);
2047 : : #else /* CONFIG_WPS */
2048 : : return pos;
2049 : : #endif /* CONFIG_WPS */
2050 : : }
2051 : :
2052 : :
2053 : : /* Format one result on one text line into a buffer. */
2054 : 0 : static int wpa_supplicant_ctrl_iface_scan_result(
2055 : : struct wpa_supplicant *wpa_s,
2056 : : const struct wpa_bss *bss, char *buf, size_t buflen)
2057 : : {
2058 : : char *pos, *end;
2059 : : int ret;
2060 : : const u8 *ie, *ie2, *p2p;
2061 : :
2062 : 0 : p2p = wpa_bss_get_vendor_ie(bss, P2P_IE_VENDOR_TYPE);
2063 [ # # ]: 0 : if (!p2p)
2064 : 0 : p2p = wpa_bss_get_vendor_ie_beacon(bss, P2P_IE_VENDOR_TYPE);
2065 [ # # ][ # # ]: 0 : if (p2p && bss->ssid_len == P2P_WILDCARD_SSID_LEN &&
[ # # ]
2066 : 0 : os_memcmp(bss->ssid, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN) ==
2067 : : 0)
2068 : 0 : return 0; /* Do not show P2P listen discovery results here */
2069 : :
2070 : 0 : pos = buf;
2071 : 0 : end = buf + buflen;
2072 : :
2073 : 0 : ret = os_snprintf(pos, end - pos, MACSTR "\t%d\t%d\t",
2074 : 0 : MAC2STR(bss->bssid), bss->freq, bss->level);
2075 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2076 : 0 : return -1;
2077 : 0 : pos += ret;
2078 : 0 : ie = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
2079 [ # # ]: 0 : if (ie)
2080 : 0 : pos = wpa_supplicant_ie_txt(pos, end, "WPA", ie, 2 + ie[1]);
2081 : 0 : ie2 = wpa_bss_get_ie(bss, WLAN_EID_RSN);
2082 [ # # ]: 0 : if (ie2)
2083 : 0 : pos = wpa_supplicant_ie_txt(pos, end, "WPA2", ie2, 2 + ie2[1]);
2084 : 0 : pos = wpa_supplicant_wps_ie_txt(wpa_s, pos, end, bss);
2085 [ # # ][ # # ]: 0 : if (!ie && !ie2 && bss->caps & IEEE80211_CAP_PRIVACY) {
[ # # ]
2086 : 0 : ret = os_snprintf(pos, end - pos, "[WEP]");
2087 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2088 : 0 : return -1;
2089 : 0 : pos += ret;
2090 : : }
2091 [ # # ]: 0 : if (bss->caps & IEEE80211_CAP_IBSS) {
2092 : 0 : ret = os_snprintf(pos, end - pos, "[IBSS]");
2093 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2094 : 0 : return -1;
2095 : 0 : pos += ret;
2096 : : }
2097 [ # # ]: 0 : if (bss->caps & IEEE80211_CAP_ESS) {
2098 : 0 : ret = os_snprintf(pos, end - pos, "[ESS]");
2099 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2100 : 0 : return -1;
2101 : 0 : pos += ret;
2102 : : }
2103 [ # # ]: 0 : if (p2p) {
2104 : 0 : ret = os_snprintf(pos, end - pos, "[P2P]");
2105 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2106 : 0 : return -1;
2107 : 0 : pos += ret;
2108 : : }
2109 : : #ifdef CONFIG_HS20
2110 [ # # ][ # # ]: 0 : if (wpa_bss_get_vendor_ie(bss, HS20_IE_VENDOR_TYPE) && ie2) {
2111 : 0 : ret = os_snprintf(pos, end - pos, "[HS20]");
2112 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2113 : 0 : return -1;
2114 : 0 : pos += ret;
2115 : : }
2116 : : #endif /* CONFIG_HS20 */
2117 : :
2118 : 0 : ret = os_snprintf(pos, end - pos, "\t%s",
2119 : 0 : wpa_ssid_txt(bss->ssid, bss->ssid_len));
2120 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2121 : 0 : return -1;
2122 : 0 : pos += ret;
2123 : :
2124 : 0 : ret = os_snprintf(pos, end - pos, "\n");
2125 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2126 : 0 : return -1;
2127 : 0 : pos += ret;
2128 : :
2129 : 0 : return pos - buf;
2130 : : }
2131 : :
2132 : :
2133 : 0 : static int wpa_supplicant_ctrl_iface_scan_results(
2134 : : struct wpa_supplicant *wpa_s, char *buf, size_t buflen)
2135 : : {
2136 : : char *pos, *end;
2137 : : struct wpa_bss *bss;
2138 : : int ret;
2139 : :
2140 : 0 : pos = buf;
2141 : 0 : end = buf + buflen;
2142 : 0 : ret = os_snprintf(pos, end - pos, "bssid / frequency / signal level / "
2143 : : "flags / ssid\n");
2144 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2145 : 0 : return pos - buf;
2146 : 0 : pos += ret;
2147 : :
2148 [ # # ]: 0 : dl_list_for_each(bss, &wpa_s->bss_id, struct wpa_bss, list_id) {
2149 : 0 : ret = wpa_supplicant_ctrl_iface_scan_result(wpa_s, bss, pos,
2150 : 0 : end - pos);
2151 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2152 : 0 : return pos - buf;
2153 : 0 : pos += ret;
2154 : : }
2155 : :
2156 : 0 : return pos - buf;
2157 : : }
2158 : :
2159 : :
2160 : 250 : static int wpa_supplicant_ctrl_iface_select_network(
2161 : : struct wpa_supplicant *wpa_s, char *cmd)
2162 : : {
2163 : : int id;
2164 : : struct wpa_ssid *ssid;
2165 : :
2166 : : /* cmd: "<network id>" or "any" */
2167 [ - + ]: 250 : if (os_strcmp(cmd, "any") == 0) {
2168 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: SELECT_NETWORK any");
2169 : 0 : ssid = NULL;
2170 : : } else {
2171 : 250 : id = atoi(cmd);
2172 : 250 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: SELECT_NETWORK id=%d", id);
2173 : :
2174 : 250 : ssid = wpa_config_get_network(wpa_s->conf, id);
2175 [ - + ]: 250 : if (ssid == NULL) {
2176 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find "
2177 : : "network id=%d", id);
2178 : 0 : return -1;
2179 : : }
2180 [ - + ]: 250 : if (ssid->disabled == 2) {
2181 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: Cannot use "
2182 : : "SELECT_NETWORK with persistent P2P group");
2183 : 0 : return -1;
2184 : : }
2185 : : }
2186 : :
2187 : 250 : wpa_supplicant_select_network(wpa_s, ssid);
2188 : :
2189 : 250 : return 0;
2190 : : }
2191 : :
2192 : :
2193 : 0 : static int wpa_supplicant_ctrl_iface_enable_network(
2194 : : struct wpa_supplicant *wpa_s, char *cmd)
2195 : : {
2196 : : int id;
2197 : : struct wpa_ssid *ssid;
2198 : :
2199 : : /* cmd: "<network id>" or "all" */
2200 [ # # ]: 0 : if (os_strcmp(cmd, "all") == 0) {
2201 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: ENABLE_NETWORK all");
2202 : 0 : ssid = NULL;
2203 : : } else {
2204 : 0 : id = atoi(cmd);
2205 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: ENABLE_NETWORK id=%d", id);
2206 : :
2207 : 0 : ssid = wpa_config_get_network(wpa_s->conf, id);
2208 [ # # ]: 0 : if (ssid == NULL) {
2209 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find "
2210 : : "network id=%d", id);
2211 : 0 : return -1;
2212 : : }
2213 [ # # ]: 0 : if (ssid->disabled == 2) {
2214 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: Cannot use "
2215 : : "ENABLE_NETWORK with persistent P2P group");
2216 : 0 : return -1;
2217 : : }
2218 : :
2219 [ # # ]: 0 : if (os_strstr(cmd, " no-connect")) {
2220 : 0 : ssid->disabled = 0;
2221 : 0 : return 0;
2222 : : }
2223 : : }
2224 : 0 : wpa_supplicant_enable_network(wpa_s, ssid);
2225 : :
2226 : 0 : return 0;
2227 : : }
2228 : :
2229 : :
2230 : 0 : static int wpa_supplicant_ctrl_iface_disable_network(
2231 : : struct wpa_supplicant *wpa_s, char *cmd)
2232 : : {
2233 : : int id;
2234 : : struct wpa_ssid *ssid;
2235 : :
2236 : : /* cmd: "<network id>" or "all" */
2237 [ # # ]: 0 : if (os_strcmp(cmd, "all") == 0) {
2238 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: DISABLE_NETWORK all");
2239 : 0 : ssid = NULL;
2240 : : } else {
2241 : 0 : id = atoi(cmd);
2242 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: DISABLE_NETWORK id=%d", id);
2243 : :
2244 : 0 : ssid = wpa_config_get_network(wpa_s->conf, id);
2245 [ # # ]: 0 : if (ssid == NULL) {
2246 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find "
2247 : : "network id=%d", id);
2248 : 0 : return -1;
2249 : : }
2250 [ # # ]: 0 : if (ssid->disabled == 2) {
2251 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: Cannot use "
2252 : : "DISABLE_NETWORK with persistent P2P "
2253 : : "group");
2254 : 0 : return -1;
2255 : : }
2256 : : }
2257 : 0 : wpa_supplicant_disable_network(wpa_s, ssid);
2258 : :
2259 : 0 : return 0;
2260 : : }
2261 : :
2262 : :
2263 : 248 : static int wpa_supplicant_ctrl_iface_add_network(
2264 : : struct wpa_supplicant *wpa_s, char *buf, size_t buflen)
2265 : : {
2266 : : struct wpa_ssid *ssid;
2267 : : int ret;
2268 : :
2269 : 248 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: ADD_NETWORK");
2270 : :
2271 : 248 : ssid = wpa_config_add_network(wpa_s->conf);
2272 [ - + ]: 248 : if (ssid == NULL)
2273 : 0 : return -1;
2274 : :
2275 : 248 : wpas_notify_network_added(wpa_s, ssid);
2276 : :
2277 : 248 : ssid->disabled = 1;
2278 : 248 : wpa_config_set_network_defaults(ssid);
2279 : :
2280 : 248 : ret = os_snprintf(buf, buflen, "%d\n", ssid->id);
2281 [ + - ][ - + ]: 248 : if (ret < 0 || (size_t) ret >= buflen)
2282 : 0 : return -1;
2283 : 248 : return ret;
2284 : : }
2285 : :
2286 : :
2287 : 850 : static int wpa_supplicant_ctrl_iface_remove_network(
2288 : : struct wpa_supplicant *wpa_s, char *cmd)
2289 : : {
2290 : : int id;
2291 : : struct wpa_ssid *ssid;
2292 : : int was_disabled;
2293 : :
2294 : : /* cmd: "<network id>" or "all" */
2295 [ + + ]: 850 : if (os_strcmp(cmd, "all") == 0) {
2296 : 754 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: REMOVE_NETWORK all");
2297 [ - + ]: 754 : if (wpa_s->sched_scanning)
2298 : 0 : wpa_supplicant_cancel_sched_scan(wpa_s);
2299 : :
2300 : 754 : eapol_sm_invalidate_cached_session(wpa_s->eapol);
2301 [ + + ]: 754 : if (wpa_s->current_ssid) {
2302 : : #ifdef CONFIG_SME
2303 : 28 : wpa_s->sme.prev_bssid_set = 0;
2304 : : #endif /* CONFIG_SME */
2305 : 28 : wpa_sm_set_config(wpa_s->wpa, NULL);
2306 : 28 : eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
2307 : 28 : wpa_supplicant_deauthenticate(
2308 : : wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2309 : : }
2310 : 754 : ssid = wpa_s->conf->ssid;
2311 [ + + ]: 972 : while (ssid) {
2312 : 218 : struct wpa_ssid *remove_ssid = ssid;
2313 : 218 : id = ssid->id;
2314 : 218 : ssid = ssid->next;
2315 : 218 : wpas_notify_network_removed(wpa_s, remove_ssid);
2316 : 218 : wpa_config_remove_network(wpa_s->conf, id);
2317 : : }
2318 : 754 : return 0;
2319 : : }
2320 : :
2321 : 96 : id = atoi(cmd);
2322 : 96 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: REMOVE_NETWORK id=%d", id);
2323 : :
2324 : 96 : ssid = wpa_config_get_network(wpa_s->conf, id);
2325 [ + - ]: 96 : if (ssid)
2326 : 96 : wpas_notify_network_removed(wpa_s, ssid);
2327 [ - + ]: 96 : if (ssid == NULL) {
2328 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find network "
2329 : : "id=%d", id);
2330 : 0 : return -1;
2331 : : }
2332 : :
2333 [ + + ][ + - ]: 96 : if (ssid == wpa_s->current_ssid || wpa_s->current_ssid == NULL) {
2334 : : #ifdef CONFIG_SME
2335 : 96 : wpa_s->sme.prev_bssid_set = 0;
2336 : : #endif /* CONFIG_SME */
2337 : : /*
2338 : : * Invalidate the EAP session cache if the current or
2339 : : * previously used network is removed.
2340 : : */
2341 : 96 : eapol_sm_invalidate_cached_session(wpa_s->eapol);
2342 : : }
2343 : :
2344 [ + + ]: 96 : if (ssid == wpa_s->current_ssid) {
2345 : 91 : wpa_sm_set_config(wpa_s->wpa, NULL);
2346 : 91 : eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
2347 : :
2348 : 91 : wpa_supplicant_deauthenticate(wpa_s,
2349 : : WLAN_REASON_DEAUTH_LEAVING);
2350 : : }
2351 : :
2352 : 96 : was_disabled = ssid->disabled;
2353 : :
2354 [ - + ]: 96 : if (wpa_config_remove_network(wpa_s->conf, id) < 0) {
2355 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: Not able to remove the "
2356 : : "network id=%d", id);
2357 : 0 : return -1;
2358 : : }
2359 : :
2360 [ + + ][ - + ]: 96 : if (!was_disabled && wpa_s->sched_scanning) {
2361 : 0 : wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan to remove "
2362 : : "network from filters");
2363 : 0 : wpa_supplicant_cancel_sched_scan(wpa_s);
2364 : 0 : wpa_supplicant_req_scan(wpa_s, 0, 0);
2365 : : }
2366 : :
2367 : 850 : return 0;
2368 : : }
2369 : :
2370 : :
2371 : 1176 : static int wpa_supplicant_ctrl_iface_set_network(
2372 : : struct wpa_supplicant *wpa_s, char *cmd)
2373 : : {
2374 : : int id;
2375 : : struct wpa_ssid *ssid;
2376 : : char *name, *value;
2377 : :
2378 : : /* cmd: "<network id> <variable name> <value>" */
2379 : 1176 : name = os_strchr(cmd, ' ');
2380 [ - + ]: 1176 : if (name == NULL)
2381 : 0 : return -1;
2382 : 1176 : *name++ = '\0';
2383 : :
2384 : 1176 : value = os_strchr(name, ' ');
2385 [ - + ]: 1176 : if (value == NULL)
2386 : 0 : return -1;
2387 : 1176 : *value++ = '\0';
2388 : :
2389 : 1176 : id = atoi(cmd);
2390 : 1176 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: SET_NETWORK id=%d name='%s'",
2391 : : id, name);
2392 : 1176 : wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: value",
2393 : : (u8 *) value, os_strlen(value));
2394 : :
2395 : 1176 : ssid = wpa_config_get_network(wpa_s->conf, id);
2396 [ - + ]: 1176 : if (ssid == NULL) {
2397 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find network "
2398 : : "id=%d", id);
2399 : 0 : return -1;
2400 : : }
2401 : :
2402 [ - + ]: 1176 : if (wpa_config_set(ssid, name, value, 0) < 0) {
2403 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: Failed to set network "
2404 : : "variable '%s'", name);
2405 : 0 : return -1;
2406 : : }
2407 : :
2408 [ + - ][ + - ]: 1176 : if (os_strcmp(name, "bssid") != 0 &&
2409 : 1176 : os_strcmp(name, "priority") != 0)
2410 : 1176 : wpa_sm_pmksa_cache_flush(wpa_s->wpa, ssid);
2411 : :
2412 [ + - ][ + + ]: 1176 : if (wpa_s->current_ssid == ssid || wpa_s->current_ssid == NULL) {
2413 : : /*
2414 : : * Invalidate the EAP session cache if anything in the current
2415 : : * or previously used configuration changes.
2416 : : */
2417 : 1173 : eapol_sm_invalidate_cached_session(wpa_s->eapol);
2418 : : }
2419 : :
2420 [ + + ][ + - ]: 1176 : if ((os_strcmp(name, "psk") == 0 &&
2421 [ - + ][ + + ]: 1176 : value[0] == '"' && ssid->ssid_len) ||
2422 [ + + ]: 249 : (os_strcmp(name, "ssid") == 0 && ssid->passphrase))
2423 : 81 : wpa_config_update_psk(ssid);
2424 [ - + ]: 1095 : else if (os_strcmp(name, "priority") == 0)
2425 : 0 : wpa_config_update_prio_list(wpa_s->conf);
2426 : :
2427 : 1176 : return 0;
2428 : : }
2429 : :
2430 : :
2431 : 0 : static int wpa_supplicant_ctrl_iface_get_network(
2432 : : struct wpa_supplicant *wpa_s, char *cmd, char *buf, size_t buflen)
2433 : : {
2434 : : int id;
2435 : : size_t res;
2436 : : struct wpa_ssid *ssid;
2437 : : char *name, *value;
2438 : :
2439 : : /* cmd: "<network id> <variable name>" */
2440 : 0 : name = os_strchr(cmd, ' ');
2441 [ # # ][ # # ]: 0 : if (name == NULL || buflen == 0)
2442 : 0 : return -1;
2443 : 0 : *name++ = '\0';
2444 : :
2445 : 0 : id = atoi(cmd);
2446 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: GET_NETWORK id=%d name='%s'",
2447 : : id, name);
2448 : :
2449 : 0 : ssid = wpa_config_get_network(wpa_s->conf, id);
2450 [ # # ]: 0 : if (ssid == NULL) {
2451 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find network "
2452 : : "id=%d", id);
2453 : 0 : return -1;
2454 : : }
2455 : :
2456 : 0 : value = wpa_config_get_no_key(ssid, name);
2457 [ # # ]: 0 : if (value == NULL) {
2458 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: Failed to get network "
2459 : : "variable '%s'", name);
2460 : 0 : return -1;
2461 : : }
2462 : :
2463 : 0 : res = os_strlcpy(buf, value, buflen);
2464 [ # # ]: 0 : if (res >= buflen) {
2465 : 0 : os_free(value);
2466 : 0 : return -1;
2467 : : }
2468 : :
2469 : 0 : os_free(value);
2470 : :
2471 : 0 : return res;
2472 : : }
2473 : :
2474 : :
2475 : 0 : static int wpa_supplicant_ctrl_iface_list_creds(struct wpa_supplicant *wpa_s,
2476 : : char *buf, size_t buflen)
2477 : : {
2478 : : char *pos, *end;
2479 : : struct wpa_cred *cred;
2480 : : int ret;
2481 : :
2482 : 0 : pos = buf;
2483 : 0 : end = buf + buflen;
2484 : 0 : ret = os_snprintf(pos, end - pos,
2485 : : "cred id / realm / username / domain / imsi\n");
2486 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2487 : 0 : return pos - buf;
2488 : 0 : pos += ret;
2489 : :
2490 : 0 : cred = wpa_s->conf->cred;
2491 [ # # ]: 0 : while (cred) {
2492 [ # # ][ # # ]: 0 : ret = os_snprintf(pos, end - pos, "%d\t%s\t%s\t%s\t%s\n",
[ # # ][ # # ]
2493 : 0 : cred->id, cred->realm ? cred->realm : "",
2494 : 0 : cred->username ? cred->username : "",
2495 : 0 : cred->domain ? cred->domain[0] : "",
2496 : 0 : cred->imsi ? cred->imsi : "");
2497 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2498 : 0 : return pos - buf;
2499 : 0 : pos += ret;
2500 : :
2501 : 0 : cred = cred->next;
2502 : : }
2503 : :
2504 : 0 : return pos - buf;
2505 : : }
2506 : :
2507 : :
2508 : 30 : static int wpa_supplicant_ctrl_iface_add_cred(struct wpa_supplicant *wpa_s,
2509 : : char *buf, size_t buflen)
2510 : : {
2511 : : struct wpa_cred *cred;
2512 : : int ret;
2513 : :
2514 : 30 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: ADD_CRED");
2515 : :
2516 : 30 : cred = wpa_config_add_cred(wpa_s->conf);
2517 [ - + ]: 30 : if (cred == NULL)
2518 : 0 : return -1;
2519 : :
2520 : 30 : ret = os_snprintf(buf, buflen, "%d\n", cred->id);
2521 [ + - ][ - + ]: 30 : if (ret < 0 || (size_t) ret >= buflen)
2522 : 0 : return -1;
2523 : 30 : return ret;
2524 : : }
2525 : :
2526 : :
2527 : 30 : static int wpas_ctrl_remove_cred(struct wpa_supplicant *wpa_s,
2528 : : struct wpa_cred *cred)
2529 : : {
2530 : : struct wpa_ssid *ssid;
2531 : : char str[20];
2532 : :
2533 [ + - ][ - + ]: 30 : if (cred == NULL || wpa_config_remove_cred(wpa_s->conf, cred->id) < 0) {
2534 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find cred");
2535 : 0 : return -1;
2536 : : }
2537 : :
2538 : : /* Remove any network entry created based on the removed credential */
2539 : 30 : ssid = wpa_s->conf->ssid;
2540 [ + + ]: 34 : while (ssid) {
2541 [ + - ]: 4 : if (ssid->parent_cred == cred) {
2542 : 4 : wpa_printf(MSG_DEBUG, "Remove network id %d since it "
2543 : : "used the removed credential", ssid->id);
2544 : 4 : os_snprintf(str, sizeof(str), "%d", ssid->id);
2545 : 4 : ssid = ssid->next;
2546 : 4 : wpa_supplicant_ctrl_iface_remove_network(wpa_s, str);
2547 : : } else
2548 : 0 : ssid = ssid->next;
2549 : : }
2550 : :
2551 : 30 : return 0;
2552 : : }
2553 : :
2554 : :
2555 : 732 : static int wpa_supplicant_ctrl_iface_remove_cred(struct wpa_supplicant *wpa_s,
2556 : : char *cmd)
2557 : : {
2558 : : int id;
2559 : : struct wpa_cred *cred, *prev;
2560 : :
2561 : : /* cmd: "<cred id>", "all", or "sp_fqdn=<FQDN>" */
2562 [ + + ]: 732 : if (os_strcmp(cmd, "all") == 0) {
2563 : 727 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: REMOVE_CRED all");
2564 : 727 : cred = wpa_s->conf->cred;
2565 [ + + ]: 752 : while (cred) {
2566 : 25 : prev = cred;
2567 : 25 : cred = cred->next;
2568 : 25 : wpas_ctrl_remove_cred(wpa_s, prev);
2569 : : }
2570 : 727 : return 0;
2571 : : }
2572 : :
2573 [ - + ]: 5 : if (os_strncmp(cmd, "sp_fqdn=", 8) == 0) {
2574 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: REMOVE_CRED SP FQDN '%s'",
2575 : : cmd + 8);
2576 : 0 : cred = wpa_s->conf->cred;
2577 [ # # ]: 0 : while (cred) {
2578 : 0 : prev = cred;
2579 : 0 : cred = cred->next;
2580 [ # # ]: 0 : if (prev->domain) {
2581 : : size_t i;
2582 [ # # ]: 0 : for (i = 0; i < prev->num_domain; i++) {
2583 [ # # ]: 0 : if (os_strcmp(prev->domain[i], cmd + 8)
2584 : : != 0)
2585 : 0 : continue;
2586 : 0 : wpas_ctrl_remove_cred(wpa_s, prev);
2587 : 0 : break;
2588 : : }
2589 : : }
2590 : : }
2591 : 0 : return 0;
2592 : : }
2593 : :
2594 : 5 : id = atoi(cmd);
2595 : 5 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: REMOVE_CRED id=%d", id);
2596 : :
2597 : 5 : cred = wpa_config_get_cred(wpa_s->conf, id);
2598 : 732 : return wpas_ctrl_remove_cred(wpa_s, cred);
2599 : : }
2600 : :
2601 : :
2602 : 109 : static int wpa_supplicant_ctrl_iface_set_cred(struct wpa_supplicant *wpa_s,
2603 : : char *cmd)
2604 : : {
2605 : : int id;
2606 : : struct wpa_cred *cred;
2607 : : char *name, *value;
2608 : :
2609 : : /* cmd: "<cred id> <variable name> <value>" */
2610 : 109 : name = os_strchr(cmd, ' ');
2611 [ - + ]: 109 : if (name == NULL)
2612 : 0 : return -1;
2613 : 109 : *name++ = '\0';
2614 : :
2615 : 109 : value = os_strchr(name, ' ');
2616 [ - + ]: 109 : if (value == NULL)
2617 : 0 : return -1;
2618 : 109 : *value++ = '\0';
2619 : :
2620 : 109 : id = atoi(cmd);
2621 : 109 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: SET_CRED id=%d name='%s'",
2622 : : id, name);
2623 : 109 : wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: value",
2624 : : (u8 *) value, os_strlen(value));
2625 : :
2626 : 109 : cred = wpa_config_get_cred(wpa_s->conf, id);
2627 [ - + ]: 109 : if (cred == NULL) {
2628 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find cred id=%d",
2629 : : id);
2630 : 0 : return -1;
2631 : : }
2632 : :
2633 [ - + ]: 109 : if (wpa_config_set_cred(cred, name, value, 0) < 0) {
2634 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: Failed to set cred "
2635 : : "variable '%s'", name);
2636 : 0 : return -1;
2637 : : }
2638 : :
2639 : 109 : return 0;
2640 : : }
2641 : :
2642 : :
2643 : : #ifndef CONFIG_NO_CONFIG_WRITE
2644 : 0 : static int wpa_supplicant_ctrl_iface_save_config(struct wpa_supplicant *wpa_s)
2645 : : {
2646 : : int ret;
2647 : :
2648 [ # # ]: 0 : if (!wpa_s->conf->update_config) {
2649 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: SAVE_CONFIG - Not allowed "
2650 : : "to update configuration (update_config=0)");
2651 : 0 : return -1;
2652 : : }
2653 : :
2654 : 0 : ret = wpa_config_write(wpa_s->confname, wpa_s->conf);
2655 [ # # ]: 0 : if (ret) {
2656 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: SAVE_CONFIG - Failed to "
2657 : : "update configuration");
2658 : : } else {
2659 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: SAVE_CONFIG - Configuration"
2660 : : " updated");
2661 : : }
2662 : :
2663 : 0 : return ret;
2664 : : }
2665 : : #endif /* CONFIG_NO_CONFIG_WRITE */
2666 : :
2667 : :
2668 : : struct cipher_info {
2669 : : unsigned int capa;
2670 : : const char *name;
2671 : : int group_only;
2672 : : };
2673 : :
2674 : : static const struct cipher_info ciphers[] = {
2675 : : { WPA_DRIVER_CAPA_ENC_CCMP_256, "CCMP-256", 0 },
2676 : : { WPA_DRIVER_CAPA_ENC_GCMP_256, "GCMP-256", 0 },
2677 : : { WPA_DRIVER_CAPA_ENC_CCMP, "CCMP", 0 },
2678 : : { WPA_DRIVER_CAPA_ENC_GCMP, "GCMP", 0 },
2679 : : { WPA_DRIVER_CAPA_ENC_TKIP, "TKIP", 0 },
2680 : : { WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE, "NONE", 0 },
2681 : : { WPA_DRIVER_CAPA_ENC_WEP104, "WEP104", 1 },
2682 : : { WPA_DRIVER_CAPA_ENC_WEP40, "WEP40", 1 }
2683 : : };
2684 : :
2685 : :
2686 : 5 : static int ctrl_iface_get_capability_pairwise(int res, char *strict,
2687 : : struct wpa_driver_capa *capa,
2688 : : char *buf, size_t buflen)
2689 : : {
2690 : 5 : int ret, first = 1;
2691 : : char *pos, *end;
2692 : : size_t len;
2693 : : unsigned int i;
2694 : :
2695 : 5 : pos = buf;
2696 : 5 : end = pos + buflen;
2697 : :
2698 [ - + ]: 5 : if (res < 0) {
2699 [ # # ]: 0 : if (strict)
2700 : 0 : return 0;
2701 : 0 : len = os_strlcpy(buf, "CCMP TKIP NONE", buflen);
2702 [ # # ]: 0 : if (len >= buflen)
2703 : 0 : return -1;
2704 : 0 : return len;
2705 : : }
2706 : :
2707 [ + + ]: 45 : for (i = 0; i < ARRAY_SIZE(ciphers); i++) {
2708 [ + + ][ + + ]: 40 : if (!ciphers[i].group_only && capa->enc & ciphers[i].capa) {
2709 [ + + ]: 10 : ret = os_snprintf(pos, end - pos, "%s%s",
2710 : : first ? "" : " ", ciphers[i].name);
2711 [ + - ][ - + ]: 10 : if (ret < 0 || ret >= end - pos)
2712 : 0 : return pos - buf;
2713 : 10 : pos += ret;
2714 : 10 : first = 0;
2715 : : }
2716 : : }
2717 : :
2718 : 5 : return pos - buf;
2719 : : }
2720 : :
2721 : :
2722 : 0 : static int ctrl_iface_get_capability_group(int res, char *strict,
2723 : : struct wpa_driver_capa *capa,
2724 : : char *buf, size_t buflen)
2725 : : {
2726 : 0 : int ret, first = 1;
2727 : : char *pos, *end;
2728 : : size_t len;
2729 : : unsigned int i;
2730 : :
2731 : 0 : pos = buf;
2732 : 0 : end = pos + buflen;
2733 : :
2734 [ # # ]: 0 : if (res < 0) {
2735 [ # # ]: 0 : if (strict)
2736 : 0 : return 0;
2737 : 0 : len = os_strlcpy(buf, "CCMP TKIP WEP104 WEP40", buflen);
2738 [ # # ]: 0 : if (len >= buflen)
2739 : 0 : return -1;
2740 : 0 : return len;
2741 : : }
2742 : :
2743 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(ciphers); i++) {
2744 [ # # ]: 0 : if (capa->enc & ciphers[i].capa) {
2745 [ # # ]: 0 : ret = os_snprintf(pos, end - pos, "%s%s",
2746 : : first ? "" : " ", ciphers[i].name);
2747 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2748 : 0 : return pos - buf;
2749 : 0 : pos += ret;
2750 : 0 : first = 0;
2751 : : }
2752 : : }
2753 : :
2754 : 0 : return pos - buf;
2755 : : }
2756 : :
2757 : :
2758 : 0 : static int ctrl_iface_get_capability_key_mgmt(int res, char *strict,
2759 : : struct wpa_driver_capa *capa,
2760 : : char *buf, size_t buflen)
2761 : : {
2762 : : int ret;
2763 : : char *pos, *end;
2764 : : size_t len;
2765 : :
2766 : 0 : pos = buf;
2767 : 0 : end = pos + buflen;
2768 : :
2769 [ # # ]: 0 : if (res < 0) {
2770 [ # # ]: 0 : if (strict)
2771 : 0 : return 0;
2772 : 0 : len = os_strlcpy(buf, "WPA-PSK WPA-EAP IEEE8021X WPA-NONE "
2773 : : "NONE", buflen);
2774 [ # # ]: 0 : if (len >= buflen)
2775 : 0 : return -1;
2776 : 0 : return len;
2777 : : }
2778 : :
2779 : 0 : ret = os_snprintf(pos, end - pos, "NONE IEEE8021X");
2780 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2781 : 0 : return pos - buf;
2782 : 0 : pos += ret;
2783 : :
2784 [ # # ]: 0 : if (capa->key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA |
2785 : : WPA_DRIVER_CAPA_KEY_MGMT_WPA2)) {
2786 : 0 : ret = os_snprintf(pos, end - pos, " WPA-EAP");
2787 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2788 : 0 : return pos - buf;
2789 : 0 : pos += ret;
2790 : : }
2791 : :
2792 [ # # ]: 0 : if (capa->key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK |
2793 : : WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK)) {
2794 : 0 : ret = os_snprintf(pos, end - pos, " WPA-PSK");
2795 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2796 : 0 : return pos - buf;
2797 : 0 : pos += ret;
2798 : : }
2799 : :
2800 [ # # ]: 0 : if (capa->key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE) {
2801 : 0 : ret = os_snprintf(pos, end - pos, " WPA-NONE");
2802 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2803 : 0 : return pos - buf;
2804 : 0 : pos += ret;
2805 : : }
2806 : :
2807 : 0 : return pos - buf;
2808 : : }
2809 : :
2810 : :
2811 : 0 : static int ctrl_iface_get_capability_proto(int res, char *strict,
2812 : : struct wpa_driver_capa *capa,
2813 : : char *buf, size_t buflen)
2814 : : {
2815 : 0 : int ret, first = 1;
2816 : : char *pos, *end;
2817 : : size_t len;
2818 : :
2819 : 0 : pos = buf;
2820 : 0 : end = pos + buflen;
2821 : :
2822 [ # # ]: 0 : if (res < 0) {
2823 [ # # ]: 0 : if (strict)
2824 : 0 : return 0;
2825 : 0 : len = os_strlcpy(buf, "RSN WPA", buflen);
2826 [ # # ]: 0 : if (len >= buflen)
2827 : 0 : return -1;
2828 : 0 : return len;
2829 : : }
2830 : :
2831 [ # # ]: 0 : if (capa->key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA2 |
2832 : : WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK)) {
2833 [ # # ]: 0 : ret = os_snprintf(pos, end - pos, "%sRSN", first ? "" : " ");
2834 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2835 : 0 : return pos - buf;
2836 : 0 : pos += ret;
2837 : 0 : first = 0;
2838 : : }
2839 : :
2840 [ # # ]: 0 : if (capa->key_mgmt & (WPA_DRIVER_CAPA_KEY_MGMT_WPA |
2841 : : WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK)) {
2842 [ # # ]: 0 : ret = os_snprintf(pos, end - pos, "%sWPA", first ? "" : " ");
2843 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2844 : 0 : return pos - buf;
2845 : 0 : pos += ret;
2846 : 0 : first = 0;
2847 : : }
2848 : :
2849 : 0 : return pos - buf;
2850 : : }
2851 : :
2852 : :
2853 : 0 : static int ctrl_iface_get_capability_auth_alg(int res, char *strict,
2854 : : struct wpa_driver_capa *capa,
2855 : : char *buf, size_t buflen)
2856 : : {
2857 : 0 : int ret, first = 1;
2858 : : char *pos, *end;
2859 : : size_t len;
2860 : :
2861 : 0 : pos = buf;
2862 : 0 : end = pos + buflen;
2863 : :
2864 [ # # ]: 0 : if (res < 0) {
2865 [ # # ]: 0 : if (strict)
2866 : 0 : return 0;
2867 : 0 : len = os_strlcpy(buf, "OPEN SHARED LEAP", buflen);
2868 [ # # ]: 0 : if (len >= buflen)
2869 : 0 : return -1;
2870 : 0 : return len;
2871 : : }
2872 : :
2873 [ # # ]: 0 : if (capa->auth & (WPA_DRIVER_AUTH_OPEN)) {
2874 [ # # ]: 0 : ret = os_snprintf(pos, end - pos, "%sOPEN", first ? "" : " ");
2875 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2876 : 0 : return pos - buf;
2877 : 0 : pos += ret;
2878 : 0 : first = 0;
2879 : : }
2880 : :
2881 [ # # ]: 0 : if (capa->auth & (WPA_DRIVER_AUTH_SHARED)) {
2882 [ # # ]: 0 : ret = os_snprintf(pos, end - pos, "%sSHARED",
2883 : : first ? "" : " ");
2884 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2885 : 0 : return pos - buf;
2886 : 0 : pos += ret;
2887 : 0 : first = 0;
2888 : : }
2889 : :
2890 [ # # ]: 0 : if (capa->auth & (WPA_DRIVER_AUTH_LEAP)) {
2891 [ # # ]: 0 : ret = os_snprintf(pos, end - pos, "%sLEAP", first ? "" : " ");
2892 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2893 : 0 : return pos - buf;
2894 : 0 : pos += ret;
2895 : 0 : first = 0;
2896 : : }
2897 : :
2898 : 0 : return pos - buf;
2899 : : }
2900 : :
2901 : :
2902 : 0 : static int ctrl_iface_get_capability_modes(int res, char *strict,
2903 : : struct wpa_driver_capa *capa,
2904 : : char *buf, size_t buflen)
2905 : : {
2906 : 0 : int ret, first = 1;
2907 : : char *pos, *end;
2908 : : size_t len;
2909 : :
2910 : 0 : pos = buf;
2911 : 0 : end = pos + buflen;
2912 : :
2913 [ # # ]: 0 : if (res < 0) {
2914 [ # # ]: 0 : if (strict)
2915 : 0 : return 0;
2916 : 0 : len = os_strlcpy(buf, "IBSS AP", buflen);
2917 [ # # ]: 0 : if (len >= buflen)
2918 : 0 : return -1;
2919 : 0 : return len;
2920 : : }
2921 : :
2922 [ # # ]: 0 : if (capa->flags & WPA_DRIVER_FLAGS_IBSS) {
2923 [ # # ]: 0 : ret = os_snprintf(pos, end - pos, "%sIBSS", first ? "" : " ");
2924 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2925 : 0 : return pos - buf;
2926 : 0 : pos += ret;
2927 : 0 : first = 0;
2928 : : }
2929 : :
2930 [ # # ]: 0 : if (capa->flags & WPA_DRIVER_FLAGS_AP) {
2931 [ # # ]: 0 : ret = os_snprintf(pos, end - pos, "%sAP", first ? "" : " ");
2932 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2933 : 0 : return pos - buf;
2934 : 0 : pos += ret;
2935 : 0 : first = 0;
2936 : : }
2937 : :
2938 : 0 : return pos - buf;
2939 : : }
2940 : :
2941 : :
2942 : 0 : static int ctrl_iface_get_capability_channels(struct wpa_supplicant *wpa_s,
2943 : : char *buf, size_t buflen)
2944 : : {
2945 : : struct hostapd_channel_data *chnl;
2946 : : int ret, i, j;
2947 : : char *pos, *end, *hmode;
2948 : :
2949 : 0 : pos = buf;
2950 : 0 : end = pos + buflen;
2951 : :
2952 [ # # ]: 0 : for (j = 0; j < wpa_s->hw.num_modes; j++) {
2953 [ # # # # : 0 : switch (wpa_s->hw.modes[j].mode) {
# ]
2954 : : case HOSTAPD_MODE_IEEE80211B:
2955 : 0 : hmode = "B";
2956 : 0 : break;
2957 : : case HOSTAPD_MODE_IEEE80211G:
2958 : 0 : hmode = "G";
2959 : 0 : break;
2960 : : case HOSTAPD_MODE_IEEE80211A:
2961 : 0 : hmode = "A";
2962 : 0 : break;
2963 : : case HOSTAPD_MODE_IEEE80211AD:
2964 : 0 : hmode = "AD";
2965 : 0 : break;
2966 : : default:
2967 : 0 : continue;
2968 : : }
2969 : 0 : ret = os_snprintf(pos, end - pos, "Mode[%s] Channels:", hmode);
2970 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2971 : 0 : return pos - buf;
2972 : 0 : pos += ret;
2973 : 0 : chnl = wpa_s->hw.modes[j].channels;
2974 [ # # ]: 0 : for (i = 0; i < wpa_s->hw.modes[j].num_channels; i++) {
2975 [ # # ]: 0 : if (chnl[i].flag & HOSTAPD_CHAN_DISABLED)
2976 : 0 : continue;
2977 : 0 : ret = os_snprintf(pos, end - pos, " %d", chnl[i].chan);
2978 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2979 : 0 : return pos - buf;
2980 : 0 : pos += ret;
2981 : : }
2982 : 0 : ret = os_snprintf(pos, end - pos, "\n");
2983 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
2984 : 0 : return pos - buf;
2985 : 0 : pos += ret;
2986 : : }
2987 : :
2988 : 0 : return pos - buf;
2989 : : }
2990 : :
2991 : :
2992 : 0 : static int ctrl_iface_get_capability_freq(struct wpa_supplicant *wpa_s,
2993 : : char *buf, size_t buflen)
2994 : : {
2995 : : struct hostapd_channel_data *chnl;
2996 : : int ret, i, j;
2997 : : char *pos, *end, *hmode;
2998 : :
2999 : 0 : pos = buf;
3000 : 0 : end = pos + buflen;
3001 : :
3002 [ # # ]: 0 : for (j = 0; j < wpa_s->hw.num_modes; j++) {
3003 [ # # # # : 0 : switch (wpa_s->hw.modes[j].mode) {
# ]
3004 : : case HOSTAPD_MODE_IEEE80211B:
3005 : 0 : hmode = "B";
3006 : 0 : break;
3007 : : case HOSTAPD_MODE_IEEE80211G:
3008 : 0 : hmode = "G";
3009 : 0 : break;
3010 : : case HOSTAPD_MODE_IEEE80211A:
3011 : 0 : hmode = "A";
3012 : 0 : break;
3013 : : case HOSTAPD_MODE_IEEE80211AD:
3014 : 0 : hmode = "AD";
3015 : 0 : break;
3016 : : default:
3017 : 0 : continue;
3018 : : }
3019 : 0 : ret = os_snprintf(pos, end - pos, "Mode[%s] Channels:\n",
3020 : : hmode);
3021 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
3022 : 0 : return pos - buf;
3023 : 0 : pos += ret;
3024 : 0 : chnl = wpa_s->hw.modes[j].channels;
3025 [ # # ]: 0 : for (i = 0; i < wpa_s->hw.modes[j].num_channels; i++) {
3026 [ # # ]: 0 : if (chnl[i].flag & HOSTAPD_CHAN_DISABLED)
3027 : 0 : continue;
3028 [ # # ]: 0 : ret = os_snprintf(pos, end - pos, " %d = %d MHz%s\n",
3029 : 0 : chnl[i].chan, chnl[i].freq,
3030 : 0 : chnl[i].flag & HOSTAPD_CHAN_NO_IBSS ?
3031 : : " (NO_IBSS)" : "");
3032 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
3033 : 0 : return pos - buf;
3034 : 0 : pos += ret;
3035 : : }
3036 : 0 : ret = os_snprintf(pos, end - pos, "\n");
3037 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
3038 : 0 : return pos - buf;
3039 : 0 : pos += ret;
3040 : : }
3041 : :
3042 : 0 : return pos - buf;
3043 : : }
3044 : :
3045 : :
3046 : 5 : static int wpa_supplicant_ctrl_iface_get_capability(
3047 : : struct wpa_supplicant *wpa_s, const char *_field, char *buf,
3048 : : size_t buflen)
3049 : : {
3050 : : struct wpa_driver_capa capa;
3051 : : int res;
3052 : : char *strict;
3053 : : char field[30];
3054 : : size_t len;
3055 : :
3056 : : /* Determine whether or not strict checking was requested */
3057 : 5 : len = os_strlcpy(field, _field, sizeof(field));
3058 [ - + ]: 5 : if (len >= sizeof(field))
3059 : 0 : return -1;
3060 : 5 : strict = os_strchr(field, ' ');
3061 [ - + ]: 5 : if (strict != NULL) {
3062 : 0 : *strict++ = '\0';
3063 [ # # ]: 0 : if (os_strcmp(strict, "strict") != 0)
3064 : 0 : return -1;
3065 : : }
3066 : :
3067 [ - + ]: 5 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: GET_CAPABILITY '%s' %s",
3068 : : field, strict ? strict : "");
3069 : :
3070 [ - + ]: 5 : if (os_strcmp(field, "eap") == 0) {
3071 : 0 : return eap_get_names(buf, buflen);
3072 : : }
3073 : :
3074 : 5 : res = wpa_drv_get_capa(wpa_s, &capa);
3075 : :
3076 [ + - ]: 5 : if (os_strcmp(field, "pairwise") == 0)
3077 : 5 : return ctrl_iface_get_capability_pairwise(res, strict, &capa,
3078 : : buf, buflen);
3079 : :
3080 [ # # ]: 0 : if (os_strcmp(field, "group") == 0)
3081 : 0 : return ctrl_iface_get_capability_group(res, strict, &capa,
3082 : : buf, buflen);
3083 : :
3084 [ # # ]: 0 : if (os_strcmp(field, "key_mgmt") == 0)
3085 : 0 : return ctrl_iface_get_capability_key_mgmt(res, strict, &capa,
3086 : : buf, buflen);
3087 : :
3088 [ # # ]: 0 : if (os_strcmp(field, "proto") == 0)
3089 : 0 : return ctrl_iface_get_capability_proto(res, strict, &capa,
3090 : : buf, buflen);
3091 : :
3092 [ # # ]: 0 : if (os_strcmp(field, "auth_alg") == 0)
3093 : 0 : return ctrl_iface_get_capability_auth_alg(res, strict, &capa,
3094 : : buf, buflen);
3095 : :
3096 [ # # ]: 0 : if (os_strcmp(field, "modes") == 0)
3097 : 0 : return ctrl_iface_get_capability_modes(res, strict, &capa,
3098 : : buf, buflen);
3099 : :
3100 [ # # ]: 0 : if (os_strcmp(field, "channels") == 0)
3101 : 0 : return ctrl_iface_get_capability_channels(wpa_s, buf, buflen);
3102 : :
3103 [ # # ]: 0 : if (os_strcmp(field, "freq") == 0)
3104 : 0 : return ctrl_iface_get_capability_freq(wpa_s, buf, buflen);
3105 : :
3106 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: Unknown GET_CAPABILITY field '%s'",
3107 : : field);
3108 : :
3109 : 5 : return -1;
3110 : : }
3111 : :
3112 : :
3113 : : #ifdef CONFIG_INTERWORKING
3114 : 40 : static char * anqp_add_hex(char *pos, char *end, const char *title,
3115 : : struct wpabuf *data)
3116 : : {
3117 : 40 : char *start = pos;
3118 : : size_t i;
3119 : : int ret;
3120 : : const u8 *d;
3121 : :
3122 [ + + ]: 40 : if (data == NULL)
3123 : 32 : return start;
3124 : :
3125 : 8 : ret = os_snprintf(pos, end - pos, "%s=", title);
3126 [ + - ][ - + ]: 8 : if (ret < 0 || ret >= end - pos)
3127 : 0 : return start;
3128 : 8 : pos += ret;
3129 : :
3130 : 8 : d = wpabuf_head_u8(data);
3131 [ + + ]: 340 : for (i = 0; i < wpabuf_len(data); i++) {
3132 : 332 : ret = os_snprintf(pos, end - pos, "%02x", *d++);
3133 [ + - ][ - + ]: 332 : if (ret < 0 || ret >= end - pos)
3134 : 0 : return start;
3135 : 332 : pos += ret;
3136 : : }
3137 : :
3138 : 8 : ret = os_snprintf(pos, end - pos, "\n");
3139 [ + - ][ - + ]: 8 : if (ret < 0 || ret >= end - pos)
3140 : 0 : return start;
3141 : 8 : pos += ret;
3142 : :
3143 : 40 : return pos;
3144 : : }
3145 : : #endif /* CONFIG_INTERWORKING */
3146 : :
3147 : :
3148 : 172 : static int print_bss_info(struct wpa_supplicant *wpa_s, struct wpa_bss *bss,
3149 : : unsigned long mask, char *buf, size_t buflen)
3150 : : {
3151 : : size_t i;
3152 : : int ret;
3153 : : char *pos, *end;
3154 : : const u8 *ie, *ie2;
3155 : :
3156 : 172 : pos = buf;
3157 : 172 : end = buf + buflen;
3158 : :
3159 [ + + ]: 172 : if (mask & WPA_BSS_MASK_ID) {
3160 : 31 : ret = os_snprintf(pos, end - pos, "id=%u\n", bss->id);
3161 [ + - ][ - + ]: 31 : if (ret < 0 || ret >= end - pos)
3162 : 0 : return 0;
3163 : 31 : pos += ret;
3164 : : }
3165 : :
3166 [ + + ]: 172 : if (mask & WPA_BSS_MASK_BSSID) {
3167 : 1026 : ret = os_snprintf(pos, end - pos, "bssid=" MACSTR "\n",
3168 : 1026 : MAC2STR(bss->bssid));
3169 [ + - ][ - + ]: 171 : if (ret < 0 || ret >= end - pos)
3170 : 0 : return 0;
3171 : 171 : pos += ret;
3172 : : }
3173 : :
3174 [ + + ]: 172 : if (mask & WPA_BSS_MASK_FREQ) {
3175 : 30 : ret = os_snprintf(pos, end - pos, "freq=%d\n", bss->freq);
3176 [ + - ][ - + ]: 30 : if (ret < 0 || ret >= end - pos)
3177 : 0 : return 0;
3178 : 30 : pos += ret;
3179 : : }
3180 : :
3181 [ + + ]: 172 : if (mask & WPA_BSS_MASK_BEACON_INT) {
3182 : 30 : ret = os_snprintf(pos, end - pos, "beacon_int=%d\n",
3183 : 30 : bss->beacon_int);
3184 [ + - ][ - + ]: 30 : if (ret < 0 || ret >= end - pos)
3185 : 0 : return 0;
3186 : 30 : pos += ret;
3187 : : }
3188 : :
3189 [ + + ]: 172 : if (mask & WPA_BSS_MASK_CAPABILITIES) {
3190 : 30 : ret = os_snprintf(pos, end - pos, "capabilities=0x%04x\n",
3191 : 30 : bss->caps);
3192 [ + - ][ - + ]: 30 : if (ret < 0 || ret >= end - pos)
3193 : 0 : return 0;
3194 : 30 : pos += ret;
3195 : : }
3196 : :
3197 [ + + ]: 172 : if (mask & WPA_BSS_MASK_QUAL) {
3198 : 30 : ret = os_snprintf(pos, end - pos, "qual=%d\n", bss->qual);
3199 [ + - ][ - + ]: 30 : if (ret < 0 || ret >= end - pos)
3200 : 0 : return 0;
3201 : 30 : pos += ret;
3202 : : }
3203 : :
3204 [ + + ]: 172 : if (mask & WPA_BSS_MASK_NOISE) {
3205 : 30 : ret = os_snprintf(pos, end - pos, "noise=%d\n", bss->noise);
3206 [ + - ][ - + ]: 30 : if (ret < 0 || ret >= end - pos)
3207 : 0 : return 0;
3208 : 30 : pos += ret;
3209 : : }
3210 : :
3211 [ + + ]: 172 : if (mask & WPA_BSS_MASK_LEVEL) {
3212 : 30 : ret = os_snprintf(pos, end - pos, "level=%d\n", bss->level);
3213 [ + - ][ - + ]: 30 : if (ret < 0 || ret >= end - pos)
3214 : 0 : return 0;
3215 : 30 : pos += ret;
3216 : : }
3217 : :
3218 [ + + ]: 172 : if (mask & WPA_BSS_MASK_TSF) {
3219 : 30 : ret = os_snprintf(pos, end - pos, "tsf=%016llu\n",
3220 : 30 : (unsigned long long) bss->tsf);
3221 [ + - ][ - + ]: 30 : if (ret < 0 || ret >= end - pos)
3222 : 0 : return 0;
3223 : 30 : pos += ret;
3224 : : }
3225 : :
3226 [ + + ]: 172 : if (mask & WPA_BSS_MASK_AGE) {
3227 : : struct os_reltime now;
3228 : :
3229 : 30 : os_get_reltime(&now);
3230 : 60 : ret = os_snprintf(pos, end - pos, "age=%d\n",
3231 : 60 : (int) (now.sec - bss->last_update.sec));
3232 [ + - ][ - + ]: 30 : if (ret < 0 || ret >= end - pos)
3233 : 0 : return 0;
3234 : 30 : pos += ret;
3235 : : }
3236 : :
3237 [ + + ]: 172 : if (mask & WPA_BSS_MASK_IE) {
3238 : 30 : ret = os_snprintf(pos, end - pos, "ie=");
3239 [ + - ][ - + ]: 30 : if (ret < 0 || ret >= end - pos)
3240 : 0 : return 0;
3241 : 30 : pos += ret;
3242 : :
3243 : 30 : ie = (const u8 *) (bss + 1);
3244 [ + + ]: 6387 : for (i = 0; i < bss->ie_len; i++) {
3245 : 6357 : ret = os_snprintf(pos, end - pos, "%02x", *ie++);
3246 [ + - ][ - + ]: 6357 : if (ret < 0 || ret >= end - pos)
3247 : 0 : return 0;
3248 : 6357 : pos += ret;
3249 : : }
3250 : :
3251 : 30 : ret = os_snprintf(pos, end - pos, "\n");
3252 [ + - ][ - + ]: 30 : if (ret < 0 || ret >= end - pos)
3253 : 0 : return 0;
3254 : 30 : pos += ret;
3255 : : }
3256 : :
3257 [ + + ]: 172 : if (mask & WPA_BSS_MASK_FLAGS) {
3258 : 30 : ret = os_snprintf(pos, end - pos, "flags=");
3259 [ + - ][ - + ]: 30 : if (ret < 0 || ret >= end - pos)
3260 : 0 : return 0;
3261 : 30 : pos += ret;
3262 : :
3263 : 30 : ie = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
3264 [ + + ]: 30 : if (ie)
3265 : 5 : pos = wpa_supplicant_ie_txt(pos, end, "WPA", ie,
3266 : 5 : 2 + ie[1]);
3267 : 30 : ie2 = wpa_bss_get_ie(bss, WLAN_EID_RSN);
3268 [ + + ]: 30 : if (ie2)
3269 : 20 : pos = wpa_supplicant_ie_txt(pos, end, "WPA2", ie2,
3270 : 20 : 2 + ie2[1]);
3271 : 30 : pos = wpa_supplicant_wps_ie_txt(wpa_s, pos, end, bss);
3272 [ + + ][ + + ]: 30 : if (!ie && !ie2 && bss->caps & IEEE80211_CAP_PRIVACY) {
[ - + ]
3273 : 0 : ret = os_snprintf(pos, end - pos, "[WEP]");
3274 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
3275 : 0 : return 0;
3276 : 0 : pos += ret;
3277 : : }
3278 [ - + ]: 30 : if (bss->caps & IEEE80211_CAP_IBSS) {
3279 : 0 : ret = os_snprintf(pos, end - pos, "[IBSS]");
3280 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
3281 : 0 : return 0;
3282 : 0 : pos += ret;
3283 : : }
3284 [ + - ]: 30 : if (bss->caps & IEEE80211_CAP_ESS) {
3285 : 30 : ret = os_snprintf(pos, end - pos, "[ESS]");
3286 [ + - ][ - + ]: 30 : if (ret < 0 || ret >= end - pos)
3287 : 0 : return 0;
3288 : 30 : pos += ret;
3289 : : }
3290 [ + + - + ]: 56 : if (wpa_bss_get_vendor_ie(bss, P2P_IE_VENDOR_TYPE) ||
3291 : 26 : wpa_bss_get_vendor_ie_beacon(bss, P2P_IE_VENDOR_TYPE)) {
3292 : 4 : ret = os_snprintf(pos, end - pos, "[P2P]");
3293 [ + - ][ - + ]: 4 : if (ret < 0 || ret >= end - pos)
3294 : 0 : return 0;
3295 : 4 : pos += ret;
3296 : : }
3297 : : #ifdef CONFIG_HS20
3298 [ + + ]: 30 : if (wpa_bss_get_vendor_ie(bss, HS20_IE_VENDOR_TYPE)) {
3299 : 4 : ret = os_snprintf(pos, end - pos, "[HS20]");
3300 [ + - ][ - + ]: 4 : if (ret < 0 || ret >= end - pos)
3301 : 0 : return 0;
3302 : 4 : pos += ret;
3303 : : }
3304 : : #endif /* CONFIG_HS20 */
3305 : :
3306 : 30 : ret = os_snprintf(pos, end - pos, "\n");
3307 [ + - ][ - + ]: 30 : if (ret < 0 || ret >= end - pos)
3308 : 0 : return 0;
3309 : 30 : pos += ret;
3310 : : }
3311 : :
3312 [ + + ]: 172 : if (mask & WPA_BSS_MASK_SSID) {
3313 : 30 : ret = os_snprintf(pos, end - pos, "ssid=%s\n",
3314 : 30 : wpa_ssid_txt(bss->ssid, bss->ssid_len));
3315 [ + - ][ - + ]: 30 : if (ret < 0 || ret >= end - pos)
3316 : 0 : return 0;
3317 : 30 : pos += ret;
3318 : : }
3319 : :
3320 : : #ifdef CONFIG_WPS
3321 [ + + ]: 172 : if (mask & WPA_BSS_MASK_WPS_SCAN) {
3322 : 30 : ie = (const u8 *) (bss + 1);
3323 : 30 : ret = wpas_wps_scan_result_text(ie, bss->ie_len, pos, end);
3324 [ + - ][ - + ]: 30 : if (ret < 0 || ret >= end - pos)
3325 : 0 : return 0;
3326 : 30 : pos += ret;
3327 : : }
3328 : : #endif /* CONFIG_WPS */
3329 : :
3330 : : #ifdef CONFIG_P2P
3331 [ + + ]: 172 : if (mask & WPA_BSS_MASK_P2P_SCAN) {
3332 : 30 : ie = (const u8 *) (bss + 1);
3333 : 30 : ret = wpas_p2p_scan_result_text(ie, bss->ie_len, pos, end);
3334 [ + - ][ - + ]: 30 : if (ret < 0 || ret >= end - pos)
3335 : 0 : return 0;
3336 : 30 : pos += ret;
3337 : : }
3338 : : #endif /* CONFIG_P2P */
3339 : :
3340 : : #ifdef CONFIG_WIFI_DISPLAY
3341 [ + + ]: 172 : if (mask & WPA_BSS_MASK_WIFI_DISPLAY) {
3342 : : struct wpabuf *wfd;
3343 : 30 : ie = (const u8 *) (bss + 1);
3344 : 30 : wfd = ieee802_11_vendor_ie_concat(ie, bss->ie_len,
3345 : : WFD_IE_VENDOR_TYPE);
3346 [ + + ]: 30 : if (wfd) {
3347 : 4 : ret = os_snprintf(pos, end - pos, "wfd_subelems=");
3348 [ + - ][ - + ]: 4 : if (ret < 0 || ret >= end - pos)
3349 : 0 : return 0;
3350 : 4 : pos += ret;
3351 : :
3352 : 8 : pos += wpa_snprintf_hex(pos, end - pos,
3353 : 4 : wpabuf_head(wfd),
3354 : : wpabuf_len(wfd));
3355 : 4 : wpabuf_free(wfd);
3356 : :
3357 : 4 : ret = os_snprintf(pos, end - pos, "\n");
3358 [ + - ][ - + ]: 4 : if (ret < 0 || ret >= end - pos)
3359 : 0 : return 0;
3360 : 4 : pos += ret;
3361 : : }
3362 : : }
3363 : : #endif /* CONFIG_WIFI_DISPLAY */
3364 : :
3365 : : #ifdef CONFIG_INTERWORKING
3366 [ + + ][ + + ]: 172 : if ((mask & WPA_BSS_MASK_INTERNETW) && bss->anqp) {
3367 : 4 : struct wpa_bss_anqp *anqp = bss->anqp;
3368 : 4 : pos = anqp_add_hex(pos, end, "anqp_venue_name",
3369 : : anqp->venue_name);
3370 : 4 : pos = anqp_add_hex(pos, end, "anqp_network_auth_type",
3371 : : anqp->network_auth_type);
3372 : 4 : pos = anqp_add_hex(pos, end, "anqp_roaming_consortium",
3373 : : anqp->roaming_consortium);
3374 : 4 : pos = anqp_add_hex(pos, end, "anqp_ip_addr_type_availability",
3375 : : anqp->ip_addr_type_availability);
3376 : 4 : pos = anqp_add_hex(pos, end, "anqp_nai_realm",
3377 : : anqp->nai_realm);
3378 : 4 : pos = anqp_add_hex(pos, end, "anqp_3gpp", anqp->anqp_3gpp);
3379 : 4 : pos = anqp_add_hex(pos, end, "anqp_domain_name",
3380 : : anqp->domain_name);
3381 : : #ifdef CONFIG_HS20
3382 : 4 : pos = anqp_add_hex(pos, end, "hs20_operator_friendly_name",
3383 : : anqp->hs20_operator_friendly_name);
3384 : 4 : pos = anqp_add_hex(pos, end, "hs20_wan_metrics",
3385 : : anqp->hs20_wan_metrics);
3386 : 4 : pos = anqp_add_hex(pos, end, "hs20_connection_capability",
3387 : : anqp->hs20_connection_capability);
3388 : : #endif /* CONFIG_HS20 */
3389 : : }
3390 : : #endif /* CONFIG_INTERWORKING */
3391 : :
3392 [ - + ]: 172 : if (mask & WPA_BSS_MASK_DELIM) {
3393 : 0 : ret = os_snprintf(pos, end - pos, "====\n");
3394 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
3395 : 0 : return 0;
3396 : 0 : pos += ret;
3397 : : }
3398 : :
3399 : 172 : return pos - buf;
3400 : : }
3401 : :
3402 : :
3403 : 112 : static int wpa_supplicant_ctrl_iface_bss(struct wpa_supplicant *wpa_s,
3404 : : const char *cmd, char *buf,
3405 : : size_t buflen)
3406 : : {
3407 : : u8 bssid[ETH_ALEN];
3408 : : size_t i;
3409 : : struct wpa_bss *bss;
3410 : 112 : struct wpa_bss *bsslast = NULL;
3411 : : struct dl_list *next;
3412 : 112 : int ret = 0;
3413 : : int len;
3414 : : char *ctmp;
3415 : 112 : unsigned long mask = WPA_BSS_MASK_ALL;
3416 : :
3417 [ + + ]: 112 : if (os_strncmp(cmd, "RANGE=", 6) == 0) {
3418 [ + + ]: 82 : if (os_strncmp(cmd + 6, "ALL", 3) == 0) {
3419 [ + + ]: 81 : bss = dl_list_first(&wpa_s->bss_id, struct wpa_bss,
3420 : : list_id);
3421 [ + + ]: 81 : bsslast = dl_list_last(&wpa_s->bss_id, struct wpa_bss,
3422 : : list_id);
3423 : : } else { /* N1-N2 */
3424 : : unsigned int id1, id2;
3425 : :
3426 [ - + ]: 1 : if ((ctmp = os_strchr(cmd + 6, '-')) == NULL) {
3427 : 0 : wpa_printf(MSG_INFO, "Wrong BSS range "
3428 : : "format");
3429 : 0 : return 0;
3430 : : }
3431 : :
3432 [ - + ]: 1 : if (*(cmd + 6) == '-')
3433 : 0 : id1 = 0;
3434 : : else
3435 : 1 : id1 = atoi(cmd + 6);
3436 : 1 : ctmp++;
3437 [ - + ][ # # ]: 1 : if (*ctmp >= '0' && *ctmp <= '9')
3438 : 0 : id2 = atoi(ctmp);
3439 : : else
3440 : 1 : id2 = (unsigned int) -1;
3441 : 1 : bss = wpa_bss_get_id_range(wpa_s, id1, id2);
3442 [ + - ]: 1 : if (id2 == (unsigned int) -1)
3443 [ + - ]: 1 : bsslast = dl_list_last(&wpa_s->bss_id,
3444 : : struct wpa_bss,
3445 : : list_id);
3446 : : else {
3447 : 0 : bsslast = wpa_bss_get_id(wpa_s, id2);
3448 [ # # ][ # # ]: 0 : if (bsslast == NULL && bss && id2 > id1) {
[ # # ]
3449 : 0 : struct wpa_bss *tmp = bss;
3450 : : for (;;) {
3451 : 0 : next = tmp->list_id.next;
3452 [ # # ]: 0 : if (next == &wpa_s->bss_id)
3453 : 0 : break;
3454 : 0 : tmp = dl_list_entry(
3455 : : next, struct wpa_bss,
3456 : : list_id);
3457 [ # # ]: 0 : if (tmp->id > id2)
3458 : 0 : break;
3459 : 0 : bsslast = tmp;
3460 : 82 : }
3461 : : }
3462 : : }
3463 : : }
3464 [ - + ]: 30 : } else if (os_strncmp(cmd, "FIRST", 5) == 0)
3465 [ # # ]: 0 : bss = dl_list_first(&wpa_s->bss_id, struct wpa_bss, list_id);
3466 [ - + ]: 30 : else if (os_strncmp(cmd, "LAST", 4) == 0)
3467 [ # # ]: 0 : bss = dl_list_last(&wpa_s->bss_id, struct wpa_bss, list_id);
3468 [ + + ]: 30 : else if (os_strncmp(cmd, "ID-", 3) == 0) {
3469 : 1 : i = atoi(cmd + 3);
3470 : 1 : bss = wpa_bss_get_id(wpa_s, i);
3471 [ - + ]: 29 : } else if (os_strncmp(cmd, "NEXT-", 5) == 0) {
3472 : 0 : i = atoi(cmd + 5);
3473 : 0 : bss = wpa_bss_get_id(wpa_s, i);
3474 [ # # ]: 0 : if (bss) {
3475 : 0 : next = bss->list_id.next;
3476 [ # # ]: 0 : if (next == &wpa_s->bss_id)
3477 : 0 : bss = NULL;
3478 : : else
3479 : 0 : bss = dl_list_entry(next, struct wpa_bss,
3480 : : list_id);
3481 : : }
3482 : : #ifdef CONFIG_P2P
3483 [ + + ]: 29 : } else if (os_strncmp(cmd, "p2p_dev_addr=", 13) == 0) {
3484 [ + - ]: 3 : if (hwaddr_aton(cmd + 13, bssid) == 0)
3485 : 3 : bss = wpa_bss_get_p2p_dev_addr(wpa_s, bssid);
3486 : : else
3487 : 0 : bss = NULL;
3488 : : #endif /* CONFIG_P2P */
3489 [ + - ]: 26 : } else if (hwaddr_aton(cmd, bssid) == 0)
3490 : 26 : bss = wpa_bss_get_bssid(wpa_s, bssid);
3491 : : else {
3492 : : struct wpa_bss *tmp;
3493 : 0 : i = atoi(cmd);
3494 : 0 : bss = NULL;
3495 [ # # ]: 0 : dl_list_for_each(tmp, &wpa_s->bss_id, struct wpa_bss, list_id)
3496 : : {
3497 [ # # ]: 0 : if (i-- == 0) {
3498 : 0 : bss = tmp;
3499 : 0 : break;
3500 : : }
3501 : : }
3502 : : }
3503 : :
3504 [ + + ]: 112 : if ((ctmp = os_strstr(cmd, "MASK=")) != NULL) {
3505 : 82 : mask = strtoul(ctmp + 5, NULL, 0x10);
3506 [ - + ]: 82 : if (mask == 0)
3507 : 0 : mask = WPA_BSS_MASK_ALL;
3508 : : }
3509 : :
3510 [ + + ]: 112 : if (bss == NULL)
3511 : 14 : return 0;
3512 : :
3513 [ + + ]: 98 : if (bsslast == NULL)
3514 : 30 : bsslast = bss;
3515 : : do {
3516 : 172 : len = print_bss_info(wpa_s, bss, mask, buf, buflen);
3517 : 172 : ret += len;
3518 : 172 : buf += len;
3519 : 172 : buflen -= len;
3520 [ + + ]: 172 : if (bss == bsslast) {
3521 [ - + ][ # # ]: 98 : if ((mask & WPA_BSS_MASK_DELIM) && len &&
[ # # ]
3522 [ # # ]: 0 : (bss == dl_list_last(&wpa_s->bss_id,
3523 : : struct wpa_bss, list_id)))
3524 : 0 : os_snprintf(buf - 5, 5, "####\n");
3525 : 98 : break;
3526 : : }
3527 : 74 : next = bss->list_id.next;
3528 [ - + ]: 74 : if (next == &wpa_s->bss_id)
3529 : 0 : break;
3530 : 74 : bss = dl_list_entry(next, struct wpa_bss, list_id);
3531 [ + - ][ + - ]: 74 : } while (bss && len);
3532 : :
3533 : 112 : return ret;
3534 : : }
3535 : :
3536 : :
3537 : 0 : static int wpa_supplicant_ctrl_iface_ap_scan(
3538 : : struct wpa_supplicant *wpa_s, char *cmd)
3539 : : {
3540 : 0 : int ap_scan = atoi(cmd);
3541 : 0 : return wpa_supplicant_set_ap_scan(wpa_s, ap_scan);
3542 : : }
3543 : :
3544 : :
3545 : 0 : static int wpa_supplicant_ctrl_iface_scan_interval(
3546 : : struct wpa_supplicant *wpa_s, char *cmd)
3547 : : {
3548 : 0 : int scan_int = atoi(cmd);
3549 : 0 : return wpa_supplicant_set_scan_interval(wpa_s, scan_int);
3550 : : }
3551 : :
3552 : :
3553 : 0 : static int wpa_supplicant_ctrl_iface_bss_expire_age(
3554 : : struct wpa_supplicant *wpa_s, char *cmd)
3555 : : {
3556 : 0 : int expire_age = atoi(cmd);
3557 : 0 : return wpa_supplicant_set_bss_expiration_age(wpa_s, expire_age);
3558 : : }
3559 : :
3560 : :
3561 : 0 : static int wpa_supplicant_ctrl_iface_bss_expire_count(
3562 : : struct wpa_supplicant *wpa_s, char *cmd)
3563 : : {
3564 : 0 : int expire_count = atoi(cmd);
3565 : 0 : return wpa_supplicant_set_bss_expiration_count(wpa_s, expire_count);
3566 : : }
3567 : :
3568 : :
3569 : 81 : static int wpa_supplicant_ctrl_iface_bss_flush(
3570 : : struct wpa_supplicant *wpa_s, char *cmd)
3571 : : {
3572 : 81 : int flush_age = atoi(cmd);
3573 : :
3574 [ + - ]: 81 : if (flush_age == 0)
3575 : 81 : wpa_bss_flush(wpa_s);
3576 : : else
3577 : 0 : wpa_bss_flush_by_age(wpa_s, flush_age);
3578 : 81 : return 0;
3579 : : }
3580 : :
3581 : :
3582 : 0 : static void wpa_supplicant_ctrl_iface_drop_sa(struct wpa_supplicant *wpa_s)
3583 : : {
3584 : 0 : wpa_printf(MSG_DEBUG, "Dropping SA without deauthentication");
3585 : : /* MLME-DELETEKEYS.request */
3586 : 0 : wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 0, 0, NULL, 0, NULL, 0);
3587 : 0 : wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 1, 0, NULL, 0, NULL, 0);
3588 : 0 : wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 2, 0, NULL, 0, NULL, 0);
3589 : 0 : wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 3, 0, NULL, 0, NULL, 0);
3590 : : #ifdef CONFIG_IEEE80211W
3591 : 0 : wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 4, 0, NULL, 0, NULL, 0);
3592 : 0 : wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 5, 0, NULL, 0, NULL, 0);
3593 : : #endif /* CONFIG_IEEE80211W */
3594 : :
3595 : 0 : wpa_drv_set_key(wpa_s, WPA_ALG_NONE, wpa_s->bssid, 0, 0, NULL, 0, NULL,
3596 : : 0);
3597 : : /* MLME-SETPROTECTION.request(None) */
3598 : 0 : wpa_drv_mlme_setprotection(wpa_s, wpa_s->bssid,
3599 : : MLME_SETPROTECTION_PROTECT_TYPE_NONE,
3600 : : MLME_SETPROTECTION_KEY_TYPE_PAIRWISE);
3601 : 0 : wpa_sm_drop_sa(wpa_s->wpa);
3602 : 0 : }
3603 : :
3604 : :
3605 : 20 : static int wpa_supplicant_ctrl_iface_roam(struct wpa_supplicant *wpa_s,
3606 : : char *addr)
3607 : : {
3608 : : #ifdef CONFIG_NO_SCAN_PROCESSING
3609 : : return -1;
3610 : : #else /* CONFIG_NO_SCAN_PROCESSING */
3611 : : u8 bssid[ETH_ALEN];
3612 : : struct wpa_bss *bss;
3613 : 20 : struct wpa_ssid *ssid = wpa_s->current_ssid;
3614 : :
3615 [ - + ]: 20 : if (hwaddr_aton(addr, bssid)) {
3616 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE ROAM: invalid "
3617 : : "address '%s'", addr);
3618 : 0 : return -1;
3619 : : }
3620 : :
3621 : 20 : wpa_printf(MSG_DEBUG, "CTRL_IFACE ROAM " MACSTR, MAC2STR(bssid));
3622 : :
3623 [ - + ]: 20 : if (!ssid) {
3624 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE ROAM: No network "
3625 : : "configuration known for the target AP");
3626 : 0 : return -1;
3627 : : }
3628 : :
3629 : 20 : bss = wpa_bss_get(wpa_s, bssid, ssid->ssid, ssid->ssid_len);
3630 [ - + ]: 20 : if (!bss) {
3631 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE ROAM: Target AP not found "
3632 : : "from BSS table");
3633 : 0 : return -1;
3634 : : }
3635 : :
3636 : : /*
3637 : : * TODO: Find best network configuration block from configuration to
3638 : : * allow roaming to other networks
3639 : : */
3640 : :
3641 : 20 : wpa_s->reassociate = 1;
3642 : 20 : wpa_supplicant_connect(wpa_s, bss, ssid);
3643 : :
3644 : 20 : return 0;
3645 : : #endif /* CONFIG_NO_SCAN_PROCESSING */
3646 : : }
3647 : :
3648 : :
3649 : : #ifdef CONFIG_P2P
3650 : 110 : static int p2p_ctrl_find(struct wpa_supplicant *wpa_s, char *cmd)
3651 : : {
3652 : 110 : unsigned int timeout = atoi(cmd);
3653 : 110 : enum p2p_discovery_type type = P2P_FIND_START_WITH_FULL;
3654 : 110 : u8 dev_id[ETH_ALEN], *_dev_id = NULL;
3655 : : char *pos;
3656 : : unsigned int search_delay;
3657 : :
3658 [ + + ]: 110 : if (os_strstr(cmd, "type=social"))
3659 : 96 : type = P2P_FIND_ONLY_SOCIAL;
3660 [ - + ]: 14 : else if (os_strstr(cmd, "type=progressive"))
3661 : 0 : type = P2P_FIND_PROGRESSIVE;
3662 : :
3663 : 110 : pos = os_strstr(cmd, "dev_id=");
3664 [ - + ]: 110 : if (pos) {
3665 : 0 : pos += 7;
3666 [ # # ]: 0 : if (hwaddr_aton(pos, dev_id))
3667 : 0 : return -1;
3668 : 0 : _dev_id = dev_id;
3669 : : }
3670 : :
3671 : 110 : pos = os_strstr(cmd, "delay=");
3672 [ - + ]: 110 : if (pos) {
3673 : 0 : pos += 6;
3674 : 0 : search_delay = atoi(pos);
3675 : : } else
3676 : 110 : search_delay = wpas_p2p_search_delay(wpa_s);
3677 : :
3678 : 110 : return wpas_p2p_find(wpa_s, timeout, type, 0, NULL, _dev_id,
3679 : : search_delay);
3680 : : }
3681 : :
3682 : :
3683 : 99 : static int p2p_ctrl_connect(struct wpa_supplicant *wpa_s, char *cmd,
3684 : : char *buf, size_t buflen)
3685 : : {
3686 : : u8 addr[ETH_ALEN];
3687 : : char *pos, *pos2;
3688 : 99 : char *pin = NULL;
3689 : : enum p2p_wps_method wps_method;
3690 : : int new_pin;
3691 : : int ret;
3692 : 99 : int persistent_group, persistent_id = -1;
3693 : : int join;
3694 : : int auth;
3695 : : int automatic;
3696 : 99 : int go_intent = -1;
3697 : 99 : int freq = 0;
3698 : : int pd;
3699 : : int ht40, vht;
3700 : :
3701 : : /* <addr> <"pbc" | "pin" | PIN> [label|display|keypad]
3702 : : * [persistent|persistent=<network id>]
3703 : : * [join] [auth] [go_intent=<0..15>] [freq=<in MHz>] [provdisc]
3704 : : * [ht40] [vht] */
3705 : :
3706 [ - + ]: 99 : if (hwaddr_aton(cmd, addr))
3707 : 0 : return -1;
3708 : :
3709 : 99 : pos = cmd + 17;
3710 [ - + ]: 99 : if (*pos != ' ')
3711 : 0 : return -1;
3712 : 99 : pos++;
3713 : :
3714 : 99 : persistent_group = os_strstr(pos, " persistent") != NULL;
3715 : 99 : pos2 = os_strstr(pos, " persistent=");
3716 [ - + ]: 99 : if (pos2) {
3717 : : struct wpa_ssid *ssid;
3718 : 0 : persistent_id = atoi(pos2 + 12);
3719 : 0 : ssid = wpa_config_get_network(wpa_s->conf, persistent_id);
3720 [ # # ][ # # ]: 0 : if (ssid == NULL || ssid->disabled != 2 ||
[ # # ]
3721 : 0 : ssid->mode != WPAS_MODE_P2P_GO) {
3722 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find "
3723 : : "SSID id=%d for persistent P2P group (GO)",
3724 : : persistent_id);
3725 : 0 : return -1;
3726 : : }
3727 : : }
3728 : 99 : join = os_strstr(pos, " join") != NULL;
3729 : 99 : auth = os_strstr(pos, " auth") != NULL;
3730 : 99 : automatic = os_strstr(pos, " auto") != NULL;
3731 : 99 : pd = os_strstr(pos, " provdisc") != NULL;
3732 [ + - ][ - + ]: 99 : vht = (os_strstr(cmd, " vht") != NULL) || wpa_s->conf->p2p_go_vht;
3733 [ + - ][ + - ]: 99 : ht40 = (os_strstr(cmd, " ht40") != NULL) || wpa_s->conf->p2p_go_ht40 ||
[ - + ]
3734 : : vht;
3735 : :
3736 : 99 : pos2 = os_strstr(pos, " go_intent=");
3737 [ + + ]: 99 : if (pos2) {
3738 : 37 : pos2 += 11;
3739 : 37 : go_intent = atoi(pos2);
3740 [ + - ][ - + ]: 37 : if (go_intent < 0 || go_intent > 15)
3741 : 0 : return -1;
3742 : : }
3743 : :
3744 : 99 : pos2 = os_strstr(pos, " freq=");
3745 [ + + ]: 99 : if (pos2) {
3746 : 14 : pos2 += 6;
3747 : 14 : freq = atoi(pos2);
3748 [ - + ]: 14 : if (freq <= 0)
3749 : 0 : return -1;
3750 : : }
3751 : :
3752 [ - + ]: 99 : if (os_strncmp(pos, "pin", 3) == 0) {
3753 : : /* Request random PIN (to be displayed) and enable the PIN */
3754 : 0 : wps_method = WPS_PIN_DISPLAY;
3755 [ + + ]: 99 : } else if (os_strncmp(pos, "pbc", 3) == 0) {
3756 : 6 : wps_method = WPS_PBC;
3757 : : } else {
3758 : 93 : pin = pos;
3759 : 93 : pos = os_strchr(pin, ' ');
3760 : 93 : wps_method = WPS_PIN_KEYPAD;
3761 [ + - ]: 93 : if (pos) {
3762 : 93 : *pos++ = '\0';
3763 [ + + ]: 93 : if (os_strncmp(pos, "display", 7) == 0)
3764 : 38 : wps_method = WPS_PIN_DISPLAY;
3765 : : }
3766 [ - + ]: 93 : if (!wps_pin_str_valid(pin)) {
3767 : 0 : os_memcpy(buf, "FAIL-INVALID-PIN\n", 17);
3768 : 0 : return 17;
3769 : : }
3770 : : }
3771 : :
3772 : 99 : new_pin = wpas_p2p_connect(wpa_s, addr, pin, wps_method,
3773 : : persistent_group, automatic, join,
3774 : : auth, go_intent, freq, persistent_id, pd,
3775 : : ht40, vht);
3776 [ - + ]: 99 : if (new_pin == -2) {
3777 : 0 : os_memcpy(buf, "FAIL-CHANNEL-UNAVAILABLE\n", 25);
3778 : 0 : return 25;
3779 : : }
3780 [ - + ]: 99 : if (new_pin == -3) {
3781 : 0 : os_memcpy(buf, "FAIL-CHANNEL-UNSUPPORTED\n", 25);
3782 : 0 : return 25;
3783 : : }
3784 [ - + ]: 99 : if (new_pin < 0)
3785 : 0 : return -1;
3786 [ + + ][ - + ]: 99 : if (wps_method == WPS_PIN_DISPLAY && pin == NULL) {
3787 : 0 : ret = os_snprintf(buf, buflen, "%08d", new_pin);
3788 [ # # ][ # # ]: 0 : if (ret < 0 || (size_t) ret >= buflen)
3789 : 0 : return -1;
3790 : 0 : return ret;
3791 : : }
3792 : :
3793 : 99 : os_memcpy(buf, "OK\n", 3);
3794 : 99 : return 3;
3795 : : }
3796 : :
3797 : :
3798 : 95 : static int p2p_ctrl_listen(struct wpa_supplicant *wpa_s, char *cmd)
3799 : : {
3800 : 95 : unsigned int timeout = atoi(cmd);
3801 : 95 : return wpas_p2p_listen(wpa_s, timeout);
3802 : : }
3803 : :
3804 : :
3805 : 3 : static int p2p_ctrl_prov_disc(struct wpa_supplicant *wpa_s, char *cmd)
3806 : : {
3807 : : u8 addr[ETH_ALEN];
3808 : : char *pos;
3809 : 3 : enum wpas_p2p_prov_disc_use use = WPAS_P2P_PD_FOR_GO_NEG;
3810 : :
3811 : : /* <addr> <config method> [join|auto] */
3812 : :
3813 [ - + ]: 3 : if (hwaddr_aton(cmd, addr))
3814 : 0 : return -1;
3815 : :
3816 : 3 : pos = cmd + 17;
3817 [ - + ]: 3 : if (*pos != ' ')
3818 : 0 : return -1;
3819 : 3 : pos++;
3820 : :
3821 [ - + ]: 3 : if (os_strstr(pos, " join") != NULL)
3822 : 0 : use = WPAS_P2P_PD_FOR_JOIN;
3823 [ - + ]: 3 : else if (os_strstr(pos, " auto") != NULL)
3824 : 0 : use = WPAS_P2P_PD_AUTO;
3825 : :
3826 : 3 : return wpas_p2p_prov_disc(wpa_s, addr, pos, use);
3827 : : }
3828 : :
3829 : :
3830 : 0 : static int p2p_get_passphrase(struct wpa_supplicant *wpa_s, char *buf,
3831 : : size_t buflen)
3832 : : {
3833 : 0 : struct wpa_ssid *ssid = wpa_s->current_ssid;
3834 : :
3835 [ # # ][ # # ]: 0 : if (ssid == NULL || ssid->mode != WPAS_MODE_P2P_GO ||
[ # # ]
3836 : 0 : ssid->passphrase == NULL)
3837 : 0 : return -1;
3838 : :
3839 : 0 : os_strlcpy(buf, ssid->passphrase, buflen);
3840 : 0 : return os_strlen(buf);
3841 : : }
3842 : :
3843 : :
3844 : 13 : static int p2p_ctrl_serv_disc_req(struct wpa_supplicant *wpa_s, char *cmd,
3845 : : char *buf, size_t buflen)
3846 : : {
3847 : : u64 ref;
3848 : : int res;
3849 : : u8 dst_buf[ETH_ALEN], *dst;
3850 : : struct wpabuf *tlvs;
3851 : : char *pos;
3852 : : size_t len;
3853 : :
3854 [ - + ]: 13 : if (hwaddr_aton(cmd, dst_buf))
3855 : 0 : return -1;
3856 : 13 : dst = dst_buf;
3857 [ + + ][ + - ]: 13 : if (dst[0] == 0 && dst[1] == 0 && dst[2] == 0 &&
[ + - ][ + - ]
3858 [ + - ][ + - ]: 7 : dst[3] == 0 && dst[4] == 0 && dst[5] == 0)
3859 : 7 : dst = NULL;
3860 : 13 : pos = cmd + 17;
3861 [ - + ]: 13 : if (*pos != ' ')
3862 : 0 : return -1;
3863 : 13 : pos++;
3864 : :
3865 [ + + ]: 13 : if (os_strncmp(pos, "upnp ", 5) == 0) {
3866 : : u8 version;
3867 : 1 : pos += 5;
3868 [ - + ]: 1 : if (hexstr2bin(pos, &version, 1) < 0)
3869 : 0 : return -1;
3870 : 1 : pos += 2;
3871 [ - + ]: 1 : if (*pos != ' ')
3872 : 0 : return -1;
3873 : 1 : pos++;
3874 : 1 : ref = wpas_p2p_sd_request_upnp(wpa_s, dst, version, pos);
3875 : : #ifdef CONFIG_WIFI_DISPLAY
3876 [ - + ]: 12 : } else if (os_strncmp(pos, "wifi-display ", 13) == 0) {
3877 : 0 : ref = wpas_p2p_sd_request_wifi_display(wpa_s, dst, pos + 13);
3878 : : #endif /* CONFIG_WIFI_DISPLAY */
3879 : : } else {
3880 : 12 : len = os_strlen(pos);
3881 [ - + ]: 12 : if (len & 1)
3882 : 0 : return -1;
3883 : 12 : len /= 2;
3884 : 12 : tlvs = wpabuf_alloc(len);
3885 [ - + ]: 12 : if (tlvs == NULL)
3886 : 0 : return -1;
3887 [ - + ]: 12 : if (hexstr2bin(pos, wpabuf_put(tlvs, len), len) < 0) {
3888 : 0 : wpabuf_free(tlvs);
3889 : 0 : return -1;
3890 : : }
3891 : :
3892 : 12 : ref = wpas_p2p_sd_request(wpa_s, dst, tlvs);
3893 : 12 : wpabuf_free(tlvs);
3894 : : }
3895 [ - + ]: 13 : if (ref == 0)
3896 : 0 : return -1;
3897 : 13 : res = os_snprintf(buf, buflen, "%llx", (long long unsigned) ref);
3898 [ + - ][ - + ]: 13 : if (res < 0 || (unsigned) res >= buflen)
3899 : 0 : return -1;
3900 : 13 : return res;
3901 : : }
3902 : :
3903 : :
3904 : 5 : static int p2p_ctrl_serv_disc_cancel_req(struct wpa_supplicant *wpa_s,
3905 : : char *cmd)
3906 : : {
3907 : : long long unsigned val;
3908 : : u64 req;
3909 [ - + ]: 5 : if (sscanf(cmd, "%llx", &val) != 1)
3910 : 0 : return -1;
3911 : 5 : req = val;
3912 : 5 : return wpas_p2p_sd_cancel_request(wpa_s, req);
3913 : : }
3914 : :
3915 : :
3916 : 0 : static int p2p_ctrl_serv_disc_resp(struct wpa_supplicant *wpa_s, char *cmd)
3917 : : {
3918 : : int freq;
3919 : : u8 dst[ETH_ALEN];
3920 : : u8 dialog_token;
3921 : : struct wpabuf *resp_tlvs;
3922 : : char *pos, *pos2;
3923 : : size_t len;
3924 : :
3925 : 0 : pos = os_strchr(cmd, ' ');
3926 [ # # ]: 0 : if (pos == NULL)
3927 : 0 : return -1;
3928 : 0 : *pos++ = '\0';
3929 : 0 : freq = atoi(cmd);
3930 [ # # ]: 0 : if (freq == 0)
3931 : 0 : return -1;
3932 : :
3933 [ # # ]: 0 : if (hwaddr_aton(pos, dst))
3934 : 0 : return -1;
3935 : 0 : pos += 17;
3936 [ # # ]: 0 : if (*pos != ' ')
3937 : 0 : return -1;
3938 : 0 : pos++;
3939 : :
3940 : 0 : pos2 = os_strchr(pos, ' ');
3941 [ # # ]: 0 : if (pos2 == NULL)
3942 : 0 : return -1;
3943 : 0 : *pos2++ = '\0';
3944 : 0 : dialog_token = atoi(pos);
3945 : :
3946 : 0 : len = os_strlen(pos2);
3947 [ # # ]: 0 : if (len & 1)
3948 : 0 : return -1;
3949 : 0 : len /= 2;
3950 : 0 : resp_tlvs = wpabuf_alloc(len);
3951 [ # # ]: 0 : if (resp_tlvs == NULL)
3952 : 0 : return -1;
3953 [ # # ]: 0 : if (hexstr2bin(pos2, wpabuf_put(resp_tlvs, len), len) < 0) {
3954 : 0 : wpabuf_free(resp_tlvs);
3955 : 0 : return -1;
3956 : : }
3957 : :
3958 : 0 : wpas_p2p_sd_response(wpa_s, freq, dst, dialog_token, resp_tlvs);
3959 : 0 : wpabuf_free(resp_tlvs);
3960 : 0 : return 0;
3961 : : }
3962 : :
3963 : :
3964 : 0 : static int p2p_ctrl_serv_disc_external(struct wpa_supplicant *wpa_s,
3965 : : char *cmd)
3966 : : {
3967 [ # # ][ # # ]: 0 : if (os_strcmp(cmd, "0") && os_strcmp(cmd, "1"))
3968 : 0 : return -1;
3969 : 0 : wpa_s->p2p_sd_over_ctrl_iface = atoi(cmd);
3970 : 0 : return 0;
3971 : : }
3972 : :
3973 : :
3974 : 36 : static int p2p_ctrl_service_add_bonjour(struct wpa_supplicant *wpa_s,
3975 : : char *cmd)
3976 : : {
3977 : : char *pos;
3978 : : size_t len;
3979 : : struct wpabuf *query, *resp;
3980 : :
3981 : 36 : pos = os_strchr(cmd, ' ');
3982 [ - + ]: 36 : if (pos == NULL)
3983 : 0 : return -1;
3984 : 36 : *pos++ = '\0';
3985 : :
3986 : 36 : len = os_strlen(cmd);
3987 [ - + ]: 36 : if (len & 1)
3988 : 0 : return -1;
3989 : 36 : len /= 2;
3990 : 36 : query = wpabuf_alloc(len);
3991 [ - + ]: 36 : if (query == NULL)
3992 : 0 : return -1;
3993 [ - + ]: 36 : if (hexstr2bin(cmd, wpabuf_put(query, len), len) < 0) {
3994 : 0 : wpabuf_free(query);
3995 : 0 : return -1;
3996 : : }
3997 : :
3998 : 36 : len = os_strlen(pos);
3999 [ - + ]: 36 : if (len & 1) {
4000 : 0 : wpabuf_free(query);
4001 : 0 : return -1;
4002 : : }
4003 : 36 : len /= 2;
4004 : 36 : resp = wpabuf_alloc(len);
4005 [ - + ]: 36 : if (resp == NULL) {
4006 : 0 : wpabuf_free(query);
4007 : 0 : return -1;
4008 : : }
4009 [ - + ]: 36 : if (hexstr2bin(pos, wpabuf_put(resp, len), len) < 0) {
4010 : 0 : wpabuf_free(query);
4011 : 0 : wpabuf_free(resp);
4012 : 0 : return -1;
4013 : : }
4014 : :
4015 [ - + ]: 36 : if (wpas_p2p_service_add_bonjour(wpa_s, query, resp) < 0) {
4016 : 0 : wpabuf_free(query);
4017 : 0 : wpabuf_free(resp);
4018 : 0 : return -1;
4019 : : }
4020 : 36 : return 0;
4021 : : }
4022 : :
4023 : :
4024 : 245 : static int p2p_ctrl_service_add_upnp(struct wpa_supplicant *wpa_s, char *cmd)
4025 : : {
4026 : : char *pos;
4027 : : u8 version;
4028 : :
4029 : 245 : pos = os_strchr(cmd, ' ');
4030 [ - + ]: 245 : if (pos == NULL)
4031 : 0 : return -1;
4032 : 245 : *pos++ = '\0';
4033 : :
4034 [ - + ]: 245 : if (hexstr2bin(cmd, &version, 1) < 0)
4035 : 0 : return -1;
4036 : :
4037 : 245 : return wpas_p2p_service_add_upnp(wpa_s, version, pos);
4038 : : }
4039 : :
4040 : :
4041 : 281 : static int p2p_ctrl_service_add(struct wpa_supplicant *wpa_s, char *cmd)
4042 : : {
4043 : : char *pos;
4044 : :
4045 : 281 : pos = os_strchr(cmd, ' ');
4046 [ - + ]: 281 : if (pos == NULL)
4047 : 0 : return -1;
4048 : 281 : *pos++ = '\0';
4049 : :
4050 [ + + ]: 281 : if (os_strcmp(cmd, "bonjour") == 0)
4051 : 36 : return p2p_ctrl_service_add_bonjour(wpa_s, pos);
4052 [ + - ]: 245 : if (os_strcmp(cmd, "upnp") == 0)
4053 : 245 : return p2p_ctrl_service_add_upnp(wpa_s, pos);
4054 : 0 : wpa_printf(MSG_DEBUG, "Unknown service '%s'", cmd);
4055 : 281 : return -1;
4056 : : }
4057 : :
4058 : :
4059 : 0 : static int p2p_ctrl_service_del_bonjour(struct wpa_supplicant *wpa_s,
4060 : : char *cmd)
4061 : : {
4062 : : size_t len;
4063 : : struct wpabuf *query;
4064 : : int ret;
4065 : :
4066 : 0 : len = os_strlen(cmd);
4067 [ # # ]: 0 : if (len & 1)
4068 : 0 : return -1;
4069 : 0 : len /= 2;
4070 : 0 : query = wpabuf_alloc(len);
4071 [ # # ]: 0 : if (query == NULL)
4072 : 0 : return -1;
4073 [ # # ]: 0 : if (hexstr2bin(cmd, wpabuf_put(query, len), len) < 0) {
4074 : 0 : wpabuf_free(query);
4075 : 0 : return -1;
4076 : : }
4077 : :
4078 : 0 : ret = wpas_p2p_service_del_bonjour(wpa_s, query);
4079 : 0 : wpabuf_free(query);
4080 : 0 : return ret;
4081 : : }
4082 : :
4083 : :
4084 : 0 : static int p2p_ctrl_service_del_upnp(struct wpa_supplicant *wpa_s, char *cmd)
4085 : : {
4086 : : char *pos;
4087 : : u8 version;
4088 : :
4089 : 0 : pos = os_strchr(cmd, ' ');
4090 [ # # ]: 0 : if (pos == NULL)
4091 : 0 : return -1;
4092 : 0 : *pos++ = '\0';
4093 : :
4094 [ # # ]: 0 : if (hexstr2bin(cmd, &version, 1) < 0)
4095 : 0 : return -1;
4096 : :
4097 : 0 : return wpas_p2p_service_del_upnp(wpa_s, version, pos);
4098 : : }
4099 : :
4100 : :
4101 : 0 : static int p2p_ctrl_service_del(struct wpa_supplicant *wpa_s, char *cmd)
4102 : : {
4103 : : char *pos;
4104 : :
4105 : 0 : pos = os_strchr(cmd, ' ');
4106 [ # # ]: 0 : if (pos == NULL)
4107 : 0 : return -1;
4108 : 0 : *pos++ = '\0';
4109 : :
4110 [ # # ]: 0 : if (os_strcmp(cmd, "bonjour") == 0)
4111 : 0 : return p2p_ctrl_service_del_bonjour(wpa_s, pos);
4112 [ # # ]: 0 : if (os_strcmp(cmd, "upnp") == 0)
4113 : 0 : return p2p_ctrl_service_del_upnp(wpa_s, pos);
4114 : 0 : wpa_printf(MSG_DEBUG, "Unknown service '%s'", cmd);
4115 : 0 : return -1;
4116 : : }
4117 : :
4118 : :
4119 : 0 : static int p2p_ctrl_reject(struct wpa_supplicant *wpa_s, char *cmd)
4120 : : {
4121 : : u8 addr[ETH_ALEN];
4122 : :
4123 : : /* <addr> */
4124 : :
4125 [ # # ]: 0 : if (hwaddr_aton(cmd, addr))
4126 : 0 : return -1;
4127 : :
4128 : 0 : return wpas_p2p_reject(wpa_s, addr);
4129 : : }
4130 : :
4131 : :
4132 : 7 : static int p2p_ctrl_invite_persistent(struct wpa_supplicant *wpa_s, char *cmd)
4133 : : {
4134 : : char *pos;
4135 : : int id;
4136 : : struct wpa_ssid *ssid;
4137 : 7 : u8 *_peer = NULL, peer[ETH_ALEN];
4138 : 7 : int freq = 0, pref_freq = 0;
4139 : : int ht40, vht;
4140 : :
4141 : 7 : id = atoi(cmd);
4142 : 7 : pos = os_strstr(cmd, " peer=");
4143 [ + - ]: 7 : if (pos) {
4144 : 7 : pos += 6;
4145 [ - + ]: 7 : if (hwaddr_aton(pos, peer))
4146 : 0 : return -1;
4147 : 7 : _peer = peer;
4148 : : }
4149 : 7 : ssid = wpa_config_get_network(wpa_s->conf, id);
4150 [ + - ][ - + ]: 7 : if (ssid == NULL || ssid->disabled != 2) {
4151 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find SSID id=%d "
4152 : : "for persistent P2P group",
4153 : : id);
4154 : 0 : return -1;
4155 : : }
4156 : :
4157 : 7 : pos = os_strstr(cmd, " freq=");
4158 [ + + ]: 7 : if (pos) {
4159 : 2 : pos += 6;
4160 : 2 : freq = atoi(pos);
4161 [ - + ]: 2 : if (freq <= 0)
4162 : 0 : return -1;
4163 : : }
4164 : :
4165 : 7 : pos = os_strstr(cmd, " pref=");
4166 [ + + ]: 7 : if (pos) {
4167 : 1 : pos += 6;
4168 : 1 : pref_freq = atoi(pos);
4169 [ - + ]: 1 : if (pref_freq <= 0)
4170 : 0 : return -1;
4171 : : }
4172 : :
4173 [ + - ][ - + ]: 7 : vht = (os_strstr(cmd, " vht") != NULL) || wpa_s->conf->p2p_go_vht;
4174 [ + - ][ + - ]: 7 : ht40 = (os_strstr(cmd, " ht40") != NULL) || wpa_s->conf->p2p_go_ht40 ||
[ - + ]
4175 : : vht;
4176 : :
4177 : 7 : return wpas_p2p_invite(wpa_s, _peer, ssid, NULL, freq, ht40, vht,
4178 : : pref_freq);
4179 : : }
4180 : :
4181 : :
4182 : 4 : static int p2p_ctrl_invite_group(struct wpa_supplicant *wpa_s, char *cmd)
4183 : : {
4184 : : char *pos;
4185 : 4 : u8 peer[ETH_ALEN], go_dev_addr[ETH_ALEN], *go_dev = NULL;
4186 : :
4187 : 4 : pos = os_strstr(cmd, " peer=");
4188 [ - + ]: 4 : if (!pos)
4189 : 0 : return -1;
4190 : :
4191 : 4 : *pos = '\0';
4192 : 4 : pos += 6;
4193 [ - + ]: 4 : if (hwaddr_aton(pos, peer)) {
4194 : 0 : wpa_printf(MSG_DEBUG, "P2P: Invalid MAC address '%s'", pos);
4195 : 0 : return -1;
4196 : : }
4197 : :
4198 : 4 : pos = os_strstr(pos, " go_dev_addr=");
4199 [ - + ]: 4 : if (pos) {
4200 : 0 : pos += 13;
4201 [ # # ]: 0 : if (hwaddr_aton(pos, go_dev_addr)) {
4202 : 0 : wpa_printf(MSG_DEBUG, "P2P: Invalid MAC address '%s'",
4203 : : pos);
4204 : 0 : return -1;
4205 : : }
4206 : 0 : go_dev = go_dev_addr;
4207 : : }
4208 : :
4209 : 4 : return wpas_p2p_invite_group(wpa_s, cmd, peer, go_dev);
4210 : : }
4211 : :
4212 : :
4213 : 11 : static int p2p_ctrl_invite(struct wpa_supplicant *wpa_s, char *cmd)
4214 : : {
4215 [ + + ]: 11 : if (os_strncmp(cmd, "persistent=", 11) == 0)
4216 : 7 : return p2p_ctrl_invite_persistent(wpa_s, cmd + 11);
4217 [ + - ]: 4 : if (os_strncmp(cmd, "group=", 6) == 0)
4218 : 4 : return p2p_ctrl_invite_group(wpa_s, cmd + 6);
4219 : :
4220 : 11 : return -1;
4221 : : }
4222 : :
4223 : :
4224 : 4 : static int p2p_ctrl_group_add_persistent(struct wpa_supplicant *wpa_s,
4225 : : char *cmd, int freq, int ht40,
4226 : : int vht)
4227 : : {
4228 : : int id;
4229 : : struct wpa_ssid *ssid;
4230 : :
4231 : 4 : id = atoi(cmd);
4232 : 4 : ssid = wpa_config_get_network(wpa_s->conf, id);
4233 [ + - ][ - + ]: 4 : if (ssid == NULL || ssid->disabled != 2) {
4234 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find SSID id=%d "
4235 : : "for persistent P2P group",
4236 : : id);
4237 : 0 : return -1;
4238 : : }
4239 : :
4240 : 4 : return wpas_p2p_group_add_persistent(wpa_s, ssid, 0, freq, ht40, vht,
4241 : : NULL, 0);
4242 : : }
4243 : :
4244 : :
4245 : 11 : static int p2p_ctrl_group_add(struct wpa_supplicant *wpa_s, char *cmd)
4246 : : {
4247 : 11 : int freq = 0, ht40, vht;
4248 : : char *pos;
4249 : :
4250 : 11 : pos = os_strstr(cmd, "freq=");
4251 [ + + ]: 11 : if (pos)
4252 : 7 : freq = atoi(pos + 5);
4253 : :
4254 [ + - ][ - + ]: 11 : vht = (os_strstr(cmd, "vht") != NULL) || wpa_s->conf->p2p_go_vht;
4255 [ + - ][ + - ]: 11 : ht40 = (os_strstr(cmd, "ht40") != NULL) || wpa_s->conf->p2p_go_ht40 ||
[ - + ]
4256 : : vht;
4257 : :
4258 [ + + ]: 11 : if (os_strncmp(cmd, "persistent=", 11) == 0)
4259 : 4 : return p2p_ctrl_group_add_persistent(wpa_s, cmd + 11, freq,
4260 : : ht40, vht);
4261 [ + - ][ - + ]: 7 : if (os_strcmp(cmd, "persistent") == 0 ||
4262 : 7 : os_strncmp(cmd, "persistent ", 11) == 0)
4263 : 0 : return wpas_p2p_group_add(wpa_s, 1, freq, ht40, vht);
4264 [ + - ]: 7 : if (os_strncmp(cmd, "freq=", 5) == 0)
4265 : 7 : return wpas_p2p_group_add(wpa_s, 0, freq, ht40, vht);
4266 [ # # ]: 0 : if (ht40)
4267 : 0 : return wpas_p2p_group_add(wpa_s, 0, freq, ht40, vht);
4268 : :
4269 : 0 : wpa_printf(MSG_DEBUG, "CTRL: Invalid P2P_GROUP_ADD parameters '%s'",
4270 : : cmd);
4271 : 11 : return -1;
4272 : : }
4273 : :
4274 : :
4275 : 267 : static int p2p_ctrl_peer(struct wpa_supplicant *wpa_s, char *cmd,
4276 : : char *buf, size_t buflen)
4277 : : {
4278 : : u8 addr[ETH_ALEN], *addr_ptr;
4279 : : int next, res;
4280 : : const struct p2p_peer_info *info;
4281 : : char *pos, *end;
4282 : : char devtype[WPS_DEV_TYPE_BUFSIZE];
4283 : : struct wpa_ssid *ssid;
4284 : : size_t i;
4285 : :
4286 [ - + ]: 267 : if (!wpa_s->global->p2p)
4287 : 0 : return -1;
4288 : :
4289 [ - + ]: 267 : if (os_strcmp(cmd, "FIRST") == 0) {
4290 : 0 : addr_ptr = NULL;
4291 : 0 : next = 0;
4292 [ - + ]: 267 : } else if (os_strncmp(cmd, "NEXT-", 5) == 0) {
4293 [ # # ]: 0 : if (hwaddr_aton(cmd + 5, addr) < 0)
4294 : 0 : return -1;
4295 : 0 : addr_ptr = addr;
4296 : 0 : next = 1;
4297 : : } else {
4298 [ - + ]: 267 : if (hwaddr_aton(cmd, addr) < 0)
4299 : 0 : return -1;
4300 : 267 : addr_ptr = addr;
4301 : 267 : next = 0;
4302 : : }
4303 : :
4304 : 267 : info = p2p_get_peer_info(wpa_s->global->p2p, addr_ptr, next);
4305 [ + + ]: 267 : if (info == NULL)
4306 : 85 : return -1;
4307 : :
4308 : 182 : pos = buf;
4309 : 182 : end = buf + buflen;
4310 : :
4311 : 182 : res = os_snprintf(pos, end - pos, MACSTR "\n"
4312 : : "pri_dev_type=%s\n"
4313 : : "device_name=%s\n"
4314 : : "manufacturer=%s\n"
4315 : : "model_name=%s\n"
4316 : : "model_number=%s\n"
4317 : : "serial_number=%s\n"
4318 : : "config_methods=0x%x\n"
4319 : : "dev_capab=0x%x\n"
4320 : : "group_capab=0x%x\n"
4321 : : "level=%d\n",
4322 : 1092 : MAC2STR(info->p2p_device_addr),
4323 : 182 : wps_dev_type_bin2str(info->pri_dev_type,
4324 : : devtype, sizeof(devtype)),
4325 : 182 : info->device_name,
4326 : 182 : info->manufacturer,
4327 : 182 : info->model_name,
4328 : 182 : info->model_number,
4329 : 182 : info->serial_number,
4330 : 182 : info->config_methods,
4331 : 182 : info->dev_capab,
4332 : 182 : info->group_capab,
4333 : : info->level);
4334 [ + - ][ - + ]: 182 : if (res < 0 || res >= end - pos)
4335 : 0 : return pos - buf;
4336 : 182 : pos += res;
4337 : :
4338 [ - + ]: 182 : for (i = 0; i < info->wps_sec_dev_type_list_len / WPS_DEV_TYPE_LEN; i++)
4339 : : {
4340 : : const u8 *t;
4341 : 0 : t = &info->wps_sec_dev_type_list[i * WPS_DEV_TYPE_LEN];
4342 : 0 : res = os_snprintf(pos, end - pos, "sec_dev_type=%s\n",
4343 : : wps_dev_type_bin2str(t, devtype,
4344 : : sizeof(devtype)));
4345 [ # # ][ # # ]: 0 : if (res < 0 || res >= end - pos)
4346 : 0 : return pos - buf;
4347 : 0 : pos += res;
4348 : : }
4349 : :
4350 : 182 : ssid = wpas_p2p_get_persistent(wpa_s, info->p2p_device_addr, NULL, 0);
4351 [ + + ]: 182 : if (ssid) {
4352 : 18 : res = os_snprintf(pos, end - pos, "persistent=%d\n", ssid->id);
4353 [ + - ][ - + ]: 18 : if (res < 0 || res >= end - pos)
4354 : 0 : return pos - buf;
4355 : 18 : pos += res;
4356 : : }
4357 : :
4358 : 182 : res = p2p_get_peer_info_txt(info, pos, end - pos);
4359 [ - + ]: 182 : if (res < 0)
4360 : 0 : return pos - buf;
4361 : 182 : pos += res;
4362 : :
4363 : 267 : return pos - buf;
4364 : : }
4365 : :
4366 : :
4367 : 0 : static int p2p_ctrl_disallow_freq(struct wpa_supplicant *wpa_s,
4368 : : const char *param)
4369 : : {
4370 : : unsigned int i;
4371 : :
4372 [ # # ]: 0 : if (wpa_s->global->p2p == NULL)
4373 : 0 : return -1;
4374 : :
4375 [ # # ]: 0 : if (freq_range_list_parse(&wpa_s->global->p2p_disallow_freq, param) < 0)
4376 : 0 : return -1;
4377 : :
4378 [ # # ]: 0 : for (i = 0; i < wpa_s->global->p2p_disallow_freq.num; i++) {
4379 : : struct wpa_freq_range *freq;
4380 : 0 : freq = &wpa_s->global->p2p_disallow_freq.range[i];
4381 : 0 : wpa_printf(MSG_DEBUG, "P2P: Disallowed frequency range %u-%u",
4382 : : freq->min, freq->max);
4383 : : }
4384 : :
4385 : 0 : wpas_p2p_update_channel_list(wpa_s);
4386 : 0 : return 0;
4387 : : }
4388 : :
4389 : :
4390 : 6 : static int p2p_ctrl_set(struct wpa_supplicant *wpa_s, char *cmd)
4391 : : {
4392 : : char *param;
4393 : :
4394 [ - + ]: 6 : if (wpa_s->global->p2p == NULL)
4395 : 0 : return -1;
4396 : :
4397 : 6 : param = os_strchr(cmd, ' ');
4398 [ - + ]: 6 : if (param == NULL)
4399 : 0 : return -1;
4400 : 6 : *param++ = '\0';
4401 : :
4402 [ - + ]: 6 : if (os_strcmp(cmd, "discoverability") == 0) {
4403 : 0 : p2p_set_client_discoverability(wpa_s->global->p2p,
4404 : : atoi(param));
4405 : 0 : return 0;
4406 : : }
4407 : :
4408 [ - + ]: 6 : if (os_strcmp(cmd, "managed") == 0) {
4409 : 0 : p2p_set_managed_oper(wpa_s->global->p2p, atoi(param));
4410 : 0 : return 0;
4411 : : }
4412 : :
4413 [ - + ]: 6 : if (os_strcmp(cmd, "listen_channel") == 0) {
4414 : 0 : return p2p_set_listen_channel(wpa_s->global->p2p, 81,
4415 : 0 : atoi(param));
4416 : : }
4417 : :
4418 [ - + ]: 6 : if (os_strcmp(cmd, "ssid_postfix") == 0) {
4419 : 0 : return p2p_set_ssid_postfix(wpa_s->global->p2p, (u8 *) param,
4420 : : os_strlen(param));
4421 : : }
4422 : :
4423 [ - + ]: 6 : if (os_strcmp(cmd, "noa") == 0) {
4424 : : char *pos;
4425 : : int count, start, duration;
4426 : : /* GO NoA parameters: count,start_offset(ms),duration(ms) */
4427 : 0 : count = atoi(param);
4428 : 0 : pos = os_strchr(param, ',');
4429 [ # # ]: 0 : if (pos == NULL)
4430 : 0 : return -1;
4431 : 0 : pos++;
4432 : 0 : start = atoi(pos);
4433 : 0 : pos = os_strchr(pos, ',');
4434 [ # # ]: 0 : if (pos == NULL)
4435 : 0 : return -1;
4436 : 0 : pos++;
4437 : 0 : duration = atoi(pos);
4438 [ # # ][ # # ]: 0 : if (count < 0 || count > 255 || start < 0 || duration < 0)
[ # # ][ # # ]
4439 : 0 : return -1;
4440 [ # # ][ # # ]: 0 : if (count == 0 && duration > 0)
4441 : 0 : return -1;
4442 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: P2P_SET GO NoA: count=%d "
4443 : : "start=%d duration=%d", count, start, duration);
4444 : 0 : return wpas_p2p_set_noa(wpa_s, count, start, duration);
4445 : : }
4446 : :
4447 [ - + ]: 6 : if (os_strcmp(cmd, "ps") == 0)
4448 : 0 : return wpa_drv_set_p2p_powersave(wpa_s, atoi(param), -1, -1);
4449 : :
4450 [ - + ]: 6 : if (os_strcmp(cmd, "oppps") == 0)
4451 : 0 : return wpa_drv_set_p2p_powersave(wpa_s, -1, atoi(param), -1);
4452 : :
4453 [ - + ]: 6 : if (os_strcmp(cmd, "ctwindow") == 0)
4454 : 0 : return wpa_drv_set_p2p_powersave(wpa_s, -1, -1, atoi(param));
4455 : :
4456 [ + + ]: 6 : if (os_strcmp(cmd, "disabled") == 0) {
4457 : 2 : wpa_s->global->p2p_disabled = atoi(param);
4458 [ + - ]: 2 : wpa_printf(MSG_DEBUG, "P2P functionality %s",
4459 : 2 : wpa_s->global->p2p_disabled ?
4460 : : "disabled" : "enabled");
4461 [ + - ]: 2 : if (wpa_s->global->p2p_disabled) {
4462 : 2 : wpas_p2p_stop_find(wpa_s);
4463 : 2 : os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
4464 : 2 : p2p_flush(wpa_s->global->p2p);
4465 : : }
4466 : 2 : return 0;
4467 : : }
4468 : :
4469 [ - + ]: 4 : if (os_strcmp(cmd, "conc_pref") == 0) {
4470 [ # # ]: 0 : if (os_strcmp(param, "sta") == 0)
4471 : 0 : wpa_s->global->conc_pref = WPA_CONC_PREF_STA;
4472 [ # # ]: 0 : else if (os_strcmp(param, "p2p") == 0)
4473 : 0 : wpa_s->global->conc_pref = WPA_CONC_PREF_P2P;
4474 : : else {
4475 : 0 : wpa_printf(MSG_INFO, "Invalid conc_pref value");
4476 : 0 : return -1;
4477 : : }
4478 : 0 : wpa_printf(MSG_DEBUG, "Single channel concurrency preference: "
4479 : : "%s", param);
4480 : 0 : return 0;
4481 : : }
4482 : :
4483 [ - + ]: 4 : if (os_strcmp(cmd, "force_long_sd") == 0) {
4484 : 0 : wpa_s->force_long_sd = atoi(param);
4485 : 0 : return 0;
4486 : : }
4487 : :
4488 [ - + ]: 4 : if (os_strcmp(cmd, "peer_filter") == 0) {
4489 : : u8 addr[ETH_ALEN];
4490 [ # # ]: 0 : if (hwaddr_aton(param, addr))
4491 : 0 : return -1;
4492 : 0 : p2p_set_peer_filter(wpa_s->global->p2p, addr);
4493 : 0 : return 0;
4494 : : }
4495 : :
4496 [ - + ]: 4 : if (os_strcmp(cmd, "cross_connect") == 0)
4497 : 0 : return wpas_p2p_set_cross_connect(wpa_s, atoi(param));
4498 : :
4499 [ - + ]: 4 : if (os_strcmp(cmd, "go_apsd") == 0) {
4500 [ # # ]: 0 : if (os_strcmp(param, "disable") == 0)
4501 : 0 : wpa_s->set_ap_uapsd = 0;
4502 : : else {
4503 : 0 : wpa_s->set_ap_uapsd = 1;
4504 : 0 : wpa_s->ap_uapsd = atoi(param);
4505 : : }
4506 : 0 : return 0;
4507 : : }
4508 : :
4509 [ - + ]: 4 : if (os_strcmp(cmd, "client_apsd") == 0) {
4510 [ # # ]: 0 : if (os_strcmp(param, "disable") == 0)
4511 : 0 : wpa_s->set_sta_uapsd = 0;
4512 : : else {
4513 : : int be, bk, vi, vo;
4514 : : char *pos;
4515 : : /* format: BE,BK,VI,VO;max SP Length */
4516 : 0 : be = atoi(param);
4517 : 0 : pos = os_strchr(param, ',');
4518 [ # # ]: 0 : if (pos == NULL)
4519 : 0 : return -1;
4520 : 0 : pos++;
4521 : 0 : bk = atoi(pos);
4522 : 0 : pos = os_strchr(pos, ',');
4523 [ # # ]: 0 : if (pos == NULL)
4524 : 0 : return -1;
4525 : 0 : pos++;
4526 : 0 : vi = atoi(pos);
4527 : 0 : pos = os_strchr(pos, ',');
4528 [ # # ]: 0 : if (pos == NULL)
4529 : 0 : return -1;
4530 : 0 : pos++;
4531 : 0 : vo = atoi(pos);
4532 : : /* ignore max SP Length for now */
4533 : :
4534 : 0 : wpa_s->set_sta_uapsd = 1;
4535 : 0 : wpa_s->sta_uapsd = 0;
4536 [ # # ]: 0 : if (be)
4537 : 0 : wpa_s->sta_uapsd |= BIT(0);
4538 [ # # ]: 0 : if (bk)
4539 : 0 : wpa_s->sta_uapsd |= BIT(1);
4540 [ # # ]: 0 : if (vi)
4541 : 0 : wpa_s->sta_uapsd |= BIT(2);
4542 [ # # ]: 0 : if (vo)
4543 : 0 : wpa_s->sta_uapsd |= BIT(3);
4544 : : }
4545 : 0 : return 0;
4546 : : }
4547 : :
4548 [ - + ]: 4 : if (os_strcmp(cmd, "disallow_freq") == 0)
4549 : 0 : return p2p_ctrl_disallow_freq(wpa_s, param);
4550 : :
4551 [ - + ]: 4 : if (os_strcmp(cmd, "disc_int") == 0) {
4552 : : int min_disc_int, max_disc_int, max_disc_tu;
4553 : : char *pos;
4554 : :
4555 : 0 : pos = param;
4556 : :
4557 : 0 : min_disc_int = atoi(pos);
4558 : 0 : pos = os_strchr(pos, ' ');
4559 [ # # ]: 0 : if (pos == NULL)
4560 : 0 : return -1;
4561 : 0 : *pos++ = '\0';
4562 : :
4563 : 0 : max_disc_int = atoi(pos);
4564 : 0 : pos = os_strchr(pos, ' ');
4565 [ # # ]: 0 : if (pos == NULL)
4566 : 0 : return -1;
4567 : 0 : *pos++ = '\0';
4568 : :
4569 : 0 : max_disc_tu = atoi(pos);
4570 : :
4571 : 0 : return p2p_set_disc_int(wpa_s->global->p2p, min_disc_int,
4572 : : max_disc_int, max_disc_tu);
4573 : : }
4574 : :
4575 [ + - ]: 4 : if (os_strcmp(cmd, "per_sta_psk") == 0) {
4576 : 4 : wpa_s->global->p2p_per_sta_psk = !!atoi(param);
4577 : 4 : return 0;
4578 : : }
4579 : :
4580 : 0 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: Unknown P2P_SET field value '%s'",
4581 : : cmd);
4582 : :
4583 : 6 : return -1;
4584 : : }
4585 : :
4586 : :
4587 : 736 : static void p2p_ctrl_flush(struct wpa_supplicant *wpa_s)
4588 : : {
4589 : 736 : os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
4590 : 736 : wpa_s->force_long_sd = 0;
4591 [ + - ]: 736 : if (wpa_s->global->p2p)
4592 : 736 : p2p_flush(wpa_s->global->p2p);
4593 : 736 : }
4594 : :
4595 : :
4596 : 1 : static int p2p_ctrl_presence_req(struct wpa_supplicant *wpa_s, char *cmd)
4597 : : {
4598 : : char *pos, *pos2;
4599 : 1 : unsigned int dur1 = 0, int1 = 0, dur2 = 0, int2 = 0;
4600 : :
4601 [ + - ]: 1 : if (cmd[0]) {
4602 : 1 : pos = os_strchr(cmd, ' ');
4603 [ - + ]: 1 : if (pos == NULL)
4604 : 0 : return -1;
4605 : 1 : *pos++ = '\0';
4606 : 1 : dur1 = atoi(cmd);
4607 : :
4608 : 1 : pos2 = os_strchr(pos, ' ');
4609 [ - + ]: 1 : if (pos2)
4610 : 0 : *pos2++ = '\0';
4611 : 1 : int1 = atoi(pos);
4612 : : } else
4613 : 0 : pos2 = NULL;
4614 : :
4615 [ - + ]: 1 : if (pos2) {
4616 : 0 : pos = os_strchr(pos2, ' ');
4617 [ # # ]: 0 : if (pos == NULL)
4618 : 0 : return -1;
4619 : 0 : *pos++ = '\0';
4620 : 0 : dur2 = atoi(pos2);
4621 : 0 : int2 = atoi(pos);
4622 : : }
4623 : :
4624 : 1 : return wpas_p2p_presence_req(wpa_s, dur1, int1, dur2, int2);
4625 : : }
4626 : :
4627 : :
4628 : 0 : static int p2p_ctrl_ext_listen(struct wpa_supplicant *wpa_s, char *cmd)
4629 : : {
4630 : : char *pos;
4631 : 0 : unsigned int period = 0, interval = 0;
4632 : :
4633 [ # # ]: 0 : if (cmd[0]) {
4634 : 0 : pos = os_strchr(cmd, ' ');
4635 [ # # ]: 0 : if (pos == NULL)
4636 : 0 : return -1;
4637 : 0 : *pos++ = '\0';
4638 : 0 : period = atoi(cmd);
4639 : 0 : interval = atoi(pos);
4640 : : }
4641 : :
4642 : 0 : return wpas_p2p_ext_listen(wpa_s, period, interval);
4643 : : }
4644 : :
4645 : :
4646 : 4 : static int p2p_ctrl_remove_client(struct wpa_supplicant *wpa_s, const char *cmd)
4647 : : {
4648 : : const char *pos;
4649 : : u8 peer[ETH_ALEN];
4650 : 4 : int iface_addr = 0;
4651 : :
4652 : 4 : pos = cmd;
4653 [ - + ]: 4 : if (os_strncmp(pos, "iface=", 6) == 0) {
4654 : 0 : iface_addr = 1;
4655 : 0 : pos += 6;
4656 : : }
4657 [ - + ]: 4 : if (hwaddr_aton(pos, peer))
4658 : 0 : return -1;
4659 : :
4660 : 4 : wpas_p2p_remove_client(wpa_s, peer, iface_addr);
4661 : 4 : return 0;
4662 : : }
4663 : :
4664 : : #endif /* CONFIG_P2P */
4665 : :
4666 : :
4667 : 75 : static int * freq_range_to_channel_list(struct wpa_supplicant *wpa_s, char *val)
4668 : : {
4669 : : struct wpa_freq_range_list ranges;
4670 : 75 : int *freqs = NULL;
4671 : : struct hostapd_hw_modes *mode;
4672 : : u16 i;
4673 : :
4674 [ - + ]: 75 : if (wpa_s->hw.modes == NULL)
4675 : 0 : return NULL;
4676 : :
4677 : 75 : os_memset(&ranges, 0, sizeof(ranges));
4678 [ - + ]: 75 : if (freq_range_list_parse(&ranges, val) < 0)
4679 : 0 : return NULL;
4680 : :
4681 [ + + ]: 300 : for (i = 0; i < wpa_s->hw.num_modes; i++) {
4682 : : int j;
4683 : :
4684 : 225 : mode = &wpa_s->hw.modes[i];
4685 [ + + ]: 4125 : for (j = 0; j < mode->num_channels; j++) {
4686 : : unsigned int freq;
4687 : :
4688 [ + + ]: 3900 : if (mode->channels[j].flag & HOSTAPD_CHAN_DISABLED)
4689 : 1125 : continue;
4690 : :
4691 : 2775 : freq = mode->channels[j].freq;
4692 [ + + ]: 2775 : if (!freq_range_list_includes(&ranges, freq))
4693 : 2583 : continue;
4694 : :
4695 : 192 : int_array_add_unique(&freqs, freq);
4696 : : }
4697 : : }
4698 : :
4699 : 75 : os_free(ranges.range);
4700 : 75 : return freqs;
4701 : : }
4702 : :
4703 : :
4704 : : #ifdef CONFIG_INTERWORKING
4705 : :
4706 : 35 : static int ctrl_interworking_select(struct wpa_supplicant *wpa_s, char *param)
4707 : : {
4708 : 35 : int auto_sel = 0;
4709 : 35 : int *freqs = NULL;
4710 : :
4711 [ + + ]: 35 : if (param) {
4712 : : char *pos;
4713 : :
4714 : 34 : auto_sel = os_strstr(param, "auto") != NULL;
4715 : :
4716 : 34 : pos = os_strstr(param, "freq=");
4717 [ + + ]: 34 : if (pos) {
4718 : 33 : freqs = freq_range_to_channel_list(wpa_s, pos + 5);
4719 [ - + ]: 33 : if (freqs == NULL)
4720 : 0 : return -1;
4721 : : }
4722 : :
4723 : : }
4724 : :
4725 : 35 : return interworking_select(wpa_s, auto_sel, freqs);
4726 : : }
4727 : :
4728 : :
4729 : 22 : static int ctrl_interworking_connect(struct wpa_supplicant *wpa_s, char *dst)
4730 : : {
4731 : : u8 bssid[ETH_ALEN];
4732 : : struct wpa_bss *bss;
4733 : :
4734 [ - + ]: 22 : if (hwaddr_aton(dst, bssid)) {
4735 : 0 : wpa_printf(MSG_DEBUG, "Invalid BSSID '%s'", dst);
4736 : 0 : return -1;
4737 : : }
4738 : :
4739 : 22 : bss = wpa_bss_get_bssid(wpa_s, bssid);
4740 [ - + ]: 22 : if (bss == NULL) {
4741 : 0 : wpa_printf(MSG_DEBUG, "Could not find BSS " MACSTR,
4742 : 0 : MAC2STR(bssid));
4743 : 0 : return -1;
4744 : : }
4745 : :
4746 : 22 : return interworking_connect(wpa_s, bss);
4747 : : }
4748 : :
4749 : :
4750 : 6 : static int get_anqp(struct wpa_supplicant *wpa_s, char *dst)
4751 : : {
4752 : : u8 dst_addr[ETH_ALEN];
4753 : : int used;
4754 : : char *pos;
4755 : : #define MAX_ANQP_INFO_ID 100
4756 : : u16 id[MAX_ANQP_INFO_ID];
4757 : 6 : size_t num_id = 0;
4758 : :
4759 : 6 : used = hwaddr_aton2(dst, dst_addr);
4760 [ - + ]: 6 : if (used < 0)
4761 : 0 : return -1;
4762 : 6 : pos = dst + used;
4763 [ + - ]: 6 : while (num_id < MAX_ANQP_INFO_ID) {
4764 : 6 : id[num_id] = atoi(pos);
4765 [ + - ]: 6 : if (id[num_id])
4766 : 6 : num_id++;
4767 : 6 : pos = os_strchr(pos + 1, ',');
4768 [ + - ]: 6 : if (pos == NULL)
4769 : 6 : break;
4770 : 0 : pos++;
4771 : : }
4772 : :
4773 [ - + ]: 6 : if (num_id == 0)
4774 : 0 : return -1;
4775 : :
4776 : 6 : return anqp_send_req(wpa_s, dst_addr, id, num_id);
4777 : : }
4778 : :
4779 : :
4780 : 7 : static int gas_request(struct wpa_supplicant *wpa_s, char *cmd)
4781 : : {
4782 : : u8 dst_addr[ETH_ALEN];
4783 : 7 : struct wpabuf *advproto, *query = NULL;
4784 : 7 : int used, ret = -1;
4785 : : char *pos, *end;
4786 : : size_t len;
4787 : :
4788 : 7 : used = hwaddr_aton2(cmd, dst_addr);
4789 [ - + ]: 7 : if (used < 0)
4790 : 0 : return -1;
4791 : :
4792 : 7 : pos = cmd + used;
4793 [ + + ]: 14 : while (*pos == ' ')
4794 : 7 : pos++;
4795 : :
4796 : : /* Advertisement Protocol ID */
4797 : 7 : end = os_strchr(pos, ' ');
4798 [ + - ]: 7 : if (end)
4799 : 7 : len = end - pos;
4800 : : else
4801 : 0 : len = os_strlen(pos);
4802 [ - + ]: 7 : if (len & 0x01)
4803 : 0 : return -1;
4804 : 7 : len /= 2;
4805 [ - + ]: 7 : if (len == 0)
4806 : 0 : return -1;
4807 : 7 : advproto = wpabuf_alloc(len);
4808 [ - + ]: 7 : if (advproto == NULL)
4809 : 0 : return -1;
4810 [ - + ]: 7 : if (hexstr2bin(pos, wpabuf_put(advproto, len), len) < 0)
4811 : 0 : goto fail;
4812 : :
4813 [ + - ]: 7 : if (end) {
4814 : : /* Optional Query Request */
4815 : 7 : pos = end + 1;
4816 [ - + ]: 7 : while (*pos == ' ')
4817 : 0 : pos++;
4818 : :
4819 : 7 : len = os_strlen(pos);
4820 [ + - ]: 7 : if (len) {
4821 [ - + ]: 7 : if (len & 0x01)
4822 : 0 : goto fail;
4823 : 7 : len /= 2;
4824 [ - + ]: 7 : if (len == 0)
4825 : 0 : goto fail;
4826 : 7 : query = wpabuf_alloc(len);
4827 [ - + ]: 7 : if (query == NULL)
4828 : 0 : goto fail;
4829 [ - + ]: 7 : if (hexstr2bin(pos, wpabuf_put(query, len), len) < 0)
4830 : 0 : goto fail;
4831 : : }
4832 : : }
4833 : :
4834 : 7 : ret = gas_send_request(wpa_s, dst_addr, advproto, query);
4835 : :
4836 : : fail:
4837 : 7 : wpabuf_free(advproto);
4838 : 7 : wpabuf_free(query);
4839 : :
4840 : 7 : return ret;
4841 : : }
4842 : :
4843 : :
4844 : 7 : static int gas_response_get(struct wpa_supplicant *wpa_s, char *cmd, char *buf,
4845 : : size_t buflen)
4846 : : {
4847 : : u8 addr[ETH_ALEN];
4848 : : int dialog_token;
4849 : : int used;
4850 : : char *pos;
4851 : : size_t resp_len, start, requested_len;
4852 : :
4853 [ - + ]: 7 : if (!wpa_s->last_gas_resp)
4854 : 0 : return -1;
4855 : :
4856 : 7 : used = hwaddr_aton2(cmd, addr);
4857 [ - + ]: 7 : if (used < 0)
4858 : 0 : return -1;
4859 : :
4860 : 7 : pos = cmd + used;
4861 [ + + ]: 14 : while (*pos == ' ')
4862 : 7 : pos++;
4863 : 7 : dialog_token = atoi(pos);
4864 : :
4865 [ + - ][ + + ]: 7 : if (os_memcmp(addr, wpa_s->last_gas_addr, ETH_ALEN) != 0 ||
4866 : 7 : dialog_token != wpa_s->last_gas_dialog_token)
4867 : 1 : return -1;
4868 : :
4869 : 6 : resp_len = wpabuf_len(wpa_s->last_gas_resp);
4870 : 6 : start = 0;
4871 : 6 : requested_len = resp_len;
4872 : :
4873 : 6 : pos = os_strchr(pos, ' ');
4874 [ - + ]: 6 : if (pos) {
4875 : 0 : start = atoi(pos);
4876 [ # # ]: 0 : if (start > resp_len)
4877 : 0 : return os_snprintf(buf, buflen, "FAIL-Invalid range");
4878 : 0 : pos = os_strchr(pos, ',');
4879 [ # # ]: 0 : if (pos == NULL)
4880 : 0 : return -1;
4881 : 0 : pos++;
4882 : 0 : requested_len = atoi(pos);
4883 [ # # ]: 0 : if (start + requested_len > resp_len)
4884 : 0 : return os_snprintf(buf, buflen, "FAIL-Invalid range");
4885 : : }
4886 : :
4887 [ - + ]: 6 : if (requested_len * 2 + 1 > buflen)
4888 : 0 : return os_snprintf(buf, buflen, "FAIL-Too long response");
4889 : :
4890 : 7 : return wpa_snprintf_hex(buf, buflen,
4891 : 6 : wpabuf_head_u8(wpa_s->last_gas_resp) + start,
4892 : : requested_len);
4893 : : }
4894 : : #endif /* CONFIG_INTERWORKING */
4895 : :
4896 : :
4897 : : #ifdef CONFIG_HS20
4898 : :
4899 : 0 : static int get_hs20_anqp(struct wpa_supplicant *wpa_s, char *dst)
4900 : : {
4901 : : u8 dst_addr[ETH_ALEN];
4902 : : int used;
4903 : : char *pos;
4904 : 0 : u32 subtypes = 0;
4905 : :
4906 : 0 : used = hwaddr_aton2(dst, dst_addr);
4907 [ # # ]: 0 : if (used < 0)
4908 : 0 : return -1;
4909 : 0 : pos = dst + used;
4910 : : for (;;) {
4911 : 0 : int num = atoi(pos);
4912 [ # # ][ # # ]: 0 : if (num <= 0 || num > 31)
4913 : 0 : return -1;
4914 : 0 : subtypes |= BIT(num);
4915 : 0 : pos = os_strchr(pos + 1, ',');
4916 [ # # ]: 0 : if (pos == NULL)
4917 : 0 : break;
4918 : 0 : pos++;
4919 : 0 : }
4920 : :
4921 [ # # ]: 0 : if (subtypes == 0)
4922 : 0 : return -1;
4923 : :
4924 : 0 : return hs20_anqp_send_req(wpa_s, dst_addr, subtypes, NULL, 0);
4925 : : }
4926 : :
4927 : :
4928 : 0 : static int hs20_nai_home_realm_list(struct wpa_supplicant *wpa_s,
4929 : : const u8 *addr, const char *realm)
4930 : : {
4931 : : u8 *buf;
4932 : : size_t rlen, len;
4933 : : int ret;
4934 : :
4935 : 0 : rlen = os_strlen(realm);
4936 : 0 : len = 3 + rlen;
4937 : 0 : buf = os_malloc(len);
4938 [ # # ]: 0 : if (buf == NULL)
4939 : 0 : return -1;
4940 : 0 : buf[0] = 1; /* NAI Home Realm Count */
4941 : 0 : buf[1] = 0; /* Formatted in accordance with RFC 4282 */
4942 : 0 : buf[2] = rlen;
4943 : 0 : os_memcpy(buf + 3, realm, rlen);
4944 : :
4945 : 0 : ret = hs20_anqp_send_req(wpa_s, addr,
4946 : : BIT(HS20_STYPE_NAI_HOME_REALM_QUERY),
4947 : : buf, len);
4948 : :
4949 : 0 : os_free(buf);
4950 : :
4951 : 0 : return ret;
4952 : : }
4953 : :
4954 : :
4955 : 0 : static int hs20_get_nai_home_realm_list(struct wpa_supplicant *wpa_s,
4956 : : char *dst)
4957 : : {
4958 : 0 : struct wpa_cred *cred = wpa_s->conf->cred;
4959 : : u8 dst_addr[ETH_ALEN];
4960 : : int used;
4961 : : u8 *buf;
4962 : : size_t len;
4963 : : int ret;
4964 : :
4965 : 0 : used = hwaddr_aton2(dst, dst_addr);
4966 [ # # ]: 0 : if (used < 0)
4967 : 0 : return -1;
4968 : :
4969 [ # # ]: 0 : while (dst[used] == ' ')
4970 : 0 : used++;
4971 [ # # ]: 0 : if (os_strncmp(dst + used, "realm=", 6) == 0)
4972 : 0 : return hs20_nai_home_realm_list(wpa_s, dst_addr,
4973 : 0 : dst + used + 6);
4974 : :
4975 : 0 : len = os_strlen(dst + used);
4976 : :
4977 [ # # ][ # # ]: 0 : if (len == 0 && cred && cred->realm)
[ # # ]
4978 : 0 : return hs20_nai_home_realm_list(wpa_s, dst_addr, cred->realm);
4979 : :
4980 : : if (len % 1)
4981 : : return -1;
4982 : 0 : len /= 2;
4983 : 0 : buf = os_malloc(len);
4984 [ # # ]: 0 : if (buf == NULL)
4985 : 0 : return -1;
4986 [ # # ]: 0 : if (hexstr2bin(dst + used, buf, len) < 0) {
4987 : 0 : os_free(buf);
4988 : 0 : return -1;
4989 : : }
4990 : :
4991 : 0 : ret = hs20_anqp_send_req(wpa_s, dst_addr,
4992 : : BIT(HS20_STYPE_NAI_HOME_REALM_QUERY),
4993 : : buf, len);
4994 : 0 : os_free(buf);
4995 : :
4996 : 0 : return ret;
4997 : : }
4998 : :
4999 : : #endif /* CONFIG_HS20 */
5000 : :
5001 : :
5002 : 0 : static int wpa_supplicant_ctrl_iface_sta_autoconnect(
5003 : : struct wpa_supplicant *wpa_s, char *cmd)
5004 : : {
5005 : 0 : wpa_s->auto_reconnect_disabled = atoi(cmd) == 0 ? 1 : 0;
5006 : 0 : return 0;
5007 : : }
5008 : :
5009 : :
5010 : : #ifdef CONFIG_AUTOSCAN
5011 : :
5012 : 0 : static int wpa_supplicant_ctrl_iface_autoscan(struct wpa_supplicant *wpa_s,
5013 : : char *cmd)
5014 : : {
5015 : 0 : enum wpa_states state = wpa_s->wpa_state;
5016 : 0 : char *new_params = NULL;
5017 : :
5018 [ # # ]: 0 : if (os_strlen(cmd) > 0) {
5019 : 0 : new_params = os_strdup(cmd);
5020 [ # # ]: 0 : if (new_params == NULL)
5021 : 0 : return -1;
5022 : : }
5023 : :
5024 : 0 : os_free(wpa_s->conf->autoscan);
5025 : 0 : wpa_s->conf->autoscan = new_params;
5026 : :
5027 [ # # ]: 0 : if (wpa_s->conf->autoscan == NULL)
5028 : 0 : autoscan_deinit(wpa_s);
5029 [ # # ][ # # ]: 0 : else if (state == WPA_DISCONNECTED || state == WPA_INACTIVE)
5030 : 0 : autoscan_init(wpa_s, 1);
5031 [ # # ]: 0 : else if (state == WPA_SCANNING)
5032 : 0 : wpa_supplicant_reinit_autoscan(wpa_s);
5033 : :
5034 : 0 : return 0;
5035 : : }
5036 : :
5037 : : #endif /* CONFIG_AUTOSCAN */
5038 : :
5039 : :
5040 : : #ifdef CONFIG_WNM
5041 : :
5042 : 6 : static int wpas_ctrl_iface_wnm_sleep(struct wpa_supplicant *wpa_s, char *cmd)
5043 : : {
5044 : : int enter;
5045 : 6 : int intval = 0;
5046 : : char *pos;
5047 : : int ret;
5048 : 6 : struct wpabuf *tfs_req = NULL;
5049 : :
5050 [ + + ]: 6 : if (os_strncmp(cmd, "enter", 5) == 0)
5051 : 3 : enter = 1;
5052 [ + - ]: 3 : else if (os_strncmp(cmd, "exit", 4) == 0)
5053 : 3 : enter = 0;
5054 : : else
5055 : 0 : return -1;
5056 : :
5057 : 6 : pos = os_strstr(cmd, " interval=");
5058 [ - + ]: 6 : if (pos)
5059 : 0 : intval = atoi(pos + 10);
5060 : :
5061 : 6 : pos = os_strstr(cmd, " tfs_req=");
5062 [ - + ]: 6 : if (pos) {
5063 : : char *end;
5064 : : size_t len;
5065 : 0 : pos += 9;
5066 : 0 : end = os_strchr(pos, ' ');
5067 [ # # ]: 0 : if (end)
5068 : 0 : len = end - pos;
5069 : : else
5070 : 0 : len = os_strlen(pos);
5071 [ # # ]: 0 : if (len & 1)
5072 : 0 : return -1;
5073 : 0 : len /= 2;
5074 : 0 : tfs_req = wpabuf_alloc(len);
5075 [ # # ]: 0 : if (tfs_req == NULL)
5076 : 0 : return -1;
5077 [ # # ]: 0 : if (hexstr2bin(pos, wpabuf_put(tfs_req, len), len) < 0) {
5078 : 0 : wpabuf_free(tfs_req);
5079 : 0 : return -1;
5080 : : }
5081 : : }
5082 : :
5083 : 6 : ret = ieee802_11_send_wnmsleep_req(wpa_s, enter ? WNM_SLEEP_MODE_ENTER :
5084 : : WNM_SLEEP_MODE_EXIT, intval,
5085 : : tfs_req);
5086 : 6 : wpabuf_free(tfs_req);
5087 : :
5088 : 6 : return ret;
5089 : : }
5090 : :
5091 : :
5092 : 1 : static int wpas_ctrl_iface_wnm_bss_query(struct wpa_supplicant *wpa_s, char *cmd)
5093 : : {
5094 : : int query_reason;
5095 : :
5096 : 1 : query_reason = atoi(cmd);
5097 : :
5098 : 1 : wpa_printf(MSG_DEBUG, "CTRL_IFACE: WNM_BSS_QUERY query_reason=%d",
5099 : : query_reason);
5100 : :
5101 : 1 : return wnm_send_bss_transition_mgmt_query(wpa_s, query_reason);
5102 : : }
5103 : :
5104 : : #endif /* CONFIG_WNM */
5105 : :
5106 : :
5107 : : /* Get string representation of channel width */
5108 : 0 : static const char * channel_width_name(enum chan_width width)
5109 : : {
5110 [ # # # # : 0 : switch (width) {
# # # ]
5111 : : case CHAN_WIDTH_20_NOHT:
5112 : 0 : return "20 MHz (no HT)";
5113 : : case CHAN_WIDTH_20:
5114 : 0 : return "20 MHz";
5115 : : case CHAN_WIDTH_40:
5116 : 0 : return "40 MHz";
5117 : : case CHAN_WIDTH_80:
5118 : 0 : return "80 MHz";
5119 : : case CHAN_WIDTH_80P80:
5120 : 0 : return "80+80 MHz";
5121 : : case CHAN_WIDTH_160:
5122 : 0 : return "160 MHz";
5123 : : default:
5124 : 0 : return "unknown";
5125 : : }
5126 : : }
5127 : :
5128 : :
5129 : 0 : static int wpa_supplicant_signal_poll(struct wpa_supplicant *wpa_s, char *buf,
5130 : : size_t buflen)
5131 : : {
5132 : : struct wpa_signal_info si;
5133 : : int ret;
5134 : : char *pos, *end;
5135 : :
5136 : 0 : ret = wpa_drv_signal_poll(wpa_s, &si);
5137 [ # # ]: 0 : if (ret)
5138 : 0 : return -1;
5139 : :
5140 : 0 : pos = buf;
5141 : 0 : end = buf + buflen;
5142 : :
5143 : 0 : ret = os_snprintf(pos, end - pos, "RSSI=%d\nLINKSPEED=%d\n"
5144 : : "NOISE=%d\nFREQUENCY=%u\n",
5145 : 0 : si.current_signal, si.current_txrate / 1000,
5146 : : si.current_noise, si.frequency);
5147 [ # # ][ # # ]: 0 : if (ret < 0 || ret > end - pos)
5148 : 0 : return -1;
5149 : 0 : pos += ret;
5150 : :
5151 [ # # ]: 0 : if (si.chanwidth != CHAN_WIDTH_UNKNOWN) {
5152 : 0 : ret = os_snprintf(pos, end - pos, "WIDTH=%s\n",
5153 : : channel_width_name(si.chanwidth));
5154 [ # # ][ # # ]: 0 : if (ret < 0 || ret > end - pos)
5155 : 0 : return -1;
5156 : 0 : pos += ret;
5157 : : }
5158 : :
5159 [ # # ][ # # ]: 0 : if (si.center_frq1 > 0 && si.center_frq2 > 0) {
5160 : 0 : ret = os_snprintf(pos, end - pos,
5161 : : "CENTER_FRQ1=%d\nCENTER_FRQ2=%d\n",
5162 : : si.center_frq1, si.center_frq2);
5163 [ # # ][ # # ]: 0 : if (ret < 0 || ret > end - pos)
5164 : 0 : return -1;
5165 : 0 : pos += ret;
5166 : : }
5167 : :
5168 [ # # ]: 0 : if (si.avg_signal) {
5169 : 0 : ret = os_snprintf(pos, end - pos,
5170 : : "AVG_RSSI=%d\n", si.avg_signal);
5171 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
5172 : 0 : return -1;
5173 : 0 : pos += ret;
5174 : : }
5175 : :
5176 : 0 : return pos - buf;
5177 : : }
5178 : :
5179 : :
5180 : 0 : static int wpa_supplicant_pktcnt_poll(struct wpa_supplicant *wpa_s, char *buf,
5181 : : size_t buflen)
5182 : : {
5183 : : struct hostap_sta_driver_data sta;
5184 : : int ret;
5185 : :
5186 : 0 : ret = wpa_drv_pktcnt_poll(wpa_s, &sta);
5187 [ # # ]: 0 : if (ret)
5188 : 0 : return -1;
5189 : :
5190 : 0 : ret = os_snprintf(buf, buflen, "TXGOOD=%lu\nTXBAD=%lu\nRXGOOD=%lu\n",
5191 : : sta.tx_packets, sta.tx_retry_failed, sta.rx_packets);
5192 [ # # ][ # # ]: 0 : if (ret < 0 || (size_t) ret > buflen)
5193 : 0 : return -1;
5194 : 0 : return ret;
5195 : : }
5196 : :
5197 : :
5198 : : #ifdef ANDROID
5199 : : static int wpa_supplicant_driver_cmd(struct wpa_supplicant *wpa_s, char *cmd,
5200 : : char *buf, size_t buflen)
5201 : : {
5202 : : int ret;
5203 : :
5204 : : ret = wpa_drv_driver_cmd(wpa_s, cmd, buf, buflen);
5205 : : if (ret == 0) {
5206 : : if (os_strncasecmp(cmd, "COUNTRY", 7) == 0) {
5207 : : struct p2p_data *p2p = wpa_s->global->p2p;
5208 : : if (p2p) {
5209 : : char country[3];
5210 : : country[0] = cmd[8];
5211 : : country[1] = cmd[9];
5212 : : country[2] = 0x04;
5213 : : p2p_set_country(p2p, country);
5214 : : }
5215 : : }
5216 : : ret = os_snprintf(buf, buflen, "%s\n", "OK");
5217 : : }
5218 : : return ret;
5219 : : }
5220 : : #endif /* ANDROID */
5221 : :
5222 : :
5223 : 727 : static void wpa_supplicant_ctrl_iface_flush(struct wpa_supplicant *wpa_s)
5224 : : {
5225 : 727 : wpa_dbg(wpa_s, MSG_DEBUG, "Flush all wpa_supplicant state");
5226 : :
5227 : : #ifdef CONFIG_P2P
5228 : 727 : wpas_p2p_stop_find(wpa_s);
5229 : 727 : p2p_ctrl_flush(wpa_s);
5230 : 727 : wpas_p2p_group_remove(wpa_s, "*");
5231 : 727 : wpas_p2p_service_flush(wpa_s);
5232 : 727 : wpa_s->global->p2p_disabled = 0;
5233 : 727 : wpa_s->global->p2p_per_sta_psk = 0;
5234 : : #endif /* CONFIG_P2P */
5235 : :
5236 : : #ifdef CONFIG_WPS_TESTING
5237 : 727 : wps_version_number = 0x20;
5238 : 727 : wps_testing_dummy_cred = 0;
5239 : : #endif /* CONFIG_WPS_TESTING */
5240 : : #ifdef CONFIG_WPS
5241 : 727 : wpa_s->wps_fragment_size = 0;
5242 : 727 : wpas_wps_cancel(wpa_s);
5243 : : #endif /* CONFIG_WPS */
5244 : 727 : wpa_s->after_wps = 0;
5245 : 727 : wpa_s->known_wps_freq = 0;
5246 : :
5247 : : #ifdef CONFIG_TDLS
5248 : : #ifdef CONFIG_TDLS_TESTING
5249 : : extern unsigned int tdls_testing;
5250 : 727 : tdls_testing = 0;
5251 : : #endif /* CONFIG_TDLS_TESTING */
5252 : 727 : wpa_drv_tdls_oper(wpa_s, TDLS_ENABLE, NULL);
5253 : 727 : wpa_tdls_enable(wpa_s->wpa, 1);
5254 : : #endif /* CONFIG_TDLS */
5255 : :
5256 : 727 : eloop_cancel_timeout(wpa_supplicant_stop_countermeasures, wpa_s, NULL);
5257 : 727 : wpa_supplicant_stop_countermeasures(wpa_s, NULL);
5258 : :
5259 : 727 : wpa_s->no_keep_alive = 0;
5260 : :
5261 : 727 : os_free(wpa_s->disallow_aps_bssid);
5262 : 727 : wpa_s->disallow_aps_bssid = NULL;
5263 : 727 : wpa_s->disallow_aps_bssid_count = 0;
5264 : 727 : os_free(wpa_s->disallow_aps_ssid);
5265 : 727 : wpa_s->disallow_aps_ssid = NULL;
5266 : 727 : wpa_s->disallow_aps_ssid_count = 0;
5267 : :
5268 : 727 : wpa_s->set_sta_uapsd = 0;
5269 : 727 : wpa_s->sta_uapsd = 0;
5270 : :
5271 : 727 : wpa_drv_radio_disable(wpa_s, 0);
5272 : :
5273 : 727 : wpa_bss_flush(wpa_s);
5274 : 727 : wpa_blacklist_clear(wpa_s);
5275 : 727 : wpa_s->extra_blacklist_count = 0;
5276 : 727 : wpa_supplicant_ctrl_iface_remove_network(wpa_s, "all");
5277 : 727 : wpa_supplicant_ctrl_iface_remove_cred(wpa_s, "all");
5278 : :
5279 : 727 : wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME, 43200);
5280 : 727 : wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD, 70);
5281 : 727 : wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT, 60);
5282 : 727 : eapol_sm_notify_logoff(wpa_s->eapol, FALSE);
5283 : :
5284 : 727 : radio_remove_unstarted_work(wpa_s, NULL);
5285 : 727 : }
5286 : :
5287 : :
5288 : 2 : static int wpas_ctrl_radio_work_show(struct wpa_supplicant *wpa_s,
5289 : : char *buf, size_t buflen)
5290 : : {
5291 : : struct wpa_radio_work *work;
5292 : : char *pos, *end;
5293 : : struct os_reltime now, diff;
5294 : :
5295 : 2 : pos = buf;
5296 : 2 : end = buf + buflen;
5297 : :
5298 : 2 : os_get_reltime(&now);
5299 : :
5300 [ + + ]: 5 : dl_list_for_each(work, &wpa_s->radio->work, struct wpa_radio_work, list)
5301 : : {
5302 : : int ret;
5303 : :
5304 : 3 : os_reltime_sub(&now, &work->time, &diff);
5305 : 9 : ret = os_snprintf(pos, end - pos, "%s@%s:%u:%u:%ld.%06ld\n",
5306 : 3 : work->type, work->wpa_s->ifname, work->freq,
5307 : 3 : work->started, diff.sec, diff.usec);
5308 [ + - ][ + - ]: 3 : if (ret < 0 || ret >= end - pos)
5309 : : break;
5310 : 3 : pos += ret;
5311 : : }
5312 : :
5313 : 2 : return pos - buf;
5314 : : }
5315 : :
5316 : :
5317 : 0 : static void wpas_ctrl_radio_work_timeout(void *eloop_ctx, void *timeout_ctx)
5318 : : {
5319 : 0 : struct wpa_radio_work *work = eloop_ctx;
5320 : 0 : struct wpa_external_work *ework = work->ctx;
5321 : :
5322 : 0 : wpa_dbg(work->wpa_s, MSG_DEBUG,
5323 : : "Timing out external radio work %u (%s)",
5324 : : ework->id, work->type);
5325 : 0 : wpa_msg(work->wpa_s, MSG_INFO, EXT_RADIO_WORK_TIMEOUT "%u", ework->id);
5326 : 0 : os_free(ework);
5327 : 0 : radio_work_done(work);
5328 : 0 : }
5329 : :
5330 : :
5331 : 2 : static void wpas_ctrl_radio_work_cb(struct wpa_radio_work *work, int deinit)
5332 : : {
5333 : 2 : struct wpa_external_work *ework = work->ctx;
5334 : :
5335 [ - + ]: 2 : if (deinit) {
5336 : 0 : os_free(ework);
5337 : 2 : return;
5338 : : }
5339 : :
5340 : 2 : wpa_dbg(work->wpa_s, MSG_DEBUG, "Starting external radio work %u (%s)",
5341 : : ework->id, ework->type);
5342 : 2 : wpa_msg(work->wpa_s, MSG_INFO, EXT_RADIO_WORK_START "%u", ework->id);
5343 [ + - ]: 2 : if (!ework->timeout)
5344 : 2 : ework->timeout = 10;
5345 : 2 : eloop_register_timeout(ework->timeout, 0, wpas_ctrl_radio_work_timeout,
5346 : : work, NULL);
5347 : : }
5348 : :
5349 : :
5350 : 3 : static int wpas_ctrl_radio_work_add(struct wpa_supplicant *wpa_s, char *cmd,
5351 : : char *buf, size_t buflen)
5352 : : {
5353 : : struct wpa_external_work *ework;
5354 : : char *pos, *pos2;
5355 : : size_t type_len;
5356 : : int ret;
5357 : 3 : unsigned int freq = 0;
5358 : :
5359 : : /* format: <name> [freq=<MHz>] [timeout=<seconds>] */
5360 : :
5361 : 3 : ework = os_zalloc(sizeof(*ework));
5362 [ - + ]: 3 : if (ework == NULL)
5363 : 0 : return -1;
5364 : :
5365 : 3 : pos = os_strchr(cmd, ' ');
5366 [ + + ]: 3 : if (pos) {
5367 : 1 : type_len = pos - cmd;
5368 : 1 : pos++;
5369 : :
5370 : 1 : pos2 = os_strstr(pos, "freq=");
5371 [ + - ]: 1 : if (pos2)
5372 : 1 : freq = atoi(pos2 + 5);
5373 : :
5374 : 1 : pos2 = os_strstr(pos, "timeout=");
5375 [ - + ]: 1 : if (pos2)
5376 : 0 : ework->timeout = atoi(pos2 + 8);
5377 : : } else {
5378 : 2 : type_len = os_strlen(cmd);
5379 : : }
5380 [ - + ]: 3 : if (4 + type_len >= sizeof(ework->type))
5381 : 0 : type_len = sizeof(ework->type) - 4 - 1;
5382 : 3 : os_strlcpy(ework->type, "ext:", sizeof(ework->type));
5383 : 3 : os_memcpy(ework->type + 4, cmd, type_len);
5384 : 3 : ework->type[4 + type_len] = '\0';
5385 : :
5386 : 3 : wpa_s->ext_work_id++;
5387 [ - + ]: 3 : if (wpa_s->ext_work_id == 0)
5388 : 0 : wpa_s->ext_work_id++;
5389 : 3 : ework->id = wpa_s->ext_work_id;
5390 : :
5391 [ - + ]: 3 : if (radio_add_work(wpa_s, freq, ework->type, 0, wpas_ctrl_radio_work_cb,
5392 : : ework) < 0) {
5393 : 0 : os_free(ework);
5394 : 0 : return -1;
5395 : : }
5396 : :
5397 : 3 : ret = os_snprintf(buf, buflen, "%u", ework->id);
5398 [ + - ][ - + ]: 3 : if (ret < 0 || (size_t) ret >= buflen)
5399 : 0 : return -1;
5400 : 3 : return ret;
5401 : : }
5402 : :
5403 : :
5404 : 3 : static int wpas_ctrl_radio_work_done(struct wpa_supplicant *wpa_s, char *cmd)
5405 : : {
5406 : : struct wpa_radio_work *work;
5407 : 3 : unsigned int id = atoi(cmd);
5408 : :
5409 [ + - ]: 4 : dl_list_for_each(work, &wpa_s->radio->work, struct wpa_radio_work, list)
5410 : : {
5411 : : struct wpa_external_work *ework;
5412 : :
5413 [ - + ]: 4 : if (os_strncmp(work->type, "ext:", 4) != 0)
5414 : 0 : continue;
5415 : 4 : ework = work->ctx;
5416 [ + - ][ + + ]: 4 : if (id && ework->id != id)
5417 : 1 : continue;
5418 : 3 : wpa_dbg(wpa_s, MSG_DEBUG,
5419 : : "Completed external radio work %u (%s)",
5420 : : ework->id, ework->type);
5421 : 3 : eloop_cancel_timeout(wpas_ctrl_radio_work_timeout, work, NULL);
5422 : 3 : os_free(ework);
5423 : 3 : radio_work_done(work);
5424 : 3 : return 3; /* "OK\n" */
5425 : : }
5426 : :
5427 : 3 : return -1;
5428 : : }
5429 : :
5430 : :
5431 : 8 : static int wpas_ctrl_radio_work(struct wpa_supplicant *wpa_s, char *cmd,
5432 : : char *buf, size_t buflen)
5433 : : {
5434 [ + + ]: 8 : if (os_strcmp(cmd, "show") == 0)
5435 : 2 : return wpas_ctrl_radio_work_show(wpa_s, buf, buflen);
5436 [ + + ]: 6 : if (os_strncmp(cmd, "add ", 4) == 0)
5437 : 3 : return wpas_ctrl_radio_work_add(wpa_s, cmd + 4, buf, buflen);
5438 [ + - ]: 3 : if (os_strncmp(cmd, "done ", 5) == 0)
5439 : 3 : return wpas_ctrl_radio_work_done(wpa_s, cmd + 4);
5440 : 8 : return -1;
5441 : : }
5442 : :
5443 : :
5444 : 33 : void wpas_ctrl_radio_work_flush(struct wpa_supplicant *wpa_s)
5445 : : {
5446 : : struct wpa_radio_work *work, *tmp;
5447 : :
5448 [ - + ]: 33 : dl_list_for_each_safe(work, tmp, &wpa_s->radio->work,
5449 : : struct wpa_radio_work, list) {
5450 : : struct wpa_external_work *ework;
5451 : :
5452 [ # # ]: 0 : if (os_strncmp(work->type, "ext:", 4) != 0)
5453 : 0 : continue;
5454 : 0 : ework = work->ctx;
5455 [ # # ]: 0 : wpa_dbg(wpa_s, MSG_DEBUG,
5456 : : "Flushing %sexternal radio work %u (%s)",
5457 : : work->started ? " started" : "", ework->id,
5458 : : ework->type);
5459 [ # # ]: 0 : if (work->started)
5460 : 0 : eloop_cancel_timeout(wpas_ctrl_radio_work_timeout,
5461 : : work, NULL);
5462 : 0 : os_free(ework);
5463 : 0 : radio_work_done(work);
5464 : : }
5465 : 33 : }
5466 : :
5467 : :
5468 : 9 : static void wpas_ctrl_eapol_response(void *eloop_ctx, void *timeout_ctx)
5469 : : {
5470 : 9 : struct wpa_supplicant *wpa_s = eloop_ctx;
5471 : 9 : eapol_sm_notify_ctrl_response(wpa_s->eapol);
5472 : 9 : }
5473 : :
5474 : :
5475 : 42 : static int set_scan_freqs(struct wpa_supplicant *wpa_s, char *val)
5476 : : {
5477 : 42 : int *freqs = NULL;
5478 : :
5479 : 42 : freqs = freq_range_to_channel_list(wpa_s, val);
5480 [ - + ]: 42 : if (freqs == NULL)
5481 : 0 : return -1;
5482 : :
5483 : 42 : os_free(wpa_s->manual_scan_freqs);
5484 : 42 : wpa_s->manual_scan_freqs = freqs;
5485 : :
5486 : 42 : return 0;
5487 : : }
5488 : :
5489 : :
5490 : 50 : static void wpas_ctrl_scan(struct wpa_supplicant *wpa_s, char *params,
5491 : : char *reply, int reply_size, int *reply_len)
5492 : : {
5493 : : char *pos;
5494 : :
5495 [ - + ]: 50 : if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
5496 : 0 : *reply_len = -1;
5497 : 0 : return;
5498 : : }
5499 : :
5500 : 50 : wpa_s->manual_scan_passive = 0;
5501 : 50 : wpa_s->manual_scan_use_id = 0;
5502 : 50 : wpa_s->manual_scan_only_new = 0;
5503 : :
5504 [ + + ]: 50 : if (params) {
5505 [ + + ]: 47 : if (os_strncasecmp(params, "TYPE=ONLY", 9) == 0)
5506 : 7 : wpa_s->scan_res_handler = scan_only_handler;
5507 : :
5508 : 47 : pos = os_strstr(params, "freq=");
5509 [ + + ][ - + ]: 47 : if (pos && set_scan_freqs(wpa_s, pos + 5) < 0) {
5510 : 0 : *reply_len = -1;
5511 : 0 : return;
5512 : : }
5513 : :
5514 : 47 : pos = os_strstr(params, "passive=");
5515 [ + + ]: 47 : if (pos)
5516 : 6 : wpa_s->manual_scan_passive = !!atoi(pos + 8);
5517 : :
5518 : 47 : pos = os_strstr(params, "use_id=");
5519 [ + + ]: 47 : if (pos)
5520 : 11 : wpa_s->manual_scan_use_id = atoi(pos + 7);
5521 : :
5522 : 47 : pos = os_strstr(params, "only_new=1");
5523 [ - + ]: 47 : if (pos)
5524 : 0 : wpa_s->manual_scan_only_new = 1;
5525 : : } else {
5526 : 3 : os_free(wpa_s->manual_scan_freqs);
5527 : 3 : wpa_s->manual_scan_freqs = NULL;
5528 [ - + ]: 3 : if (wpa_s->scan_res_handler == scan_only_handler)
5529 : 0 : wpa_s->scan_res_handler = NULL;
5530 : : }
5531 : :
5532 [ + - ][ + - ]: 50 : if (!wpa_s->sched_scanning && !wpa_s->scanning &&
[ + + ]
5533 [ + - ]: 8 : ((wpa_s->wpa_state <= WPA_SCANNING) ||
5534 : 8 : (wpa_s->wpa_state == WPA_COMPLETED))) {
5535 : 50 : wpa_s->normal_scans = 0;
5536 : 50 : wpa_s->scan_req = MANUAL_SCAN_REQ;
5537 : 50 : wpa_s->after_wps = 0;
5538 : 50 : wpa_s->known_wps_freq = 0;
5539 : 50 : wpa_supplicant_req_scan(wpa_s, 0, 0);
5540 [ + + ]: 61 : if (wpa_s->manual_scan_use_id) {
5541 : 11 : wpa_s->manual_scan_id++;
5542 : 11 : wpa_dbg(wpa_s, MSG_DEBUG, "Assigned scan id %u",
5543 : : wpa_s->manual_scan_id);
5544 : 11 : *reply_len = os_snprintf(reply, reply_size, "%u\n",
5545 : : wpa_s->manual_scan_id);
5546 : : }
5547 [ # # ]: 0 : } else if (wpa_s->sched_scanning) {
5548 : 0 : wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan to allow requested full scan to proceed");
5549 : 0 : wpa_supplicant_cancel_sched_scan(wpa_s);
5550 : 0 : wpa_s->scan_req = MANUAL_SCAN_REQ;
5551 : 0 : wpa_supplicant_req_scan(wpa_s, 0, 0);
5552 [ # # ]: 0 : if (wpa_s->manual_scan_use_id) {
5553 : 0 : wpa_s->manual_scan_id++;
5554 : 0 : *reply_len = os_snprintf(reply, reply_size, "%u\n",
5555 : : wpa_s->manual_scan_id);
5556 : 0 : wpa_dbg(wpa_s, MSG_DEBUG, "Assigned scan id %u",
5557 : : wpa_s->manual_scan_id);
5558 : : }
5559 : : } else {
5560 : 0 : wpa_printf(MSG_DEBUG, "Ongoing scan action - reject new request");
5561 : 50 : *reply_len = os_snprintf(reply, reply_size, "FAIL-BUSY\n");
5562 : : }
5563 : : }
5564 : :
5565 : :
5566 : 13524 : char * wpa_supplicant_ctrl_iface_process(struct wpa_supplicant *wpa_s,
5567 : : char *buf, size_t *resp_len)
5568 : : {
5569 : : char *reply;
5570 : 13524 : const int reply_size = 4096;
5571 : : int reply_len;
5572 : :
5573 [ + + ][ + + ]: 13524 : if (os_strncmp(buf, WPA_CTRL_RSP, os_strlen(WPA_CTRL_RSP)) == 0 ||
5574 : 13515 : os_strncmp(buf, "SET_NETWORK ", 12) == 0) {
5575 [ + - ]: 2370 : if (wpa_debug_show_keys)
5576 : 1185 : wpa_dbg(wpa_s, MSG_DEBUG,
5577 : : "Control interface command '%s'", buf);
5578 : : else
5579 [ # # ]: 0 : wpa_dbg(wpa_s, MSG_DEBUG,
5580 : : "Control interface command '%s [REMOVED]'",
5581 : : os_strncmp(buf, WPA_CTRL_RSP,
5582 : : os_strlen(WPA_CTRL_RSP)) == 0 ?
5583 : : WPA_CTRL_RSP : "SET_NETWORK");
5584 [ + + ][ + + ]: 12339 : } else if (os_strncmp(buf, "WPS_NFC_TAG_READ", 16) == 0 ||
5585 [ - + ]: 12335 : os_strncmp(buf, "NFC_REPORT_HANDOVER", 19) == 0 ||
5586 : 12335 : os_strncmp(buf, "NFC_RX_HANDOVER_SEL", 19) == 0) {
5587 : 4 : wpa_hexdump_ascii_key(MSG_DEBUG, "RX ctrl_iface",
5588 : : (const u8 *) buf, os_strlen(buf));
5589 : : } else {
5590 : 12335 : int level = MSG_DEBUG;
5591 [ + + ]: 12335 : if (os_strcmp(buf, "PING") == 0)
5592 : 731 : level = MSG_EXCESSIVE;
5593 : 12335 : wpa_dbg(wpa_s, level, "Control interface command '%s'", buf);
5594 : : }
5595 : :
5596 : 13524 : reply = os_malloc(reply_size);
5597 [ - + ]: 13524 : if (reply == NULL) {
5598 : 0 : *resp_len = 1;
5599 : 0 : return NULL;
5600 : : }
5601 : :
5602 : 13524 : os_memcpy(reply, "OK\n", 3);
5603 : 13524 : reply_len = 3;
5604 : :
5605 [ + + ]: 13524 : if (os_strcmp(buf, "PING") == 0) {
5606 : 731 : os_memcpy(reply, "PONG\n", 5);
5607 : 731 : reply_len = 5;
5608 [ - + ]: 12793 : } else if (os_strcmp(buf, "IFNAME") == 0) {
5609 : 0 : reply_len = os_strlen(wpa_s->ifname);
5610 : 0 : os_memcpy(reply, wpa_s->ifname, reply_len);
5611 [ + + ]: 12793 : } else if (os_strncmp(buf, "RELOG", 5) == 0) {
5612 [ - + ]: 731 : if (wpa_debug_reopen_file() < 0)
5613 : 0 : reply_len = -1;
5614 [ + + ]: 12062 : } else if (os_strncmp(buf, "NOTE ", 5) == 0) {
5615 : 1446 : wpa_printf(MSG_INFO, "NOTE: %s", buf + 5);
5616 [ - + ]: 10616 : } else if (os_strcmp(buf, "MIB") == 0) {
5617 : 0 : reply_len = wpa_sm_get_mib(wpa_s->wpa, reply, reply_size);
5618 [ # # ]: 0 : if (reply_len >= 0) {
5619 : : int res;
5620 : 0 : res = eapol_sm_get_mib(wpa_s->eapol, reply + reply_len,
5621 : 0 : reply_size - reply_len);
5622 [ # # ]: 0 : if (res < 0)
5623 : 0 : reply_len = -1;
5624 : : else
5625 : 0 : reply_len += res;
5626 : : }
5627 [ + + ]: 10616 : } else if (os_strncmp(buf, "STATUS", 6) == 0) {
5628 : 1165 : reply_len = wpa_supplicant_ctrl_iface_status(
5629 : : wpa_s, buf + 6, reply, reply_size);
5630 [ + + ]: 9451 : } else if (os_strcmp(buf, "PMKSA") == 0) {
5631 : 11 : reply_len = wpa_sm_pmksa_cache_list(wpa_s->wpa, reply,
5632 : : reply_size);
5633 [ + + ]: 9440 : } else if (os_strncmp(buf, "SET ", 4) == 0) {
5634 [ - + ]: 5227 : if (wpa_supplicant_ctrl_iface_set(wpa_s, buf + 4))
5635 : 0 : reply_len = -1;
5636 [ - + ]: 4213 : } else if (os_strncmp(buf, "GET ", 4) == 0) {
5637 : 0 : reply_len = wpa_supplicant_ctrl_iface_get(wpa_s, buf + 4,
5638 : : reply, reply_size);
5639 [ + + ]: 4213 : } else if (os_strcmp(buf, "LOGON") == 0) {
5640 : 1 : eapol_sm_notify_logoff(wpa_s->eapol, FALSE);
5641 [ + + ]: 4212 : } else if (os_strcmp(buf, "LOGOFF") == 0) {
5642 : 1 : eapol_sm_notify_logoff(wpa_s->eapol, TRUE);
5643 [ + + ]: 4211 : } else if (os_strcmp(buf, "REASSOCIATE") == 0) {
5644 [ - + ]: 1 : if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED)
5645 : 0 : reply_len = -1;
5646 : : else
5647 : 1 : wpas_request_connection(wpa_s);
5648 [ + + ]: 4210 : } else if (os_strcmp(buf, "RECONNECT") == 0) {
5649 [ - + ]: 1 : if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED)
5650 : 0 : reply_len = -1;
5651 [ + - ]: 1 : else if (wpa_s->disconnected)
5652 : 1 : wpas_request_connection(wpa_s);
5653 : : #ifdef IEEE8021X_EAPOL
5654 [ - + ]: 4209 : } else if (os_strncmp(buf, "PREAUTH ", 8) == 0) {
5655 [ # # ]: 0 : if (wpa_supplicant_ctrl_iface_preauth(wpa_s, buf + 8))
5656 : 0 : reply_len = -1;
5657 : : #endif /* IEEE8021X_EAPOL */
5658 : : #ifdef CONFIG_PEERKEY
5659 [ + + ]: 4209 : } else if (os_strncmp(buf, "STKSTART ", 9) == 0) {
5660 [ - + ]: 1 : if (wpa_supplicant_ctrl_iface_stkstart(wpa_s, buf + 9))
5661 : 0 : reply_len = -1;
5662 : : #endif /* CONFIG_PEERKEY */
5663 : : #ifdef CONFIG_IEEE80211R
5664 [ + + ]: 4208 : } else if (os_strncmp(buf, "FT_DS ", 6) == 0) {
5665 [ - + ]: 6 : if (wpa_supplicant_ctrl_iface_ft_ds(wpa_s, buf + 6))
5666 : 0 : reply_len = -1;
5667 : : #endif /* CONFIG_IEEE80211R */
5668 : : #ifdef CONFIG_WPS
5669 [ + + ]: 4202 : } else if (os_strcmp(buf, "WPS_PBC") == 0) {
5670 : 14 : int res = wpa_supplicant_ctrl_iface_wps_pbc(wpa_s, NULL);
5671 [ - + ]: 14 : if (res == -2) {
5672 : 0 : os_memcpy(reply, "FAIL-PBC-OVERLAP\n", 17);
5673 : 0 : reply_len = 17;
5674 [ - + ]: 14 : } else if (res)
5675 : 0 : reply_len = -1;
5676 [ - + ]: 4188 : } else if (os_strncmp(buf, "WPS_PBC ", 8) == 0) {
5677 : 0 : int res = wpa_supplicant_ctrl_iface_wps_pbc(wpa_s, buf + 8);
5678 [ # # ]: 0 : if (res == -2) {
5679 : 0 : os_memcpy(reply, "FAIL-PBC-OVERLAP\n", 17);
5680 : 0 : reply_len = 17;
5681 [ # # ]: 0 : } else if (res)
5682 : 0 : reply_len = -1;
5683 [ + + ]: 4188 : } else if (os_strncmp(buf, "WPS_PIN ", 8) == 0) {
5684 : 29 : reply_len = wpa_supplicant_ctrl_iface_wps_pin(wpa_s, buf + 8,
5685 : : reply,
5686 : : reply_size);
5687 [ + + ]: 4159 : } else if (os_strncmp(buf, "WPS_CHECK_PIN ", 14) == 0) {
5688 : 5 : reply_len = wpa_supplicant_ctrl_iface_wps_check_pin(
5689 : : wpa_s, buf + 14, reply, reply_size);
5690 [ + + ]: 4154 : } else if (os_strcmp(buf, "WPS_CANCEL") == 0) {
5691 [ - + ]: 1 : if (wpas_wps_cancel(wpa_s))
5692 : 0 : reply_len = -1;
5693 : : #ifdef CONFIG_WPS_NFC
5694 [ + + ]: 4153 : } else if (os_strcmp(buf, "WPS_NFC") == 0) {
5695 [ - + ]: 2 : if (wpa_supplicant_ctrl_iface_wps_nfc(wpa_s, NULL))
5696 : 0 : reply_len = -1;
5697 [ - + ]: 4151 : } else if (os_strncmp(buf, "WPS_NFC ", 8) == 0) {
5698 [ # # ]: 0 : if (wpa_supplicant_ctrl_iface_wps_nfc(wpa_s, buf + 8))
5699 : 0 : reply_len = -1;
5700 [ - + ]: 4151 : } else if (os_strncmp(buf, "WPS_NFC_CONFIG_TOKEN ", 21) == 0) {
5701 : 0 : reply_len = wpa_supplicant_ctrl_iface_wps_nfc_config_token(
5702 : : wpa_s, buf + 21, reply, reply_size);
5703 [ + + ]: 4151 : } else if (os_strncmp(buf, "WPS_NFC_TOKEN ", 14) == 0) {
5704 : 2 : reply_len = wpa_supplicant_ctrl_iface_wps_nfc_token(
5705 : : wpa_s, buf + 14, reply, reply_size);
5706 [ + + ]: 4149 : } else if (os_strncmp(buf, "WPS_NFC_TAG_READ ", 17) == 0) {
5707 [ - + ]: 3 : if (wpa_supplicant_ctrl_iface_wps_nfc_tag_read(wpa_s,
5708 : : buf + 17))
5709 : 0 : reply_len = -1;
5710 [ + + ]: 4146 : } else if (os_strncmp(buf, "NFC_GET_HANDOVER_REQ ", 21) == 0) {
5711 : 1 : reply_len = wpas_ctrl_nfc_get_handover_req(
5712 : : wpa_s, buf + 21, reply, reply_size);
5713 [ - + ]: 4145 : } else if (os_strncmp(buf, "NFC_GET_HANDOVER_SEL ", 21) == 0) {
5714 : 0 : reply_len = wpas_ctrl_nfc_get_handover_sel(
5715 : : wpa_s, buf + 21, reply, reply_size);
5716 [ - + ]: 4145 : } else if (os_strncmp(buf, "NFC_RX_HANDOVER_REQ ", 20) == 0) {
5717 : 0 : reply_len = wpas_ctrl_nfc_rx_handover_req(
5718 : : wpa_s, buf + 20, reply, reply_size);
5719 [ - + ]: 4145 : } else if (os_strncmp(buf, "NFC_RX_HANDOVER_SEL ", 20) == 0) {
5720 [ # # ]: 0 : if (wpas_ctrl_nfc_rx_handover_sel(wpa_s, buf + 20))
5721 : 0 : reply_len = -1;
5722 [ + + ]: 4145 : } else if (os_strncmp(buf, "NFC_REPORT_HANDOVER ", 20) == 0) {
5723 [ - + ]: 1 : if (wpas_ctrl_nfc_report_handover(wpa_s, buf + 20))
5724 : 0 : reply_len = -1;
5725 : : #endif /* CONFIG_WPS_NFC */
5726 [ + + ]: 4144 : } else if (os_strncmp(buf, "WPS_REG ", 8) == 0) {
5727 [ - + ]: 16 : if (wpa_supplicant_ctrl_iface_wps_reg(wpa_s, buf + 8))
5728 : 0 : reply_len = -1;
5729 : : #ifdef CONFIG_AP
5730 [ - + ]: 4128 : } else if (os_strncmp(buf, "WPS_AP_PIN ", 11) == 0) {
5731 : 0 : reply_len = wpa_supplicant_ctrl_iface_wps_ap_pin(
5732 : : wpa_s, buf + 11, reply, reply_size);
5733 : : #endif /* CONFIG_AP */
5734 : : #ifdef CONFIG_WPS_ER
5735 [ - + ]: 4128 : } else if (os_strcmp(buf, "WPS_ER_START") == 0) {
5736 [ # # ]: 0 : if (wpas_wps_er_start(wpa_s, NULL))
5737 : 0 : reply_len = -1;
5738 [ + + ]: 4128 : } else if (os_strncmp(buf, "WPS_ER_START ", 13) == 0) {
5739 [ - + ]: 3 : if (wpas_wps_er_start(wpa_s, buf + 13))
5740 : 0 : reply_len = -1;
5741 [ + + ]: 4125 : } else if (os_strcmp(buf, "WPS_ER_STOP") == 0) {
5742 [ - + ]: 1 : if (wpas_wps_er_stop(wpa_s))
5743 : 0 : reply_len = -1;
5744 [ + + ]: 4124 : } else if (os_strncmp(buf, "WPS_ER_PIN ", 11) == 0) {
5745 [ - + ]: 2 : if (wpa_supplicant_ctrl_iface_wps_er_pin(wpa_s, buf + 11))
5746 : 0 : reply_len = -1;
5747 [ + + ]: 4122 : } else if (os_strncmp(buf, "WPS_ER_PBC ", 11) == 0) {
5748 : 1 : int ret = wpas_wps_er_pbc(wpa_s, buf + 11);
5749 [ - + ]: 1 : if (ret == -2) {
5750 : 0 : os_memcpy(reply, "FAIL-PBC-OVERLAP\n", 17);
5751 : 0 : reply_len = 17;
5752 [ - + ]: 1 : } else if (ret == -3) {
5753 : 0 : os_memcpy(reply, "FAIL-UNKNOWN-UUID\n", 18);
5754 : 0 : reply_len = 18;
5755 [ - + ]: 1 : } else if (ret == -4) {
5756 : 0 : os_memcpy(reply, "FAIL-NO-AP-SETTINGS\n", 20);
5757 : 0 : reply_len = 20;
5758 [ - + ]: 1 : } else if (ret)
5759 : 0 : reply_len = -1;
5760 [ + + ]: 4121 : } else if (os_strncmp(buf, "WPS_ER_LEARN ", 13) == 0) {
5761 [ - + ]: 1 : if (wpa_supplicant_ctrl_iface_wps_er_learn(wpa_s, buf + 13))
5762 : 0 : reply_len = -1;
5763 [ + + ]: 4120 : } else if (os_strncmp(buf, "WPS_ER_SET_CONFIG ", 18) == 0) {
5764 [ - + ]: 2 : if (wpa_supplicant_ctrl_iface_wps_er_set_config(wpa_s,
5765 : : buf + 18))
5766 : 0 : reply_len = -1;
5767 [ + + ]: 4118 : } else if (os_strncmp(buf, "WPS_ER_CONFIG ", 14) == 0) {
5768 [ - + ]: 1 : if (wpa_supplicant_ctrl_iface_wps_er_config(wpa_s, buf + 14))
5769 : 0 : reply_len = -1;
5770 : : #ifdef CONFIG_WPS_NFC
5771 [ - + ]: 4117 : } else if (os_strncmp(buf, "WPS_ER_NFC_CONFIG_TOKEN ", 24) == 0) {
5772 : 0 : reply_len = wpa_supplicant_ctrl_iface_wps_er_nfc_config_token(
5773 : : wpa_s, buf + 24, reply, reply_size);
5774 : : #endif /* CONFIG_WPS_NFC */
5775 : : #endif /* CONFIG_WPS_ER */
5776 : : #endif /* CONFIG_WPS */
5777 : : #ifdef CONFIG_IBSS_RSN
5778 [ - + ]: 4117 : } else if (os_strncmp(buf, "IBSS_RSN ", 9) == 0) {
5779 [ # # ]: 0 : if (wpa_supplicant_ctrl_iface_ibss_rsn(wpa_s, buf + 9))
5780 : 0 : reply_len = -1;
5781 : : #endif /* CONFIG_IBSS_RSN */
5782 : : #ifdef CONFIG_P2P
5783 [ + + ]: 4117 : } else if (os_strncmp(buf, "P2P_FIND ", 9) == 0) {
5784 [ + + ]: 96 : if (p2p_ctrl_find(wpa_s, buf + 9))
5785 : 2 : reply_len = -1;
5786 [ + + ]: 4021 : } else if (os_strcmp(buf, "P2P_FIND") == 0) {
5787 [ - + ]: 14 : if (p2p_ctrl_find(wpa_s, ""))
5788 : 0 : reply_len = -1;
5789 [ - + ]: 4007 : } else if (os_strcmp(buf, "P2P_STOP_FIND") == 0) {
5790 : 0 : wpas_p2p_stop_find(wpa_s);
5791 [ + + ]: 4007 : } else if (os_strncmp(buf, "P2P_CONNECT ", 12) == 0) {
5792 : 99 : reply_len = p2p_ctrl_connect(wpa_s, buf + 12, reply,
5793 : : reply_size);
5794 [ - + ]: 3908 : } else if (os_strncmp(buf, "P2P_LISTEN ", 11) == 0) {
5795 [ # # ]: 0 : if (p2p_ctrl_listen(wpa_s, buf + 11))
5796 : 0 : reply_len = -1;
5797 [ + + ]: 3908 : } else if (os_strcmp(buf, "P2P_LISTEN") == 0) {
5798 [ - + ]: 95 : if (p2p_ctrl_listen(wpa_s, ""))
5799 : 0 : reply_len = -1;
5800 [ + + ]: 3813 : } else if (os_strncmp(buf, "P2P_GROUP_REMOVE ", 17) == 0) {
5801 [ + + ]: 85 : if (wpas_p2p_group_remove(wpa_s, buf + 17))
5802 : 13 : reply_len = -1;
5803 [ + + ]: 3728 : } else if (os_strcmp(buf, "P2P_GROUP_ADD") == 0) {
5804 [ - + ]: 8 : if (wpas_p2p_group_add(wpa_s, 0, 0, 0, 0))
5805 : 0 : reply_len = -1;
5806 [ + + ]: 3720 : } else if (os_strncmp(buf, "P2P_GROUP_ADD ", 14) == 0) {
5807 [ - + ]: 11 : if (p2p_ctrl_group_add(wpa_s, buf + 14))
5808 : 0 : reply_len = -1;
5809 [ + + ]: 3709 : } else if (os_strncmp(buf, "P2P_PROV_DISC ", 14) == 0) {
5810 [ - + ]: 3 : if (p2p_ctrl_prov_disc(wpa_s, buf + 14))
5811 : 0 : reply_len = -1;
5812 [ - + ]: 3706 : } else if (os_strcmp(buf, "P2P_GET_PASSPHRASE") == 0) {
5813 : 0 : reply_len = p2p_get_passphrase(wpa_s, reply, reply_size);
5814 [ + + ]: 3706 : } else if (os_strncmp(buf, "P2P_SERV_DISC_REQ ", 18) == 0) {
5815 : 13 : reply_len = p2p_ctrl_serv_disc_req(wpa_s, buf + 18, reply,
5816 : : reply_size);
5817 [ + + ]: 3693 : } else if (os_strncmp(buf, "P2P_SERV_DISC_CANCEL_REQ ", 25) == 0) {
5818 [ + + ]: 5 : if (p2p_ctrl_serv_disc_cancel_req(wpa_s, buf + 25) < 0)
5819 : 1 : reply_len = -1;
5820 [ - + ]: 3688 : } else if (os_strncmp(buf, "P2P_SERV_DISC_RESP ", 19) == 0) {
5821 [ # # ]: 0 : if (p2p_ctrl_serv_disc_resp(wpa_s, buf + 19) < 0)
5822 : 0 : reply_len = -1;
5823 [ - + ]: 3688 : } else if (os_strcmp(buf, "P2P_SERVICE_UPDATE") == 0) {
5824 : 0 : wpas_p2p_sd_service_update(wpa_s);
5825 [ - + ]: 3688 : } else if (os_strncmp(buf, "P2P_SERV_DISC_EXTERNAL ", 23) == 0) {
5826 [ # # ]: 0 : if (p2p_ctrl_serv_disc_external(wpa_s, buf + 23) < 0)
5827 : 0 : reply_len = -1;
5828 [ - + ]: 3688 : } else if (os_strcmp(buf, "P2P_SERVICE_FLUSH") == 0) {
5829 : 0 : wpas_p2p_service_flush(wpa_s);
5830 [ + + ]: 3688 : } else if (os_strncmp(buf, "P2P_SERVICE_ADD ", 16) == 0) {
5831 [ - + ]: 281 : if (p2p_ctrl_service_add(wpa_s, buf + 16) < 0)
5832 : 0 : reply_len = -1;
5833 [ - + ]: 3407 : } else if (os_strncmp(buf, "P2P_SERVICE_DEL ", 16) == 0) {
5834 [ # # ]: 0 : if (p2p_ctrl_service_del(wpa_s, buf + 16) < 0)
5835 : 0 : reply_len = -1;
5836 [ - + ]: 3407 : } else if (os_strncmp(buf, "P2P_REJECT ", 11) == 0) {
5837 [ # # ]: 0 : if (p2p_ctrl_reject(wpa_s, buf + 11) < 0)
5838 : 0 : reply_len = -1;
5839 [ + + ]: 3407 : } else if (os_strncmp(buf, "P2P_INVITE ", 11) == 0) {
5840 [ - + ]: 11 : if (p2p_ctrl_invite(wpa_s, buf + 11) < 0)
5841 : 0 : reply_len = -1;
5842 [ + + ]: 3396 : } else if (os_strncmp(buf, "P2P_PEER ", 9) == 0) {
5843 : 267 : reply_len = p2p_ctrl_peer(wpa_s, buf + 9, reply,
5844 : : reply_size);
5845 [ + + ]: 3129 : } else if (os_strncmp(buf, "P2P_SET ", 8) == 0) {
5846 [ - + ]: 6 : if (p2p_ctrl_set(wpa_s, buf + 8) < 0)
5847 : 0 : reply_len = -1;
5848 [ + + ]: 3123 : } else if (os_strcmp(buf, "P2P_FLUSH") == 0) {
5849 : 9 : p2p_ctrl_flush(wpa_s);
5850 [ - + ]: 3114 : } else if (os_strncmp(buf, "P2P_UNAUTHORIZE ", 16) == 0) {
5851 [ # # ]: 0 : if (wpas_p2p_unauthorize(wpa_s, buf + 16) < 0)
5852 : 0 : reply_len = -1;
5853 [ - + ]: 3114 : } else if (os_strcmp(buf, "P2P_CANCEL") == 0) {
5854 [ # # ]: 0 : if (wpas_p2p_cancel(wpa_s))
5855 : 0 : reply_len = -1;
5856 [ + + ]: 3114 : } else if (os_strncmp(buf, "P2P_PRESENCE_REQ ", 17) == 0) {
5857 [ - + ]: 1 : if (p2p_ctrl_presence_req(wpa_s, buf + 17) < 0)
5858 : 0 : reply_len = -1;
5859 [ - + ]: 3113 : } else if (os_strcmp(buf, "P2P_PRESENCE_REQ") == 0) {
5860 [ # # ]: 0 : if (p2p_ctrl_presence_req(wpa_s, "") < 0)
5861 : 0 : reply_len = -1;
5862 [ - + ]: 3113 : } else if (os_strncmp(buf, "P2P_EXT_LISTEN ", 15) == 0) {
5863 [ # # ]: 0 : if (p2p_ctrl_ext_listen(wpa_s, buf + 15) < 0)
5864 : 0 : reply_len = -1;
5865 [ - + ]: 3113 : } else if (os_strcmp(buf, "P2P_EXT_LISTEN") == 0) {
5866 [ # # ]: 0 : if (p2p_ctrl_ext_listen(wpa_s, "") < 0)
5867 : 0 : reply_len = -1;
5868 [ + + ]: 3113 : } else if (os_strncmp(buf, "P2P_REMOVE_CLIENT ", 18) == 0) {
5869 [ - + ]: 4 : if (p2p_ctrl_remove_client(wpa_s, buf + 18) < 0)
5870 : 0 : reply_len = -1;
5871 : : #endif /* CONFIG_P2P */
5872 : : #ifdef CONFIG_WIFI_DISPLAY
5873 [ + + ]: 3109 : } else if (os_strncmp(buf, "WFD_SUBELEM_SET ", 16) == 0) {
5874 [ - + ]: 3 : if (wifi_display_subelem_set(wpa_s->global, buf + 16) < 0)
5875 : 0 : reply_len = -1;
5876 [ + + ]: 3106 : } else if (os_strncmp(buf, "WFD_SUBELEM_GET ", 16) == 0) {
5877 : 2 : reply_len = wifi_display_subelem_get(wpa_s->global, buf + 16,
5878 : : reply, reply_size);
5879 : : #endif /* CONFIG_WIFI_DISPLAY */
5880 : : #ifdef CONFIG_INTERWORKING
5881 [ + + ]: 3104 : } else if (os_strcmp(buf, "FETCH_ANQP") == 0) {
5882 [ - + ]: 4 : if (interworking_fetch_anqp(wpa_s) < 0)
5883 : 0 : reply_len = -1;
5884 [ - + ]: 3100 : } else if (os_strcmp(buf, "STOP_FETCH_ANQP") == 0) {
5885 : 0 : interworking_stop_fetch_anqp(wpa_s);
5886 [ + + ]: 3100 : } else if (os_strcmp(buf, "INTERWORKING_SELECT") == 0) {
5887 [ - + ]: 1 : if (ctrl_interworking_select(wpa_s, NULL) < 0)
5888 : 0 : reply_len = -1;
5889 [ + + ]: 3099 : } else if (os_strncmp(buf, "INTERWORKING_SELECT ", 20) == 0) {
5890 [ - + ]: 34 : if (ctrl_interworking_select(wpa_s, buf + 20) < 0)
5891 : 0 : reply_len = -1;
5892 [ + + ]: 3065 : } else if (os_strncmp(buf, "INTERWORKING_CONNECT ", 21) == 0) {
5893 [ + + ]: 22 : if (ctrl_interworking_connect(wpa_s, buf + 21) < 0)
5894 : 1 : reply_len = -1;
5895 [ + + ]: 3043 : } else if (os_strncmp(buf, "ANQP_GET ", 9) == 0) {
5896 [ - + ]: 6 : if (get_anqp(wpa_s, buf + 9) < 0)
5897 : 0 : reply_len = -1;
5898 [ + + ]: 3037 : } else if (os_strncmp(buf, "GAS_REQUEST ", 12) == 0) {
5899 [ - + ]: 7 : if (gas_request(wpa_s, buf + 12) < 0)
5900 : 0 : reply_len = -1;
5901 [ + + ]: 3030 : } else if (os_strncmp(buf, "GAS_RESPONSE_GET ", 17) == 0) {
5902 : 7 : reply_len = gas_response_get(wpa_s, buf + 17, reply,
5903 : : reply_size);
5904 : : #endif /* CONFIG_INTERWORKING */
5905 : : #ifdef CONFIG_HS20
5906 [ - + ]: 3023 : } else if (os_strncmp(buf, "HS20_ANQP_GET ", 14) == 0) {
5907 [ # # ]: 0 : if (get_hs20_anqp(wpa_s, buf + 14) < 0)
5908 : 0 : reply_len = -1;
5909 [ - + ]: 3023 : } else if (os_strncmp(buf, "HS20_GET_NAI_HOME_REALM_LIST ", 29) == 0) {
5910 [ # # ]: 0 : if (hs20_get_nai_home_realm_list(wpa_s, buf + 29) < 0)
5911 : 0 : reply_len = -1;
5912 : : #endif /* CONFIG_HS20 */
5913 [ + + ]: 3023 : } else if (os_strncmp(buf, WPA_CTRL_RSP, os_strlen(WPA_CTRL_RSP)) == 0)
5914 : : {
5915 [ - + ]: 9 : if (wpa_supplicant_ctrl_iface_ctrl_rsp(
5916 : : wpa_s, buf + os_strlen(WPA_CTRL_RSP)))
5917 : 0 : reply_len = -1;
5918 : : else {
5919 : : /*
5920 : : * Notify response from timeout to allow the control
5921 : : * interface response to be sent first.
5922 : : */
5923 : 9 : eloop_register_timeout(0, 0, wpas_ctrl_eapol_response,
5924 : : wpa_s, NULL);
5925 : : }
5926 [ - + ]: 3014 : } else if (os_strcmp(buf, "RECONFIGURE") == 0) {
5927 [ # # ]: 0 : if (wpa_supplicant_reload_configuration(wpa_s))
5928 : 0 : reply_len = -1;
5929 [ - + ]: 3014 : } else if (os_strcmp(buf, "TERMINATE") == 0) {
5930 : 0 : wpa_supplicant_terminate_proc(wpa_s->global);
5931 [ - + ]: 3014 : } else if (os_strncmp(buf, "BSSID ", 6) == 0) {
5932 [ # # ]: 0 : if (wpa_supplicant_ctrl_iface_bssid(wpa_s, buf + 6))
5933 : 0 : reply_len = -1;
5934 [ - + ]: 3014 : } else if (os_strncmp(buf, "BLACKLIST", 9) == 0) {
5935 : 0 : reply_len = wpa_supplicant_ctrl_iface_blacklist(
5936 : : wpa_s, buf + 9, reply, reply_size);
5937 [ - + ]: 3014 : } else if (os_strncmp(buf, "LOG_LEVEL", 9) == 0) {
5938 : 0 : reply_len = wpa_supplicant_ctrl_iface_log_level(
5939 : : wpa_s, buf + 9, reply, reply_size);
5940 [ + + ]: 3014 : } else if (os_strcmp(buf, "LIST_NETWORKS") == 0) {
5941 : 2 : reply_len = wpa_supplicant_ctrl_iface_list_networks(
5942 : : wpa_s, reply, reply_size);
5943 [ + + ]: 3012 : } else if (os_strcmp(buf, "DISCONNECT") == 0) {
5944 : : #ifdef CONFIG_SME
5945 : 12 : wpa_s->sme.prev_bssid_set = 0;
5946 : : #endif /* CONFIG_SME */
5947 : 12 : wpa_s->reassociate = 0;
5948 : 12 : wpa_s->disconnected = 1;
5949 : 12 : wpa_supplicant_cancel_sched_scan(wpa_s);
5950 : 12 : wpa_supplicant_cancel_scan(wpa_s);
5951 : 12 : wpa_supplicant_deauthenticate(wpa_s,
5952 : : WLAN_REASON_DEAUTH_LEAVING);
5953 [ + + ]: 3000 : } else if (os_strcmp(buf, "SCAN") == 0) {
5954 : 3 : wpas_ctrl_scan(wpa_s, NULL, reply, reply_size, &reply_len);
5955 [ + + ]: 2997 : } else if (os_strncmp(buf, "SCAN ", 5) == 0) {
5956 : 47 : wpas_ctrl_scan(wpa_s, buf + 5, reply, reply_size, &reply_len);
5957 [ - + ]: 2950 : } else if (os_strcmp(buf, "SCAN_RESULTS") == 0) {
5958 : 0 : reply_len = wpa_supplicant_ctrl_iface_scan_results(
5959 : : wpa_s, reply, reply_size);
5960 [ + + ]: 2950 : } else if (os_strncmp(buf, "SELECT_NETWORK ", 15) == 0) {
5961 [ - + ]: 250 : if (wpa_supplicant_ctrl_iface_select_network(wpa_s, buf + 15))
5962 : 0 : reply_len = -1;
5963 [ - + ]: 2700 : } else if (os_strncmp(buf, "ENABLE_NETWORK ", 15) == 0) {
5964 [ # # ]: 0 : if (wpa_supplicant_ctrl_iface_enable_network(wpa_s, buf + 15))
5965 : 0 : reply_len = -1;
5966 [ - + ]: 2700 : } else if (os_strncmp(buf, "DISABLE_NETWORK ", 16) == 0) {
5967 [ # # ]: 0 : if (wpa_supplicant_ctrl_iface_disable_network(wpa_s, buf + 16))
5968 : 0 : reply_len = -1;
5969 [ + + ]: 2700 : } else if (os_strcmp(buf, "ADD_NETWORK") == 0) {
5970 : 248 : reply_len = wpa_supplicant_ctrl_iface_add_network(
5971 : : wpa_s, reply, reply_size);
5972 [ + + ]: 2452 : } else if (os_strncmp(buf, "REMOVE_NETWORK ", 15) == 0) {
5973 [ - + ]: 119 : if (wpa_supplicant_ctrl_iface_remove_network(wpa_s, buf + 15))
5974 : 0 : reply_len = -1;
5975 [ + + ]: 2333 : } else if (os_strncmp(buf, "SET_NETWORK ", 12) == 0) {
5976 [ - + ]: 1176 : if (wpa_supplicant_ctrl_iface_set_network(wpa_s, buf + 12))
5977 : 0 : reply_len = -1;
5978 [ - + ]: 1157 : } else if (os_strncmp(buf, "GET_NETWORK ", 12) == 0) {
5979 : 0 : reply_len = wpa_supplicant_ctrl_iface_get_network(
5980 : : wpa_s, buf + 12, reply, reply_size);
5981 [ - + ]: 1157 : } else if (os_strcmp(buf, "LIST_CREDS") == 0) {
5982 : 0 : reply_len = wpa_supplicant_ctrl_iface_list_creds(
5983 : : wpa_s, reply, reply_size);
5984 [ + + ]: 1157 : } else if (os_strcmp(buf, "ADD_CRED") == 0) {
5985 : 30 : reply_len = wpa_supplicant_ctrl_iface_add_cred(
5986 : : wpa_s, reply, reply_size);
5987 [ + + ]: 1127 : } else if (os_strncmp(buf, "REMOVE_CRED ", 12) == 0) {
5988 [ - + ]: 5 : if (wpa_supplicant_ctrl_iface_remove_cred(wpa_s, buf + 12))
5989 : 0 : reply_len = -1;
5990 [ + + ]: 1122 : } else if (os_strncmp(buf, "SET_CRED ", 9) == 0) {
5991 [ - + ]: 109 : if (wpa_supplicant_ctrl_iface_set_cred(wpa_s, buf + 9))
5992 : 0 : reply_len = -1;
5993 : : #ifndef CONFIG_NO_CONFIG_WRITE
5994 [ - + ]: 1013 : } else if (os_strcmp(buf, "SAVE_CONFIG") == 0) {
5995 [ # # ]: 0 : if (wpa_supplicant_ctrl_iface_save_config(wpa_s))
5996 : 0 : reply_len = -1;
5997 : : #endif /* CONFIG_NO_CONFIG_WRITE */
5998 [ + + ]: 1013 : } else if (os_strncmp(buf, "GET_CAPABILITY ", 15) == 0) {
5999 : 5 : reply_len = wpa_supplicant_ctrl_iface_get_capability(
6000 : : wpa_s, buf + 15, reply, reply_size);
6001 [ - + ]: 1008 : } else if (os_strncmp(buf, "AP_SCAN ", 8) == 0) {
6002 [ # # ]: 0 : if (wpa_supplicant_ctrl_iface_ap_scan(wpa_s, buf + 8))
6003 : 0 : reply_len = -1;
6004 [ - + ]: 1008 : } else if (os_strncmp(buf, "SCAN_INTERVAL ", 14) == 0) {
6005 [ # # ]: 0 : if (wpa_supplicant_ctrl_iface_scan_interval(wpa_s, buf + 14))
6006 : 0 : reply_len = -1;
6007 [ - + ]: 1008 : } else if (os_strcmp(buf, "INTERFACE_LIST") == 0) {
6008 : 0 : reply_len = wpa_supplicant_global_iface_list(
6009 : : wpa_s->global, reply, reply_size);
6010 [ - + ]: 1008 : } else if (os_strcmp(buf, "INTERFACES") == 0) {
6011 : 0 : reply_len = wpa_supplicant_global_iface_interfaces(
6012 : : wpa_s->global, reply, reply_size);
6013 [ + + ]: 1008 : } else if (os_strncmp(buf, "BSS ", 4) == 0) {
6014 : 112 : reply_len = wpa_supplicant_ctrl_iface_bss(
6015 : : wpa_s, buf + 4, reply, reply_size);
6016 : : #ifdef CONFIG_AP
6017 [ - + ]: 896 : } else if (os_strcmp(buf, "STA-FIRST") == 0) {
6018 : 0 : reply_len = ap_ctrl_iface_sta_first(wpa_s, reply, reply_size);
6019 [ - + ]: 896 : } else if (os_strncmp(buf, "STA ", 4) == 0) {
6020 : 0 : reply_len = ap_ctrl_iface_sta(wpa_s, buf + 4, reply,
6021 : : reply_size);
6022 [ - + ]: 896 : } else if (os_strncmp(buf, "STA-NEXT ", 9) == 0) {
6023 : 0 : reply_len = ap_ctrl_iface_sta_next(wpa_s, buf + 9, reply,
6024 : : reply_size);
6025 [ - + ]: 896 : } else if (os_strncmp(buf, "DEAUTHENTICATE ", 15) == 0) {
6026 [ # # ]: 0 : if (ap_ctrl_iface_sta_deauthenticate(wpa_s, buf + 15))
6027 : 0 : reply_len = -1;
6028 [ - + ]: 896 : } else if (os_strncmp(buf, "DISASSOCIATE ", 13) == 0) {
6029 [ # # ]: 0 : if (ap_ctrl_iface_sta_disassociate(wpa_s, buf + 13))
6030 : 0 : reply_len = -1;
6031 [ + + ]: 896 : } else if (os_strncmp(buf, "CHAN_SWITCH ", 12) == 0) {
6032 [ + - ]: 1 : if (ap_ctrl_iface_chanswitch(wpa_s, buf + 12))
6033 : 1 : reply_len = -1;
6034 : : #endif /* CONFIG_AP */
6035 [ - + ]: 895 : } else if (os_strcmp(buf, "SUSPEND") == 0) {
6036 : 0 : wpas_notify_suspend(wpa_s->global);
6037 [ - + ]: 895 : } else if (os_strcmp(buf, "RESUME") == 0) {
6038 : 0 : wpas_notify_resume(wpa_s->global);
6039 [ - + ]: 895 : } else if (os_strcmp(buf, "DROP_SA") == 0) {
6040 : 0 : wpa_supplicant_ctrl_iface_drop_sa(wpa_s);
6041 [ + + ]: 895 : } else if (os_strncmp(buf, "ROAM ", 5) == 0) {
6042 [ - + ]: 20 : if (wpa_supplicant_ctrl_iface_roam(wpa_s, buf + 5))
6043 : 0 : reply_len = -1;
6044 [ - + ]: 875 : } else if (os_strncmp(buf, "STA_AUTOCONNECT ", 16) == 0) {
6045 [ # # ]: 0 : if (wpa_supplicant_ctrl_iface_sta_autoconnect(wpa_s, buf + 16))
6046 : 0 : reply_len = -1;
6047 [ - + ]: 875 : } else if (os_strncmp(buf, "BSS_EXPIRE_AGE ", 15) == 0) {
6048 [ # # ]: 0 : if (wpa_supplicant_ctrl_iface_bss_expire_age(wpa_s, buf + 15))
6049 : 0 : reply_len = -1;
6050 [ - + ]: 875 : } else if (os_strncmp(buf, "BSS_EXPIRE_COUNT ", 17) == 0) {
6051 [ # # ]: 0 : if (wpa_supplicant_ctrl_iface_bss_expire_count(wpa_s,
6052 : : buf + 17))
6053 : 0 : reply_len = -1;
6054 [ + + ]: 875 : } else if (os_strncmp(buf, "BSS_FLUSH ", 10) == 0) {
6055 [ - + ]: 81 : if (wpa_supplicant_ctrl_iface_bss_flush(wpa_s, buf + 10))
6056 : 0 : reply_len = -1;
6057 : : #ifdef CONFIG_TDLS
6058 [ - + ]: 794 : } else if (os_strncmp(buf, "TDLS_DISCOVER ", 14) == 0) {
6059 [ # # ]: 0 : if (wpa_supplicant_ctrl_iface_tdls_discover(wpa_s, buf + 14))
6060 : 0 : reply_len = -1;
6061 [ + + ]: 794 : } else if (os_strncmp(buf, "TDLS_SETUP ", 11) == 0) {
6062 [ - + ]: 21 : if (wpa_supplicant_ctrl_iface_tdls_setup(wpa_s, buf + 11))
6063 : 0 : reply_len = -1;
6064 [ + + ]: 773 : } else if (os_strncmp(buf, "TDLS_TEARDOWN ", 14) == 0) {
6065 [ - + ]: 8 : if (wpa_supplicant_ctrl_iface_tdls_teardown(wpa_s, buf + 14))
6066 : 0 : reply_len = -1;
6067 : : #endif /* CONFIG_TDLS */
6068 [ - + ]: 765 : } else if (os_strncmp(buf, "SIGNAL_POLL", 11) == 0) {
6069 : 0 : reply_len = wpa_supplicant_signal_poll(wpa_s, reply,
6070 : : reply_size);
6071 [ - + ]: 765 : } else if (os_strncmp(buf, "PKTCNT_POLL", 11) == 0) {
6072 : 0 : reply_len = wpa_supplicant_pktcnt_poll(wpa_s, reply,
6073 : : reply_size);
6074 : : #ifdef CONFIG_AUTOSCAN
6075 [ - + ]: 765 : } else if (os_strncmp(buf, "AUTOSCAN ", 9) == 0) {
6076 [ # # ]: 0 : if (wpa_supplicant_ctrl_iface_autoscan(wpa_s, buf + 9))
6077 : 0 : reply_len = -1;
6078 : : #endif /* CONFIG_AUTOSCAN */
6079 : : #ifdef ANDROID
6080 : : } else if (os_strncmp(buf, "DRIVER ", 7) == 0) {
6081 : : reply_len = wpa_supplicant_driver_cmd(wpa_s, buf + 7, reply,
6082 : : reply_size);
6083 : : #endif /* ANDROID */
6084 [ + + ]: 765 : } else if (os_strcmp(buf, "REAUTHENTICATE") == 0) {
6085 : 23 : pmksa_cache_clear_current(wpa_s->wpa);
6086 : 23 : eapol_sm_request_reauth(wpa_s->eapol);
6087 : : #ifdef CONFIG_WNM
6088 [ + + ]: 742 : } else if (os_strncmp(buf, "WNM_SLEEP ", 10) == 0) {
6089 [ - + ]: 6 : if (wpas_ctrl_iface_wnm_sleep(wpa_s, buf + 10))
6090 : 0 : reply_len = -1;
6091 [ + + ]: 736 : } else if (os_strncmp(buf, "WNM_BSS_QUERY ", 10) == 0) {
6092 [ - + ]: 1 : if (wpas_ctrl_iface_wnm_bss_query(wpa_s, buf + 10))
6093 : 0 : reply_len = -1;
6094 : : #endif /* CONFIG_WNM */
6095 [ + + ]: 735 : } else if (os_strcmp(buf, "FLUSH") == 0) {
6096 : 727 : wpa_supplicant_ctrl_iface_flush(wpa_s);
6097 [ + - ]: 8 : } else if (os_strncmp(buf, "RADIO_WORK ", 11) == 0) {
6098 : 8 : reply_len = wpas_ctrl_radio_work(wpa_s, buf + 11, reply,
6099 : : reply_size);
6100 : : } else {
6101 : 0 : os_memcpy(reply, "UNKNOWN COMMAND\n", 16);
6102 : 0 : reply_len = 16;
6103 : : }
6104 : :
6105 [ + + ]: 13524 : if (reply_len < 0) {
6106 : 104 : os_memcpy(reply, "FAIL\n", 5);
6107 : 104 : reply_len = 5;
6108 : : }
6109 : :
6110 : 13524 : *resp_len = reply_len;
6111 : 13524 : return reply;
6112 : : }
6113 : :
6114 : :
6115 : 8 : static int wpa_supplicant_global_iface_add(struct wpa_global *global,
6116 : : char *cmd)
6117 : : {
6118 : : struct wpa_interface iface;
6119 : : char *pos;
6120 : :
6121 : : /*
6122 : : * <ifname>TAB<confname>TAB<driver>TAB<ctrl_interface>TAB<driver_param>
6123 : : * TAB<bridge_ifname>
6124 : : */
6125 : 8 : wpa_printf(MSG_DEBUG, "CTRL_IFACE GLOBAL INTERFACE_ADD '%s'", cmd);
6126 : :
6127 : 8 : os_memset(&iface, 0, sizeof(iface));
6128 : :
6129 : : do {
6130 : 8 : iface.ifname = pos = cmd;
6131 : 8 : pos = os_strchr(pos, '\t');
6132 [ + - ]: 8 : if (pos)
6133 : 8 : *pos++ = '\0';
6134 [ - + ]: 8 : if (iface.ifname[0] == '\0')
6135 : 0 : return -1;
6136 [ - + ]: 8 : if (pos == NULL)
6137 : 0 : break;
6138 : :
6139 : 8 : iface.confname = pos;
6140 : 8 : pos = os_strchr(pos, '\t');
6141 [ + - ]: 8 : if (pos)
6142 : 8 : *pos++ = '\0';
6143 [ + - ]: 8 : if (iface.confname[0] == '\0')
6144 : 8 : iface.confname = NULL;
6145 [ - + ]: 8 : if (pos == NULL)
6146 : 0 : break;
6147 : :
6148 : 8 : iface.driver = pos;
6149 : 8 : pos = os_strchr(pos, '\t');
6150 [ + - ]: 8 : if (pos)
6151 : 8 : *pos++ = '\0';
6152 [ - + ]: 8 : if (iface.driver[0] == '\0')
6153 : 0 : iface.driver = NULL;
6154 [ - + ]: 8 : if (pos == NULL)
6155 : 0 : break;
6156 : :
6157 : 8 : iface.ctrl_interface = pos;
6158 : 8 : pos = os_strchr(pos, '\t');
6159 [ + + ]: 8 : if (pos)
6160 : 5 : *pos++ = '\0';
6161 [ - + ]: 8 : if (iface.ctrl_interface[0] == '\0')
6162 : 0 : iface.ctrl_interface = NULL;
6163 [ + + ]: 8 : if (pos == NULL)
6164 : 3 : break;
6165 : :
6166 : 5 : iface.driver_param = pos;
6167 : 5 : pos = os_strchr(pos, '\t');
6168 [ - + ]: 5 : if (pos)
6169 : 0 : *pos++ = '\0';
6170 [ - + ]: 5 : if (iface.driver_param[0] == '\0')
6171 : 0 : iface.driver_param = NULL;
6172 [ + - ]: 5 : if (pos == NULL)
6173 : 5 : break;
6174 : :
6175 : 0 : iface.bridge_ifname = pos;
6176 : 0 : pos = os_strchr(pos, '\t');
6177 [ # # ]: 0 : if (pos)
6178 : 0 : *pos++ = '\0';
6179 [ # # ]: 0 : if (iface.bridge_ifname[0] == '\0')
6180 : 0 : iface.bridge_ifname = NULL;
6181 [ # # ]: 0 : if (pos == NULL)
6182 : 0 : break;
6183 : : } while (0);
6184 : :
6185 [ - + ]: 8 : if (wpa_supplicant_get_iface(global, iface.ifname))
6186 : 0 : return -1;
6187 : :
6188 [ + - ]: 8 : return wpa_supplicant_add_iface(global, &iface) ? 0 : -1;
6189 : : }
6190 : :
6191 : :
6192 : 242 : static int wpa_supplicant_global_iface_remove(struct wpa_global *global,
6193 : : char *cmd)
6194 : : {
6195 : : struct wpa_supplicant *wpa_s;
6196 : :
6197 : 242 : wpa_printf(MSG_DEBUG, "CTRL_IFACE GLOBAL INTERFACE_REMOVE '%s'", cmd);
6198 : :
6199 : 242 : wpa_s = wpa_supplicant_get_iface(global, cmd);
6200 [ + + ]: 242 : if (wpa_s == NULL)
6201 : 234 : return -1;
6202 : 242 : return wpa_supplicant_remove_iface(global, wpa_s, 0);
6203 : : }
6204 : :
6205 : :
6206 : 0 : static void wpa_free_iface_info(struct wpa_interface_info *iface)
6207 : : {
6208 : : struct wpa_interface_info *prev;
6209 : :
6210 [ # # ]: 0 : while (iface) {
6211 : 0 : prev = iface;
6212 : 0 : iface = iface->next;
6213 : :
6214 : 0 : os_free(prev->ifname);
6215 : 0 : os_free(prev->desc);
6216 : 0 : os_free(prev);
6217 : : }
6218 : 0 : }
6219 : :
6220 : :
6221 : 0 : static int wpa_supplicant_global_iface_list(struct wpa_global *global,
6222 : : char *buf, int len)
6223 : : {
6224 : : int i, res;
6225 : 0 : struct wpa_interface_info *iface = NULL, *last = NULL, *tmp;
6226 : : char *pos, *end;
6227 : :
6228 [ # # ]: 0 : for (i = 0; wpa_drivers[i]; i++) {
6229 : 0 : struct wpa_driver_ops *drv = wpa_drivers[i];
6230 [ # # ]: 0 : if (drv->get_interfaces == NULL)
6231 : 0 : continue;
6232 : 0 : tmp = drv->get_interfaces(global->drv_priv[i]);
6233 [ # # ]: 0 : if (tmp == NULL)
6234 : 0 : continue;
6235 : :
6236 [ # # ]: 0 : if (last == NULL)
6237 : 0 : iface = last = tmp;
6238 : : else
6239 : 0 : last->next = tmp;
6240 [ # # ]: 0 : while (last->next)
6241 : 0 : last = last->next;
6242 : : }
6243 : :
6244 : 0 : pos = buf;
6245 : 0 : end = buf + len;
6246 [ # # ]: 0 : for (tmp = iface; tmp; tmp = tmp->next) {
6247 [ # # ]: 0 : res = os_snprintf(pos, end - pos, "%s\t%s\t%s\n",
6248 : : tmp->drv_name, tmp->ifname,
6249 : 0 : tmp->desc ? tmp->desc : "");
6250 [ # # ][ # # ]: 0 : if (res < 0 || res >= end - pos) {
6251 : 0 : *pos = '\0';
6252 : 0 : break;
6253 : : }
6254 : 0 : pos += res;
6255 : : }
6256 : :
6257 : 0 : wpa_free_iface_info(iface);
6258 : :
6259 : 0 : return pos - buf;
6260 : : }
6261 : :
6262 : :
6263 : 0 : static int wpa_supplicant_global_iface_interfaces(struct wpa_global *global,
6264 : : char *buf, int len)
6265 : : {
6266 : : int res;
6267 : : char *pos, *end;
6268 : : struct wpa_supplicant *wpa_s;
6269 : :
6270 : 0 : wpa_s = global->ifaces;
6271 : 0 : pos = buf;
6272 : 0 : end = buf + len;
6273 : :
6274 [ # # ]: 0 : while (wpa_s) {
6275 : 0 : res = os_snprintf(pos, end - pos, "%s\n", wpa_s->ifname);
6276 [ # # ][ # # ]: 0 : if (res < 0 || res >= end - pos) {
6277 : 0 : *pos = '\0';
6278 : 0 : break;
6279 : : }
6280 : 0 : pos += res;
6281 : 0 : wpa_s = wpa_s->next;
6282 : : }
6283 : 0 : return pos - buf;
6284 : : }
6285 : :
6286 : :
6287 : 0 : static char * wpas_global_ctrl_iface_ifname(struct wpa_global *global,
6288 : : const char *ifname,
6289 : : char *cmd, size_t *resp_len)
6290 : : {
6291 : : struct wpa_supplicant *wpa_s;
6292 : :
6293 [ # # ]: 0 : for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
6294 [ # # ]: 0 : if (os_strcmp(ifname, wpa_s->ifname) == 0)
6295 : 0 : break;
6296 : : }
6297 : :
6298 [ # # ]: 0 : if (wpa_s == NULL) {
6299 : 0 : char *resp = os_strdup("FAIL-NO-IFNAME-MATCH\n");
6300 [ # # ]: 0 : if (resp)
6301 : 0 : *resp_len = os_strlen(resp);
6302 : : else
6303 : 0 : *resp_len = 1;
6304 : 0 : return resp;
6305 : : }
6306 : :
6307 : 0 : return wpa_supplicant_ctrl_iface_process(wpa_s, cmd, resp_len);
6308 : : }
6309 : :
6310 : :
6311 : 945 : static char * wpas_global_ctrl_iface_redir_p2p(struct wpa_global *global,
6312 : : char *buf, size_t *resp_len)
6313 : : {
6314 : : #ifdef CONFIG_P2P
6315 : : static const char * cmd[] = {
6316 : : "P2P_FIND",
6317 : : "P2P_STOP_FIND",
6318 : : "P2P_LISTEN",
6319 : : "P2P_GROUP_ADD",
6320 : : "P2P_GET_PASSPHRASE",
6321 : : "P2P_SERVICE_UPDATE",
6322 : : "P2P_SERVICE_FLUSH",
6323 : : "P2P_FLUSH",
6324 : : "P2P_CANCEL",
6325 : : "P2P_PRESENCE_REQ",
6326 : : "P2P_EXT_LISTEN",
6327 : : NULL
6328 : : };
6329 : : static const char * prefix[] = {
6330 : : "P2P_FIND ",
6331 : : "P2P_CONNECT ",
6332 : : "P2P_LISTEN ",
6333 : : "P2P_GROUP_REMOVE ",
6334 : : "P2P_GROUP_ADD ",
6335 : : "P2P_PROV_DISC ",
6336 : : "P2P_SERV_DISC_REQ ",
6337 : : "P2P_SERV_DISC_CANCEL_REQ ",
6338 : : "P2P_SERV_DISC_RESP ",
6339 : : "P2P_SERV_DISC_EXTERNAL ",
6340 : : "P2P_SERVICE_ADD ",
6341 : : "P2P_SERVICE_DEL ",
6342 : : "P2P_REJECT ",
6343 : : "P2P_INVITE ",
6344 : : "P2P_PEER ",
6345 : : "P2P_SET ",
6346 : : "P2P_UNAUTHORIZE ",
6347 : : "P2P_PRESENCE_REQ ",
6348 : : "P2P_EXT_LISTEN ",
6349 : : "P2P_REMOVE_CLIENT ",
6350 : : NULL
6351 : : };
6352 : 945 : int found = 0;
6353 : : int i;
6354 : :
6355 [ + + ]: 945 : if (global->p2p_init_wpa_s == NULL)
6356 : 242 : return NULL;
6357 : :
6358 [ + + ][ + + ]: 7480 : for (i = 0; !found && cmd[i]; i++) {
6359 [ + + ]: 6777 : if (os_strcmp(buf, cmd[i]) == 0)
6360 : 117 : found = 1;
6361 : : }
6362 : :
6363 [ + + ][ + + ]: 5867 : for (i = 0; !found && prefix[i]; i++) {
6364 [ + + ]: 5164 : if (os_strncmp(buf, prefix[i], os_strlen(prefix[i])) == 0)
6365 : 575 : found = 1;
6366 : : }
6367 : :
6368 [ + + ]: 703 : if (found)
6369 : 692 : return wpa_supplicant_ctrl_iface_process(global->p2p_init_wpa_s,
6370 : : buf, resp_len);
6371 : : #endif /* CONFIG_P2P */
6372 : 945 : return NULL;
6373 : : }
6374 : :
6375 : :
6376 : 253 : static char * wpas_global_ctrl_iface_redir_wfd(struct wpa_global *global,
6377 : : char *buf, size_t *resp_len)
6378 : : {
6379 : : #ifdef CONFIG_WIFI_DISPLAY
6380 [ + + ]: 253 : if (global->p2p_init_wpa_s == NULL)
6381 : 242 : return NULL;
6382 [ + - ][ - + ]: 11 : if (os_strncmp(buf, "WFD_SUBELEM_SET ", 16) == 0 ||
6383 : 11 : os_strncmp(buf, "WFD_SUBELEM_GET ", 16) == 0)
6384 : 0 : return wpa_supplicant_ctrl_iface_process(global->p2p_init_wpa_s,
6385 : : buf, resp_len);
6386 : : #endif /* CONFIG_WIFI_DISPLAY */
6387 : 253 : return NULL;
6388 : : }
6389 : :
6390 : :
6391 : 945 : static char * wpas_global_ctrl_iface_redir(struct wpa_global *global,
6392 : : char *buf, size_t *resp_len)
6393 : : {
6394 : : char *ret;
6395 : :
6396 : 945 : ret = wpas_global_ctrl_iface_redir_p2p(global, buf, resp_len);
6397 [ + + ]: 945 : if (ret)
6398 : 692 : return ret;
6399 : :
6400 : 253 : ret = wpas_global_ctrl_iface_redir_wfd(global, buf, resp_len);
6401 [ - + ]: 253 : if (ret)
6402 : 0 : return ret;
6403 : :
6404 : 945 : return NULL;
6405 : : }
6406 : :
6407 : :
6408 : 0 : static int wpas_global_ctrl_iface_set(struct wpa_global *global, char *cmd)
6409 : : {
6410 : : char *value;
6411 : :
6412 : 0 : value = os_strchr(cmd, ' ');
6413 [ # # ]: 0 : if (value == NULL)
6414 : 0 : return -1;
6415 : 0 : *value++ = '\0';
6416 : :
6417 : 0 : wpa_printf(MSG_DEBUG, "GLOBAL_CTRL_IFACE SET '%s'='%s'", cmd, value);
6418 : :
6419 : : #ifdef CONFIG_WIFI_DISPLAY
6420 [ # # ]: 0 : if (os_strcasecmp(cmd, "wifi_display") == 0) {
6421 : 0 : wifi_display_enable(global, !!atoi(value));
6422 : 0 : return 0;
6423 : : }
6424 : : #endif /* CONFIG_WIFI_DISPLAY */
6425 : :
6426 : 0 : return -1;
6427 : : }
6428 : :
6429 : :
6430 : : #ifndef CONFIG_NO_CONFIG_WRITE
6431 : 0 : static int wpas_global_ctrl_iface_save_config(struct wpa_global *global)
6432 : : {
6433 : 0 : int ret = 0;
6434 : : struct wpa_supplicant *wpa_s;
6435 : :
6436 [ # # ]: 0 : for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
6437 [ # # ]: 0 : if (!wpa_s->conf->update_config) {
6438 : 0 : wpa_dbg(wpa_s, MSG_DEBUG, "CTRL_IFACE: SAVE_CONFIG - Not allowed to update configuration (update_config=0)");
6439 : 0 : continue;
6440 : : }
6441 : :
6442 [ # # ]: 0 : if (wpa_config_write(wpa_s->confname, wpa_s->conf)) {
6443 : 0 : wpa_dbg(wpa_s, MSG_DEBUG, "CTRL_IFACE: SAVE_CONFIG - Failed to update configuration");
6444 : 0 : ret = 1;
6445 : : } else {
6446 : 0 : wpa_dbg(wpa_s, MSG_DEBUG, "CTRL_IFACE: SAVE_CONFIG - Configuration updated");
6447 : : }
6448 : : }
6449 : :
6450 : 0 : return ret;
6451 : : }
6452 : : #endif /* CONFIG_NO_CONFIG_WRITE */
6453 : :
6454 : :
6455 : 0 : static int wpas_global_ctrl_iface_status(struct wpa_global *global,
6456 : : char *buf, size_t buflen)
6457 : : {
6458 : : char *pos, *end;
6459 : : int ret;
6460 : : struct wpa_supplicant *wpa_s;
6461 : :
6462 : 0 : pos = buf;
6463 : 0 : end = buf + buflen;
6464 : :
6465 : : #ifdef CONFIG_P2P
6466 [ # # ][ # # ]: 0 : if (global->p2p && !global->p2p_disabled) {
6467 : 0 : ret = os_snprintf(pos, end - pos, "p2p_device_address=" MACSTR
6468 : : "\n"
6469 : : "p2p_state=%s\n",
6470 : 0 : MAC2STR(global->p2p_dev_addr),
6471 : : p2p_get_state_txt(global->p2p));
6472 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
6473 : 0 : return pos - buf;
6474 : 0 : pos += ret;
6475 [ # # ]: 0 : } else if (global->p2p) {
6476 : 0 : ret = os_snprintf(pos, end - pos, "p2p_state=DISABLED\n");
6477 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
6478 : 0 : return pos - buf;
6479 : 0 : pos += ret;
6480 : : }
6481 : : #endif /* CONFIG_P2P */
6482 : :
6483 : : #ifdef CONFIG_WIFI_DISPLAY
6484 : 0 : ret = os_snprintf(pos, end - pos, "wifi_display=%d\n",
6485 : 0 : !!global->wifi_display);
6486 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
6487 : 0 : return pos - buf;
6488 : 0 : pos += ret;
6489 : : #endif /* CONFIG_WIFI_DISPLAY */
6490 : :
6491 [ # # ]: 0 : for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
6492 : 0 : ret = os_snprintf(pos, end - pos, "ifname=%s\n"
6493 : : "address=" MACSTR "\n",
6494 : 0 : wpa_s->ifname, MAC2STR(wpa_s->own_addr));
6495 [ # # ][ # # ]: 0 : if (ret < 0 || ret >= end - pos)
6496 : 0 : return pos - buf;
6497 : 0 : pos += ret;
6498 : : }
6499 : :
6500 : 0 : return pos - buf;
6501 : : }
6502 : :
6503 : :
6504 : 945 : char * wpa_supplicant_global_ctrl_iface_process(struct wpa_global *global,
6505 : : char *buf, size_t *resp_len)
6506 : : {
6507 : : char *reply;
6508 : 945 : const int reply_size = 2048;
6509 : : int reply_len;
6510 : 945 : int level = MSG_DEBUG;
6511 : :
6512 [ - + ]: 945 : if (os_strncmp(buf, "IFNAME=", 7) == 0) {
6513 : 0 : char *pos = os_strchr(buf + 7, ' ');
6514 [ # # ]: 0 : if (pos) {
6515 : 0 : *pos++ = '\0';
6516 : 0 : return wpas_global_ctrl_iface_ifname(global,
6517 : : buf + 7, pos,
6518 : : resp_len);
6519 : : }
6520 : : }
6521 : :
6522 : 945 : reply = wpas_global_ctrl_iface_redir(global, buf, resp_len);
6523 [ + + ]: 945 : if (reply)
6524 : 692 : return reply;
6525 : :
6526 [ + + ]: 253 : if (os_strcmp(buf, "PING") == 0)
6527 : 3 : level = MSG_EXCESSIVE;
6528 : 253 : wpa_hexdump_ascii(level, "RX global ctrl_iface",
6529 : : (const u8 *) buf, os_strlen(buf));
6530 : :
6531 : 253 : reply = os_malloc(reply_size);
6532 [ - + ]: 253 : if (reply == NULL) {
6533 : 0 : *resp_len = 1;
6534 : 0 : return NULL;
6535 : : }
6536 : :
6537 : 253 : os_memcpy(reply, "OK\n", 3);
6538 : 253 : reply_len = 3;
6539 : :
6540 [ + + ]: 253 : if (os_strcmp(buf, "PING") == 0) {
6541 : 3 : os_memcpy(reply, "PONG\n", 5);
6542 : 3 : reply_len = 5;
6543 [ + + ]: 250 : } else if (os_strncmp(buf, "INTERFACE_ADD ", 14) == 0) {
6544 [ - + ]: 8 : if (wpa_supplicant_global_iface_add(global, buf + 14))
6545 : 0 : reply_len = -1;
6546 [ + - ]: 242 : } else if (os_strncmp(buf, "INTERFACE_REMOVE ", 17) == 0) {
6547 [ + + ]: 242 : if (wpa_supplicant_global_iface_remove(global, buf + 17))
6548 : 234 : reply_len = -1;
6549 [ # # ]: 0 : } else if (os_strcmp(buf, "INTERFACE_LIST") == 0) {
6550 : 0 : reply_len = wpa_supplicant_global_iface_list(
6551 : : global, reply, reply_size);
6552 [ # # ]: 0 : } else if (os_strcmp(buf, "INTERFACES") == 0) {
6553 : 0 : reply_len = wpa_supplicant_global_iface_interfaces(
6554 : : global, reply, reply_size);
6555 [ # # ]: 0 : } else if (os_strcmp(buf, "TERMINATE") == 0) {
6556 : 0 : wpa_supplicant_terminate_proc(global);
6557 [ # # ]: 0 : } else if (os_strcmp(buf, "SUSPEND") == 0) {
6558 : 0 : wpas_notify_suspend(global);
6559 [ # # ]: 0 : } else if (os_strcmp(buf, "RESUME") == 0) {
6560 : 0 : wpas_notify_resume(global);
6561 [ # # ]: 0 : } else if (os_strncmp(buf, "SET ", 4) == 0) {
6562 [ # # ]: 0 : if (wpas_global_ctrl_iface_set(global, buf + 4))
6563 : 0 : reply_len = -1;
6564 : : #ifndef CONFIG_NO_CONFIG_WRITE
6565 [ # # ]: 0 : } else if (os_strcmp(buf, "SAVE_CONFIG") == 0) {
6566 [ # # ]: 0 : if (wpas_global_ctrl_iface_save_config(global))
6567 : 0 : reply_len = -1;
6568 : : #endif /* CONFIG_NO_CONFIG_WRITE */
6569 [ # # ]: 0 : } else if (os_strcmp(buf, "STATUS") == 0) {
6570 : 0 : reply_len = wpas_global_ctrl_iface_status(global, reply,
6571 : : reply_size);
6572 : : } else {
6573 : 0 : os_memcpy(reply, "UNKNOWN COMMAND\n", 16);
6574 : 0 : reply_len = 16;
6575 : : }
6576 : :
6577 [ + + ]: 253 : if (reply_len < 0) {
6578 : 234 : os_memcpy(reply, "FAIL\n", 5);
6579 : 234 : reply_len = 5;
6580 : : }
6581 : :
6582 : 253 : *resp_len = reply_len;
6583 : 945 : return reply;
6584 : : }
|
