Line data Source code
1 : /*
2 : * WPA Supplicant - Basic mesh mode routines
3 : * Copyright (c) 2013-2014, cozybit, Inc. All rights reserved.
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/ieee802_11_defs.h"
15 : #include "common/wpa_ctrl.h"
16 : #include "ap/sta_info.h"
17 : #include "ap/hostapd.h"
18 : #include "ap/ieee802_11.h"
19 : #include "config_ssid.h"
20 : #include "config.h"
21 : #include "wpa_supplicant_i.h"
22 : #include "driver_i.h"
23 : #include "notify.h"
24 : #include "ap.h"
25 : #include "mesh_mpm.h"
26 : #include "mesh_rsn.h"
27 : #include "mesh.h"
28 :
29 :
30 58 : static void wpa_supplicant_mesh_deinit(struct wpa_supplicant *wpa_s)
31 : {
32 58 : wpa_supplicant_mesh_iface_deinit(wpa_s, wpa_s->ifmsh);
33 58 : wpa_s->ifmsh = NULL;
34 58 : wpa_s->current_ssid = NULL;
35 58 : os_free(wpa_s->mesh_rsn);
36 58 : wpa_s->mesh_rsn = NULL;
37 : /* TODO: leave mesh (stop beacon). This will happen on link down
38 : * anyway, so it's not urgent */
39 58 : }
40 :
41 :
42 58 : void wpa_supplicant_mesh_iface_deinit(struct wpa_supplicant *wpa_s,
43 : struct hostapd_iface *ifmsh)
44 : {
45 58 : if (!ifmsh)
46 87 : return;
47 :
48 29 : if (ifmsh->mconf) {
49 29 : mesh_mpm_deinit(wpa_s, ifmsh);
50 29 : if (ifmsh->mconf->ies) {
51 7 : ifmsh->mconf->ies = NULL;
52 : /* We cannot free this struct
53 : * because wpa_authenticator on
54 : * hostapd side is also using it
55 : * for now just set to NULL and
56 : * let hostapd code free it.
57 : */
58 : }
59 29 : os_free(ifmsh->mconf);
60 29 : ifmsh->mconf = NULL;
61 : }
62 :
63 : /* take care of shared data */
64 29 : hostapd_interface_deinit(ifmsh);
65 29 : hostapd_interface_free(ifmsh);
66 : }
67 :
68 :
69 29 : static struct mesh_conf * mesh_config_create(struct wpa_ssid *ssid)
70 : {
71 : struct mesh_conf *conf;
72 :
73 29 : conf = os_zalloc(sizeof(struct mesh_conf));
74 29 : if (!conf)
75 0 : return NULL;
76 :
77 29 : os_memcpy(conf->meshid, ssid->ssid, ssid->ssid_len);
78 29 : conf->meshid_len = ssid->ssid_len;
79 :
80 29 : if (ssid->key_mgmt & WPA_KEY_MGMT_SAE)
81 8 : conf->security |= MESH_CONF_SEC_AUTH |
82 : MESH_CONF_SEC_AMPE;
83 : else
84 21 : conf->security |= MESH_CONF_SEC_NONE;
85 :
86 : /* defaults */
87 29 : conf->mesh_pp_id = MESH_PATH_PROTOCOL_HWMP;
88 29 : conf->mesh_pm_id = MESH_PATH_METRIC_AIRTIME;
89 29 : conf->mesh_cc_id = 0;
90 29 : conf->mesh_sp_id = MESH_SYNC_METHOD_NEIGHBOR_OFFSET;
91 29 : conf->mesh_auth_id = (conf->security & MESH_CONF_SEC_AUTH) ? 1 : 0;
92 29 : conf->dot11MeshMaxRetries = ssid->dot11MeshMaxRetries;
93 29 : conf->dot11MeshRetryTimeout = ssid->dot11MeshRetryTimeout;
94 29 : conf->dot11MeshConfirmTimeout = ssid->dot11MeshConfirmTimeout;
95 29 : conf->dot11MeshHoldingTimeout = ssid->dot11MeshHoldingTimeout;
96 :
97 29 : return conf;
98 : }
99 :
100 :
101 5 : static void wpas_mesh_copy_groups(struct hostapd_data *bss,
102 : struct wpa_supplicant *wpa_s)
103 : {
104 : int num_groups;
105 : size_t groups_size;
106 :
107 16 : for (num_groups = 0; wpa_s->conf->sae_groups[num_groups] > 0;
108 6 : num_groups++)
109 : ;
110 :
111 5 : groups_size = (num_groups + 1) * sizeof(wpa_s->conf->sae_groups[0]);
112 5 : bss->conf->sae_groups = os_malloc(groups_size);
113 5 : if (bss->conf->sae_groups)
114 5 : os_memcpy(bss->conf->sae_groups, wpa_s->conf->sae_groups,
115 : groups_size);
116 5 : }
117 :
118 :
119 29 : static int wpa_supplicant_mesh_init(struct wpa_supplicant *wpa_s,
120 : struct wpa_ssid *ssid)
121 : {
122 : struct hostapd_iface *ifmsh;
123 : struct hostapd_data *bss;
124 : struct hostapd_config *conf;
125 : struct mesh_conf *mconf;
126 29 : int basic_rates_erp[] = { 10, 20, 55, 60, 110, 120, 240, -1 };
127 : static int default_groups[] = { 19, 20, 21, 25, 26, -1 };
128 : size_t len;
129 : int rate_len;
130 :
131 29 : if (!wpa_s->conf->user_mpm) {
132 : /* not much for us to do here */
133 0 : wpa_msg(wpa_s, MSG_WARNING,
134 : "user_mpm is not enabled in configuration");
135 0 : return 0;
136 : }
137 :
138 29 : wpa_s->ifmsh = ifmsh = os_zalloc(sizeof(*wpa_s->ifmsh));
139 29 : if (!ifmsh)
140 0 : return -ENOMEM;
141 :
142 29 : ifmsh->drv_flags = wpa_s->drv_flags;
143 29 : ifmsh->num_bss = 1;
144 29 : ifmsh->bss = os_calloc(wpa_s->ifmsh->num_bss,
145 : sizeof(struct hostapd_data *));
146 29 : if (!ifmsh->bss)
147 0 : goto out_free;
148 :
149 29 : ifmsh->bss[0] = bss = os_zalloc(sizeof(struct hostapd_data));
150 29 : if (!bss)
151 0 : goto out_free;
152 :
153 29 : os_memcpy(bss->own_addr, wpa_s->own_addr, ETH_ALEN);
154 29 : bss->driver = wpa_s->driver;
155 29 : bss->drv_priv = wpa_s->drv_priv;
156 29 : bss->iface = ifmsh;
157 29 : bss->mesh_sta_free_cb = mesh_mpm_free_sta;
158 29 : wpa_s->assoc_freq = ssid->frequency;
159 29 : wpa_s->current_ssid = ssid;
160 :
161 : /* setup an AP config for auth processing */
162 29 : conf = hostapd_config_defaults();
163 29 : if (!conf)
164 0 : goto out_free;
165 :
166 29 : bss->conf = *conf->bss;
167 29 : bss->conf->start_disabled = 1;
168 29 : bss->conf->mesh = MESH_ENABLED;
169 29 : bss->conf->ap_max_inactivity = wpa_s->conf->mesh_max_inactivity;
170 29 : bss->iconf = conf;
171 29 : ifmsh->conf = conf;
172 :
173 29 : ifmsh->bss[0]->max_plinks = wpa_s->conf->max_peer_links;
174 29 : os_strlcpy(bss->conf->iface, wpa_s->ifname, sizeof(bss->conf->iface));
175 :
176 29 : mconf = mesh_config_create(ssid);
177 29 : if (!mconf)
178 0 : goto out_free;
179 29 : ifmsh->mconf = mconf;
180 :
181 : /* need conf->hw_mode for supported rates. */
182 29 : if (ssid->frequency == 0) {
183 0 : conf->hw_mode = HOSTAPD_MODE_IEEE80211G;
184 0 : conf->channel = 1;
185 : } else {
186 29 : conf->hw_mode = ieee80211_freq_to_chan(ssid->frequency,
187 : &conf->channel);
188 : }
189 29 : if (conf->hw_mode == NUM_HOSTAPD_MODES) {
190 0 : wpa_printf(MSG_ERROR, "Unsupported mesh mode frequency: %d MHz",
191 : ssid->frequency);
192 0 : goto out_free;
193 : }
194 :
195 29 : if (ssid->mesh_basic_rates == NULL) {
196 : /*
197 : * XXX: Hack! This is so an MPM which correctly sets the ERP
198 : * mandatory rates as BSSBasicRateSet doesn't reject us. We
199 : * could add a new hw_mode HOSTAPD_MODE_IEEE80211G_ERP, but
200 : * this is way easier. This also makes our BSSBasicRateSet
201 : * advertised in beacons match the one in peering frames, sigh.
202 : */
203 29 : if (conf->hw_mode == HOSTAPD_MODE_IEEE80211G) {
204 27 : conf->basic_rates = os_malloc(sizeof(basic_rates_erp));
205 27 : if (!conf->basic_rates)
206 0 : goto out_free;
207 27 : os_memcpy(conf->basic_rates, basic_rates_erp,
208 : sizeof(basic_rates_erp));
209 : }
210 : } else {
211 0 : rate_len = 0;
212 : while (1) {
213 0 : if (ssid->mesh_basic_rates[rate_len] < 1)
214 0 : break;
215 0 : rate_len++;
216 0 : }
217 0 : conf->basic_rates = os_calloc(rate_len + 1, sizeof(int));
218 0 : if (conf->basic_rates == NULL)
219 0 : goto out_free;
220 0 : os_memcpy(conf->basic_rates, ssid->mesh_basic_rates,
221 : rate_len * sizeof(int));
222 0 : conf->basic_rates[rate_len] = -1;
223 : }
224 :
225 29 : if (hostapd_setup_interface(ifmsh)) {
226 0 : wpa_printf(MSG_ERROR,
227 : "Failed to initialize hostapd interface for mesh");
228 0 : return -1;
229 : }
230 :
231 29 : if (wpa_drv_init_mesh(wpa_s)) {
232 0 : wpa_msg(wpa_s, MSG_ERROR, "Failed to init mesh in driver");
233 0 : return -1;
234 : }
235 :
236 29 : if (mconf->security != MESH_CONF_SEC_NONE) {
237 8 : if (ssid->passphrase == NULL) {
238 1 : wpa_printf(MSG_ERROR,
239 : "mesh: Passphrase for SAE not configured");
240 1 : goto out_free;
241 : }
242 :
243 7 : bss->conf->wpa = ssid->proto;
244 7 : bss->conf->wpa_key_mgmt = ssid->key_mgmt;
245 :
246 14 : if (wpa_s->conf->sae_groups &&
247 7 : wpa_s->conf->sae_groups[0] > 0) {
248 5 : wpas_mesh_copy_groups(bss, wpa_s);
249 : } else {
250 4 : bss->conf->sae_groups =
251 2 : os_malloc(sizeof(default_groups));
252 2 : if (!bss->conf->sae_groups)
253 0 : goto out_free;
254 2 : os_memcpy(bss->conf->sae_groups, default_groups,
255 : sizeof(default_groups));
256 : }
257 :
258 7 : len = os_strlen(ssid->passphrase);
259 14 : bss->conf->ssid.wpa_passphrase =
260 7 : dup_binstr(ssid->passphrase, len);
261 :
262 7 : wpa_s->mesh_rsn = mesh_rsn_auth_init(wpa_s, mconf);
263 7 : if (!wpa_s->mesh_rsn)
264 0 : goto out_free;
265 : }
266 :
267 28 : wpa_supplicant_conf_ap_ht(wpa_s, ssid, conf);
268 :
269 28 : return 0;
270 : out_free:
271 1 : wpa_supplicant_mesh_deinit(wpa_s);
272 1 : return -ENOMEM;
273 : }
274 :
275 :
276 50 : void wpa_mesh_notify_peer(struct wpa_supplicant *wpa_s, const u8 *addr,
277 : const u8 *ies, size_t ie_len)
278 : {
279 : struct ieee802_11_elems elems;
280 :
281 300 : wpa_msg(wpa_s, MSG_INFO,
282 300 : "new peer notification for " MACSTR, MAC2STR(addr));
283 :
284 50 : if (ieee802_11_parse_elems(ies, ie_len, &elems, 0) == ParseFailed) {
285 0 : wpa_msg(wpa_s, MSG_INFO, "Could not parse beacon from " MACSTR,
286 0 : MAC2STR(addr));
287 50 : return;
288 : }
289 50 : wpa_mesh_new_mesh_peer(wpa_s, addr, &elems);
290 : }
291 :
292 :
293 1953 : void wpa_supplicant_mesh_add_scan_ie(struct wpa_supplicant *wpa_s,
294 : struct wpabuf **extra_ie)
295 : {
296 : /* EID + 0-length (wildcard) mesh-id */
297 1953 : size_t ielen = 2;
298 :
299 1953 : if (wpabuf_resize(extra_ie, ielen) == 0) {
300 1953 : wpabuf_put_u8(*extra_ie, WLAN_EID_MESH_ID);
301 1953 : wpabuf_put_u8(*extra_ie, 0);
302 : }
303 1953 : }
304 :
305 :
306 29 : int wpa_supplicant_join_mesh(struct wpa_supplicant *wpa_s,
307 : struct wpa_ssid *ssid)
308 : {
309 : struct wpa_driver_mesh_join_params params;
310 29 : int ret = 0;
311 :
312 29 : if (!ssid || !ssid->ssid || !ssid->ssid_len || !ssid->frequency) {
313 0 : ret = -ENOENT;
314 0 : goto out;
315 : }
316 :
317 29 : wpa_supplicant_mesh_deinit(wpa_s);
318 :
319 29 : os_memset(¶ms, 0, sizeof(params));
320 29 : params.meshid = ssid->ssid;
321 29 : params.meshid_len = ssid->ssid_len;
322 29 : ibss_mesh_setup_freq(wpa_s, ssid, ¶ms.freq);
323 29 : wpa_s->mesh_ht_enabled = !!params.freq.ht_enabled;
324 29 : if (ssid->beacon_int > 0)
325 3 : params.beacon_int = ssid->beacon_int;
326 26 : else if (wpa_s->conf->beacon_int > 0)
327 0 : params.beacon_int = wpa_s->conf->beacon_int;
328 29 : params.max_peer_links = wpa_s->conf->max_peer_links;
329 :
330 29 : if (ssid->key_mgmt & WPA_KEY_MGMT_SAE) {
331 8 : params.flags |= WPA_DRIVER_MESH_FLAG_SAE_AUTH;
332 8 : params.flags |= WPA_DRIVER_MESH_FLAG_AMPE;
333 8 : wpa_s->conf->user_mpm = 1;
334 : }
335 :
336 29 : if (wpa_s->conf->user_mpm) {
337 29 : params.flags |= WPA_DRIVER_MESH_FLAG_USER_MPM;
338 29 : params.conf.flags &= ~WPA_DRIVER_MESH_CONF_FLAG_AUTO_PLINKS;
339 : } else {
340 0 : params.flags |= WPA_DRIVER_MESH_FLAG_DRIVER_MPM;
341 0 : params.conf.flags |= WPA_DRIVER_MESH_CONF_FLAG_AUTO_PLINKS;
342 : }
343 29 : params.conf.peer_link_timeout = wpa_s->conf->mesh_max_inactivity;
344 :
345 29 : if (wpa_supplicant_mesh_init(wpa_s, ssid)) {
346 1 : wpa_msg(wpa_s, MSG_ERROR, "Failed to init mesh");
347 1 : ret = -1;
348 1 : goto out;
349 : }
350 :
351 28 : if (wpa_s->ifmsh) {
352 28 : params.ies = wpa_s->ifmsh->mconf->ies;
353 28 : params.ie_len = wpa_s->ifmsh->mconf->ie_len;
354 28 : params.basic_rates = wpa_s->ifmsh->basic_rates;
355 : }
356 :
357 56 : wpa_msg(wpa_s, MSG_INFO, "joining mesh %s",
358 28 : wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
359 28 : ret = wpa_drv_join_mesh(wpa_s, ¶ms);
360 28 : if (ret)
361 0 : wpa_msg(wpa_s, MSG_ERROR, "mesh join error=%d\n", ret);
362 :
363 : /* hostapd sets the interface down until we associate */
364 28 : wpa_drv_set_operstate(wpa_s, 1);
365 :
366 : out:
367 29 : return ret;
368 : }
369 :
370 :
371 28 : int wpa_supplicant_leave_mesh(struct wpa_supplicant *wpa_s)
372 : {
373 28 : int ret = 0;
374 :
375 28 : wpa_msg(wpa_s, MSG_INFO, "leaving mesh");
376 :
377 : /* Need to send peering close messages first */
378 28 : wpa_supplicant_mesh_deinit(wpa_s);
379 :
380 28 : ret = wpa_drv_leave_mesh(wpa_s);
381 28 : if (ret)
382 0 : wpa_msg(wpa_s, MSG_ERROR, "mesh leave error=%d", ret);
383 :
384 28 : wpa_drv_set_operstate(wpa_s, 1);
385 :
386 28 : return ret;
387 : }
388 :
389 :
390 398 : static int mesh_attr_text(const u8 *ies, size_t ies_len, char *buf, char *end)
391 : {
392 : struct ieee802_11_elems elems;
393 398 : char *mesh_id, *pos = buf;
394 : u8 *bss_basic_rate_set;
395 : int bss_basic_rate_set_len, ret, i;
396 :
397 398 : if (ieee802_11_parse_elems(ies, ies_len, &elems, 0) == ParseFailed)
398 0 : return -1;
399 :
400 398 : if (elems.mesh_id_len < 1)
401 397 : return 0;
402 :
403 1 : mesh_id = os_malloc(elems.mesh_id_len + 1);
404 1 : if (mesh_id == NULL)
405 0 : return -1;
406 :
407 1 : os_memcpy(mesh_id, elems.mesh_id, elems.mesh_id_len);
408 1 : mesh_id[elems.mesh_id_len] = '\0';
409 1 : ret = os_snprintf(pos, end - pos, "mesh_id=%s\n", mesh_id);
410 1 : os_free(mesh_id);
411 1 : if (os_snprintf_error(end - pos, ret))
412 0 : return pos - buf;
413 1 : pos += ret;
414 :
415 1 : if (elems.mesh_config_len > 6) {
416 7 : ret = os_snprintf(pos, end - pos,
417 : "active_path_selection_protocol_id=0x%02x\n"
418 : "active_path_selection_metric_id=0x%02x\n"
419 : "congestion_control_mode_id=0x%02x\n"
420 : "synchronization_method_id=0x%02x\n"
421 : "authentication_protocol_id=0x%02x\n"
422 : "mesh_formation_info=0x%02x\n"
423 : "mesh_capability=0x%02x\n",
424 2 : elems.mesh_config[0], elems.mesh_config[1],
425 2 : elems.mesh_config[2], elems.mesh_config[3],
426 2 : elems.mesh_config[4], elems.mesh_config[5],
427 1 : elems.mesh_config[6]);
428 1 : if (os_snprintf_error(end - pos, ret))
429 0 : return pos - buf;
430 1 : pos += ret;
431 : }
432 :
433 2 : bss_basic_rate_set = os_malloc(elems.supp_rates_len +
434 1 : elems.ext_supp_rates_len);
435 1 : if (bss_basic_rate_set == NULL)
436 0 : return -1;
437 :
438 1 : bss_basic_rate_set_len = 0;
439 9 : for (i = 0; i < elems.supp_rates_len; i++) {
440 8 : if (elems.supp_rates[i] & 0x80) {
441 12 : bss_basic_rate_set[bss_basic_rate_set_len++] =
442 6 : (elems.supp_rates[i] & 0x7f) * 5;
443 : }
444 : }
445 5 : for (i = 0; i < elems.ext_supp_rates_len; i++) {
446 4 : if (elems.ext_supp_rates[i] & 0x80) {
447 2 : bss_basic_rate_set[bss_basic_rate_set_len++] =
448 1 : (elems.ext_supp_rates[i] & 0x7f) * 5;
449 : }
450 : }
451 1 : if (bss_basic_rate_set_len > 0) {
452 1 : ret = os_snprintf(pos, end - pos, "bss_basic_rate_set=%d",
453 1 : bss_basic_rate_set[0]);
454 1 : if (os_snprintf_error(end - pos, ret))
455 0 : return pos - buf;
456 1 : pos += ret;
457 :
458 7 : for (i = 1; i < bss_basic_rate_set_len; i++) {
459 6 : ret = os_snprintf(pos, end - pos, " %d",
460 6 : bss_basic_rate_set[i]);
461 6 : if (os_snprintf_error(end - pos, ret))
462 0 : return pos - buf;
463 6 : pos += ret;
464 : }
465 :
466 1 : ret = os_snprintf(pos, end - pos, "\n");
467 1 : if (os_snprintf_error(end - pos, ret))
468 0 : return pos - buf;
469 1 : pos += ret;
470 : }
471 1 : os_free(bss_basic_rate_set);
472 :
473 1 : return pos - buf;
474 : }
475 :
476 :
477 398 : int wpas_mesh_scan_result_text(const u8 *ies, size_t ies_len, char *buf,
478 : char *end)
479 : {
480 398 : return mesh_attr_text(ies, ies_len, buf, end);
481 : }
482 :
483 :
484 2 : static int wpas_mesh_get_ifname(struct wpa_supplicant *wpa_s, char *ifname,
485 : size_t len)
486 : {
487 2 : char *ifname_ptr = wpa_s->ifname;
488 : int res;
489 :
490 2 : res = os_snprintf(ifname, len, "mesh-%s-%d", ifname_ptr,
491 : wpa_s->mesh_if_idx);
492 4 : if (os_snprintf_error(len, res) ||
493 2 : (os_strlen(ifname) >= IFNAMSIZ &&
494 0 : os_strlen(wpa_s->ifname) < IFNAMSIZ)) {
495 : /* Try to avoid going over the IFNAMSIZ length limit */
496 0 : res = os_snprintf(ifname, len, "mesh-%d", wpa_s->mesh_if_idx);
497 0 : if (os_snprintf_error(len, res))
498 0 : return -1;
499 : }
500 2 : wpa_s->mesh_if_idx++;
501 2 : return 0;
502 : }
503 :
504 :
505 4 : int wpas_mesh_add_interface(struct wpa_supplicant *wpa_s, char *ifname,
506 : size_t len)
507 : {
508 : struct wpa_interface iface;
509 : struct wpa_supplicant *mesh_wpa_s;
510 : u8 addr[ETH_ALEN];
511 :
512 4 : if (ifname[0] == '\0' && wpas_mesh_get_ifname(wpa_s, ifname, len) < 0)
513 0 : return -1;
514 :
515 4 : if (wpa_drv_if_add(wpa_s, WPA_IF_MESH, ifname, NULL, NULL, NULL, addr,
516 : NULL) < 0) {
517 0 : wpa_printf(MSG_ERROR,
518 : "mesh: Failed to create new mesh interface");
519 0 : return -1;
520 : }
521 24 : wpa_printf(MSG_INFO, "mesh: Created virtual interface %s addr "
522 24 : MACSTR, ifname, MAC2STR(addr));
523 :
524 4 : os_memset(&iface, 0, sizeof(iface));
525 4 : iface.ifname = ifname;
526 4 : iface.driver = wpa_s->driver->name;
527 4 : iface.driver_param = wpa_s->conf->driver_param;
528 4 : iface.ctrl_interface = wpa_s->conf->ctrl_interface;
529 :
530 4 : mesh_wpa_s = wpa_supplicant_add_iface(wpa_s->global, &iface);
531 4 : if (!mesh_wpa_s) {
532 0 : wpa_printf(MSG_ERROR,
533 : "mesh: Failed to create new wpa_supplicant interface");
534 0 : wpa_supplicant_remove_iface(wpa_s->global, wpa_s, 0);
535 0 : return -1;
536 : }
537 4 : mesh_wpa_s->mesh_if_created = 1;
538 4 : mesh_wpa_s->parent = wpa_s;
539 4 : return 0;
540 : }
|
