1 /*
2  * FST module - FST group object implementation
3  * Copyright (c) 2014, Qualcomm Atheros, Inc.
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 #include "utils/common.h"
11 #include "common/defs.h"
12 #include "common/ieee802_11_defs.h"
13 #include "common/ieee802_11_common.h"
14 #include "drivers/driver.h"
15 #include "fst/fst_internal.h"
16 #include "fst/fst_defs.h"
17 
18 
19 struct dl_list fst_global_groups_list;
20 
21 
22 static void fst_dump_mb_ies(const char *group_id, const char *ifname,
23 			    struct wpabuf *mbies)
24 {
25 	const u8 *p = wpabuf_head(mbies);
26 	size_t s = wpabuf_len(mbies);
27 
28 	while (s >= 2) {
29 		const struct multi_band_ie *mbie =
30 			(const struct multi_band_ie *) p;
31 		WPA_ASSERT(mbie->eid == WLAN_EID_MULTI_BAND);
32 		WPA_ASSERT(2U + mbie->len >= sizeof(*mbie));
33 
34 		fst_printf(MSG_WARNING,
35 			   "%s: %s: mb_ctrl=%u band_id=%u op_class=%u chan=%u bssid="
36 			   MACSTR
37 			   " beacon_int=%u tsf_offs=[%u %u %u %u %u %u %u %u] mb_cc=0x%02x tmout=%u",
38 			   group_id, ifname,
39 			   mbie->mb_ctrl, mbie->band_id, mbie->op_class,
40 			   mbie->chan, MAC2STR(mbie->bssid), mbie->beacon_int,
41 			   mbie->tsf_offs[0], mbie->tsf_offs[1],
42 			   mbie->tsf_offs[2], mbie->tsf_offs[3],
43 			   mbie->tsf_offs[4], mbie->tsf_offs[5],
44 			   mbie->tsf_offs[6], mbie->tsf_offs[7],
45 			   mbie->mb_connection_capability,
46 			   mbie->fst_session_tmout);
47 
48 		p += 2 + mbie->len;
49 		s -= 2 + mbie->len;
50 	}
51 }
52 
53 
54 static void fst_fill_mb_ie(struct wpabuf *buf, const u8 *bssid,
55 			   const u8 *own_addr, enum mb_band_id band, u8 channel)
56 {
57 	struct multi_band_ie *mbie;
58 	size_t len = sizeof(*mbie);
59 
60 	if (own_addr)
61 		len += ETH_ALEN;
62 
63 	mbie = wpabuf_put(buf, len);
64 
65 	os_memset(mbie, 0, len);
66 
67 	mbie->eid = WLAN_EID_MULTI_BAND;
68 	mbie->len = len - 2;
69 #ifdef HOSTAPD
70 	mbie->mb_ctrl = MB_STA_ROLE_AP;
71 	mbie->mb_connection_capability = MB_CONNECTION_CAPABILITY_AP;
72 #else /* HOSTAPD */
73 	mbie->mb_ctrl = MB_STA_ROLE_NON_PCP_NON_AP;
74 	mbie->mb_connection_capability = 0;
75 #endif /* HOSTAPD */
76 	if (bssid)
77 		os_memcpy(mbie->bssid, bssid, ETH_ALEN);
78 	mbie->band_id = band;
79 	mbie->op_class = 0;  /* means all */
80 	mbie->chan = channel;
81 	mbie->fst_session_tmout = FST_DEFAULT_SESSION_TIMEOUT_TU;
82 
83 	if (own_addr) {
84 		mbie->mb_ctrl |= MB_CTRL_STA_MAC_PRESENT;
85 		os_memcpy(&mbie[1], own_addr, ETH_ALEN);
86 	}
87 }
88 
89 
90 static unsigned fst_fill_iface_mb_ies(struct fst_iface *f, struct wpabuf *buf)
91 {
92 	const  u8 *bssid;
93 
94 	bssid = fst_iface_get_bssid(f);
95 	if (bssid) {
96 		enum hostapd_hw_mode hw_mode;
97 		u8 channel;
98 
99 		if (buf) {
100 			fst_iface_get_channel_info(f, &hw_mode, &channel);
101 			fst_fill_mb_ie(buf, bssid, fst_iface_get_addr(f),
102 				       fst_hw_mode_to_band(hw_mode), channel);
103 		}
104 		return 1;
105 	} else {
106 		unsigned bands[MB_BAND_ID_WIFI_60GHZ + 1] = {};
107 		struct hostapd_hw_modes *modes;
108 		enum mb_band_id b;
109 		int num_modes = fst_iface_get_hw_modes(f, &modes);
110 		int ret = 0;
111 
112 		while (num_modes--) {
113 			b = fst_hw_mode_to_band(modes->mode);
114 			modes++;
115 			if (b >= ARRAY_SIZE(bands) || bands[b]++)
116 				continue;
117 			ret++;
118 			if (buf)
119 				fst_fill_mb_ie(buf, NULL, fst_iface_get_addr(f),
120 					       b, MB_STA_CHANNEL_ALL);
121 		}
122 		return ret;
123 	}
124 }
125 
126 
127 static struct wpabuf * fst_group_create_mb_ie(struct fst_group *g,
128 					      struct fst_iface *i)
129 {
130 	struct wpabuf *buf;
131 	struct fst_iface *f;
132 	unsigned int nof_mbies = 0;
133 	unsigned int nof_ifaces_added = 0;
134 
135 	foreach_fst_group_iface(g, f) {
136 		if (f == i)
137 			continue;
138 		nof_mbies += fst_fill_iface_mb_ies(f, NULL);
139 	}
140 
141 	buf = wpabuf_alloc(nof_mbies *
142 			   (sizeof(struct multi_band_ie) + ETH_ALEN));
143 	if (!buf) {
144 		fst_printf_iface(i, MSG_ERROR,
145 				 "cannot allocate mem for %u MB IEs",
146 				 nof_mbies);
147 		return NULL;
148 	}
149 
150 	/* The list is sorted in descending order by priorities, so MB IEs will
151 	 * be arranged in the same order, as required by spec (see corresponding
152 	 * comment in.fst_attach().
153 	 */
154 	foreach_fst_group_iface(g, f) {
155 		if (f == i)
156 			continue;
157 
158 		fst_fill_iface_mb_ies(f, buf);
159 		++nof_ifaces_added;
160 
161 		fst_printf_iface(i, MSG_DEBUG, "added to MB IE");
162 	}
163 
164 	if (!nof_ifaces_added) {
165 		wpabuf_free(buf);
166 		buf = NULL;
167 		fst_printf_iface(i, MSG_INFO,
168 				 "cannot add MB IE: no backup ifaces");
169 	} else {
170 		fst_dump_mb_ies(fst_group_get_id(g), fst_iface_get_name(i),
171 				buf);
172 	}
173 
174 	return buf;
175 }
176 
177 
178 static const u8 * fst_mbie_get_peer_addr(const struct multi_band_ie *mbie)
179 {
180 	const u8 *peer_addr = NULL;
181 
182 	switch (MB_CTRL_ROLE(mbie->mb_ctrl)) {
183 	case MB_STA_ROLE_AP:
184 		peer_addr = mbie->bssid;
185 		break;
186 	case MB_STA_ROLE_NON_PCP_NON_AP:
187 		if (mbie->mb_ctrl & MB_CTRL_STA_MAC_PRESENT &&
188 		    (size_t) 2 + mbie->len >= sizeof(*mbie) + ETH_ALEN)
189 			peer_addr = (const u8 *) &mbie[1];
190 		break;
191 	default:
192 		break;
193 	}
194 
195 	return peer_addr;
196 }
197 
198 
199 static const u8 * fst_mbie_get_peer_addr_for_band(const struct wpabuf *mbies,
200 						  u8 band_id)
201 {
202 	const u8 *p = wpabuf_head(mbies);
203 	size_t s = wpabuf_len(mbies);
204 
205 	while (s >= 2) {
206 		const struct multi_band_ie *mbie =
207 			(const struct multi_band_ie *) p;
208 
209 		if (mbie->eid != WLAN_EID_MULTI_BAND) {
210 			fst_printf(MSG_INFO, "unexpected eid %d", mbie->eid);
211 			return NULL;
212 		}
213 
214 		if (mbie->len < sizeof(*mbie) - 2 || mbie->len > s - 2) {
215 			fst_printf(MSG_INFO, "invalid mbie len %d",
216 				   mbie->len);
217 			return NULL;
218 		}
219 
220 		if (mbie->band_id == band_id)
221 			return fst_mbie_get_peer_addr(mbie);
222 
223 		p += 2 + mbie->len;
224 		s -= 2 + mbie->len;
225 	}
226 
227 	fst_printf(MSG_INFO, "mbie doesn't contain band %d", band_id);
228 	return NULL;
229 }
230 
231 
232 struct fst_iface * fst_group_get_iface_by_name(struct fst_group *g,
233 					       const char *ifname)
234 {
235 	struct fst_iface *f;
236 
237 	foreach_fst_group_iface(g, f) {
238 		const char *in = fst_iface_get_name(f);
239 
240 		if (os_strncmp(in, ifname, os_strlen(in)) == 0)
241 			return f;
242 	}
243 
244 	return NULL;
245 }
246 
247 
248 u8 fst_group_assign_dialog_token(struct fst_group *g)
249 {
250 	g->dialog_token++;
251 	if (g->dialog_token == 0)
252 		g->dialog_token++;
253 	return g->dialog_token;
254 }
255 
256 
257 u32 fst_group_assign_fsts_id(struct fst_group *g)
258 {
259 	g->fsts_id++;
260 	return g->fsts_id;
261 }
262 
263 
264 /**
265  * fst_group_get_peer_other_connection_1 - Find peer's "other" connection
266  * (iface, MAC tuple) by using peer's MB IE on iface.
267  *
268  * @iface: iface on which FST Setup Request was received
269  * @peer_addr: Peer address on iface
270  * @band_id: "other" connection band id
271  * @other_peer_addr (out): Peer's MAC address on the "other" connection (on the
272  *   "other" iface)
273  *
274  * This function parses peer's MB IE on iface. It looks for peer's MAC address
275  * on band_id (tmp_peer_addr). Next all interfaces are iterated to find an
276  * interface which correlates with band_id. If such interface is found, peer
277  * database is iterated to see if tmp_peer_addr is connected over it.
278  */
279 static struct fst_iface *
280 fst_group_get_peer_other_connection_1(struct fst_iface *iface,
281 				      const u8 *peer_addr, u8 band_id,
282 				      u8 *other_peer_addr)
283 {
284 	const struct wpabuf *mbies;
285 	struct fst_iface *other_iface;
286 	const u8 *tmp_peer_addr;
287 
288 	/* Get peer's MB IEs on iface */
289 	mbies = fst_iface_get_peer_mb_ie(iface, peer_addr);
290 	if (!mbies)
291 		return NULL;
292 
293 	/* Get peer's MAC address on the "other" interface */
294 	tmp_peer_addr = fst_mbie_get_peer_addr_for_band(mbies, band_id);
295 	if (!tmp_peer_addr) {
296 		fst_printf(MSG_INFO,
297 			   "couldn't extract other peer addr from mbies");
298 		return NULL;
299 	}
300 
301 	fst_printf(MSG_DEBUG, "found other peer addr from mbies: " MACSTR,
302 		   MAC2STR(tmp_peer_addr));
303 
304 	foreach_fst_group_iface(fst_iface_get_group(iface), other_iface) {
305 		if (other_iface == iface ||
306 		    band_id != fst_iface_get_band_id(other_iface))
307 			continue;
308 		if (fst_iface_is_connected(other_iface, tmp_peer_addr, FALSE)) {
309 			os_memcpy(other_peer_addr, tmp_peer_addr, ETH_ALEN);
310 			return other_iface;
311 		}
312 	}
313 
314 	return NULL;
315 }
316 
317 
318 /**
319  * fst_group_get_peer_other_connection_2 - Find peer's "other" connection
320  * (iface, MAC tuple) by using MB IEs of other peers.
321  *
322  * @iface: iface on which FST Setup Request was received
323  * @peer_addr: Peer address on iface
324  * @band_id: "other" connection band id
325  * @other_peer_addr (out): Peer's MAC address on the "other" connection (on the
326  *   "other" iface)
327  *
328  * This function iterates all connection (other_iface, cur_peer_addr tuples).
329  * For each connection, MB IE (of cur_peer_addr on other_iface) is parsed and
330  * MAC address on iface's band_id is extracted (this_peer_addr).
331  * this_peer_addr is then compared to peer_addr. A match indicates we have
332  * found the "other" connection.
333  */
334 static struct fst_iface *
335 fst_group_get_peer_other_connection_2(struct fst_iface *iface,
336 				      const u8 *peer_addr, u8 band_id,
337 				      u8 *other_peer_addr)
338 {
339 	u8 this_band_id = fst_iface_get_band_id(iface);
340 	const u8 *cur_peer_addr, *this_peer_addr;
341 	struct fst_get_peer_ctx *ctx;
342 	struct fst_iface *other_iface;
343 	const struct wpabuf *cur_mbie;
344 
345 	foreach_fst_group_iface(fst_iface_get_group(iface), other_iface) {
346 		if (other_iface == iface ||
347 		    band_id != fst_iface_get_band_id(other_iface))
348 			continue;
349 		cur_peer_addr = fst_iface_get_peer_first(other_iface, &ctx,
350 							 TRUE);
351 		for (; cur_peer_addr;
352 		     cur_peer_addr = fst_iface_get_peer_next(other_iface, &ctx,
353 							     TRUE)) {
354 			cur_mbie = fst_iface_get_peer_mb_ie(other_iface,
355 							    cur_peer_addr);
356 			if (!cur_mbie)
357 				continue;
358 			this_peer_addr = fst_mbie_get_peer_addr_for_band(
359 				cur_mbie, this_band_id);
360 			if (!this_peer_addr)
361 				continue;
362 			if (os_memcmp(this_peer_addr, peer_addr, ETH_ALEN) ==
363 			    0) {
364 				os_memcpy(other_peer_addr, cur_peer_addr,
365 					  ETH_ALEN);
366 				return other_iface;
367 			}
368 		}
369 	}
370 
371 	return NULL;
372 }
373 
374 
375 /**
376  * fst_group_get_peer_other_connection - Find peer's "other" connection (iface,
377  * MAC tuple).
378  *
379  * @iface: iface on which FST Setup Request was received
380  * @peer_addr: Peer address on iface
381  * @band_id: "other" connection band id
382  * @other_peer_addr (out): Peer's MAC address on the "other" connection (on the
383  *   "other" iface)
384  *
385  * This function is called upon receiving FST Setup Request from some peer who
386  * has peer_addr on iface. It searches for another connection of the same peer
387  * on different interface which correlates with band_id. MB IEs received from
388  * peer (on the two different interfaces) are used to identify same peer.
389  */
390 struct fst_iface *
391 fst_group_get_peer_other_connection(struct fst_iface *iface,
392 				    const u8 *peer_addr, u8 band_id,
393 				    u8 *other_peer_addr)
394 {
395 	struct fst_iface *other_iface;
396 
397 	fst_printf(MSG_DEBUG, "%s: %s:" MACSTR ", %d", __func__,
398 		   fst_iface_get_name(iface), MAC2STR(peer_addr), band_id);
399 
400 	/*
401 	 * Two search methods are used:
402 	 * 1. Use peer's MB IE on iface to extract peer's MAC address on
403 	 *    "other" connection. Then check if such "other" connection exists.
404 	 * 2. Iterate peer database, examine each MB IE to see if it points to
405 	 *    (iface, peer_addr) tuple
406 	 */
407 
408 	other_iface = fst_group_get_peer_other_connection_1(iface, peer_addr,
409 							    band_id,
410 							    other_peer_addr);
411 	if (other_iface) {
412 		fst_printf(MSG_DEBUG, "found by method #1. %s:" MACSTR,
413 			   fst_iface_get_name(other_iface),
414 			   MAC2STR(other_peer_addr));
415 		return other_iface;
416 	}
417 
418 	other_iface = fst_group_get_peer_other_connection_2(iface, peer_addr,
419 							    band_id,
420 							    other_peer_addr);
421 	if (other_iface) {
422 		fst_printf(MSG_DEBUG, "found by method #2. %s:" MACSTR,
423 			   fst_iface_get_name(other_iface),
424 			   MAC2STR(other_peer_addr));
425 		return other_iface;
426 	}
427 
428 	fst_printf(MSG_INFO, "%s: other connection not found", __func__);
429 	return NULL;
430 }
431 
432 
433 struct fst_group * fst_group_create(const char *group_id)
434 {
435 	struct fst_group *g;
436 
437 	g = os_zalloc(sizeof(*g));
438 	if (g == NULL) {
439 		fst_printf(MSG_ERROR, "%s: Cannot alloc group", group_id);
440 		return NULL;
441 	}
442 
443 	dl_list_init(&g->ifaces);
444 	os_strlcpy(g->group_id, group_id, sizeof(g->group_id));
445 
446 	dl_list_add_tail(&fst_global_groups_list, &g->global_groups_lentry);
447 	fst_printf_group(g, MSG_DEBUG, "instance created");
448 
449 	foreach_fst_ctrl_call(on_group_created, g);
450 
451 	return g;
452 }
453 
454 
455 void fst_group_attach_iface(struct fst_group *g, struct fst_iface *i)
456 {
457 	struct dl_list *list = &g->ifaces;
458 	struct fst_iface *f;
459 
460 	/*
461 	 * Add new interface to the list.
462 	 * The list is sorted in descending order by priority to allow
463 	 * multiple MB IEs creation according to the spec (see 10.32 Multi-band
464 	 * operation, 10.32.1 General), as they should be ordered according to
465 	 * priorities.
466 	 */
467 	foreach_fst_group_iface(g, f) {
468 		if (fst_iface_get_priority(f) < fst_iface_get_priority(i))
469 			break;
470 		list = &f->group_lentry;
471 	}
472 	dl_list_add(list, &i->group_lentry);
473 }
474 
475 
476 void fst_group_detach_iface(struct fst_group *g, struct fst_iface *i)
477 {
478 	dl_list_del(&i->group_lentry);
479 }
480 
481 
482 void fst_group_delete(struct fst_group *group)
483 {
484 	struct fst_session *s;
485 
486 	dl_list_del(&group->global_groups_lentry);
487 	WPA_ASSERT(dl_list_empty(&group->ifaces));
488 	foreach_fst_ctrl_call(on_group_deleted, group);
489 	fst_printf_group(group, MSG_DEBUG, "instance deleted");
490 	while ((s = fst_session_global_get_first_by_group(group)) != NULL)
491 		fst_session_delete(s);
492 	os_free(group);
493 }
494 
495 
496 Boolean fst_group_delete_if_empty(struct fst_group *group)
497 {
498 	Boolean is_empty = !fst_group_has_ifaces(group) &&
499 		!fst_session_global_get_first_by_group(group);
500 
501 	if (is_empty)
502 		fst_group_delete(group);
503 
504 	return is_empty;
505 }
506 
507 
508 void fst_group_update_ie(struct fst_group *g)
509 {
510 	struct fst_iface *i;
511 
512 	foreach_fst_group_iface(g, i) {
513 		struct wpabuf *mbie = fst_group_create_mb_ie(g, i);
514 
515 		if (!mbie)
516 			fst_printf_iface(i, MSG_WARNING, "cannot create MB IE");
517 
518 		fst_iface_attach_mbie(i, mbie);
519 		fst_iface_set_ies(i, mbie);
520 		fst_printf_iface(i, MSG_DEBUG, "multi-band IE set to %p", mbie);
521 	}
522 }
523