1 /* Copyright (C) 2006, Red Hat, Inc. */
3 #include <linux/bitops.h>
4 #include <net/ieee80211.h>
5 #include <linux/etherdevice.h>
14 static const u8 bssid_any
[ETH_ALEN
] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
15 static const u8 bssid_off
[ETH_ALEN
] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
17 static void print_assoc_req(const char * extra
, struct assoc_request
* assoc_req
)
20 "#### Association Request: %s\n"
26 " BSSID: " MAC_FMT
"\n"
27 " Encryption:%s%s%s\n"
29 extra
, assoc_req
->flags
,
30 escape_essid(assoc_req
->ssid
, assoc_req
->ssid_len
),
31 assoc_req
->channel
, assoc_req
->band
, assoc_req
->mode
,
32 MAC_ARG(assoc_req
->bssid
),
33 assoc_req
->secinfo
.WPAenabled
? " WPA" : "",
34 assoc_req
->secinfo
.WPA2enabled
? " WPA2" : "",
35 assoc_req
->secinfo
.wep_enabled
? " WEP" : "",
36 assoc_req
->secinfo
.auth_mode
);
40 static int assoc_helper_essid(wlan_private
*priv
,
41 struct assoc_request
* assoc_req
)
43 wlan_adapter
*adapter
= priv
->adapter
;
45 struct bss_descriptor
* bss
;
48 lbs_deb_enter(LBS_DEB_ASSOC
);
50 /* FIXME: take channel into account when picking SSIDs if a channel
54 if (test_bit(ASSOC_FLAG_CHANNEL
, &assoc_req
->flags
))
55 channel
= assoc_req
->channel
;
57 lbs_deb_assoc("New SSID requested: '%s'\n",
58 escape_essid(assoc_req
->ssid
, assoc_req
->ssid_len
));
59 if (assoc_req
->mode
== IW_MODE_INFRA
) {
60 if (adapter
->prescan
) {
61 libertas_send_specific_ssid_scan(priv
, assoc_req
->ssid
,
62 assoc_req
->ssid_len
, 0);
65 bss
= libertas_find_ssid_in_list(adapter
, assoc_req
->ssid
,
66 assoc_req
->ssid_len
, NULL
, IW_MODE_INFRA
, channel
);
68 lbs_deb_assoc("SSID found in scan list, associating\n");
69 memcpy(&assoc_req
->bss
, bss
, sizeof(struct bss_descriptor
));
70 ret
= wlan_associate(priv
, assoc_req
);
72 lbs_deb_assoc("SSID not found; cannot associate\n");
74 } else if (assoc_req
->mode
== IW_MODE_ADHOC
) {
75 /* Scan for the network, do not save previous results. Stale
76 * scan data will cause us to join a non-existant adhoc network
78 libertas_send_specific_ssid_scan(priv
, assoc_req
->ssid
,
79 assoc_req
->ssid_len
, 1);
81 /* Search for the requested SSID in the scan table */
82 bss
= libertas_find_ssid_in_list(adapter
, assoc_req
->ssid
,
83 assoc_req
->ssid_len
, NULL
, IW_MODE_ADHOC
, channel
);
85 lbs_deb_assoc("SSID found, will join\n");
86 memcpy(&assoc_req
->bss
, bss
, sizeof(struct bss_descriptor
));
87 libertas_join_adhoc_network(priv
, assoc_req
);
89 /* else send START command */
90 lbs_deb_assoc("SSID not found, creating adhoc network\n");
91 memcpy(&assoc_req
->bss
.ssid
, &assoc_req
->ssid
,
93 assoc_req
->bss
.ssid_len
= assoc_req
->ssid_len
;
94 libertas_start_adhoc_network(priv
, assoc_req
);
98 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
103 static int assoc_helper_bssid(wlan_private
*priv
,
104 struct assoc_request
* assoc_req
)
106 wlan_adapter
*adapter
= priv
->adapter
;
108 struct bss_descriptor
* bss
;
110 lbs_deb_enter_args(LBS_DEB_ASSOC
, "BSSID " MAC_FMT
,
111 MAC_ARG(assoc_req
->bssid
));
113 /* Search for index position in list for requested MAC */
114 bss
= libertas_find_bssid_in_list(adapter
, assoc_req
->bssid
,
117 lbs_deb_assoc("ASSOC: WAP: BSSID " MAC_FMT
" not found, "
118 "cannot associate.\n", MAC_ARG(assoc_req
->bssid
));
122 memcpy(&assoc_req
->bss
, bss
, sizeof(struct bss_descriptor
));
123 if (assoc_req
->mode
== IW_MODE_INFRA
) {
124 ret
= wlan_associate(priv
, assoc_req
);
125 lbs_deb_assoc("ASSOC: wlan_associate(bssid) returned %d\n", ret
);
126 } else if (assoc_req
->mode
== IW_MODE_ADHOC
) {
127 libertas_join_adhoc_network(priv
, assoc_req
);
131 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
136 static int assoc_helper_associate(wlan_private
*priv
,
137 struct assoc_request
* assoc_req
)
139 int ret
= 0, done
= 0;
141 /* If we're given and 'any' BSSID, try associating based on SSID */
143 if (test_bit(ASSOC_FLAG_BSSID
, &assoc_req
->flags
)) {
144 if (compare_ether_addr(bssid_any
, assoc_req
->bssid
)
145 && compare_ether_addr(bssid_off
, assoc_req
->bssid
)) {
146 ret
= assoc_helper_bssid(priv
, assoc_req
);
149 lbs_deb_assoc("ASSOC: bssid: ret = %d\n", ret
);
154 if (!done
&& test_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
)) {
155 ret
= assoc_helper_essid(priv
, assoc_req
);
157 lbs_deb_assoc("ASSOC: bssid: ret = %d\n", ret
);
165 static int assoc_helper_mode(wlan_private
*priv
,
166 struct assoc_request
* assoc_req
)
168 wlan_adapter
*adapter
= priv
->adapter
;
171 lbs_deb_enter(LBS_DEB_ASSOC
);
173 if (assoc_req
->mode
== adapter
->mode
)
176 if (assoc_req
->mode
== IW_MODE_INFRA
) {
177 if (adapter
->psstate
!= PS_STATE_FULL_POWER
)
178 libertas_ps_wakeup(priv
, cmd_option_waitforrsp
);
179 adapter
->psmode
= wlan802_11powermodecam
;
182 adapter
->mode
= assoc_req
->mode
;
183 ret
= libertas_prepare_and_send_command(priv
,
185 0, cmd_option_waitforrsp
,
186 OID_802_11_INFRASTRUCTURE_MODE
,
187 /* Shoot me now */ (void *) (size_t) assoc_req
->mode
);
190 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
195 static int update_channel(wlan_private
* priv
)
197 /* the channel in f/w could be out of sync, get the current channel */
198 return libertas_prepare_and_send_command(priv
, cmd_802_11_rf_channel
,
199 cmd_opt_802_11_rf_channel_get
,
200 cmd_option_waitforrsp
, 0, NULL
);
203 void libertas_sync_channel(struct work_struct
*work
)
205 wlan_private
*priv
= container_of(work
, wlan_private
, sync_channel
);
207 if (update_channel(priv
) != 0)
208 lbs_pr_info("Channel synchronization failed.");
211 static int assoc_helper_channel(wlan_private
*priv
,
212 struct assoc_request
* assoc_req
)
214 wlan_adapter
*adapter
= priv
->adapter
;
217 lbs_deb_enter(LBS_DEB_ASSOC
);
219 ret
= update_channel(priv
);
221 lbs_deb_assoc("ASSOC: channel: error getting channel.");
224 if (assoc_req
->channel
== adapter
->curbssparams
.channel
)
227 lbs_deb_assoc("ASSOC: channel: %d -> %d\n",
228 adapter
->curbssparams
.channel
, assoc_req
->channel
);
230 ret
= libertas_prepare_and_send_command(priv
, cmd_802_11_rf_channel
,
231 cmd_opt_802_11_rf_channel_set
,
232 cmd_option_waitforrsp
, 0, &assoc_req
->channel
);
234 lbs_deb_assoc("ASSOC: channel: error setting channel.");
237 ret
= update_channel(priv
);
239 lbs_deb_assoc("ASSOC: channel: error getting channel.");
242 if (assoc_req
->channel
!= adapter
->curbssparams
.channel
) {
243 lbs_deb_assoc("ASSOC: channel: failed to update channel to %d",
248 if ( assoc_req
->secinfo
.wep_enabled
249 && (assoc_req
->wep_keys
[0].len
250 || assoc_req
->wep_keys
[1].len
251 || assoc_req
->wep_keys
[2].len
252 || assoc_req
->wep_keys
[3].len
)) {
253 /* Make sure WEP keys are re-sent to firmware */
254 set_bit(ASSOC_FLAG_WEP_KEYS
, &assoc_req
->flags
);
257 /* Must restart/rejoin adhoc networks after channel change */
258 set_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
);
261 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
266 static int assoc_helper_wep_keys(wlan_private
*priv
,
267 struct assoc_request
* assoc_req
)
269 wlan_adapter
*adapter
= priv
->adapter
;
273 lbs_deb_enter(LBS_DEB_ASSOC
);
275 /* Set or remove WEP keys */
276 if ( assoc_req
->wep_keys
[0].len
277 || assoc_req
->wep_keys
[1].len
278 || assoc_req
->wep_keys
[2].len
279 || assoc_req
->wep_keys
[3].len
) {
280 ret
= libertas_prepare_and_send_command(priv
,
283 cmd_option_waitforrsp
,
286 ret
= libertas_prepare_and_send_command(priv
,
289 cmd_option_waitforrsp
,
296 /* enable/disable the MAC's WEP packet filter */
297 if (assoc_req
->secinfo
.wep_enabled
)
298 adapter
->currentpacketfilter
|= cmd_act_mac_wep_enable
;
300 adapter
->currentpacketfilter
&= ~cmd_act_mac_wep_enable
;
301 ret
= libertas_set_mac_packet_filter(priv
);
305 mutex_lock(&adapter
->lock
);
307 /* Copy WEP keys into adapter wep key fields */
308 for (i
= 0; i
< 4; i
++) {
309 memcpy(&adapter
->wep_keys
[i
], &assoc_req
->wep_keys
[i
],
310 sizeof(struct WLAN_802_11_KEY
));
312 adapter
->wep_tx_keyidx
= assoc_req
->wep_tx_keyidx
;
314 mutex_unlock(&adapter
->lock
);
317 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
321 static int assoc_helper_secinfo(wlan_private
*priv
,
322 struct assoc_request
* assoc_req
)
324 wlan_adapter
*adapter
= priv
->adapter
;
329 lbs_deb_enter(LBS_DEB_ASSOC
);
331 memcpy(&adapter
->secinfo
, &assoc_req
->secinfo
,
332 sizeof(struct wlan_802_11_security
));
334 ret
= libertas_set_mac_packet_filter(priv
);
338 /* If RSN is already enabled, don't try to enable it again, since
339 * ENABLE_RSN resets internal state machines and will clobber the
340 * 4-way WPA handshake.
343 /* Get RSN enabled/disabled */
344 ret
= libertas_prepare_and_send_command(priv
,
345 cmd_802_11_enable_rsn
,
347 cmd_option_waitforrsp
,
350 lbs_deb_assoc("Failed to get RSN status: %d", ret
);
354 /* Don't re-enable RSN if it's already enabled */
355 do_wpa
= (assoc_req
->secinfo
.WPAenabled
|| assoc_req
->secinfo
.WPA2enabled
);
359 /* Set RSN enabled/disabled */
361 ret
= libertas_prepare_and_send_command(priv
,
362 cmd_802_11_enable_rsn
,
364 cmd_option_waitforrsp
,
368 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
373 static int assoc_helper_wpa_keys(wlan_private
*priv
,
374 struct assoc_request
* assoc_req
)
378 lbs_deb_enter(LBS_DEB_ASSOC
);
380 ret
= libertas_prepare_and_send_command(priv
,
381 cmd_802_11_key_material
,
383 cmd_option_waitforrsp
,
386 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
391 static int assoc_helper_wpa_ie(wlan_private
*priv
,
392 struct assoc_request
* assoc_req
)
394 wlan_adapter
*adapter
= priv
->adapter
;
397 lbs_deb_enter(LBS_DEB_ASSOC
);
399 if (assoc_req
->secinfo
.WPAenabled
|| assoc_req
->secinfo
.WPA2enabled
) {
400 memcpy(&adapter
->wpa_ie
, &assoc_req
->wpa_ie
, assoc_req
->wpa_ie_len
);
401 adapter
->wpa_ie_len
= assoc_req
->wpa_ie_len
;
403 memset(&adapter
->wpa_ie
, 0, MAX_WPA_IE_LEN
);
404 adapter
->wpa_ie_len
= 0;
407 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
412 static int should_deauth_infrastructure(wlan_adapter
*adapter
,
413 struct assoc_request
* assoc_req
)
415 if (adapter
->connect_status
!= libertas_connected
)
418 if (test_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
)) {
419 lbs_deb_assoc("Deauthenticating due to new SSID in "
420 " configuration request.\n");
424 if (test_bit(ASSOC_FLAG_SECINFO
, &assoc_req
->flags
)) {
425 if (adapter
->secinfo
.auth_mode
!= assoc_req
->secinfo
.auth_mode
) {
426 lbs_deb_assoc("Deauthenticating due to updated security "
427 "info in configuration request.\n");
432 if (test_bit(ASSOC_FLAG_BSSID
, &assoc_req
->flags
)) {
433 lbs_deb_assoc("Deauthenticating due to new BSSID in "
434 " configuration request.\n");
438 if (test_bit(ASSOC_FLAG_CHANNEL
, &assoc_req
->flags
)) {
439 lbs_deb_assoc("Deauthenticating due to channel switch.\n");
443 /* FIXME: deal with 'auto' mode somehow */
444 if (test_bit(ASSOC_FLAG_MODE
, &assoc_req
->flags
)) {
445 if (assoc_req
->mode
!= IW_MODE_INFRA
)
453 static int should_stop_adhoc(wlan_adapter
*adapter
,
454 struct assoc_request
* assoc_req
)
456 if (adapter
->connect_status
!= libertas_connected
)
459 if (libertas_ssid_cmp(adapter
->curbssparams
.ssid
,
460 adapter
->curbssparams
.ssid_len
,
461 assoc_req
->ssid
, assoc_req
->ssid_len
) != 0)
464 /* FIXME: deal with 'auto' mode somehow */
465 if (test_bit(ASSOC_FLAG_MODE
, &assoc_req
->flags
)) {
466 if (assoc_req
->mode
!= IW_MODE_ADHOC
)
470 if (test_bit(ASSOC_FLAG_CHANNEL
, &assoc_req
->flags
)) {
471 if (assoc_req
->channel
!= adapter
->curbssparams
.channel
)
479 void libertas_association_worker(struct work_struct
*work
)
481 wlan_private
*priv
= container_of(work
, wlan_private
, assoc_work
.work
);
482 wlan_adapter
*adapter
= priv
->adapter
;
483 struct assoc_request
* assoc_req
= NULL
;
485 int find_any_ssid
= 0;
487 lbs_deb_enter(LBS_DEB_ASSOC
);
489 mutex_lock(&adapter
->lock
);
490 assoc_req
= adapter
->pending_assoc_req
;
491 adapter
->pending_assoc_req
= NULL
;
492 adapter
->in_progress_assoc_req
= assoc_req
;
493 mutex_unlock(&adapter
->lock
);
498 print_assoc_req(__func__
, assoc_req
);
500 /* If 'any' SSID was specified, find an SSID to associate with */
501 if (test_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
)
502 && !assoc_req
->ssid_len
)
505 /* But don't use 'any' SSID if there's a valid locked BSSID to use */
506 if (test_bit(ASSOC_FLAG_BSSID
, &assoc_req
->flags
)) {
507 if (compare_ether_addr(assoc_req
->bssid
, bssid_any
)
508 && compare_ether_addr(assoc_req
->bssid
, bssid_off
))
515 ret
= libertas_find_best_network_ssid(priv
, assoc_req
->ssid
,
516 &assoc_req
->ssid_len
, assoc_req
->mode
, &new_mode
);
518 lbs_deb_assoc("Could not find best network\n");
523 /* Ensure we switch to the mode of the AP */
524 if (assoc_req
->mode
== IW_MODE_AUTO
) {
525 set_bit(ASSOC_FLAG_MODE
, &assoc_req
->flags
);
526 assoc_req
->mode
= new_mode
;
531 * Check if the attributes being changing require deauthentication
532 * from the currently associated infrastructure access point.
534 if (adapter
->mode
== IW_MODE_INFRA
) {
535 if (should_deauth_infrastructure(adapter
, assoc_req
)) {
536 ret
= libertas_send_deauthentication(priv
);
538 lbs_deb_assoc("Deauthentication due to new "
539 "configuration request failed: %d\n",
543 } else if (adapter
->mode
== IW_MODE_ADHOC
) {
544 if (should_stop_adhoc(adapter
, assoc_req
)) {
545 ret
= libertas_stop_adhoc_network(priv
);
547 lbs_deb_assoc("Teardown of AdHoc network due to "
548 "new configuration request failed: %d\n",
555 /* Send the various configuration bits to the firmware */
556 if (test_bit(ASSOC_FLAG_MODE
, &assoc_req
->flags
)) {
557 ret
= assoc_helper_mode(priv
, assoc_req
);
559 lbs_deb_assoc("ASSOC(:%d) mode: ret = %d\n", __LINE__
, ret
);
564 if (test_bit(ASSOC_FLAG_CHANNEL
, &assoc_req
->flags
)) {
565 ret
= assoc_helper_channel(priv
, assoc_req
);
567 lbs_deb_assoc("ASSOC(:%d) channel: ret = %d\n",
573 if ( test_bit(ASSOC_FLAG_WEP_KEYS
, &assoc_req
->flags
)
574 || test_bit(ASSOC_FLAG_WEP_TX_KEYIDX
, &assoc_req
->flags
)) {
575 ret
= assoc_helper_wep_keys(priv
, assoc_req
);
577 lbs_deb_assoc("ASSOC(:%d) wep_keys: ret = %d\n", __LINE__
, ret
);
582 if (test_bit(ASSOC_FLAG_SECINFO
, &assoc_req
->flags
)) {
583 ret
= assoc_helper_secinfo(priv
, assoc_req
);
585 lbs_deb_assoc("ASSOC(:%d) secinfo: ret = %d\n", __LINE__
, ret
);
590 if (test_bit(ASSOC_FLAG_WPA_IE
, &assoc_req
->flags
)) {
591 ret
= assoc_helper_wpa_ie(priv
, assoc_req
);
593 lbs_deb_assoc("ASSOC(:%d) wpa_ie: ret = %d\n", __LINE__
, ret
);
598 if (test_bit(ASSOC_FLAG_WPA_MCAST_KEY
, &assoc_req
->flags
)
599 || test_bit(ASSOC_FLAG_WPA_UCAST_KEY
, &assoc_req
->flags
)) {
600 ret
= assoc_helper_wpa_keys(priv
, assoc_req
);
602 lbs_deb_assoc("ASSOC(:%d) wpa_keys: ret = %d\n", __LINE__
, ret
);
607 /* SSID/BSSID should be the _last_ config option set, because they
608 * trigger the association attempt.
610 if (test_bit(ASSOC_FLAG_BSSID
, &assoc_req
->flags
)
611 || test_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
)) {
614 ret
= assoc_helper_associate(priv
, assoc_req
);
616 lbs_deb_assoc("ASSOC: association attempt unsuccessful: %d\n",
621 if (adapter
->connect_status
!= libertas_connected
) {
622 lbs_deb_assoc("ASSOC: assoication attempt unsuccessful, "
628 lbs_deb_assoc("ASSOC: association attempt successful. "
629 "Associated to '%s' (" MAC_FMT
")\n",
630 escape_essid(adapter
->curbssparams
.ssid
,
631 adapter
->curbssparams
.ssid_len
),
632 MAC_ARG(adapter
->curbssparams
.bssid
));
633 libertas_prepare_and_send_command(priv
,
635 0, cmd_option_waitforrsp
, 0, NULL
);
637 libertas_prepare_and_send_command(priv
,
639 0, cmd_option_waitforrsp
, 0, NULL
);
647 lbs_deb_assoc("ASSOC: reconfiguration attempt unsuccessful: %d\n",
651 mutex_lock(&adapter
->lock
);
652 adapter
->in_progress_assoc_req
= NULL
;
653 mutex_unlock(&adapter
->lock
);
657 lbs_deb_leave(LBS_DEB_ASSOC
);
662 * Caller MUST hold any necessary locks
664 struct assoc_request
* wlan_get_association_request(wlan_adapter
*adapter
)
666 struct assoc_request
* assoc_req
;
668 if (!adapter
->pending_assoc_req
) {
669 adapter
->pending_assoc_req
= kzalloc(sizeof(struct assoc_request
),
671 if (!adapter
->pending_assoc_req
) {
672 lbs_pr_info("Not enough memory to allocate association"
678 /* Copy current configuration attributes to the association request,
679 * but don't overwrite any that are already set.
681 assoc_req
= adapter
->pending_assoc_req
;
682 if (!test_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
)) {
683 memcpy(&assoc_req
->ssid
, &adapter
->curbssparams
.ssid
,
685 assoc_req
->ssid_len
= adapter
->curbssparams
.ssid_len
;
688 if (!test_bit(ASSOC_FLAG_CHANNEL
, &assoc_req
->flags
))
689 assoc_req
->channel
= adapter
->curbssparams
.channel
;
691 if (!test_bit(ASSOC_FLAG_BAND
, &assoc_req
->flags
))
692 assoc_req
->band
= adapter
->curbssparams
.band
;
694 if (!test_bit(ASSOC_FLAG_MODE
, &assoc_req
->flags
))
695 assoc_req
->mode
= adapter
->mode
;
697 if (!test_bit(ASSOC_FLAG_BSSID
, &assoc_req
->flags
)) {
698 memcpy(&assoc_req
->bssid
, adapter
->curbssparams
.bssid
,
702 if (!test_bit(ASSOC_FLAG_WEP_KEYS
, &assoc_req
->flags
)) {
704 for (i
= 0; i
< 4; i
++) {
705 memcpy(&assoc_req
->wep_keys
[i
], &adapter
->wep_keys
[i
],
706 sizeof(struct WLAN_802_11_KEY
));
710 if (!test_bit(ASSOC_FLAG_WEP_TX_KEYIDX
, &assoc_req
->flags
))
711 assoc_req
->wep_tx_keyidx
= adapter
->wep_tx_keyidx
;
713 if (!test_bit(ASSOC_FLAG_WPA_MCAST_KEY
, &assoc_req
->flags
)) {
714 memcpy(&assoc_req
->wpa_mcast_key
, &adapter
->wpa_mcast_key
,
715 sizeof(struct WLAN_802_11_KEY
));
718 if (!test_bit(ASSOC_FLAG_WPA_UCAST_KEY
, &assoc_req
->flags
)) {
719 memcpy(&assoc_req
->wpa_unicast_key
, &adapter
->wpa_unicast_key
,
720 sizeof(struct WLAN_802_11_KEY
));
723 if (!test_bit(ASSOC_FLAG_SECINFO
, &assoc_req
->flags
)) {
724 memcpy(&assoc_req
->secinfo
, &adapter
->secinfo
,
725 sizeof(struct wlan_802_11_security
));
728 if (!test_bit(ASSOC_FLAG_WPA_IE
, &assoc_req
->flags
)) {
729 memcpy(&assoc_req
->wpa_ie
, &adapter
->wpa_ie
,
731 assoc_req
->wpa_ie_len
= adapter
->wpa_ie_len
;
734 print_assoc_req(__func__
, assoc_req
);