1 /*
2 * FST module - FST Session 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
11 #include "utils/common.h"
12 #include "utils/eloop.h"
13 #include "common/defs.h"
14 #include "fst/fst_internal.h"
15 #include "fst/fst_defs.h"
16 #include "fst/fst_ctrl_iface.h"
17 #ifdef CONFIG_FST_TEST
18 #include "fst/fst_ctrl_defs.h"
19 #endif /* CONFIG_FST_TEST */
20
21 #define US_80211_TU 1024
22
23 #define US_TO_TU(m) ((m) * / US_80211_TU)
24 #define TU_TO_US(m) ((m) * US_80211_TU)
25
26 #define FST_LLT_SWITCH_IMMEDIATELY 0
27
28 #define fst_printf_session(s, level, format, ...) \
29 fst_printf((level), "%u (0x%08x): [" MACSTR "," MACSTR "] :" format, \
30 (s)->id, (s)->data.fsts_id, \
31 MAC2STR((s)->data.old_peer_addr), \
32 MAC2STR((s)->data.new_peer_addr), \
33 ##__VA_ARGS__)
34
35 #define fst_printf_siface(s, iface, level, format, ...) \
36 fst_printf_session((s), (level), "%s: " format, \
37 fst_iface_get_name(iface), ##__VA_ARGS__)
38
39 #define fst_printf_sframe(s, is_old, level, format, ...) \
40 fst_printf_siface((s), \
41 (is_old) ? (s)->data.old_iface : (s)->data.new_iface, \
42 (level), format, ##__VA_ARGS__)
43
44 #define FST_LLT_MS_DEFAULT 50
45 #define FST_ACTION_MAX_SUPPORTED FST_ACTION_ON_CHANNEL_TUNNEL
46
47 const char * const fst_action_names[] = {
48 [FST_ACTION_SETUP_REQUEST] = "Setup Request",
49 [FST_ACTION_SETUP_RESPONSE] = "Setup Response",
50 [FST_ACTION_TEAR_DOWN] = "Tear Down",
51 [FST_ACTION_ACK_REQUEST] = "Ack Request",
52 [FST_ACTION_ACK_RESPONSE] = "Ack Response",
53 [FST_ACTION_ON_CHANNEL_TUNNEL] = "On Channel Tunnel",
54 };
55
56 struct fst_session {
57 struct {
58 /* Session configuration that can be zeroed on reset */
59 u8 old_peer_addr[ETH_ALEN];
60 u8 new_peer_addr[ETH_ALEN];
61 struct fst_iface *new_iface;
62 struct fst_iface *old_iface;
63 u32 llt_ms;
64 u8 pending_setup_req_dlgt;
65 u32 fsts_id; /* FSTS ID, see spec, 8.4.2.147
66 * Session Transition element */
67 } data;
68 /* Session object internal fields which won't be zeroed on reset */
69 struct dl_list global_sessions_lentry;
70 u32 id; /* Session object ID used to identify
71 * specific session object */
72 struct fst_group *group;
73 enum fst_session_state state;
74 Boolean stt_armed;
75 };
76
77 static struct dl_list global_sessions_list;
78 static u32 global_session_id = 0;
79
80 #define foreach_fst_session(s) \
81 dl_list_for_each((s), &global_sessions_list, \
82 struct fst_session, global_sessions_lentry)
83
84 #define foreach_fst_session_safe(s, temp) \
85 dl_list_for_each_safe((s), (temp), &global_sessions_list, \
86 struct fst_session, global_sessions_lentry)
87
88
fst_session_global_inc_id(void)89 static void fst_session_global_inc_id(void)
90 {
91 global_session_id++;
92 if (global_session_id == FST_INVALID_SESSION_ID)
93 global_session_id++;
94 }
95
96
fst_session_global_init(void)97 int fst_session_global_init(void)
98 {
99 dl_list_init(&global_sessions_list);
100 return 0;
101 }
102
103
fst_session_global_deinit(void)104 void fst_session_global_deinit(void)
105 {
106 WPA_ASSERT(dl_list_empty(&global_sessions_list));
107 }
108
109
fst_session_notify_ctrl(struct fst_session * s,enum fst_event_type event_type,union fst_event_extra * extra)110 static inline void fst_session_notify_ctrl(struct fst_session *s,
111 enum fst_event_type event_type,
112 union fst_event_extra *extra)
113 {
114 foreach_fst_ctrl_call(on_event, event_type, NULL, s, extra);
115 }
116
117
fst_session_set_state(struct fst_session * s,enum fst_session_state state,union fst_session_state_switch_extra * extra)118 static void fst_session_set_state(struct fst_session *s,
119 enum fst_session_state state,
120 union fst_session_state_switch_extra *extra)
121 {
122 if (s->state != state) {
123 union fst_event_extra evext = {
124 .session_state = {
125 .old_state = s->state,
126 .new_state = state,
127 },
128 };
129
130 if (extra)
131 evext.session_state.extra = *extra;
132 fst_session_notify_ctrl(s, EVENT_FST_SESSION_STATE_CHANGED,
133 &evext);
134 fst_printf_session(s, MSG_INFO, "State: %s => %s",
135 fst_session_state_name(s->state),
136 fst_session_state_name(state));
137 s->state = state;
138 }
139 }
140
141
fst_find_free_session_id(void)142 static u32 fst_find_free_session_id(void)
143 {
144 u32 i, id = FST_INVALID_SESSION_ID;
145 struct fst_session *s;
146
147 for (i = 0; i < (u32) -1; i++) {
148 Boolean in_use = FALSE;
149
150 foreach_fst_session(s) {
151 if (s->id == global_session_id) {
152 fst_session_global_inc_id();
153 in_use = TRUE;
154 break;
155 }
156 }
157 if (!in_use) {
158 id = global_session_id;
159 fst_session_global_inc_id();
160 break;
161 }
162 }
163
164 return id;
165 }
166
167
fst_session_timeout_handler(void * eloop_data,void * user_ctx)168 static void fst_session_timeout_handler(void *eloop_data, void *user_ctx)
169 {
170 struct fst_session *s = user_ctx;
171 union fst_session_state_switch_extra extra = {
172 .to_initial = {
173 .reason = REASON_STT,
174 },
175 };
176
177 fst_printf_session(s, MSG_WARNING, "Session State Timeout");
178 fst_session_set_state(s, FST_SESSION_STATE_INITIAL, &extra);
179 }
180
181
fst_session_stt_arm(struct fst_session * s)182 static void fst_session_stt_arm(struct fst_session *s)
183 {
184 /* Action frames sometimes get delayed. Use relaxed timeout (2*) */
185 eloop_register_timeout(0, 2 * TU_TO_US(FST_DEFAULT_SESSION_TIMEOUT_TU),
186 fst_session_timeout_handler, NULL, s);
187 s->stt_armed = TRUE;
188 }
189
190
fst_session_stt_disarm(struct fst_session * s)191 static void fst_session_stt_disarm(struct fst_session *s)
192 {
193 if (s->stt_armed) {
194 eloop_cancel_timeout(fst_session_timeout_handler, NULL, s);
195 s->stt_armed = FALSE;
196 }
197 }
198
199
fst_session_is_in_transition(struct fst_session * s)200 static Boolean fst_session_is_in_transition(struct fst_session *s)
201 {
202 /* See spec, 10.32.2.2 Transitioning between states */
203 return s->stt_armed;
204 }
205
206
fst_session_is_in_progress(struct fst_session * s)207 static int fst_session_is_in_progress(struct fst_session *s)
208 {
209 return s->state != FST_SESSION_STATE_INITIAL;
210 }
211
212
fst_session_is_ready_pending(struct fst_session * s)213 static int fst_session_is_ready_pending(struct fst_session *s)
214 {
215 return s->state == FST_SESSION_STATE_SETUP_COMPLETION &&
216 fst_session_is_in_transition(s);
217 }
218
219
fst_session_is_ready(struct fst_session * s)220 static int fst_session_is_ready(struct fst_session *s)
221 {
222 return s->state == FST_SESSION_STATE_SETUP_COMPLETION &&
223 !fst_session_is_in_transition(s);
224 }
225
226
fst_session_is_switch_requested(struct fst_session * s)227 static int fst_session_is_switch_requested(struct fst_session *s)
228 {
229 return s->state == FST_SESSION_STATE_TRANSITION_DONE &&
230 fst_session_is_in_transition(s);
231 }
232
233
234 static struct fst_session *
fst_find_session_in_progress(const u8 * peer_addr,struct fst_group * g)235 fst_find_session_in_progress(const u8 *peer_addr, struct fst_group *g)
236 {
237 struct fst_session *s;
238
239 foreach_fst_session(s) {
240 if (s->group == g &&
241 (os_memcmp(s->data.old_peer_addr, peer_addr,
242 ETH_ALEN) == 0 ||
243 os_memcmp(s->data.new_peer_addr, peer_addr,
244 ETH_ALEN) == 0) &&
245 fst_session_is_in_progress(s))
246 return s;
247 }
248
249 return NULL;
250 }
251
252
fst_session_reset_ex(struct fst_session * s,enum fst_reason reason)253 static void fst_session_reset_ex(struct fst_session *s, enum fst_reason reason)
254 {
255 union fst_session_state_switch_extra evext = {
256 .to_initial = {
257 .reason = reason,
258 },
259 };
260
261 if (s->state == FST_SESSION_STATE_SETUP_COMPLETION ||
262 s->state == FST_SESSION_STATE_TRANSITION_DONE)
263 fst_session_tear_down_setup(s);
264 fst_session_stt_disarm(s);
265 os_memset(&s->data, 0, sizeof(s->data));
266 fst_session_set_state(s, FST_SESSION_STATE_INITIAL, &evext);
267 }
268
269
fst_session_send_action(struct fst_session * s,Boolean old_iface,const void * payload,size_t size,const struct wpabuf * extra_buf)270 static int fst_session_send_action(struct fst_session *s, Boolean old_iface,
271 const void *payload, size_t size,
272 const struct wpabuf *extra_buf)
273 {
274 size_t len;
275 int res;
276 struct wpabuf *buf;
277 u8 action;
278 struct fst_iface *iface =
279 old_iface ? s->data.old_iface : s->data.new_iface;
280
281 WPA_ASSERT(payload != NULL);
282 WPA_ASSERT(size != 0);
283
284 action = *(const u8 *) payload;
285
286 WPA_ASSERT(action <= FST_ACTION_MAX_SUPPORTED);
287
288 if (!iface) {
289 fst_printf_session(s, MSG_ERROR,
290 "no %s interface for FST Action '%s' sending",
291 old_iface ? "old" : "new",
292 fst_action_names[action]);
293 return -1;
294 }
295
296 len = sizeof(u8) /* category */ + size;
297 if (extra_buf)
298 len += wpabuf_size(extra_buf);
299
300 buf = wpabuf_alloc(len);
301 if (!buf) {
302 fst_printf_session(s, MSG_ERROR,
303 "cannot allocate buffer of %zu bytes for FST Action '%s' sending",
304 len, fst_action_names[action]);
305 return -1;
306 }
307
308 wpabuf_put_u8(buf, WLAN_ACTION_FST);
309 wpabuf_put_data(buf, payload, size);
310 if (extra_buf)
311 wpabuf_put_buf(buf, extra_buf);
312
313 res = fst_iface_send_action(iface,
314 old_iface ? s->data.old_peer_addr :
315 s->data.new_peer_addr, buf);
316 if (res < 0)
317 fst_printf_siface(s, iface, MSG_ERROR,
318 "failed to send FST Action '%s'",
319 fst_action_names[action]);
320 else
321 fst_printf_siface(s, iface, MSG_DEBUG, "FST Action '%s' sent",
322 fst_action_names[action]);
323 wpabuf_free(buf);
324
325 return res;
326 }
327
328
fst_session_send_tear_down(struct fst_session * s)329 static int fst_session_send_tear_down(struct fst_session *s)
330 {
331 struct fst_tear_down td;
332 int res;
333
334 if (!fst_session_is_in_progress(s)) {
335 fst_printf_session(s, MSG_ERROR, "No FST setup to tear down");
336 return -1;
337 }
338
339 WPA_ASSERT(s->data.old_iface != NULL);
340 WPA_ASSERT(s->data.new_iface != NULL);
341
342 os_memset(&td, 0, sizeof(td));
343
344 td.action = FST_ACTION_TEAR_DOWN;
345 td.fsts_id = host_to_le32(s->data.fsts_id);
346
347 res = fst_session_send_action(s, TRUE, &td, sizeof(td), NULL);
348 if (!res)
349 fst_printf_sframe(s, TRUE, MSG_INFO, "FST TearDown sent");
350 else
351 fst_printf_sframe(s, TRUE, MSG_ERROR,
352 "failed to send FST TearDown");
353
354 return res;
355 }
356
357
fst_session_handle_setup_request(struct fst_iface * iface,const struct ieee80211_mgmt * mgmt,size_t frame_len)358 static void fst_session_handle_setup_request(struct fst_iface *iface,
359 const struct ieee80211_mgmt *mgmt,
360 size_t frame_len)
361 {
362 struct fst_session *s;
363 const struct fst_setup_req *req;
364 struct fst_iface *new_iface = NULL;
365 struct fst_group *g;
366 u8 new_iface_peer_addr[ETH_ALEN];
367 const struct wpabuf *peer_mbies;
368 size_t plen;
369
370 if (frame_len < IEEE80211_HDRLEN + 1 + sizeof(*req)) {
371 fst_printf_iface(iface, MSG_WARNING,
372 "FST Request dropped: too short (%zu < %zu)",
373 frame_len,
374 IEEE80211_HDRLEN + 1 + sizeof(*req));
375 return;
376 }
377 plen = frame_len - IEEE80211_HDRLEN - 1;
378 req = (const struct fst_setup_req *)
379 (((const u8 *) mgmt) + IEEE80211_HDRLEN + 1);
380 if (req->stie.element_id != WLAN_EID_SESSION_TRANSITION ||
381 req->stie.length < 11) {
382 fst_printf_iface(iface, MSG_WARNING,
383 "FST Request dropped: invalid STIE");
384 return;
385 }
386
387 if (req->stie.new_band_id == req->stie.old_band_id) {
388 fst_printf_iface(iface, MSG_WARNING,
389 "FST Request dropped: new and old band IDs are the same");
390 return;
391 }
392
393 g = fst_iface_get_group(iface);
394
395 if (plen > sizeof(*req)) {
396 fst_iface_update_mb_ie(iface, mgmt->sa, (const u8 *) (req + 1),
397 plen - sizeof(*req));
398 fst_printf_iface(iface, MSG_INFO,
399 "FST Request: MB IEs updated for " MACSTR,
400 MAC2STR(mgmt->sa));
401 }
402
403 peer_mbies = fst_iface_get_peer_mb_ie(iface, mgmt->sa);
404 if (peer_mbies) {
405 new_iface = fst_group_get_new_iface_by_stie_and_mbie(
406 g, wpabuf_head(peer_mbies), wpabuf_len(peer_mbies),
407 &req->stie, new_iface_peer_addr);
408 if (new_iface)
409 fst_printf_iface(iface, MSG_INFO,
410 "FST Request: new iface (%s:" MACSTR
411 ") found by MB IEs",
412 fst_iface_get_name(new_iface),
413 MAC2STR(new_iface_peer_addr));
414 }
415
416 if (!new_iface) {
417 new_iface = fst_group_find_new_iface_by_stie(
418 g, iface, mgmt->sa, &req->stie,
419 new_iface_peer_addr);
420 if (new_iface)
421 fst_printf_iface(iface, MSG_INFO,
422 "FST Request: new iface (%s:" MACSTR
423 ") found by others",
424 fst_iface_get_name(new_iface),
425 MAC2STR(new_iface_peer_addr));
426 }
427
428 if (!new_iface) {
429 fst_printf_iface(iface, MSG_WARNING,
430 "FST Request dropped: new iface not found");
431 return;
432 }
433
434 s = fst_find_session_in_progress(mgmt->sa, g);
435 if (s) {
436 union fst_session_state_switch_extra evext = {
437 .to_initial = {
438 .reason = REASON_SETUP,
439 },
440 };
441
442 /*
443 * 10.32.2.2 Transitioning between states:
444 * Upon receipt of an FST Setup Request frame, the responder
445 * shall respond with an FST Setup Response frame unless it has
446 * a pending FST Setup Request frame addressed to the initiator
447 * and the responder has a numerically larger MAC address than
448 * the initiator’s MAC address, in which case, the responder
449 * shall delete the received FST Setup Request.
450 */
451 if (fst_session_is_ready_pending(s) &&
452 /* waiting for Setup Response */
453 os_memcmp(mgmt->da, mgmt->sa, ETH_ALEN) > 0) {
454 fst_printf_session(s, MSG_WARNING,
455 "FST Request dropped due to MAC comparison (our MAC is "
456 MACSTR ")",
457 MAC2STR(mgmt->da));
458 return;
459 }
460
461 /*
462 * State is SETUP_COMPLETION (either in transition or not) or
463 * TRANSITION_DONE (in transition).
464 * Setup Request arriving in this state could mean:
465 * 1. peer sent it before receiving our Setup Request (race
466 * condition)
467 * 2. peer didn't receive our Setup Response. Peer is retrying
468 * after STT timeout
469 * 3. peer's FST state machines are out of sync due to some
470 * other reason
471 *
472 * We will reset our session and create a new one instead.
473 */
474
475 fst_printf_session(s, MSG_WARNING,
476 "resetting due to FST request");
477
478 /*
479 * If FST Setup Request arrived with the same FSTS ID as one we
480 * initialized before, there's no need to tear down the session.
481 * Moreover, as FSTS ID is the same, the other side will
482 * associate this tear down with the session it initiated that
483 * will break the sync.
484 */
485 if (le_to_host32(req->stie.fsts_id) != s->data.fsts_id)
486 fst_session_send_tear_down(s);
487 else
488 fst_printf_session(s, MSG_WARNING,
489 "Skipping TearDown as the FST request has the same FSTS ID as initiated");
490 fst_session_set_state(s, FST_SESSION_STATE_INITIAL, &evext);
491 fst_session_stt_disarm(s);
492 }
493
494 s = fst_session_create(g);
495 if (!s) {
496 fst_printf(MSG_WARNING,
497 "FST Request dropped: cannot create session for %s and %s",
498 fst_iface_get_name(iface),
499 fst_iface_get_name(new_iface));
500 return;
501 }
502
503 fst_session_set_iface(s, iface, TRUE);
504 fst_session_set_peer_addr(s, mgmt->sa, TRUE);
505 fst_session_set_iface(s, new_iface, FALSE);
506 fst_session_set_peer_addr(s, new_iface_peer_addr, FALSE);
507 fst_session_set_llt(s, FST_LLT_VAL_TO_MS(le_to_host32(req->llt)));
508 s->data.pending_setup_req_dlgt = req->dialog_token;
509 s->data.fsts_id = le_to_host32(req->stie.fsts_id);
510
511 fst_session_stt_arm(s);
512
513 fst_session_notify_ctrl(s, EVENT_FST_SETUP, NULL);
514
515 fst_session_set_state(s, FST_SESSION_STATE_SETUP_COMPLETION, NULL);
516 }
517
518
fst_session_handle_setup_response(struct fst_session * s,struct fst_iface * iface,const struct ieee80211_mgmt * mgmt,size_t frame_len)519 static void fst_session_handle_setup_response(struct fst_session *s,
520 struct fst_iface *iface,
521 const struct ieee80211_mgmt *mgmt,
522 size_t frame_len)
523 {
524 const struct fst_setup_res *res;
525 size_t plen = frame_len - IEEE80211_HDRLEN - 1;
526 enum hostapd_hw_mode hw_mode;
527 u8 channel;
528 union fst_session_state_switch_extra evext = {
529 .to_initial = {
530 .reject_code = 0,
531 },
532 };
533
534 if (iface != s->data.old_iface) {
535 fst_printf_session(s, MSG_WARNING,
536 "FST Response dropped: %s is not the old iface",
537 fst_iface_get_name(iface));
538 return;
539 }
540
541 if (!fst_session_is_ready_pending(s)) {
542 fst_printf_session(s, MSG_WARNING,
543 "FST Response dropped due to wrong state: %s",
544 fst_session_state_name(s->state));
545 return;
546 }
547
548 if (plen < sizeof(*res)) {
549 fst_printf_session(s, MSG_WARNING,
550 "Too short FST Response dropped");
551 return;
552 }
553 res = (const struct fst_setup_res *)
554 (((const u8 *) mgmt) + IEEE80211_HDRLEN + 1);
555 if (res->stie.element_id != WLAN_EID_SESSION_TRANSITION ||
556 res->stie.length < 11) {
557 fst_printf_iface(iface, MSG_WARNING,
558 "FST Response dropped: invalid STIE");
559 return;
560 }
561
562 if (res->dialog_token != s->data.pending_setup_req_dlgt) {
563 fst_printf_session(s, MSG_WARNING,
564 "FST Response dropped due to wrong dialog token (%u != %u)",
565 s->data.pending_setup_req_dlgt,
566 res->dialog_token);
567 return;
568 }
569
570 if (res->status_code == WLAN_STATUS_SUCCESS &&
571 le_to_host32(res->stie.fsts_id) != s->data.fsts_id) {
572 fst_printf_session(s, MSG_WARNING,
573 "FST Response dropped due to wrong FST Session ID (%u)",
574 le_to_host32(res->stie.fsts_id));
575 return;
576 }
577
578 fst_session_stt_disarm(s);
579
580 if (res->status_code != WLAN_STATUS_SUCCESS) {
581 /*
582 * 10.32.2.2 Transitioning between states
583 * The initiator shall set the STT to the value of the
584 * FSTSessionTimeOut field at ... and at each ACK frame sent in
585 * response to a received FST Setup Response with the Status
586 * Code field equal to PENDING_ADMITTING_FST_SESSION or
587 * PENDING_GAP_IN_BA_WINDOW.
588 */
589 evext.to_initial.reason = REASON_REJECT;
590 evext.to_initial.reject_code = res->status_code;
591 evext.to_initial.initiator = FST_INITIATOR_REMOTE;
592 fst_session_set_state(s, FST_SESSION_STATE_INITIAL, &evext);
593 fst_printf_session(s, MSG_WARNING,
594 "FST Setup rejected by remote side with status %u",
595 res->status_code);
596 return;
597 }
598
599 fst_iface_get_channel_info(s->data.new_iface, &hw_mode, &channel);
600
601 if (fst_hw_mode_to_band(hw_mode) != res->stie.new_band_id) {
602 evext.to_initial.reason = REASON_ERROR_PARAMS;
603 fst_session_set_state(s, FST_SESSION_STATE_INITIAL, &evext);
604 fst_printf_session(s, MSG_WARNING,
605 "invalid FST Setup parameters");
606 fst_session_tear_down_setup(s);
607 return;
608 }
609
610 fst_printf_session(s, MSG_INFO,
611 "%s: FST Setup established for %s (llt=%u)",
612 fst_iface_get_name(s->data.old_iface),
613 fst_iface_get_name(s->data.new_iface),
614 s->data.llt_ms);
615
616 fst_session_notify_ctrl(s, EVENT_FST_ESTABLISHED, NULL);
617
618 if (s->data.llt_ms == FST_LLT_SWITCH_IMMEDIATELY)
619 fst_session_initiate_switch(s);
620 }
621
622
fst_session_handle_tear_down(struct fst_session * s,struct fst_iface * iface,const struct ieee80211_mgmt * mgmt,size_t frame_len)623 static void fst_session_handle_tear_down(struct fst_session *s,
624 struct fst_iface *iface,
625 const struct ieee80211_mgmt *mgmt,
626 size_t frame_len)
627 {
628 const struct fst_tear_down *td;
629 size_t plen = frame_len - IEEE80211_HDRLEN - 1;
630 union fst_session_state_switch_extra evext = {
631 .to_initial = {
632 .reason = REASON_TEARDOWN,
633 .initiator = FST_INITIATOR_REMOTE,
634 },
635 };
636
637 if (plen < sizeof(*td)) {
638 fst_printf_session(s, MSG_WARNING,
639 "Too short FST Tear Down dropped");
640 return;
641 }
642 td = (const struct fst_tear_down *)
643 (((const u8 *) mgmt) + IEEE80211_HDRLEN + 1);
644
645 if (le_to_host32(td->fsts_id) != s->data.fsts_id) {
646 fst_printf_siface(s, iface, MSG_WARNING,
647 "tear down for wrong FST Setup ID (%u)",
648 le_to_host32(td->fsts_id));
649 return;
650 }
651
652 fst_session_stt_disarm(s);
653
654 fst_session_set_state(s, FST_SESSION_STATE_INITIAL, &evext);
655 }
656
657
fst_session_handle_ack_request(struct fst_session * s,struct fst_iface * iface,const struct ieee80211_mgmt * mgmt,size_t frame_len)658 static void fst_session_handle_ack_request(struct fst_session *s,
659 struct fst_iface *iface,
660 const struct ieee80211_mgmt *mgmt,
661 size_t frame_len)
662 {
663 const struct fst_ack_req *req;
664 size_t plen = frame_len - IEEE80211_HDRLEN - 1;
665 struct fst_ack_res res;
666 union fst_session_state_switch_extra evext = {
667 .to_initial = {
668 .reason = REASON_SWITCH,
669 .initiator = FST_INITIATOR_REMOTE,
670 },
671 };
672
673 if (!fst_session_is_ready(s) && !fst_session_is_switch_requested(s)) {
674 fst_printf_siface(s, iface, MSG_ERROR,
675 "cannot initiate switch due to wrong session state (%s)",
676 fst_session_state_name(s->state));
677 return;
678 }
679
680 WPA_ASSERT(s->data.new_iface != NULL);
681
682 if (iface != s->data.new_iface) {
683 fst_printf_siface(s, iface, MSG_ERROR,
684 "Ack received on wrong interface");
685 return;
686 }
687
688 if (plen < sizeof(*req)) {
689 fst_printf_session(s, MSG_WARNING,
690 "Too short FST Ack Request dropped");
691 return;
692 }
693 req = (const struct fst_ack_req *)
694 (((const u8 *) mgmt) + IEEE80211_HDRLEN + 1);
695
696 if (le_to_host32(req->fsts_id) != s->data.fsts_id) {
697 fst_printf_siface(s, iface, MSG_WARNING,
698 "Ack for wrong FST Setup ID (%u)",
699 le_to_host32(req->fsts_id));
700 return;
701 }
702
703 os_memset(&res, 0, sizeof(res));
704
705 res.action = FST_ACTION_ACK_RESPONSE;
706 res.dialog_token = req->dialog_token;
707 res.fsts_id = req->fsts_id;
708
709 if (!fst_session_send_action(s, FALSE, &res, sizeof(res), NULL)) {
710 fst_printf_sframe(s, FALSE, MSG_INFO, "FST Ack Response sent");
711 fst_session_stt_disarm(s);
712 fst_session_set_state(s, FST_SESSION_STATE_TRANSITION_DONE,
713 NULL);
714 fst_session_set_state(s, FST_SESSION_STATE_TRANSITION_CONFIRMED,
715 NULL);
716 fst_session_set_state(s, FST_SESSION_STATE_INITIAL, &evext);
717 }
718 }
719
720
721 static void
fst_session_handle_ack_response(struct fst_session * s,struct fst_iface * iface,const struct ieee80211_mgmt * mgmt,size_t frame_len)722 fst_session_handle_ack_response(struct fst_session *s,
723 struct fst_iface *iface,
724 const struct ieee80211_mgmt *mgmt,
725 size_t frame_len)
726 {
727 const struct fst_ack_res *res;
728 size_t plen = frame_len - IEEE80211_HDRLEN - 1;
729 union fst_session_state_switch_extra evext = {
730 .to_initial = {
731 .reason = REASON_SWITCH,
732 .initiator = FST_INITIATOR_LOCAL,
733 },
734 };
735
736 if (!fst_session_is_switch_requested(s)) {
737 fst_printf_siface(s, iface, MSG_ERROR,
738 "Ack Response in inappropriate session state (%s)",
739 fst_session_state_name(s->state));
740 return;
741 }
742
743 WPA_ASSERT(s->data.new_iface != NULL);
744
745 if (iface != s->data.new_iface) {
746 fst_printf_siface(s, iface, MSG_ERROR,
747 "Ack response received on wrong interface");
748 return;
749 }
750
751 if (plen < sizeof(*res)) {
752 fst_printf_session(s, MSG_WARNING,
753 "Too short FST Ack Response dropped");
754 return;
755 }
756 res = (const struct fst_ack_res *)
757 (((const u8 *) mgmt) + IEEE80211_HDRLEN + 1);
758
759 if (le_to_host32(res->fsts_id) != s->data.fsts_id) {
760 fst_printf_siface(s, iface, MSG_ERROR,
761 "Ack response for wrong FST Setup ID (%u)",
762 le_to_host32(res->fsts_id));
763 return;
764 }
765
766 fst_session_set_state(s, FST_SESSION_STATE_TRANSITION_CONFIRMED, NULL);
767 fst_session_set_state(s, FST_SESSION_STATE_INITIAL, &evext);
768
769 fst_session_stt_disarm(s);
770 }
771
772
fst_session_create(struct fst_group * g)773 struct fst_session * fst_session_create(struct fst_group *g)
774 {
775 struct fst_session *s;
776 u32 id;
777
778 WPA_ASSERT(!is_zero_ether_addr(own_addr));
779
780 id = fst_find_free_session_id();
781 if (id == FST_INVALID_SESSION_ID) {
782 fst_printf(MSG_ERROR, "Cannot assign new session ID");
783 return NULL;
784 }
785
786 s = os_zalloc(sizeof(*s));
787 if (!s) {
788 fst_printf(MSG_ERROR, "Cannot allocate new session object");
789 return NULL;
790 }
791
792 s->id = id;
793 s->group = g;
794 s->state = FST_SESSION_STATE_INITIAL;
795
796 s->data.llt_ms = FST_LLT_MS_DEFAULT;
797
798 fst_printf(MSG_INFO, "Session %u created", s->id);
799
800 dl_list_add_tail(&global_sessions_list, &s->global_sessions_lentry);
801
802 foreach_fst_ctrl_call(on_session_added, s);
803
804 return s;
805 }
806
807
fst_session_set_iface(struct fst_session * s,struct fst_iface * iface,Boolean is_old)808 void fst_session_set_iface(struct fst_session *s, struct fst_iface *iface,
809 Boolean is_old)
810 {
811 if (is_old)
812 s->data.old_iface = iface;
813 else
814 s->data.new_iface = iface;
815
816 }
817
818
fst_session_set_llt(struct fst_session * s,u32 llt)819 void fst_session_set_llt(struct fst_session *s, u32 llt)
820 {
821 s->data.llt_ms = llt;
822 }
823
824
fst_session_set_peer_addr(struct fst_session * s,const u8 * addr,Boolean is_old)825 void fst_session_set_peer_addr(struct fst_session *s, const u8 *addr,
826 Boolean is_old)
827 {
828 u8 *a = is_old ? s->data.old_peer_addr : s->data.new_peer_addr;
829
830 os_memcpy(a, addr, ETH_ALEN);
831 }
832
833
fst_session_initiate_setup(struct fst_session * s)834 int fst_session_initiate_setup(struct fst_session *s)
835 {
836 struct fst_setup_req req;
837 int res;
838 u32 fsts_id;
839 u8 dialog_token;
840 struct fst_session *_s;
841
842 if (fst_session_is_in_progress(s)) {
843 fst_printf_session(s, MSG_ERROR, "Session in progress");
844 return -EINVAL;
845 }
846
847 if (is_zero_ether_addr(s->data.old_peer_addr)) {
848 fst_printf_session(s, MSG_ERROR, "No old peer MAC address");
849 return -EINVAL;
850 }
851
852 if (is_zero_ether_addr(s->data.new_peer_addr)) {
853 fst_printf_session(s, MSG_ERROR, "No new peer MAC address");
854 return -EINVAL;
855 }
856
857 if (!s->data.old_iface) {
858 fst_printf_session(s, MSG_ERROR, "No old interface defined");
859 return -EINVAL;
860 }
861
862 if (!s->data.new_iface) {
863 fst_printf_session(s, MSG_ERROR, "No new interface defined");
864 return -EINVAL;
865 }
866
867 if (s->data.new_iface == s->data.old_iface) {
868 fst_printf_session(s, MSG_ERROR,
869 "Same interface set as old and new");
870 return -EINVAL;
871 }
872
873 if (!fst_iface_is_connected(s->data.old_iface, s->data.old_peer_addr,
874 FALSE)) {
875 fst_printf_session(s, MSG_ERROR,
876 "The preset old peer address is not connected");
877 return -EINVAL;
878 }
879
880 if (!fst_iface_is_connected(s->data.new_iface, s->data.new_peer_addr,
881 FALSE)) {
882 fst_printf_session(s, MSG_ERROR,
883 "The preset new peer address is not connected");
884 return -EINVAL;
885 }
886
887 _s = fst_find_session_in_progress(s->data.old_peer_addr, s->group);
888 if (_s) {
889 fst_printf_session(s, MSG_ERROR,
890 "There is another session in progress (old): %u",
891 _s->id);
892 return -EINVAL;
893 }
894
895 _s = fst_find_session_in_progress(s->data.new_peer_addr, s->group);
896 if (_s) {
897 fst_printf_session(s, MSG_ERROR,
898 "There is another session in progress (new): %u",
899 _s->id);
900 return -EINVAL;
901 }
902
903 dialog_token = fst_group_assign_dialog_token(s->group);
904 fsts_id = fst_group_assign_fsts_id(s->group);
905
906 os_memset(&req, 0, sizeof(req));
907
908 fst_printf_siface(s, s->data.old_iface, MSG_INFO,
909 "initiating FST setup for %s (llt=%u ms)",
910 fst_iface_get_name(s->data.new_iface), s->data.llt_ms);
911
912 req.action = FST_ACTION_SETUP_REQUEST;
913 req.dialog_token = dialog_token;
914 req.llt = host_to_le32(FST_LLT_MS_TO_VAL(s->data.llt_ms));
915 /* 8.4.2.147 Session Transition element */
916 req.stie.element_id = WLAN_EID_SESSION_TRANSITION;
917 req.stie.length = sizeof(req.stie) - 2;
918 req.stie.fsts_id = host_to_le32(fsts_id);
919 req.stie.session_control = SESSION_CONTROL(SESSION_TYPE_BSS, 0);
920
921 req.stie.new_band_id = fst_iface_get_band_id(s->data.new_iface);
922 req.stie.new_band_op = 1;
923 req.stie.new_band_setup = 0;
924
925 req.stie.old_band_id = fst_iface_get_band_id(s->data.old_iface);
926 req.stie.old_band_op = 1;
927 req.stie.old_band_setup = 0;
928
929 res = fst_session_send_action(s, TRUE, &req, sizeof(req),
930 fst_iface_get_mbie(s->data.old_iface));
931 if (!res) {
932 s->data.fsts_id = fsts_id;
933 s->data.pending_setup_req_dlgt = dialog_token;
934 fst_printf_sframe(s, TRUE, MSG_INFO, "FST Setup Request sent");
935 fst_session_set_state(s, FST_SESSION_STATE_SETUP_COMPLETION,
936 NULL);
937
938 fst_session_stt_arm(s);
939 }
940
941 return res;
942 }
943
944
fst_session_respond(struct fst_session * s,u8 status_code)945 int fst_session_respond(struct fst_session *s, u8 status_code)
946 {
947 struct fst_setup_res res;
948 enum hostapd_hw_mode hw_mode;
949 u8 channel;
950
951 if (!fst_session_is_ready_pending(s)) {
952 fst_printf_session(s, MSG_ERROR, "incorrect state: %s",
953 fst_session_state_name(s->state));
954 return -EINVAL;
955 }
956
957 if (is_zero_ether_addr(s->data.old_peer_addr)) {
958 fst_printf_session(s, MSG_ERROR, "No peer MAC address");
959 return -EINVAL;
960 }
961
962 if (!s->data.old_iface) {
963 fst_printf_session(s, MSG_ERROR, "No old interface defined");
964 return -EINVAL;
965 }
966
967 if (!s->data.new_iface) {
968 fst_printf_session(s, MSG_ERROR, "No new interface defined");
969 return -EINVAL;
970 }
971
972 if (s->data.new_iface == s->data.old_iface) {
973 fst_printf_session(s, MSG_ERROR,
974 "Same interface set as old and new");
975 return -EINVAL;
976 }
977
978 if (!fst_iface_is_connected(s->data.old_iface,
979 s->data.old_peer_addr, FALSE)) {
980 fst_printf_session(s, MSG_ERROR,
981 "The preset peer address is not in the peer list");
982 return -EINVAL;
983 }
984
985 fst_session_stt_disarm(s);
986
987 os_memset(&res, 0, sizeof(res));
988
989 res.action = FST_ACTION_SETUP_RESPONSE;
990 res.dialog_token = s->data.pending_setup_req_dlgt;
991 res.status_code = status_code;
992
993 res.stie.element_id = WLAN_EID_SESSION_TRANSITION;
994 res.stie.length = sizeof(res.stie) - 2;
995
996 if (status_code == WLAN_STATUS_SUCCESS) {
997 res.stie.fsts_id = s->data.fsts_id;
998 res.stie.session_control = SESSION_CONTROL(SESSION_TYPE_BSS, 0);
999
1000 fst_iface_get_channel_info(s->data.new_iface, &hw_mode,
1001 &channel);
1002 res.stie.new_band_id = fst_hw_mode_to_band(hw_mode);
1003 res.stie.new_band_op = 1;
1004 res.stie.new_band_setup = 0;
1005
1006 fst_iface_get_channel_info(s->data.old_iface, &hw_mode,
1007 &channel);
1008 res.stie.old_band_id = fst_hw_mode_to_band(hw_mode);
1009 res.stie.old_band_op = 1;
1010 res.stie.old_band_setup = 0;
1011
1012 fst_printf_session(s, MSG_INFO,
1013 "%s: FST Setup Request accepted for %s (llt=%u)",
1014 fst_iface_get_name(s->data.old_iface),
1015 fst_iface_get_name(s->data.new_iface),
1016 s->data.llt_ms);
1017 } else {
1018 fst_printf_session(s, MSG_WARNING,
1019 "%s: FST Setup Request rejected with code %d",
1020 fst_iface_get_name(s->data.old_iface),
1021 status_code);
1022 }
1023
1024 if (fst_session_send_action(s, TRUE, &res, sizeof(res),
1025 fst_iface_get_mbie(s->data.old_iface))) {
1026 fst_printf_sframe(s, TRUE, MSG_ERROR,
1027 "cannot send FST Setup Response with code %d",
1028 status_code);
1029 return -EINVAL;
1030 }
1031
1032 fst_printf_sframe(s, TRUE, MSG_INFO, "FST Setup Response sent");
1033
1034 if (status_code != WLAN_STATUS_SUCCESS) {
1035 union fst_session_state_switch_extra evext = {
1036 .to_initial = {
1037 .reason = REASON_REJECT,
1038 .reject_code = status_code,
1039 .initiator = FST_INITIATOR_LOCAL,
1040 },
1041 };
1042 fst_session_set_state(s, FST_SESSION_STATE_INITIAL, &evext);
1043 }
1044
1045 return 0;
1046 }
1047
1048
fst_session_initiate_switch(struct fst_session * s)1049 int fst_session_initiate_switch(struct fst_session *s)
1050 {
1051 struct fst_ack_req req;
1052 int res;
1053 u8 dialog_token;
1054
1055 if (!fst_session_is_ready(s)) {
1056 fst_printf_session(s, MSG_ERROR,
1057 "cannot initiate switch due to wrong setup state (%d)",
1058 s->state);
1059 return -1;
1060 }
1061
1062 dialog_token = fst_group_assign_dialog_token(s->group);
1063
1064 WPA_ASSERT(s->data.new_iface != NULL);
1065 WPA_ASSERT(s->data.old_iface != NULL);
1066
1067 fst_printf_session(s, MSG_INFO, "initiating FST switch: %s => %s",
1068 fst_iface_get_name(s->data.old_iface),
1069 fst_iface_get_name(s->data.new_iface));
1070
1071 os_memset(&req, 0, sizeof(req));
1072
1073 req.action = FST_ACTION_ACK_REQUEST;
1074 req.dialog_token = dialog_token;
1075 req.fsts_id = host_to_le32(s->data.fsts_id);
1076
1077 res = fst_session_send_action(s, FALSE, &req, sizeof(req), NULL);
1078 if (!res) {
1079 fst_printf_sframe(s, FALSE, MSG_INFO, "FST Ack Request sent");
1080 fst_session_set_state(s, FST_SESSION_STATE_TRANSITION_DONE,
1081 NULL);
1082 fst_session_stt_arm(s);
1083 } else {
1084 fst_printf_sframe(s, FALSE, MSG_ERROR,
1085 "Cannot send FST Ack Request");
1086 }
1087
1088 return res;
1089 }
1090
1091
fst_session_handle_action(struct fst_session * s,struct fst_iface * iface,const struct ieee80211_mgmt * mgmt,size_t frame_len)1092 void fst_session_handle_action(struct fst_session *s,
1093 struct fst_iface *iface,
1094 const struct ieee80211_mgmt *mgmt,
1095 size_t frame_len)
1096 {
1097 switch (mgmt->u.action.u.fst_action.action) {
1098 case FST_ACTION_SETUP_REQUEST:
1099 WPA_ASSERT(0);
1100 break;
1101 case FST_ACTION_SETUP_RESPONSE:
1102 fst_session_handle_setup_response(s, iface, mgmt, frame_len);
1103 break;
1104 case FST_ACTION_TEAR_DOWN:
1105 fst_session_handle_tear_down(s, iface, mgmt, frame_len);
1106 break;
1107 case FST_ACTION_ACK_REQUEST:
1108 fst_session_handle_ack_request(s, iface, mgmt, frame_len);
1109 break;
1110 case FST_ACTION_ACK_RESPONSE:
1111 fst_session_handle_ack_response(s, iface, mgmt, frame_len);
1112 break;
1113 case FST_ACTION_ON_CHANNEL_TUNNEL:
1114 default:
1115 fst_printf_sframe(s, FALSE, MSG_ERROR,
1116 "Unsupported FST Action frame");
1117 break;
1118 }
1119 }
1120
1121
fst_session_tear_down_setup(struct fst_session * s)1122 int fst_session_tear_down_setup(struct fst_session *s)
1123 {
1124 int res;
1125 union fst_session_state_switch_extra evext = {
1126 .to_initial = {
1127 .reason = REASON_TEARDOWN,
1128 .initiator = FST_INITIATOR_LOCAL,
1129 },
1130 };
1131
1132 res = fst_session_send_tear_down(s);
1133
1134 fst_session_set_state(s, FST_SESSION_STATE_INITIAL, &evext);
1135
1136 return res;
1137 }
1138
1139
fst_session_reset(struct fst_session * s)1140 void fst_session_reset(struct fst_session *s)
1141 {
1142 fst_session_reset_ex(s, REASON_RESET);
1143 }
1144
1145
fst_session_delete(struct fst_session * s)1146 void fst_session_delete(struct fst_session *s)
1147 {
1148 fst_printf(MSG_INFO, "Session %u deleted", s->id);
1149 dl_list_del(&s->global_sessions_lentry);
1150 foreach_fst_ctrl_call(on_session_removed, s);
1151 os_free(s);
1152 }
1153
1154
fst_session_get_group(struct fst_session * s)1155 struct fst_group * fst_session_get_group(struct fst_session *s)
1156 {
1157 return s->group;
1158 }
1159
1160
fst_session_get_iface(struct fst_session * s,Boolean is_old)1161 struct fst_iface * fst_session_get_iface(struct fst_session *s, Boolean is_old)
1162 {
1163 return is_old ? s->data.old_iface : s->data.new_iface;
1164 }
1165
1166
fst_session_get_id(struct fst_session * s)1167 u32 fst_session_get_id(struct fst_session *s)
1168 {
1169 return s->id;
1170 }
1171
1172
fst_session_get_peer_addr(struct fst_session * s,Boolean is_old)1173 const u8 * fst_session_get_peer_addr(struct fst_session *s, Boolean is_old)
1174 {
1175 return is_old ? s->data.old_peer_addr : s->data.new_peer_addr;
1176 }
1177
1178
fst_session_get_llt(struct fst_session * s)1179 u32 fst_session_get_llt(struct fst_session *s)
1180 {
1181 return s->data.llt_ms;
1182 }
1183
1184
fst_session_get_state(struct fst_session * s)1185 enum fst_session_state fst_session_get_state(struct fst_session *s)
1186 {
1187 return s->state;
1188 }
1189
1190
fst_session_get_by_id(u32 id)1191 struct fst_session * fst_session_get_by_id(u32 id)
1192 {
1193 struct fst_session *s;
1194
1195 foreach_fst_session(s) {
1196 if (id == s->id)
1197 return s;
1198 }
1199
1200 return NULL;
1201 }
1202
1203
fst_session_enum(struct fst_group * g,fst_session_enum_clb clb,void * ctx)1204 void fst_session_enum(struct fst_group *g, fst_session_enum_clb clb, void *ctx)
1205 {
1206 struct fst_session *s;
1207
1208 foreach_fst_session(s) {
1209 if (!g || s->group == g)
1210 clb(s->group, s, ctx);
1211 }
1212 }
1213
1214
fst_session_on_action_rx(struct fst_iface * iface,const struct ieee80211_mgmt * mgmt,size_t len)1215 void fst_session_on_action_rx(struct fst_iface *iface,
1216 const struct ieee80211_mgmt *mgmt,
1217 size_t len)
1218 {
1219 struct fst_session *s;
1220
1221 if (len < IEEE80211_HDRLEN + 2 ||
1222 mgmt->u.action.category != WLAN_ACTION_FST) {
1223 fst_printf_iface(iface, MSG_ERROR,
1224 "invalid Action frame received");
1225 return;
1226 }
1227
1228 if (mgmt->u.action.u.fst_action.action <= FST_ACTION_MAX_SUPPORTED) {
1229 fst_printf_iface(iface, MSG_DEBUG,
1230 "FST Action '%s' received!",
1231 fst_action_names[mgmt->u.action.u.fst_action.action]);
1232 } else {
1233 fst_printf_iface(iface, MSG_WARNING,
1234 "unknown FST Action (%u) received!",
1235 mgmt->u.action.u.fst_action.action);
1236 return;
1237 }
1238
1239 if (mgmt->u.action.u.fst_action.action == FST_ACTION_SETUP_REQUEST) {
1240 fst_session_handle_setup_request(iface, mgmt, len);
1241 return;
1242 }
1243
1244 s = fst_find_session_in_progress(mgmt->sa, fst_iface_get_group(iface));
1245 if (s) {
1246 fst_session_handle_action(s, iface, mgmt, len);
1247 } else {
1248 fst_printf_iface(iface, MSG_WARNING,
1249 "FST Action '%s' dropped: no session in progress found",
1250 fst_action_names[mgmt->u.action.u.fst_action.action]);
1251 }
1252 }
1253
1254
fst_session_set_str_ifname(struct fst_session * s,const char * ifname,Boolean is_old)1255 int fst_session_set_str_ifname(struct fst_session *s, const char *ifname,
1256 Boolean is_old)
1257 {
1258 struct fst_group *g = fst_session_get_group(s);
1259 struct fst_iface *i;
1260
1261 i = fst_group_get_iface_by_name(g, ifname);
1262 if (!i) {
1263 fst_printf_session(s, MSG_WARNING,
1264 "Cannot set iface %s: no such iface within group '%s'",
1265 ifname, fst_group_get_id(g));
1266 return -1;
1267 }
1268
1269 fst_session_set_iface(s, i, is_old);
1270
1271 return 0;
1272 }
1273
1274
fst_session_set_str_peer_addr(struct fst_session * s,const char * mac,Boolean is_old)1275 int fst_session_set_str_peer_addr(struct fst_session *s, const char *mac,
1276 Boolean is_old)
1277 {
1278 u8 peer_addr[ETH_ALEN];
1279 int res = fst_read_peer_addr(mac, peer_addr);
1280
1281 if (res)
1282 return res;
1283
1284 fst_session_set_peer_addr(s, peer_addr, is_old);
1285
1286 return 0;
1287 }
1288
1289
fst_session_set_str_llt(struct fst_session * s,const char * llt_str)1290 int fst_session_set_str_llt(struct fst_session *s, const char *llt_str)
1291 {
1292 char *endp;
1293 long int llt = strtol(llt_str, &endp, 0);
1294
1295 if (*endp || llt < 0 || (unsigned long int) llt > FST_MAX_LLT_MS) {
1296 fst_printf_session(s, MSG_WARNING,
1297 "Cannot set llt %s: Invalid llt value (1..%u expected)",
1298 llt_str, FST_MAX_LLT_MS);
1299 return -1;
1300 }
1301 fst_session_set_llt(s, (u32) llt);
1302
1303 return 0;
1304 }
1305
1306
fst_session_global_on_iface_detached(struct fst_iface * iface)1307 void fst_session_global_on_iface_detached(struct fst_iface *iface)
1308 {
1309 struct fst_session *s;
1310
1311 foreach_fst_session(s) {
1312 if (fst_session_is_in_progress(s) &&
1313 (s->data.new_iface == iface ||
1314 s->data.old_iface == iface))
1315 fst_session_reset_ex(s, REASON_DETACH_IFACE);
1316 }
1317 }
1318
1319
fst_session_global_get_first_by_group(struct fst_group * g)1320 struct fst_session * fst_session_global_get_first_by_group(struct fst_group *g)
1321 {
1322 struct fst_session *s;
1323
1324 foreach_fst_session(s) {
1325 if (s->group == g)
1326 return s;
1327 }
1328
1329 return NULL;
1330 }
1331
1332
1333 #ifdef CONFIG_FST_TEST
1334
get_group_fill_session(struct fst_group ** g,struct fst_session * s)1335 static int get_group_fill_session(struct fst_group **g, struct fst_session *s)
1336 {
1337 const u8 *old_addr, *new_addr;
1338 struct fst_get_peer_ctx *ctx;
1339
1340 os_memset(s, 0, sizeof(*s));
1341 foreach_fst_group(*g) {
1342 s->data.new_iface = fst_group_first_iface(*g);
1343 if (s->data.new_iface)
1344 break;
1345 }
1346 if (!s->data.new_iface)
1347 return -EINVAL;
1348
1349 s->data.old_iface = dl_list_entry(s->data.new_iface->group_lentry.next,
1350 struct fst_iface, group_lentry);
1351 if (!s->data.old_iface)
1352 return -EINVAL;
1353
1354 old_addr = fst_iface_get_peer_first(s->data.old_iface, &ctx, TRUE);
1355 if (!old_addr)
1356 return -EINVAL;
1357
1358 new_addr = fst_iface_get_peer_first(s->data.new_iface, &ctx, TRUE);
1359 if (!new_addr)
1360 return -EINVAL;
1361
1362 os_memcpy(s->data.old_peer_addr, old_addr, ETH_ALEN);
1363 os_memcpy(s->data.new_peer_addr, new_addr, ETH_ALEN);
1364
1365 return 0;
1366 }
1367
1368
1369 #define FST_MAX_COMMAND_WORD_NAME_LENGTH 16
1370
fst_test_req_send_fst_request(const char * params)1371 int fst_test_req_send_fst_request(const char *params)
1372 {
1373 int fsts_id;
1374 Boolean is_valid;
1375 char *endp;
1376 struct fst_setup_req req;
1377 struct fst_session s;
1378 struct fst_group *g;
1379 enum hostapd_hw_mode hw_mode;
1380 u8 channel;
1381 char additional_param[FST_MAX_COMMAND_WORD_NAME_LENGTH];
1382
1383 if (params[0] != ' ')
1384 return -EINVAL;
1385 params++;
1386 fsts_id = fst_read_next_int_param(params, &is_valid, &endp);
1387 if (!is_valid)
1388 return -EINVAL;
1389
1390 if (get_group_fill_session(&g, &s))
1391 return -EINVAL;
1392
1393 req.action = FST_ACTION_SETUP_REQUEST;
1394 req.dialog_token = g->dialog_token;
1395 req.llt = host_to_le32(FST_LLT_MS_DEFAULT);
1396 /* 8.4.2.147 Session Transition element */
1397 req.stie.element_id = WLAN_EID_SESSION_TRANSITION;
1398 req.stie.length = sizeof(req.stie) - 2;
1399 req.stie.fsts_id = host_to_le32(fsts_id);
1400 req.stie.session_control = SESSION_CONTROL(SESSION_TYPE_BSS, 0);
1401
1402 fst_iface_get_channel_info(s.data.new_iface, &hw_mode, &channel);
1403 req.stie.new_band_id = fst_hw_mode_to_band(hw_mode);
1404 req.stie.new_band_op = 1;
1405 req.stie.new_band_setup = 0;
1406
1407 fst_iface_get_channel_info(s.data.old_iface, &hw_mode, &channel);
1408 req.stie.old_band_id = fst_hw_mode_to_band(hw_mode);
1409 req.stie.old_band_op = 1;
1410 req.stie.old_band_setup = 0;
1411
1412 if (!fst_read_next_text_param(endp, additional_param,
1413 sizeof(additional_param), &endp)) {
1414 if (!os_strcasecmp(additional_param, FST_CTR_PVAL_BAD_NEW_BAND))
1415 req.stie.new_band_id = req.stie.old_band_id;
1416 }
1417
1418 return fst_session_send_action(&s, TRUE, &req, sizeof(req),
1419 s.data.old_iface->mb_ie);
1420 }
1421
1422
fst_test_req_send_fst_response(const char * params)1423 int fst_test_req_send_fst_response(const char *params)
1424 {
1425 int fsts_id;
1426 Boolean is_valid;
1427 char *endp;
1428 struct fst_setup_res res;
1429 struct fst_session s;
1430 struct fst_group *g;
1431 enum hostapd_hw_mode hw_mode;
1432 u8 status_code;
1433 u8 channel;
1434 char response[FST_MAX_COMMAND_WORD_NAME_LENGTH];
1435 struct fst_session *_s;
1436
1437 if (params[0] != ' ')
1438 return -EINVAL;
1439 params++;
1440 fsts_id = fst_read_next_int_param(params, &is_valid, &endp);
1441 if (!is_valid)
1442 return -EINVAL;
1443
1444 if (get_group_fill_session(&g, &s))
1445 return -EINVAL;
1446
1447 status_code = WLAN_STATUS_SUCCESS;
1448 if (!fst_read_next_text_param(endp, response, sizeof(response),
1449 &endp)) {
1450 if (!os_strcasecmp(response, FST_CS_PVAL_RESPONSE_REJECT))
1451 status_code = WLAN_STATUS_PENDING_ADMITTING_FST_SESSION;
1452 }
1453
1454 os_memset(&res, 0, sizeof(res));
1455
1456 res.action = FST_ACTION_SETUP_RESPONSE;
1457 /*
1458 * If some session has just received an FST Setup Request, then
1459 * use the correct dialog token copied from this request.
1460 */
1461 _s = fst_find_session_in_progress(fst_session_get_peer_addr(&s, TRUE),
1462 g);
1463 res.dialog_token = (_s && fst_session_is_ready_pending(_s)) ?
1464 _s->data.pending_setup_req_dlgt : g->dialog_token;
1465 res.status_code = status_code;
1466
1467 res.stie.element_id = WLAN_EID_SESSION_TRANSITION;
1468 res.stie.length = sizeof(res.stie) - 2;
1469
1470 if (res.status_code == WLAN_STATUS_SUCCESS) {
1471 res.stie.fsts_id = fsts_id;
1472 res.stie.session_control = SESSION_CONTROL(SESSION_TYPE_BSS, 0);
1473
1474 fst_iface_get_channel_info(s.data.new_iface, &hw_mode,
1475 &channel);
1476 res.stie.new_band_id = fst_hw_mode_to_band(hw_mode);
1477 res.stie.new_band_op = 1;
1478 res.stie.new_band_setup = 0;
1479
1480 fst_iface_get_channel_info(s.data.old_iface, &hw_mode,
1481 &channel);
1482 res.stie.old_band_id = fst_hw_mode_to_band(hw_mode);
1483 res.stie.old_band_op = 1;
1484 res.stie.old_band_setup = 0;
1485 }
1486
1487 if (!fst_read_next_text_param(endp, response, sizeof(response),
1488 &endp)) {
1489 if (!os_strcasecmp(response, FST_CTR_PVAL_BAD_NEW_BAND))
1490 res.stie.new_band_id = res.stie.old_band_id;
1491 }
1492
1493 return fst_session_send_action(&s, TRUE, &res, sizeof(res),
1494 s.data.old_iface->mb_ie);
1495 }
1496
1497
fst_test_req_send_ack_request(const char * params)1498 int fst_test_req_send_ack_request(const char *params)
1499 {
1500 int fsts_id;
1501 Boolean is_valid;
1502 char *endp;
1503 struct fst_ack_req req;
1504 struct fst_session s;
1505 struct fst_group *g;
1506
1507 if (params[0] != ' ')
1508 return -EINVAL;
1509 params++;
1510 fsts_id = fst_read_next_int_param(params, &is_valid, &endp);
1511 if (!is_valid)
1512 return -EINVAL;
1513
1514 if (get_group_fill_session(&g, &s))
1515 return -EINVAL;
1516
1517 os_memset(&req, 0, sizeof(req));
1518 req.action = FST_ACTION_ACK_REQUEST;
1519 req.dialog_token = g->dialog_token;
1520 req.fsts_id = fsts_id;
1521
1522 return fst_session_send_action(&s, FALSE, &req, sizeof(req), NULL);
1523 }
1524
1525
fst_test_req_send_ack_response(const char * params)1526 int fst_test_req_send_ack_response(const char *params)
1527 {
1528 int fsts_id;
1529 Boolean is_valid;
1530 char *endp;
1531 struct fst_ack_res res;
1532 struct fst_session s;
1533 struct fst_group *g;
1534
1535 if (params[0] != ' ')
1536 return -EINVAL;
1537 params++;
1538 fsts_id = fst_read_next_int_param(params, &is_valid, &endp);
1539 if (!is_valid)
1540 return -EINVAL;
1541
1542 if (get_group_fill_session(&g, &s))
1543 return -EINVAL;
1544
1545 os_memset(&res, 0, sizeof(res));
1546 res.action = FST_ACTION_ACK_RESPONSE;
1547 res.dialog_token = g->dialog_token;
1548 res.fsts_id = fsts_id;
1549
1550 return fst_session_send_action(&s, FALSE, &res, sizeof(res), NULL);
1551 }
1552
1553
fst_test_req_send_tear_down(const char * params)1554 int fst_test_req_send_tear_down(const char *params)
1555 {
1556 int fsts_id;
1557 Boolean is_valid;
1558 char *endp;
1559 struct fst_tear_down td;
1560 struct fst_session s;
1561 struct fst_group *g;
1562
1563 if (params[0] != ' ')
1564 return -EINVAL;
1565 params++;
1566 fsts_id = fst_read_next_int_param(params, &is_valid, &endp);
1567 if (!is_valid)
1568 return -EINVAL;
1569
1570 if (get_group_fill_session(&g, &s))
1571 return -EINVAL;
1572
1573 os_memset(&td, 0, sizeof(td));
1574 td.action = FST_ACTION_TEAR_DOWN;
1575 td.fsts_id = fsts_id;
1576
1577 return fst_session_send_action(&s, TRUE, &td, sizeof(td), NULL);
1578 }
1579
1580
fst_test_req_get_fsts_id(const char * params)1581 u32 fst_test_req_get_fsts_id(const char *params)
1582 {
1583 int sid;
1584 Boolean is_valid;
1585 char *endp;
1586 struct fst_session *s;
1587
1588 if (params[0] != ' ')
1589 return FST_FSTS_ID_NOT_FOUND;
1590 params++;
1591 sid = fst_read_next_int_param(params, &is_valid, &endp);
1592 if (!is_valid)
1593 return FST_FSTS_ID_NOT_FOUND;
1594
1595 s = fst_session_get_by_id(sid);
1596 if (!s)
1597 return FST_FSTS_ID_NOT_FOUND;
1598
1599 return s->data.fsts_id;
1600 }
1601
1602
fst_test_req_get_local_mbies(const char * request,char * buf,size_t buflen)1603 int fst_test_req_get_local_mbies(const char *request, char *buf, size_t buflen)
1604 {
1605 char *endp;
1606 char ifname[FST_MAX_COMMAND_WORD_NAME_LENGTH];
1607 struct fst_group *g;
1608 struct fst_iface *iface;
1609
1610 if (request[0] != ' ')
1611 return -EINVAL;
1612 request++;
1613 if (fst_read_next_text_param(request, ifname, sizeof(ifname), &endp) ||
1614 !*ifname)
1615 goto problem;
1616 g = dl_list_first(&fst_global_groups_list, struct fst_group,
1617 global_groups_lentry);
1618 if (!g)
1619 goto problem;
1620 iface = fst_group_get_iface_by_name(g, ifname);
1621 if (!iface || !iface->mb_ie)
1622 goto problem;
1623 return wpa_snprintf_hex(buf, buflen, wpabuf_head(iface->mb_ie),
1624 wpabuf_len(iface->mb_ie));
1625
1626 problem:
1627 return os_snprintf(buf, buflen, "FAIL\n");
1628 }
1629
1630 #endif /* CONFIG_FST_TEST */
1631