2 * WPA Supplicant - driver interaction with generic Linux Wireless Extensions
3 * Copyright (c) 2003-2007, Jouni Malinen <j@w1.fi>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
9 * Alternatively, this software may be distributed under the terms of BSD
12 * See README and COPYING for more details.
14 * This file implements a driver interface for the Linux Wireless Extensions.
15 * When used with WE-18 or newer, this interface can be used as-is with number
16 * of drivers. In addition to this, some of the common functions in this file
17 * can be used by other driver interface implementations that use generic WE
18 * ioctls, but require private ioctls for some of the functionality.
22 #include <sys/ioctl.h>
23 #include <net/if_arp.h>
25 #include "wireless_copy.h"
29 #include "priv_netlink.h"
30 #include "driver_wext.h"
31 #include "ieee802_11_defs.h"
32 #include "wpa_common.h"
35 static int wpa_driver_wext_flush_pmkid(void *priv
);
36 static int wpa_driver_wext_get_range(void *priv
);
37 static void wpa_driver_wext_finish_drv_init(struct wpa_driver_wext_data
*drv
);
40 static int wpa_driver_wext_send_oper_ifla(struct wpa_driver_wext_data
*drv
,
41 int linkmode
, int operstate
)
45 struct ifinfomsg ifinfo
;
52 os_memset(&req
, 0, sizeof(req
));
54 req
.hdr
.nlmsg_len
= NLMSG_LENGTH(sizeof(struct ifinfomsg
));
55 req
.hdr
.nlmsg_type
= RTM_SETLINK
;
56 req
.hdr
.nlmsg_flags
= NLM_F_REQUEST
;
57 req
.hdr
.nlmsg_seq
= ++nl_seq
;
58 req
.hdr
.nlmsg_pid
= 0;
60 req
.ifinfo
.ifi_family
= AF_UNSPEC
;
61 req
.ifinfo
.ifi_type
= 0;
62 req
.ifinfo
.ifi_index
= drv
->ifindex
;
63 req
.ifinfo
.ifi_flags
= 0;
64 req
.ifinfo
.ifi_change
= 0;
67 rta
= (struct rtattr
*)
68 ((char *) &req
+ NLMSG_ALIGN(req
.hdr
.nlmsg_len
));
69 rta
->rta_type
= IFLA_LINKMODE
;
70 rta
->rta_len
= RTA_LENGTH(sizeof(char));
71 *((char *) RTA_DATA(rta
)) = linkmode
;
72 req
.hdr
.nlmsg_len
= NLMSG_ALIGN(req
.hdr
.nlmsg_len
) +
73 RTA_LENGTH(sizeof(char));
75 if (operstate
!= -1) {
76 rta
= (struct rtattr
*)
77 ((char *) &req
+ NLMSG_ALIGN(req
.hdr
.nlmsg_len
));
78 rta
->rta_type
= IFLA_OPERSTATE
;
79 rta
->rta_len
= RTA_LENGTH(sizeof(char));
80 *((char *) RTA_DATA(rta
)) = operstate
;
81 req
.hdr
.nlmsg_len
= NLMSG_ALIGN(req
.hdr
.nlmsg_len
) +
82 RTA_LENGTH(sizeof(char));
85 wpa_printf(MSG_DEBUG
, "WEXT: Operstate: linkmode=%d, operstate=%d",
88 ret
= send(drv
->event_sock
, &req
, req
.hdr
.nlmsg_len
, 0);
90 wpa_printf(MSG_DEBUG
, "WEXT: Sending operstate IFLA failed: "
91 "%s (assume operstate is not supported)",
95 return ret
< 0 ? -1 : 0;
99 int wpa_driver_wext_set_auth_param(struct wpa_driver_wext_data
*drv
,
105 os_memset(&iwr
, 0, sizeof(iwr
));
106 os_strlcpy(iwr
.ifr_name
, drv
->ifname
, IFNAMSIZ
);
107 iwr
.u
.param
.flags
= idx
& IW_AUTH_INDEX
;
108 iwr
.u
.param
.value
= value
;
110 if (ioctl(drv
->ioctl_sock
, SIOCSIWAUTH
, &iwr
) < 0) {
111 if (errno
!= EOPNOTSUPP
) {
112 wpa_printf(MSG_DEBUG
, "WEXT: SIOCSIWAUTH(param %d "
113 "value 0x%x) failed: %s)",
114 idx
, value
, strerror(errno
));
116 ret
= errno
== EOPNOTSUPP
? -2 : -1;
124 * wpa_driver_wext_get_bssid - Get BSSID, SIOCGIWAP
125 * @priv: Pointer to private wext data from wpa_driver_wext_init()
126 * @bssid: Buffer for BSSID
127 * Returns: 0 on success, -1 on failure
129 int wpa_driver_wext_get_bssid(void *priv
, u8
*bssid
)
131 struct wpa_driver_wext_data
*drv
= priv
;
135 os_memset(&iwr
, 0, sizeof(iwr
));
136 os_strlcpy(iwr
.ifr_name
, drv
->ifname
, IFNAMSIZ
);
138 if (ioctl(drv
->ioctl_sock
, SIOCGIWAP
, &iwr
) < 0) {
139 perror("ioctl[SIOCGIWAP]");
142 os_memcpy(bssid
, iwr
.u
.ap_addr
.sa_data
, ETH_ALEN
);
149 * wpa_driver_wext_set_bssid - Set BSSID, SIOCSIWAP
150 * @priv: Pointer to private wext data from wpa_driver_wext_init()
152 * Returns: 0 on success, -1 on failure
154 int wpa_driver_wext_set_bssid(void *priv
, const u8
*bssid
)
156 struct wpa_driver_wext_data
*drv
= priv
;
160 os_memset(&iwr
, 0, sizeof(iwr
));
161 os_strlcpy(iwr
.ifr_name
, drv
->ifname
, IFNAMSIZ
);
162 iwr
.u
.ap_addr
.sa_family
= ARPHRD_ETHER
;
164 os_memcpy(iwr
.u
.ap_addr
.sa_data
, bssid
, ETH_ALEN
);
166 os_memset(iwr
.u
.ap_addr
.sa_data
, 0, ETH_ALEN
);
168 if (ioctl(drv
->ioctl_sock
, SIOCSIWAP
, &iwr
) < 0) {
169 perror("ioctl[SIOCSIWAP]");
178 * wpa_driver_wext_get_ssid - Get SSID, SIOCGIWESSID
179 * @priv: Pointer to private wext data from wpa_driver_wext_init()
180 * @ssid: Buffer for the SSID; must be at least 32 bytes long
181 * Returns: SSID length on success, -1 on failure
183 int wpa_driver_wext_get_ssid(void *priv
, u8
*ssid
)
185 struct wpa_driver_wext_data
*drv
= priv
;
189 os_memset(&iwr
, 0, sizeof(iwr
));
190 os_strlcpy(iwr
.ifr_name
, drv
->ifname
, IFNAMSIZ
);
191 iwr
.u
.essid
.pointer
= (caddr_t
) ssid
;
192 iwr
.u
.essid
.length
= 32;
194 if (ioctl(drv
->ioctl_sock
, SIOCGIWESSID
, &iwr
) < 0) {
195 perror("ioctl[SIOCGIWESSID]");
198 ret
= iwr
.u
.essid
.length
;
201 /* Some drivers include nul termination in the SSID, so let's
202 * remove it here before further processing. WE-21 changes this
203 * to explicitly require the length _not_ to include nul
205 if (ret
> 0 && ssid
[ret
- 1] == '\0' &&
206 drv
->we_version_compiled
< 21)
215 * wpa_driver_wext_set_ssid - Set SSID, SIOCSIWESSID
216 * @priv: Pointer to private wext data from wpa_driver_wext_init()
218 * @ssid_len: Length of SSID (0..32)
219 * Returns: 0 on success, -1 on failure
221 int wpa_driver_wext_set_ssid(void *priv
, const u8
*ssid
, size_t ssid_len
)
223 struct wpa_driver_wext_data
*drv
= priv
;
231 os_memset(&iwr
, 0, sizeof(iwr
));
232 os_strlcpy(iwr
.ifr_name
, drv
->ifname
, IFNAMSIZ
);
233 /* flags: 1 = ESSID is active, 0 = not (promiscuous) */
234 iwr
.u
.essid
.flags
= (ssid_len
!= 0);
235 os_memset(buf
, 0, sizeof(buf
));
236 os_memcpy(buf
, ssid
, ssid_len
);
237 iwr
.u
.essid
.pointer
= (caddr_t
) buf
;
238 if (drv
->we_version_compiled
< 21) {
239 /* For historic reasons, set SSID length to include one extra
240 * character, C string nul termination, even though SSID is
241 * really an octet string that should not be presented as a C
242 * string. Some Linux drivers decrement the length by one and
243 * can thus end up missing the last octet of the SSID if the
244 * length is not incremented here. WE-21 changes this to
245 * explicitly require the length _not_ to include nul
250 iwr
.u
.essid
.length
= ssid_len
;
252 if (ioctl(drv
->ioctl_sock
, SIOCSIWESSID
, &iwr
) < 0) {
253 perror("ioctl[SIOCSIWESSID]");
262 * wpa_driver_wext_set_freq - Set frequency/channel, SIOCSIWFREQ
263 * @priv: Pointer to private wext data from wpa_driver_wext_init()
264 * @freq: Frequency in MHz
265 * Returns: 0 on success, -1 on failure
267 int wpa_driver_wext_set_freq(void *priv
, int freq
)
269 struct wpa_driver_wext_data
*drv
= priv
;
273 os_memset(&iwr
, 0, sizeof(iwr
));
274 os_strlcpy(iwr
.ifr_name
, drv
->ifname
, IFNAMSIZ
);
275 iwr
.u
.freq
.m
= freq
* 100000;
278 if (ioctl(drv
->ioctl_sock
, SIOCSIWFREQ
, &iwr
) < 0) {
279 perror("ioctl[SIOCSIWFREQ]");
288 wpa_driver_wext_event_wireless_custom(void *ctx
, char *custom
)
290 union wpa_event_data data
;
292 wpa_printf(MSG_MSGDUMP
, "WEXT: Custom wireless event: '%s'",
295 os_memset(&data
, 0, sizeof(data
));
297 if (os_strncmp(custom
, "MLME-MICHAELMICFAILURE.indication", 33) == 0) {
298 data
.michael_mic_failure
.unicast
=
299 os_strstr(custom
, " unicast ") != NULL
;
300 /* TODO: parse parameters(?) */
301 wpa_supplicant_event(ctx
, EVENT_MICHAEL_MIC_FAILURE
, &data
);
302 } else if (os_strncmp(custom
, "ASSOCINFO(ReqIEs=", 17) == 0) {
308 bytes
= strspn(spos
, "0123456789abcdefABCDEF");
309 if (!bytes
|| (bytes
& 1))
313 data
.assoc_info
.req_ies
= os_malloc(bytes
);
314 if (data
.assoc_info
.req_ies
== NULL
)
317 data
.assoc_info
.req_ies_len
= bytes
;
318 hexstr2bin(spos
, data
.assoc_info
.req_ies
, bytes
);
322 data
.assoc_info
.resp_ies
= NULL
;
323 data
.assoc_info
.resp_ies_len
= 0;
325 if (os_strncmp(spos
, " RespIEs=", 9) == 0) {
328 bytes
= strspn(spos
, "0123456789abcdefABCDEF");
329 if (!bytes
|| (bytes
& 1))
333 data
.assoc_info
.resp_ies
= os_malloc(bytes
);
334 if (data
.assoc_info
.resp_ies
== NULL
)
337 data
.assoc_info
.resp_ies_len
= bytes
;
338 hexstr2bin(spos
, data
.assoc_info
.resp_ies
, bytes
);
341 wpa_supplicant_event(ctx
, EVENT_ASSOCINFO
, &data
);
344 os_free(data
.assoc_info
.resp_ies
);
345 os_free(data
.assoc_info
.req_ies
);
346 #ifdef CONFIG_PEERKEY
347 } else if (os_strncmp(custom
, "STKSTART.request=", 17) == 0) {
348 if (hwaddr_aton(custom
+ 17, data
.stkstart
.peer
)) {
349 wpa_printf(MSG_DEBUG
, "WEXT: unrecognized "
350 "STKSTART.request '%s'", custom
+ 17);
353 wpa_supplicant_event(ctx
, EVENT_STKSTART
, &data
);
354 #endif /* CONFIG_PEERKEY */
359 static int wpa_driver_wext_event_wireless_michaelmicfailure(
360 void *ctx
, const char *ev
, size_t len
)
362 const struct iw_michaelmicfailure
*mic
;
363 union wpa_event_data data
;
365 if (len
< sizeof(*mic
))
368 mic
= (const struct iw_michaelmicfailure
*) ev
;
370 wpa_printf(MSG_DEBUG
, "Michael MIC failure wireless event: "
371 "flags=0x%x src_addr=" MACSTR
, mic
->flags
,
372 MAC2STR(mic
->src_addr
.sa_data
));
374 os_memset(&data
, 0, sizeof(data
));
375 data
.michael_mic_failure
.unicast
= !(mic
->flags
& IW_MICFAILURE_GROUP
);
376 wpa_supplicant_event(ctx
, EVENT_MICHAEL_MIC_FAILURE
, &data
);
382 static int wpa_driver_wext_event_wireless_pmkidcand(
383 struct wpa_driver_wext_data
*drv
, const char *ev
, size_t len
)
385 const struct iw_pmkid_cand
*cand
;
386 union wpa_event_data data
;
389 if (len
< sizeof(*cand
))
392 cand
= (const struct iw_pmkid_cand
*) ev
;
393 addr
= (const u8
*) cand
->bssid
.sa_data
;
395 wpa_printf(MSG_DEBUG
, "PMKID candidate wireless event: "
396 "flags=0x%x index=%d bssid=" MACSTR
, cand
->flags
,
397 cand
->index
, MAC2STR(addr
));
399 os_memset(&data
, 0, sizeof(data
));
400 os_memcpy(data
.pmkid_candidate
.bssid
, addr
, ETH_ALEN
);
401 data
.pmkid_candidate
.index
= cand
->index
;
402 data
.pmkid_candidate
.preauth
= cand
->flags
& IW_PMKID_CAND_PREAUTH
;
403 wpa_supplicant_event(drv
->ctx
, EVENT_PMKID_CANDIDATE
, &data
);
409 static int wpa_driver_wext_event_wireless_assocreqie(
410 struct wpa_driver_wext_data
*drv
, const char *ev
, int len
)
415 wpa_hexdump(MSG_DEBUG
, "AssocReq IE wireless event", (const u8
*) ev
,
417 os_free(drv
->assoc_req_ies
);
418 drv
->assoc_req_ies
= os_malloc(len
);
419 if (drv
->assoc_req_ies
== NULL
) {
420 drv
->assoc_req_ies_len
= 0;
423 os_memcpy(drv
->assoc_req_ies
, ev
, len
);
424 drv
->assoc_req_ies_len
= len
;
430 static int wpa_driver_wext_event_wireless_assocrespie(
431 struct wpa_driver_wext_data
*drv
, const char *ev
, int len
)
436 wpa_hexdump(MSG_DEBUG
, "AssocResp IE wireless event", (const u8
*) ev
,
438 os_free(drv
->assoc_resp_ies
);
439 drv
->assoc_resp_ies
= os_malloc(len
);
440 if (drv
->assoc_resp_ies
== NULL
) {
441 drv
->assoc_resp_ies_len
= 0;
444 os_memcpy(drv
->assoc_resp_ies
, ev
, len
);
445 drv
->assoc_resp_ies_len
= len
;
451 static void wpa_driver_wext_event_assoc_ies(struct wpa_driver_wext_data
*drv
)
453 union wpa_event_data data
;
455 if (drv
->assoc_req_ies
== NULL
&& drv
->assoc_resp_ies
== NULL
)
458 os_memset(&data
, 0, sizeof(data
));
459 if (drv
->assoc_req_ies
) {
460 data
.assoc_info
.req_ies
= drv
->assoc_req_ies
;
461 drv
->assoc_req_ies
= NULL
;
462 data
.assoc_info
.req_ies_len
= drv
->assoc_req_ies_len
;
464 if (drv
->assoc_resp_ies
) {
465 data
.assoc_info
.resp_ies
= drv
->assoc_resp_ies
;
466 drv
->assoc_resp_ies
= NULL
;
467 data
.assoc_info
.resp_ies_len
= drv
->assoc_resp_ies_len
;
470 wpa_supplicant_event(drv
->ctx
, EVENT_ASSOCINFO
, &data
);
472 os_free(data
.assoc_info
.req_ies
);
473 os_free(data
.assoc_info
.resp_ies
);
477 static void wpa_driver_wext_event_wireless(struct wpa_driver_wext_data
*drv
,
478 void *ctx
, char *data
, int len
)
480 struct iw_event iwe_buf
, *iwe
= &iwe_buf
;
481 char *pos
, *end
, *custom
, *buf
;
486 while (pos
+ IW_EV_LCP_LEN
<= end
) {
487 /* Event data may be unaligned, so make a local, aligned copy
488 * before processing. */
489 os_memcpy(&iwe_buf
, pos
, IW_EV_LCP_LEN
);
490 wpa_printf(MSG_DEBUG
, "Wireless event: cmd=0x%x len=%d",
492 if (iwe
->len
<= IW_EV_LCP_LEN
)
495 custom
= pos
+ IW_EV_POINT_LEN
;
496 if (drv
->we_version_compiled
> 18 &&
497 (iwe
->cmd
== IWEVMICHAELMICFAILURE
||
498 iwe
->cmd
== IWEVCUSTOM
||
499 iwe
->cmd
== IWEVASSOCREQIE
||
500 iwe
->cmd
== IWEVASSOCRESPIE
||
501 iwe
->cmd
== IWEVPMKIDCAND
)) {
502 /* WE-19 removed the pointer from struct iw_point */
503 char *dpos
= (char *) &iwe_buf
.u
.data
.length
;
504 int dlen
= dpos
- (char *) &iwe_buf
;
505 os_memcpy(dpos
, pos
+ IW_EV_LCP_LEN
,
506 sizeof(struct iw_event
) - dlen
);
508 os_memcpy(&iwe_buf
, pos
, sizeof(struct iw_event
));
509 custom
+= IW_EV_POINT_OFF
;
514 wpa_printf(MSG_DEBUG
, "Wireless event: new AP: "
516 MAC2STR((u8
*) iwe
->u
.ap_addr
.sa_data
));
517 if (is_zero_ether_addr(
518 (const u8
*) iwe
->u
.ap_addr
.sa_data
) ||
519 os_memcmp(iwe
->u
.ap_addr
.sa_data
,
520 "\x44\x44\x44\x44\x44\x44", ETH_ALEN
) ==
522 os_free(drv
->assoc_req_ies
);
523 drv
->assoc_req_ies
= NULL
;
524 os_free(drv
->assoc_resp_ies
);
525 drv
->assoc_resp_ies
= NULL
;
526 wpa_supplicant_event(ctx
, EVENT_DISASSOC
,
530 wpa_driver_wext_event_assoc_ies(drv
);
531 wpa_supplicant_event(ctx
, EVENT_ASSOC
, NULL
);
534 case IWEVMICHAELMICFAILURE
:
535 if (custom
+ iwe
->u
.data
.length
> end
) {
536 wpa_printf(MSG_DEBUG
, "WEXT: Invalid "
537 "IWEVMICHAELMICFAILURE length");
540 wpa_driver_wext_event_wireless_michaelmicfailure(
541 ctx
, custom
, iwe
->u
.data
.length
);
544 if (custom
+ iwe
->u
.data
.length
> end
) {
545 wpa_printf(MSG_DEBUG
, "WEXT: Invalid "
546 "IWEVCUSTOM length");
549 buf
= os_malloc(iwe
->u
.data
.length
+ 1);
552 os_memcpy(buf
, custom
, iwe
->u
.data
.length
);
553 buf
[iwe
->u
.data
.length
] = '\0';
554 wpa_driver_wext_event_wireless_custom(ctx
, buf
);
558 drv
->scan_complete_events
= 1;
559 eloop_cancel_timeout(wpa_driver_wext_scan_timeout
,
561 wpa_supplicant_event(ctx
, EVENT_SCAN_RESULTS
, NULL
);
564 if (custom
+ iwe
->u
.data
.length
> end
) {
565 wpa_printf(MSG_DEBUG
, "WEXT: Invalid "
566 "IWEVASSOCREQIE length");
569 wpa_driver_wext_event_wireless_assocreqie(
570 drv
, custom
, iwe
->u
.data
.length
);
572 case IWEVASSOCRESPIE
:
573 if (custom
+ iwe
->u
.data
.length
> end
) {
574 wpa_printf(MSG_DEBUG
, "WEXT: Invalid "
575 "IWEVASSOCRESPIE length");
578 wpa_driver_wext_event_wireless_assocrespie(
579 drv
, custom
, iwe
->u
.data
.length
);
582 if (custom
+ iwe
->u
.data
.length
> end
) {
583 wpa_printf(MSG_DEBUG
, "WEXT: Invalid "
584 "IWEVPMKIDCAND length");
587 wpa_driver_wext_event_wireless_pmkidcand(
588 drv
, custom
, iwe
->u
.data
.length
);
597 static void wpa_driver_wext_event_link(struct wpa_driver_wext_data
*drv
,
598 void *ctx
, char *buf
, size_t len
,
601 union wpa_event_data event
;
603 os_memset(&event
, 0, sizeof(event
));
604 if (len
> sizeof(event
.interface_status
.ifname
))
605 len
= sizeof(event
.interface_status
.ifname
) - 1;
606 os_memcpy(event
.interface_status
.ifname
, buf
, len
);
607 event
.interface_status
.ievent
= del
? EVENT_INTERFACE_REMOVED
:
608 EVENT_INTERFACE_ADDED
;
610 wpa_printf(MSG_DEBUG
, "RTM_%sLINK, IFLA_IFNAME: Interface '%s' %s",
612 event
.interface_status
.ifname
,
613 del
? "removed" : "added");
615 if (os_strcmp(drv
->ifname
, event
.interface_status
.ifname
) == 0) {
622 wpa_supplicant_event(ctx
, EVENT_INTERFACE_STATUS
, &event
);
626 static int wpa_driver_wext_own_ifname(struct wpa_driver_wext_data
*drv
,
629 struct ifinfomsg
*ifi
;
630 int attrlen
, nlmsg_len
, rta_len
;
635 nlmsg_len
= NLMSG_ALIGN(sizeof(struct ifinfomsg
));
637 attrlen
= h
->nlmsg_len
- nlmsg_len
;
641 attr
= (struct rtattr
*) (((char *) ifi
) + nlmsg_len
);
643 rta_len
= RTA_ALIGN(sizeof(struct rtattr
));
644 while (RTA_OK(attr
, attrlen
)) {
645 if (attr
->rta_type
== IFLA_IFNAME
) {
646 if (os_strcmp(((char *) attr
) + rta_len
, drv
->ifname
)
652 attr
= RTA_NEXT(attr
, attrlen
);
659 static int wpa_driver_wext_own_ifindex(struct wpa_driver_wext_data
*drv
,
660 int ifindex
, struct nlmsghdr
*h
)
662 if (drv
->ifindex
== ifindex
|| drv
->ifindex2
== ifindex
)
665 if (drv
->if_removed
&& wpa_driver_wext_own_ifname(drv
, h
)) {
666 drv
->ifindex
= if_nametoindex(drv
->ifname
);
667 wpa_printf(MSG_DEBUG
, "WEXT: Update ifindex for a removed "
669 wpa_driver_wext_finish_drv_init(drv
);
677 static void wpa_driver_wext_event_rtm_newlink(struct wpa_driver_wext_data
*drv
,
678 void *ctx
, struct nlmsghdr
*h
,
681 struct ifinfomsg
*ifi
;
682 int attrlen
, nlmsg_len
, rta_len
;
683 struct rtattr
* attr
;
685 if (len
< sizeof(*ifi
))
690 if (!wpa_driver_wext_own_ifindex(drv
, ifi
->ifi_index
, h
)) {
691 wpa_printf(MSG_DEBUG
, "Ignore event for foreign ifindex %d",
696 wpa_printf(MSG_DEBUG
, "RTM_NEWLINK: operstate=%d ifi_flags=0x%x "
698 drv
->operstate
, ifi
->ifi_flags
,
699 (ifi
->ifi_flags
& IFF_UP
) ? "[UP]" : "",
700 (ifi
->ifi_flags
& IFF_RUNNING
) ? "[RUNNING]" : "",
701 (ifi
->ifi_flags
& IFF_LOWER_UP
) ? "[LOWER_UP]" : "",
702 (ifi
->ifi_flags
& IFF_DORMANT
) ? "[DORMANT]" : "");
704 * Some drivers send the association event before the operup event--in
705 * this case, lifting operstate in wpa_driver_wext_set_operstate()
706 * fails. This will hit us when wpa_supplicant does not need to do
707 * IEEE 802.1X authentication
709 if (drv
->operstate
== 1 &&
710 (ifi
->ifi_flags
& (IFF_LOWER_UP
| IFF_DORMANT
)) == IFF_LOWER_UP
&&
711 !(ifi
->ifi_flags
& IFF_RUNNING
))
712 wpa_driver_wext_send_oper_ifla(drv
, -1, IF_OPER_UP
);
714 nlmsg_len
= NLMSG_ALIGN(sizeof(struct ifinfomsg
));
716 attrlen
= h
->nlmsg_len
- nlmsg_len
;
720 attr
= (struct rtattr
*) (((char *) ifi
) + nlmsg_len
);
722 rta_len
= RTA_ALIGN(sizeof(struct rtattr
));
723 while (RTA_OK(attr
, attrlen
)) {
724 if (attr
->rta_type
== IFLA_WIRELESS
) {
725 wpa_driver_wext_event_wireless(
726 drv
, ctx
, ((char *) attr
) + rta_len
,
727 attr
->rta_len
- rta_len
);
728 } else if (attr
->rta_type
== IFLA_IFNAME
) {
729 wpa_driver_wext_event_link(drv
, ctx
,
730 ((char *) attr
) + rta_len
,
731 attr
->rta_len
- rta_len
, 0);
733 attr
= RTA_NEXT(attr
, attrlen
);
738 static void wpa_driver_wext_event_rtm_dellink(struct wpa_driver_wext_data
*drv
,
739 void *ctx
, struct nlmsghdr
*h
,
742 struct ifinfomsg
*ifi
;
743 int attrlen
, nlmsg_len
, rta_len
;
744 struct rtattr
* attr
;
746 if (len
< sizeof(*ifi
))
751 nlmsg_len
= NLMSG_ALIGN(sizeof(struct ifinfomsg
));
753 attrlen
= h
->nlmsg_len
- nlmsg_len
;
757 attr
= (struct rtattr
*) (((char *) ifi
) + nlmsg_len
);
759 rta_len
= RTA_ALIGN(sizeof(struct rtattr
));
760 while (RTA_OK(attr
, attrlen
)) {
761 if (attr
->rta_type
== IFLA_IFNAME
) {
762 wpa_driver_wext_event_link(drv
, ctx
,
763 ((char *) attr
) + rta_len
,
764 attr
->rta_len
- rta_len
, 1);
766 attr
= RTA_NEXT(attr
, attrlen
);
771 static void wpa_driver_wext_event_receive(int sock
, void *eloop_ctx
,
776 struct sockaddr_nl from
;
782 fromlen
= sizeof(from
);
783 left
= recvfrom(sock
, buf
, sizeof(buf
), MSG_DONTWAIT
,
784 (struct sockaddr
*) &from
, &fromlen
);
786 if (errno
!= EINTR
&& errno
!= EAGAIN
)
787 perror("recvfrom(netlink)");
791 h
= (struct nlmsghdr
*) buf
;
792 while (left
>= (int) sizeof(*h
)) {
796 plen
= len
- sizeof(*h
);
797 if (len
> left
|| plen
< 0) {
798 wpa_printf(MSG_DEBUG
, "Malformed netlink message: "
799 "len=%d left=%d plen=%d",
804 switch (h
->nlmsg_type
) {
806 wpa_driver_wext_event_rtm_newlink(eloop_ctx
, sock_ctx
,
810 wpa_driver_wext_event_rtm_dellink(eloop_ctx
, sock_ctx
,
815 len
= NLMSG_ALIGN(len
);
817 h
= (struct nlmsghdr
*) ((char *) h
+ len
);
821 wpa_printf(MSG_DEBUG
, "%d extra bytes in the end of netlink "
825 if (--max_events
> 0) {
827 * Try to receive all events in one eloop call in order to
828 * limit race condition on cases where AssocInfo event, Assoc
829 * event, and EAPOL frames are received more or less at the
830 * same time. We want to process the event messages first
831 * before starting EAPOL processing.
838 static int wpa_driver_wext_get_ifflags_ifname(struct wpa_driver_wext_data
*drv
,
839 const char *ifname
, int *flags
)
843 os_memset(&ifr
, 0, sizeof(ifr
));
844 os_strlcpy(ifr
.ifr_name
, ifname
, IFNAMSIZ
);
845 if (ioctl(drv
->ioctl_sock
, SIOCGIFFLAGS
, (caddr_t
) &ifr
) < 0) {
846 perror("ioctl[SIOCGIFFLAGS]");
849 *flags
= ifr
.ifr_flags
& 0xffff;
855 * wpa_driver_wext_get_ifflags - Get interface flags (SIOCGIFFLAGS)
856 * @drv: driver_wext private data
857 * @flags: Pointer to returned flags value
858 * Returns: 0 on success, -1 on failure
860 int wpa_driver_wext_get_ifflags(struct wpa_driver_wext_data
*drv
, int *flags
)
862 return wpa_driver_wext_get_ifflags_ifname(drv
, drv
->ifname
, flags
);
866 static int wpa_driver_wext_set_ifflags_ifname(struct wpa_driver_wext_data
*drv
,
867 const char *ifname
, int flags
)
871 os_memset(&ifr
, 0, sizeof(ifr
));
872 os_strlcpy(ifr
.ifr_name
, ifname
, IFNAMSIZ
);
873 ifr
.ifr_flags
= flags
& 0xffff;
874 if (ioctl(drv
->ioctl_sock
, SIOCSIFFLAGS
, (caddr_t
) &ifr
) < 0) {
875 perror("SIOCSIFFLAGS");
883 * wpa_driver_wext_set_ifflags - Set interface flags (SIOCSIFFLAGS)
884 * @drv: driver_wext private data
885 * @flags: New value for flags
886 * Returns: 0 on success, -1 on failure
888 int wpa_driver_wext_set_ifflags(struct wpa_driver_wext_data
*drv
, int flags
)
890 return wpa_driver_wext_set_ifflags_ifname(drv
, drv
->ifname
, flags
);
895 * wpa_driver_wext_init - Initialize WE driver interface
896 * @ctx: context to be used when calling wpa_supplicant functions,
897 * e.g., wpa_supplicant_event()
898 * @ifname: interface name, e.g., wlan0
899 * Returns: Pointer to private data, %NULL on failure
901 void * wpa_driver_wext_init(void *ctx
, const char *ifname
)
904 struct sockaddr_nl local
;
905 struct wpa_driver_wext_data
*drv
;
907 drv
= os_zalloc(sizeof(*drv
));
911 os_strlcpy(drv
->ifname
, ifname
, sizeof(drv
->ifname
));
913 drv
->ioctl_sock
= socket(PF_INET
, SOCK_DGRAM
, 0);
914 if (drv
->ioctl_sock
< 0) {
915 perror("socket(PF_INET,SOCK_DGRAM)");
920 s
= socket(PF_NETLINK
, SOCK_RAW
, NETLINK_ROUTE
);
922 perror("socket(PF_NETLINK,SOCK_RAW,NETLINK_ROUTE)");
923 close(drv
->ioctl_sock
);
928 os_memset(&local
, 0, sizeof(local
));
929 local
.nl_family
= AF_NETLINK
;
930 local
.nl_groups
= RTMGRP_LINK
;
931 if (bind(s
, (struct sockaddr
*) &local
, sizeof(local
)) < 0) {
932 perror("bind(netlink)");
934 close(drv
->ioctl_sock
);
939 eloop_register_read_sock(s
, wpa_driver_wext_event_receive
, drv
, ctx
);
944 wpa_driver_wext_finish_drv_init(drv
);
950 static void wpa_driver_wext_finish_drv_init(struct wpa_driver_wext_data
*drv
)
954 if (wpa_driver_wext_get_ifflags(drv
, &flags
) != 0)
955 printf("Could not get interface '%s' flags\n", drv
->ifname
);
956 else if (!(flags
& IFF_UP
)) {
957 if (wpa_driver_wext_set_ifflags(drv
, flags
| IFF_UP
) != 0) {
958 printf("Could not set interface '%s' UP\n",
962 * Wait some time to allow driver to initialize before
963 * starting configuring the driver. This seems to be
964 * needed at least some drivers that load firmware etc.
965 * when the interface is set up.
967 wpa_printf(MSG_DEBUG
, "Interface %s set UP - waiting "
968 "a second for the driver to complete "
969 "initialization", drv
->ifname
);
975 * Make sure that the driver does not have any obsolete PMKID entries.
977 wpa_driver_wext_flush_pmkid(drv
);
979 if (wpa_driver_wext_set_mode(drv
, 0) < 0) {
980 printf("Could not configure driver to use managed mode\n");
983 wpa_driver_wext_get_range(drv
);
985 drv
->ifindex
= if_nametoindex(drv
->ifname
);
987 if (os_strncmp(drv
->ifname
, "wlan", 4) == 0) {
989 * Host AP driver may use both wlan# and wifi# interface in
990 * wireless events. Since some of the versions included WE-18
991 * support, let's add the alternative ifindex also from
992 * driver_wext.c for the time being. This may be removed at
993 * some point once it is believed that old versions of the
994 * driver are not in use anymore.
996 char ifname2
[IFNAMSIZ
+ 1];
997 os_strlcpy(ifname2
, drv
->ifname
, sizeof(ifname2
));
998 os_memcpy(ifname2
, "wifi", 4);
999 wpa_driver_wext_alternative_ifindex(drv
, ifname2
);
1002 wpa_driver_wext_send_oper_ifla(drv
, 1, IF_OPER_DORMANT
);
1007 * wpa_driver_wext_deinit - Deinitialize WE driver interface
1008 * @priv: Pointer to private wext data from wpa_driver_wext_init()
1010 * Shut down driver interface and processing of driver events. Free
1011 * private data buffer if one was allocated in wpa_driver_wext_init().
1013 void wpa_driver_wext_deinit(void *priv
)
1015 struct wpa_driver_wext_data
*drv
= priv
;
1018 eloop_cancel_timeout(wpa_driver_wext_scan_timeout
, drv
, drv
->ctx
);
1021 * Clear possibly configured driver parameters in order to make it
1022 * easier to use the driver after wpa_supplicant has been terminated.
1024 (void) wpa_driver_wext_set_bssid(drv
,
1025 (u8
*) "\x00\x00\x00\x00\x00\x00");
1027 wpa_driver_wext_send_oper_ifla(priv
, 0, IF_OPER_UP
);
1029 eloop_unregister_read_sock(drv
->event_sock
);
1030 if (drv
->mlme_sock
>= 0)
1031 eloop_unregister_read_sock(drv
->mlme_sock
);
1033 if (wpa_driver_wext_get_ifflags(drv
, &flags
) == 0)
1034 (void) wpa_driver_wext_set_ifflags(drv
, flags
& ~IFF_UP
);
1036 close(drv
->event_sock
);
1037 close(drv
->ioctl_sock
);
1038 if (drv
->mlme_sock
>= 0)
1039 close(drv
->mlme_sock
);
1040 os_free(drv
->assoc_req_ies
);
1041 os_free(drv
->assoc_resp_ies
);
1047 * wpa_driver_wext_scan_timeout - Scan timeout to report scan completion
1048 * @eloop_ctx: Unused
1049 * @timeout_ctx: ctx argument given to wpa_driver_wext_init()
1051 * This function can be used as registered timeout when starting a scan to
1052 * generate a scan completed event if the driver does not report this.
1054 void wpa_driver_wext_scan_timeout(void *eloop_ctx
, void *timeout_ctx
)
1056 wpa_printf(MSG_DEBUG
, "Scan timeout - try to get results");
1057 wpa_supplicant_event(timeout_ctx
, EVENT_SCAN_RESULTS
, NULL
);
1062 * wpa_driver_wext_scan - Request the driver to initiate scan
1063 * @priv: Pointer to private wext data from wpa_driver_wext_init()
1064 * @ssid: Specific SSID to scan for (ProbeReq) or %NULL to scan for
1065 * all SSIDs (either active scan with broadcast SSID or passive
1067 * @ssid_len: Length of the SSID
1068 * Returns: 0 on success, -1 on failure
1070 int wpa_driver_wext_scan(void *priv
, const u8
*ssid
, size_t ssid_len
)
1072 struct wpa_driver_wext_data
*drv
= priv
;
1074 int ret
= 0, timeout
;
1075 struct iw_scan_req req
;
1077 if (ssid_len
> IW_ESSID_MAX_SIZE
) {
1078 wpa_printf(MSG_DEBUG
, "%s: too long SSID (%lu)",
1079 __FUNCTION__
, (unsigned long) ssid_len
);
1083 os_memset(&iwr
, 0, sizeof(iwr
));
1084 os_strlcpy(iwr
.ifr_name
, drv
->ifname
, IFNAMSIZ
);
1086 if (ssid
&& ssid_len
) {
1087 os_memset(&req
, 0, sizeof(req
));
1088 req
.essid_len
= ssid_len
;
1089 req
.bssid
.sa_family
= ARPHRD_ETHER
;
1090 os_memset(req
.bssid
.sa_data
, 0xff, ETH_ALEN
);
1091 os_memcpy(req
.essid
, ssid
, ssid_len
);
1092 iwr
.u
.data
.pointer
= (caddr_t
) &req
;
1093 iwr
.u
.data
.length
= sizeof(req
);
1094 iwr
.u
.data
.flags
= IW_SCAN_THIS_ESSID
;
1097 if (ioctl(drv
->ioctl_sock
, SIOCSIWSCAN
, &iwr
) < 0) {
1098 perror("ioctl[SIOCSIWSCAN]");
1102 /* Not all drivers generate "scan completed" wireless event, so try to
1103 * read results after a timeout. */
1105 if (drv
->scan_complete_events
) {
1107 * The driver seems to deliver SIOCGIWSCAN events to notify
1108 * when scan is complete, so use longer timeout to avoid race
1109 * conditions with scanning and following association request.
1113 wpa_printf(MSG_DEBUG
, "Scan requested (ret=%d) - scan timeout %d "
1114 "seconds", ret
, timeout
);
1115 eloop_cancel_timeout(wpa_driver_wext_scan_timeout
, drv
, drv
->ctx
);
1116 eloop_register_timeout(timeout
, 0, wpa_driver_wext_scan_timeout
, drv
,
1123 static u8
* wpa_driver_wext_giwscan(struct wpa_driver_wext_data
*drv
,
1130 res_buf_len
= IW_SCAN_MAX_DATA
;
1132 res_buf
= os_malloc(res_buf_len
);
1133 if (res_buf
== NULL
)
1135 os_memset(&iwr
, 0, sizeof(iwr
));
1136 os_strlcpy(iwr
.ifr_name
, drv
->ifname
, IFNAMSIZ
);
1137 iwr
.u
.data
.pointer
= res_buf
;
1138 iwr
.u
.data
.length
= res_buf_len
;
1140 if (ioctl(drv
->ioctl_sock
, SIOCGIWSCAN
, &iwr
) == 0)
1143 if (errno
== E2BIG
&& res_buf_len
< 100000) {
1147 wpa_printf(MSG_DEBUG
, "Scan results did not fit - "
1148 "trying larger buffer (%lu bytes)",
1149 (unsigned long) res_buf_len
);
1151 perror("ioctl[SIOCGIWSCAN]");
1157 if (iwr
.u
.data
.length
> res_buf_len
) {
1161 *len
= iwr
.u
.data
.length
;
1168 * Data structure for collecting WEXT scan results. This is needed to allow
1169 * the various methods of reporting IEs to be combined into a single IE buffer.
1171 struct wext_scan_data
{
1172 struct wpa_scan_res res
;
1181 static void wext_get_scan_mode(struct iw_event
*iwe
,
1182 struct wext_scan_data
*res
)
1184 if (iwe
->u
.mode
== IW_MODE_ADHOC
)
1185 res
->res
.caps
|= IEEE80211_CAP_IBSS
;
1186 else if (iwe
->u
.mode
== IW_MODE_MASTER
|| iwe
->u
.mode
== IW_MODE_INFRA
)
1187 res
->res
.caps
|= IEEE80211_CAP_ESS
;
1191 static void wext_get_scan_ssid(struct iw_event
*iwe
,
1192 struct wext_scan_data
*res
, char *custom
,
1195 int ssid_len
= iwe
->u
.essid
.length
;
1196 if (custom
+ ssid_len
> end
)
1198 if (iwe
->u
.essid
.flags
&&
1200 ssid_len
<= IW_ESSID_MAX_SIZE
) {
1201 os_memcpy(res
->ssid
, custom
, ssid_len
);
1202 res
->ssid_len
= ssid_len
;
1207 static void wext_get_scan_freq(struct iw_event
*iwe
,
1208 struct wext_scan_data
*res
)
1210 int divi
= 1000000, i
;
1212 if (iwe
->u
.freq
.e
== 0) {
1214 * Some drivers do not report frequency, but a channel.
1215 * Try to map this to frequency by assuming they are using
1216 * IEEE 802.11b/g. But don't overwrite a previously parsed
1217 * frequency if the driver sends both frequency and channel,
1218 * since the driver may be sending an A-band channel that we
1219 * don't handle here.
1225 if (iwe
->u
.freq
.m
>= 1 && iwe
->u
.freq
.m
<= 13) {
1226 res
->res
.freq
= 2407 + 5 * iwe
->u
.freq
.m
;
1228 } else if (iwe
->u
.freq
.m
== 14) {
1229 res
->res
.freq
= 2484;
1234 if (iwe
->u
.freq
.e
> 6) {
1235 wpa_printf(MSG_DEBUG
, "Invalid freq in scan results (BSSID="
1236 MACSTR
" m=%d e=%d)",
1237 MAC2STR(res
->res
.bssid
), iwe
->u
.freq
.m
,
1242 for (i
= 0; i
< iwe
->u
.freq
.e
; i
++)
1244 res
->res
.freq
= iwe
->u
.freq
.m
/ divi
;
1248 static void wext_get_scan_qual(struct iw_event
*iwe
,
1249 struct wext_scan_data
*res
)
1251 res
->res
.qual
= iwe
->u
.qual
.qual
;
1252 res
->res
.noise
= iwe
->u
.qual
.noise
;
1253 res
->res
.level
= iwe
->u
.qual
.level
;
1257 static void wext_get_scan_encode(struct iw_event
*iwe
,
1258 struct wext_scan_data
*res
)
1260 if (!(iwe
->u
.data
.flags
& IW_ENCODE_DISABLED
))
1261 res
->res
.caps
|= IEEE80211_CAP_PRIVACY
;
1265 static void wext_get_scan_rate(struct iw_event
*iwe
,
1266 struct wext_scan_data
*res
, char *pos
,
1270 char *custom
= pos
+ IW_EV_LCP_LEN
;
1275 if (custom
+ clen
> end
)
1278 while (((ssize_t
) clen
) >= (ssize_t
) sizeof(struct iw_param
)) {
1279 /* Note: may be misaligned, make a local, aligned copy */
1280 os_memcpy(&p
, custom
, sizeof(struct iw_param
));
1281 if (p
.value
> maxrate
)
1283 clen
-= sizeof(struct iw_param
);
1284 custom
+= sizeof(struct iw_param
);
1287 /* Convert the maxrate from WE-style (b/s units) to
1288 * 802.11 rates (500000 b/s units).
1290 res
->maxrate
= maxrate
/ 500000;
1294 static void wext_get_scan_iwevgenie(struct iw_event
*iwe
,
1295 struct wext_scan_data
*res
, char *custom
,
1298 char *genie
, *gpos
, *gend
;
1301 if (iwe
->u
.data
.length
== 0)
1304 gpos
= genie
= custom
;
1305 gend
= genie
+ iwe
->u
.data
.length
;
1307 wpa_printf(MSG_INFO
, "IWEVGENIE overflow");
1311 tmp
= os_realloc(res
->ie
, res
->ie_len
+ gend
- gpos
);
1314 os_memcpy(tmp
+ res
->ie_len
, gpos
, gend
- gpos
);
1316 res
->ie_len
+= gend
- gpos
;
1320 static void wext_get_scan_custom(struct iw_event
*iwe
,
1321 struct wext_scan_data
*res
, char *custom
,
1327 clen
= iwe
->u
.data
.length
;
1328 if (custom
+ clen
> end
)
1331 if (clen
> 7 && os_strncmp(custom
, "wpa_ie=", 7) == 0) {
1335 bytes
= custom
+ clen
- spos
;
1336 if (bytes
& 1 || bytes
== 0)
1339 tmp
= os_realloc(res
->ie
, res
->ie_len
+ bytes
);
1342 hexstr2bin(spos
, tmp
+ res
->ie_len
, bytes
);
1344 res
->ie_len
+= bytes
;
1345 } else if (clen
> 7 && os_strncmp(custom
, "rsn_ie=", 7) == 0) {
1349 bytes
= custom
+ clen
- spos
;
1350 if (bytes
& 1 || bytes
== 0)
1353 tmp
= os_realloc(res
->ie
, res
->ie_len
+ bytes
);
1356 hexstr2bin(spos
, tmp
+ res
->ie_len
, bytes
);
1358 res
->ie_len
+= bytes
;
1359 } else if (clen
> 4 && os_strncmp(custom
, "tsf=", 4) == 0) {
1364 bytes
= custom
+ clen
- spos
;
1366 wpa_printf(MSG_INFO
, "Invalid TSF length (%d)", bytes
);
1370 hexstr2bin(spos
, bin
, bytes
);
1371 res
->res
.tsf
+= WPA_GET_BE64(bin
);
1376 static int wext_19_iw_point(struct wpa_driver_wext_data
*drv
, u16 cmd
)
1378 return drv
->we_version_compiled
> 18 &&
1379 (cmd
== SIOCGIWESSID
|| cmd
== SIOCGIWENCODE
||
1380 cmd
== IWEVGENIE
|| cmd
== IWEVCUSTOM
);
1384 static void wpa_driver_wext_add_scan_entry(struct wpa_scan_results
*res
,
1385 struct wext_scan_data
*data
)
1387 struct wpa_scan_res
**tmp
;
1388 struct wpa_scan_res
*r
;
1390 u8
*pos
, *end
, *ssid_ie
= NULL
, *rate_ie
= NULL
;
1392 /* Figure out whether we need to fake any IEs */
1394 end
= pos
+ data
->ie_len
;
1395 while (pos
&& pos
+ 1 < end
) {
1396 if (pos
+ 2 + pos
[1] > end
)
1398 if (pos
[0] == WLAN_EID_SSID
)
1400 else if (pos
[0] == WLAN_EID_SUPP_RATES
)
1402 else if (pos
[0] == WLAN_EID_EXT_SUPP_RATES
)
1408 if (ssid_ie
== NULL
)
1409 extra_len
+= 2 + data
->ssid_len
;
1410 if (rate_ie
== NULL
&& data
->maxrate
)
1413 r
= os_zalloc(sizeof(*r
) + extra_len
+ data
->ie_len
);
1416 os_memcpy(r
, &data
->res
, sizeof(*r
));
1417 r
->ie_len
= extra_len
+ data
->ie_len
;
1418 pos
= (u8
*) (r
+ 1);
1419 if (ssid_ie
== NULL
) {
1421 * Generate a fake SSID IE since the driver did not report
1424 *pos
++ = WLAN_EID_SSID
;
1425 *pos
++ = data
->ssid_len
;
1426 os_memcpy(pos
, data
->ssid
, data
->ssid_len
);
1427 pos
+= data
->ssid_len
;
1429 if (rate_ie
== NULL
&& data
->maxrate
) {
1431 * Generate a fake Supported Rates IE since the driver did not
1432 * report a full IE list.
1434 *pos
++ = WLAN_EID_SUPP_RATES
;
1436 *pos
++ = data
->maxrate
;
1439 os_memcpy(pos
, data
->ie
, data
->ie_len
);
1441 tmp
= os_realloc(res
->res
,
1442 (res
->num
+ 1) * sizeof(struct wpa_scan_res
*));
1447 tmp
[res
->num
++] = r
;
1453 * wpa_driver_wext_get_scan_results - Fetch the latest scan results
1454 * @priv: Pointer to private wext data from wpa_driver_wext_init()
1455 * Returns: Scan results on success, -1 on failure
1457 struct wpa_scan_results
* wpa_driver_wext_get_scan_results(void *priv
)
1459 struct wpa_driver_wext_data
*drv
= priv
;
1460 size_t ap_num
= 0, len
;
1463 struct iw_event iwe_buf
, *iwe
= &iwe_buf
;
1464 char *pos
, *end
, *custom
;
1465 struct wpa_scan_results
*res
;
1466 struct wext_scan_data data
;
1468 res_buf
= wpa_driver_wext_giwscan(drv
, &len
);
1469 if (res_buf
== NULL
)
1475 res
= os_zalloc(sizeof(*res
));
1481 pos
= (char *) res_buf
;
1482 end
= (char *) res_buf
+ len
;
1483 os_memset(&data
, 0, sizeof(data
));
1485 while (pos
+ IW_EV_LCP_LEN
<= end
) {
1486 /* Event data may be unaligned, so make a local, aligned copy
1487 * before processing. */
1488 os_memcpy(&iwe_buf
, pos
, IW_EV_LCP_LEN
);
1489 if (iwe
->len
<= IW_EV_LCP_LEN
)
1492 custom
= pos
+ IW_EV_POINT_LEN
;
1493 if (wext_19_iw_point(drv
, iwe
->cmd
)) {
1494 /* WE-19 removed the pointer from struct iw_point */
1495 char *dpos
= (char *) &iwe_buf
.u
.data
.length
;
1496 int dlen
= dpos
- (char *) &iwe_buf
;
1497 os_memcpy(dpos
, pos
+ IW_EV_LCP_LEN
,
1498 sizeof(struct iw_event
) - dlen
);
1500 os_memcpy(&iwe_buf
, pos
, sizeof(struct iw_event
));
1501 custom
+= IW_EV_POINT_OFF
;
1507 wpa_driver_wext_add_scan_entry(res
, &data
);
1510 os_memset(&data
, 0, sizeof(data
));
1511 os_memcpy(data
.res
.bssid
,
1512 iwe
->u
.ap_addr
.sa_data
, ETH_ALEN
);
1515 wext_get_scan_mode(iwe
, &data
);
1518 wext_get_scan_ssid(iwe
, &data
, custom
, end
);
1521 wext_get_scan_freq(iwe
, &data
);
1524 wext_get_scan_qual(iwe
, &data
);
1527 wext_get_scan_encode(iwe
, &data
);
1530 wext_get_scan_rate(iwe
, &data
, pos
, end
);
1533 wext_get_scan_iwevgenie(iwe
, &data
, custom
, end
);
1536 wext_get_scan_custom(iwe
, &data
, custom
, end
);
1545 wpa_driver_wext_add_scan_entry(res
, &data
);
1548 wpa_printf(MSG_DEBUG
, "Received %lu bytes of scan results (%lu BSSes)",
1549 (unsigned long) len
, (unsigned long) res
->num
);
1555 static int wpa_driver_wext_get_range(void *priv
)
1557 struct wpa_driver_wext_data
*drv
= priv
;
1558 struct iw_range
*range
;
1564 * Use larger buffer than struct iw_range in order to allow the
1565 * structure to grow in the future.
1567 buflen
= sizeof(struct iw_range
) + 500;
1568 range
= os_zalloc(buflen
);
1572 os_memset(&iwr
, 0, sizeof(iwr
));
1573 os_strlcpy(iwr
.ifr_name
, drv
->ifname
, IFNAMSIZ
);
1574 iwr
.u
.data
.pointer
= (caddr_t
) range
;
1575 iwr
.u
.data
.length
= buflen
;
1577 minlen
= ((char *) &range
->enc_capa
) - (char *) range
+
1578 sizeof(range
->enc_capa
);
1580 if (ioctl(drv
->ioctl_sock
, SIOCGIWRANGE
, &iwr
) < 0) {
1581 perror("ioctl[SIOCGIWRANGE]");
1584 } else if (iwr
.u
.data
.length
>= minlen
&&
1585 range
->we_version_compiled
>= 18) {
1586 wpa_printf(MSG_DEBUG
, "SIOCGIWRANGE: WE(compiled)=%d "
1587 "WE(source)=%d enc_capa=0x%x",
1588 range
->we_version_compiled
,
1589 range
->we_version_source
,
1591 drv
->has_capability
= 1;
1592 drv
->we_version_compiled
= range
->we_version_compiled
;
1593 if (range
->enc_capa
& IW_ENC_CAPA_WPA
) {
1594 drv
->capa
.key_mgmt
|= WPA_DRIVER_CAPA_KEY_MGMT_WPA
|
1595 WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK
;
1597 if (range
->enc_capa
& IW_ENC_CAPA_WPA2
) {
1598 drv
->capa
.key_mgmt
|= WPA_DRIVER_CAPA_KEY_MGMT_WPA2
|
1599 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK
;
1601 drv
->capa
.enc
|= WPA_DRIVER_CAPA_ENC_WEP40
|
1602 WPA_DRIVER_CAPA_ENC_WEP104
;
1603 if (range
->enc_capa
& IW_ENC_CAPA_CIPHER_TKIP
)
1604 drv
->capa
.enc
|= WPA_DRIVER_CAPA_ENC_TKIP
;
1605 if (range
->enc_capa
& IW_ENC_CAPA_CIPHER_CCMP
)
1606 drv
->capa
.enc
|= WPA_DRIVER_CAPA_ENC_CCMP
;
1607 if (range
->enc_capa
& IW_ENC_CAPA_4WAY_HANDSHAKE
)
1608 drv
->capa
.flags
|= WPA_DRIVER_FLAGS_4WAY_HANDSHAKE
;
1610 wpa_printf(MSG_DEBUG
, " capabilities: key_mgmt 0x%x enc 0x%x "
1612 drv
->capa
.key_mgmt
, drv
->capa
.enc
, drv
->capa
.flags
);
1614 wpa_printf(MSG_DEBUG
, "SIOCGIWRANGE: too old (short) data - "
1615 "assuming WPA is not supported");
1623 static int wpa_driver_wext_set_wpa(void *priv
, int enabled
)
1625 struct wpa_driver_wext_data
*drv
= priv
;
1626 wpa_printf(MSG_DEBUG
, "%s", __FUNCTION__
);
1628 return wpa_driver_wext_set_auth_param(drv
, IW_AUTH_WPA_ENABLED
,
1633 static int wpa_driver_wext_set_psk(struct wpa_driver_wext_data
*drv
,
1636 struct iw_encode_ext
*ext
;
1640 wpa_printf(MSG_DEBUG
, "%s", __FUNCTION__
);
1642 if (!(drv
->capa
.flags
& WPA_DRIVER_FLAGS_4WAY_HANDSHAKE
))
1648 os_memset(&iwr
, 0, sizeof(iwr
));
1649 os_strlcpy(iwr
.ifr_name
, drv
->ifname
, IFNAMSIZ
);
1651 ext
= os_zalloc(sizeof(*ext
) + PMK_LEN
);
1655 iwr
.u
.encoding
.pointer
= (caddr_t
) ext
;
1656 iwr
.u
.encoding
.length
= sizeof(*ext
) + PMK_LEN
;
1657 ext
->key_len
= PMK_LEN
;
1658 os_memcpy(&ext
->key
, psk
, ext
->key_len
);
1659 ext
->alg
= IW_ENCODE_ALG_PMK
;
1661 ret
= ioctl(drv
->ioctl_sock
, SIOCSIWENCODEEXT
, &iwr
);
1663 perror("ioctl[SIOCSIWENCODEEXT] PMK");
1670 static int wpa_driver_wext_set_key_ext(void *priv
, wpa_alg alg
,
1671 const u8
*addr
, int key_idx
,
1672 int set_tx
, const u8
*seq
,
1674 const u8
*key
, size_t key_len
)
1676 struct wpa_driver_wext_data
*drv
= priv
;
1679 struct iw_encode_ext
*ext
;
1681 if (seq_len
> IW_ENCODE_SEQ_MAX_SIZE
) {
1682 wpa_printf(MSG_DEBUG
, "%s: Invalid seq_len %lu",
1683 __FUNCTION__
, (unsigned long) seq_len
);
1687 ext
= os_zalloc(sizeof(*ext
) + key_len
);
1690 os_memset(&iwr
, 0, sizeof(iwr
));
1691 os_strlcpy(iwr
.ifr_name
, drv
->ifname
, IFNAMSIZ
);
1692 iwr
.u
.encoding
.flags
= key_idx
+ 1;
1693 iwr
.u
.encoding
.flags
|= IW_ENCODE_TEMP
;
1694 if (alg
== WPA_ALG_NONE
)
1695 iwr
.u
.encoding
.flags
|= IW_ENCODE_DISABLED
;
1696 iwr
.u
.encoding
.pointer
= (caddr_t
) ext
;
1697 iwr
.u
.encoding
.length
= sizeof(*ext
) + key_len
;
1700 os_memcmp(addr
, "\xff\xff\xff\xff\xff\xff", ETH_ALEN
) == 0)
1701 ext
->ext_flags
|= IW_ENCODE_EXT_GROUP_KEY
;
1703 ext
->ext_flags
|= IW_ENCODE_EXT_SET_TX_KEY
;
1705 ext
->addr
.sa_family
= ARPHRD_ETHER
;
1707 os_memcpy(ext
->addr
.sa_data
, addr
, ETH_ALEN
);
1709 os_memset(ext
->addr
.sa_data
, 0xff, ETH_ALEN
);
1710 if (key
&& key_len
) {
1711 os_memcpy(ext
+ 1, key
, key_len
);
1712 ext
->key_len
= key_len
;
1716 ext
->alg
= IW_ENCODE_ALG_NONE
;
1719 ext
->alg
= IW_ENCODE_ALG_WEP
;
1722 ext
->alg
= IW_ENCODE_ALG_TKIP
;
1725 ext
->alg
= IW_ENCODE_ALG_CCMP
;
1728 ext
->alg
= IW_ENCODE_ALG_PMK
;
1730 #ifdef CONFIG_IEEE80211W
1732 ext
->alg
= IW_ENCODE_ALG_AES_CMAC
;
1734 #endif /* CONFIG_IEEE80211W */
1736 wpa_printf(MSG_DEBUG
, "%s: Unknown algorithm %d",
1742 if (seq
&& seq_len
) {
1743 ext
->ext_flags
|= IW_ENCODE_EXT_RX_SEQ_VALID
;
1744 os_memcpy(ext
->rx_seq
, seq
, seq_len
);
1747 if (ioctl(drv
->ioctl_sock
, SIOCSIWENCODEEXT
, &iwr
) < 0) {
1748 ret
= errno
== EOPNOTSUPP
? -2 : -1;
1749 if (errno
== ENODEV
) {
1751 * ndiswrapper seems to be returning incorrect error
1756 perror("ioctl[SIOCSIWENCODEEXT]");
1765 * wpa_driver_wext_set_key - Configure encryption key
1766 * @priv: Pointer to private wext data from wpa_driver_wext_init()
1767 * @priv: Private driver interface data
1768 * @alg: Encryption algorithm (%WPA_ALG_NONE, %WPA_ALG_WEP,
1769 * %WPA_ALG_TKIP, %WPA_ALG_CCMP); %WPA_ALG_NONE clears the key.
1770 * @addr: Address of the peer STA or ff:ff:ff:ff:ff:ff for
1771 * broadcast/default keys
1772 * @key_idx: key index (0..3), usually 0 for unicast keys
1773 * @set_tx: Configure this key as the default Tx key (only used when
1774 * driver does not support separate unicast/individual key
1775 * @seq: Sequence number/packet number, seq_len octets, the next
1776 * packet number to be used for in replay protection; configured
1777 * for Rx keys (in most cases, this is only used with broadcast
1778 * keys and set to zero for unicast keys)
1779 * @seq_len: Length of the seq, depends on the algorithm:
1780 * TKIP: 6 octets, CCMP: 6 octets
1781 * @key: Key buffer; TKIP: 16-byte temporal key, 8-byte Tx Mic key,
1783 * @key_len: Length of the key buffer in octets (WEP: 5 or 13,
1784 * TKIP: 32, CCMP: 16)
1785 * Returns: 0 on success, -1 on failure
1787 * This function uses SIOCSIWENCODEEXT by default, but tries to use
1788 * SIOCSIWENCODE if the extended ioctl fails when configuring a WEP key.
1790 int wpa_driver_wext_set_key(void *priv
, wpa_alg alg
,
1791 const u8
*addr
, int key_idx
,
1792 int set_tx
, const u8
*seq
, size_t seq_len
,
1793 const u8
*key
, size_t key_len
)
1795 struct wpa_driver_wext_data
*drv
= priv
;
1799 wpa_printf(MSG_DEBUG
, "%s: alg=%d key_idx=%d set_tx=%d seq_len=%lu "
1801 __FUNCTION__
, alg
, key_idx
, set_tx
,
1802 (unsigned long) seq_len
, (unsigned long) key_len
);
1804 ret
= wpa_driver_wext_set_key_ext(drv
, alg
, addr
, key_idx
, set_tx
,
1805 seq
, seq_len
, key
, key_len
);
1810 (alg
== WPA_ALG_NONE
|| alg
== WPA_ALG_WEP
)) {
1811 wpa_printf(MSG_DEBUG
, "Driver did not support "
1812 "SIOCSIWENCODEEXT, trying SIOCSIWENCODE");
1815 wpa_printf(MSG_DEBUG
, "Driver did not support "
1816 "SIOCSIWENCODEEXT");
1820 os_memset(&iwr
, 0, sizeof(iwr
));
1821 os_strlcpy(iwr
.ifr_name
, drv
->ifname
, IFNAMSIZ
);
1822 iwr
.u
.encoding
.flags
= key_idx
+ 1;
1823 iwr
.u
.encoding
.flags
|= IW_ENCODE_TEMP
;
1824 if (alg
== WPA_ALG_NONE
)
1825 iwr
.u
.encoding
.flags
|= IW_ENCODE_DISABLED
;
1826 iwr
.u
.encoding
.pointer
= (caddr_t
) key
;
1827 iwr
.u
.encoding
.length
= key_len
;
1829 if (ioctl(drv
->ioctl_sock
, SIOCSIWENCODE
, &iwr
) < 0) {
1830 perror("ioctl[SIOCSIWENCODE]");
1834 if (set_tx
&& alg
!= WPA_ALG_NONE
) {
1835 os_memset(&iwr
, 0, sizeof(iwr
));
1836 os_strlcpy(iwr
.ifr_name
, drv
->ifname
, IFNAMSIZ
);
1837 iwr
.u
.encoding
.flags
= key_idx
+ 1;
1838 iwr
.u
.encoding
.flags
|= IW_ENCODE_TEMP
;
1839 iwr
.u
.encoding
.pointer
= (caddr_t
) NULL
;
1840 iwr
.u
.encoding
.length
= 0;
1841 if (ioctl(drv
->ioctl_sock
, SIOCSIWENCODE
, &iwr
) < 0) {
1842 perror("ioctl[SIOCSIWENCODE] (set_tx)");
1851 static int wpa_driver_wext_set_countermeasures(void *priv
,
1854 struct wpa_driver_wext_data
*drv
= priv
;
1855 wpa_printf(MSG_DEBUG
, "%s", __FUNCTION__
);
1856 return wpa_driver_wext_set_auth_param(drv
,
1857 IW_AUTH_TKIP_COUNTERMEASURES
,
1862 static int wpa_driver_wext_set_drop_unencrypted(void *priv
,
1865 struct wpa_driver_wext_data
*drv
= priv
;
1866 wpa_printf(MSG_DEBUG
, "%s", __FUNCTION__
);
1867 drv
->use_crypt
= enabled
;
1868 return wpa_driver_wext_set_auth_param(drv
, IW_AUTH_DROP_UNENCRYPTED
,
1873 static int wpa_driver_wext_mlme(struct wpa_driver_wext_data
*drv
,
1874 const u8
*addr
, int cmd
, int reason_code
)
1877 struct iw_mlme mlme
;
1880 os_memset(&iwr
, 0, sizeof(iwr
));
1881 os_strlcpy(iwr
.ifr_name
, drv
->ifname
, IFNAMSIZ
);
1882 os_memset(&mlme
, 0, sizeof(mlme
));
1884 mlme
.reason_code
= reason_code
;
1885 mlme
.addr
.sa_family
= ARPHRD_ETHER
;
1886 os_memcpy(mlme
.addr
.sa_data
, addr
, ETH_ALEN
);
1887 iwr
.u
.data
.pointer
= (caddr_t
) &mlme
;
1888 iwr
.u
.data
.length
= sizeof(mlme
);
1890 if (ioctl(drv
->ioctl_sock
, SIOCSIWMLME
, &iwr
) < 0) {
1891 perror("ioctl[SIOCSIWMLME]");
1899 static int wpa_driver_wext_deauthenticate(void *priv
, const u8
*addr
,
1902 struct wpa_driver_wext_data
*drv
= priv
;
1903 wpa_printf(MSG_DEBUG
, "%s", __FUNCTION__
);
1904 return wpa_driver_wext_mlme(drv
, addr
, IW_MLME_DEAUTH
, reason_code
);
1908 static int wpa_driver_wext_disassociate(void *priv
, const u8
*addr
,
1911 struct wpa_driver_wext_data
*drv
= priv
;
1912 wpa_printf(MSG_DEBUG
, "%s", __FUNCTION__
);
1913 return wpa_driver_wext_mlme(drv
, addr
, IW_MLME_DISASSOC
,
1918 static int wpa_driver_wext_set_gen_ie(void *priv
, const u8
*ie
,
1921 struct wpa_driver_wext_data
*drv
= priv
;
1925 os_memset(&iwr
, 0, sizeof(iwr
));
1926 os_strlcpy(iwr
.ifr_name
, drv
->ifname
, IFNAMSIZ
);
1927 iwr
.u
.data
.pointer
= (caddr_t
) ie
;
1928 iwr
.u
.data
.length
= ie_len
;
1930 if (ioctl(drv
->ioctl_sock
, SIOCSIWGENIE
, &iwr
) < 0) {
1931 perror("ioctl[SIOCSIWGENIE]");
1939 int wpa_driver_wext_cipher2wext(int cipher
)
1943 return IW_AUTH_CIPHER_NONE
;
1945 return IW_AUTH_CIPHER_WEP40
;
1947 return IW_AUTH_CIPHER_TKIP
;
1949 return IW_AUTH_CIPHER_CCMP
;
1951 return IW_AUTH_CIPHER_WEP104
;
1958 int wpa_driver_wext_keymgmt2wext(int keymgmt
)
1961 case KEY_MGMT_802_1X
:
1962 case KEY_MGMT_802_1X_NO_WPA
:
1963 return IW_AUTH_KEY_MGMT_802_1X
;
1965 return IW_AUTH_KEY_MGMT_PSK
;
1973 wpa_driver_wext_auth_alg_fallback(struct wpa_driver_wext_data
*drv
,
1974 struct wpa_driver_associate_params
*params
)
1979 wpa_printf(MSG_DEBUG
, "WEXT: Driver did not support "
1980 "SIOCSIWAUTH for AUTH_ALG, trying SIOCSIWENCODE");
1982 os_memset(&iwr
, 0, sizeof(iwr
));
1983 os_strlcpy(iwr
.ifr_name
, drv
->ifname
, IFNAMSIZ
);
1984 /* Just changing mode, not actual keys */
1985 iwr
.u
.encoding
.flags
= 0;
1986 iwr
.u
.encoding
.pointer
= (caddr_t
) NULL
;
1987 iwr
.u
.encoding
.length
= 0;
1990 * Note: IW_ENCODE_{OPEN,RESTRICTED} can be interpreted to mean two
1991 * different things. Here they are used to indicate Open System vs.
1992 * Shared Key authentication algorithm. However, some drivers may use
1993 * them to select between open/restricted WEP encrypted (open = allow
1994 * both unencrypted and encrypted frames; restricted = only allow
1995 * encrypted frames).
1998 if (!drv
->use_crypt
) {
1999 iwr
.u
.encoding
.flags
|= IW_ENCODE_DISABLED
;
2001 if (params
->auth_alg
& AUTH_ALG_OPEN_SYSTEM
)
2002 iwr
.u
.encoding
.flags
|= IW_ENCODE_OPEN
;
2003 if (params
->auth_alg
& AUTH_ALG_SHARED_KEY
)
2004 iwr
.u
.encoding
.flags
|= IW_ENCODE_RESTRICTED
;
2007 if (ioctl(drv
->ioctl_sock
, SIOCSIWENCODE
, &iwr
) < 0) {
2008 perror("ioctl[SIOCSIWENCODE]");
2016 int wpa_driver_wext_associate(void *priv
,
2017 struct wpa_driver_associate_params
*params
)
2019 struct wpa_driver_wext_data
*drv
= priv
;
2021 int allow_unencrypted_eapol
;
2024 wpa_printf(MSG_DEBUG
, "%s", __FUNCTION__
);
2027 * If the driver did not support SIOCSIWAUTH, fallback to
2028 * SIOCSIWENCODE here.
2030 if (drv
->auth_alg_fallback
&&
2031 wpa_driver_wext_auth_alg_fallback(drv
, params
) < 0)
2034 if (!params
->bssid
&&
2035 wpa_driver_wext_set_bssid(drv
, NULL
) < 0)
2038 /* TODO: should consider getting wpa version and cipher/key_mgmt suites
2039 * from configuration, not from here, where only the selected suite is
2041 if (wpa_driver_wext_set_gen_ie(drv
, params
->wpa_ie
, params
->wpa_ie_len
)
2044 if (params
->wpa_ie
== NULL
|| params
->wpa_ie_len
== 0)
2045 value
= IW_AUTH_WPA_VERSION_DISABLED
;
2046 else if (params
->wpa_ie
[0] == WLAN_EID_RSN
)
2047 value
= IW_AUTH_WPA_VERSION_WPA2
;
2049 value
= IW_AUTH_WPA_VERSION_WPA
;
2050 if (wpa_driver_wext_set_auth_param(drv
,
2051 IW_AUTH_WPA_VERSION
, value
) < 0)
2053 value
= wpa_driver_wext_cipher2wext(params
->pairwise_suite
);
2054 if (wpa_driver_wext_set_auth_param(drv
,
2055 IW_AUTH_CIPHER_PAIRWISE
, value
) < 0)
2057 value
= wpa_driver_wext_cipher2wext(params
->group_suite
);
2058 if (wpa_driver_wext_set_auth_param(drv
,
2059 IW_AUTH_CIPHER_GROUP
, value
) < 0)
2061 value
= wpa_driver_wext_keymgmt2wext(params
->key_mgmt_suite
);
2062 if (wpa_driver_wext_set_auth_param(drv
,
2063 IW_AUTH_KEY_MGMT
, value
) < 0)
2065 value
= params
->key_mgmt_suite
!= KEY_MGMT_NONE
||
2066 params
->pairwise_suite
!= CIPHER_NONE
||
2067 params
->group_suite
!= CIPHER_NONE
||
2069 if (wpa_driver_wext_set_auth_param(drv
,
2070 IW_AUTH_PRIVACY_INVOKED
, value
) < 0)
2073 /* Allow unencrypted EAPOL messages even if pairwise keys are set when
2074 * not using WPA. IEEE 802.1X specifies that these frames are not
2075 * encrypted, but WPA encrypts them when pairwise keys are in use. */
2076 if (params
->key_mgmt_suite
== KEY_MGMT_802_1X
||
2077 params
->key_mgmt_suite
== KEY_MGMT_PSK
)
2078 allow_unencrypted_eapol
= 0;
2080 allow_unencrypted_eapol
= 1;
2082 if (wpa_driver_wext_set_psk(drv
, params
->psk
) < 0)
2084 if (wpa_driver_wext_set_auth_param(drv
,
2085 IW_AUTH_RX_UNENCRYPTED_EAPOL
,
2086 allow_unencrypted_eapol
) < 0)
2088 #ifdef CONFIG_IEEE80211W
2089 switch (params
->mgmt_frame_protection
) {
2090 case NO_MGMT_FRAME_PROTECTION
:
2091 value
= IW_AUTH_MFP_DISABLED
;
2093 case MGMT_FRAME_PROTECTION_OPTIONAL
:
2094 value
= IW_AUTH_MFP_OPTIONAL
;
2096 case MGMT_FRAME_PROTECTION_REQUIRED
:
2097 value
= IW_AUTH_MFP_REQUIRED
;
2100 if (wpa_driver_wext_set_auth_param(drv
, IW_AUTH_MFP
, value
) < 0)
2102 #endif /* CONFIG_IEEE80211W */
2103 if (params
->freq
&& wpa_driver_wext_set_freq(drv
, params
->freq
) < 0)
2105 if (wpa_driver_wext_set_ssid(drv
, params
->ssid
, params
->ssid_len
) < 0)
2107 if (params
->bssid
&&
2108 wpa_driver_wext_set_bssid(drv
, params
->bssid
) < 0)
2115 static int wpa_driver_wext_set_auth_alg(void *priv
, int auth_alg
)
2117 struct wpa_driver_wext_data
*drv
= priv
;
2120 if (auth_alg
& AUTH_ALG_OPEN_SYSTEM
)
2121 algs
|= IW_AUTH_ALG_OPEN_SYSTEM
;
2122 if (auth_alg
& AUTH_ALG_SHARED_KEY
)
2123 algs
|= IW_AUTH_ALG_SHARED_KEY
;
2124 if (auth_alg
& AUTH_ALG_LEAP
)
2125 algs
|= IW_AUTH_ALG_LEAP
;
2127 /* at least one algorithm should be set */
2128 algs
= IW_AUTH_ALG_OPEN_SYSTEM
;
2131 res
= wpa_driver_wext_set_auth_param(drv
, IW_AUTH_80211_AUTH_ALG
,
2133 drv
->auth_alg_fallback
= res
== -2;
2139 * wpa_driver_wext_set_mode - Set wireless mode (infra/adhoc), SIOCSIWMODE
2140 * @priv: Pointer to private wext data from wpa_driver_wext_init()
2141 * @mode: 0 = infra/BSS (associate with an AP), 1 = adhoc/IBSS
2142 * Returns: 0 on success, -1 on failure
2144 int wpa_driver_wext_set_mode(void *priv
, int mode
)
2146 struct wpa_driver_wext_data
*drv
= priv
;
2148 int ret
= -1, flags
;
2149 unsigned int new_mode
= mode
? IW_MODE_ADHOC
: IW_MODE_INFRA
;
2151 os_memset(&iwr
, 0, sizeof(iwr
));
2152 os_strlcpy(iwr
.ifr_name
, drv
->ifname
, IFNAMSIZ
);
2153 iwr
.u
.mode
= new_mode
;
2154 if (ioctl(drv
->ioctl_sock
, SIOCSIWMODE
, &iwr
) == 0) {
2159 if (errno
!= EBUSY
) {
2160 perror("ioctl[SIOCSIWMODE]");
2164 /* mac80211 doesn't allow mode changes while the device is up, so if
2165 * the device isn't in the mode we're about to change to, take device
2166 * down, try to set the mode again, and bring it back up.
2168 if (ioctl(drv
->ioctl_sock
, SIOCGIWMODE
, &iwr
) < 0) {
2169 perror("ioctl[SIOCGIWMODE]");
2173 if (iwr
.u
.mode
== new_mode
) {
2178 if (wpa_driver_wext_get_ifflags(drv
, &flags
) == 0) {
2179 (void) wpa_driver_wext_set_ifflags(drv
, flags
& ~IFF_UP
);
2181 /* Try to set the mode again while the interface is down */
2182 iwr
.u
.mode
= new_mode
;
2183 if (ioctl(drv
->ioctl_sock
, SIOCSIWMODE
, &iwr
) < 0)
2184 perror("ioctl[SIOCSIWMODE]");
2188 /* Ignore return value of get_ifflags to ensure that the device
2189 * is always up like it was before this function was called.
2191 (void) wpa_driver_wext_get_ifflags(drv
, &flags
);
2192 (void) wpa_driver_wext_set_ifflags(drv
, flags
| IFF_UP
);
2200 static int wpa_driver_wext_pmksa(struct wpa_driver_wext_data
*drv
,
2201 u32 cmd
, const u8
*bssid
, const u8
*pmkid
)
2204 struct iw_pmksa pmksa
;
2207 os_memset(&iwr
, 0, sizeof(iwr
));
2208 os_strlcpy(iwr
.ifr_name
, drv
->ifname
, IFNAMSIZ
);
2209 os_memset(&pmksa
, 0, sizeof(pmksa
));
2211 pmksa
.bssid
.sa_family
= ARPHRD_ETHER
;
2213 os_memcpy(pmksa
.bssid
.sa_data
, bssid
, ETH_ALEN
);
2215 os_memcpy(pmksa
.pmkid
, pmkid
, IW_PMKID_LEN
);
2216 iwr
.u
.data
.pointer
= (caddr_t
) &pmksa
;
2217 iwr
.u
.data
.length
= sizeof(pmksa
);
2219 if (ioctl(drv
->ioctl_sock
, SIOCSIWPMKSA
, &iwr
) < 0) {
2220 if (errno
!= EOPNOTSUPP
)
2221 perror("ioctl[SIOCSIWPMKSA]");
2229 static int wpa_driver_wext_add_pmkid(void *priv
, const u8
*bssid
,
2232 struct wpa_driver_wext_data
*drv
= priv
;
2233 return wpa_driver_wext_pmksa(drv
, IW_PMKSA_ADD
, bssid
, pmkid
);
2237 static int wpa_driver_wext_remove_pmkid(void *priv
, const u8
*bssid
,
2240 struct wpa_driver_wext_data
*drv
= priv
;
2241 return wpa_driver_wext_pmksa(drv
, IW_PMKSA_REMOVE
, bssid
, pmkid
);
2245 static int wpa_driver_wext_flush_pmkid(void *priv
)
2247 struct wpa_driver_wext_data
*drv
= priv
;
2248 return wpa_driver_wext_pmksa(drv
, IW_PMKSA_FLUSH
, NULL
, NULL
);
2252 int wpa_driver_wext_get_capa(void *priv
, struct wpa_driver_capa
*capa
)
2254 struct wpa_driver_wext_data
*drv
= priv
;
2255 if (!drv
->has_capability
)
2257 os_memcpy(capa
, &drv
->capa
, sizeof(*capa
));
2262 int wpa_driver_wext_alternative_ifindex(struct wpa_driver_wext_data
*drv
,
2265 if (ifname
== NULL
) {
2270 drv
->ifindex2
= if_nametoindex(ifname
);
2271 if (drv
->ifindex2
<= 0)
2274 wpa_printf(MSG_DEBUG
, "Added alternative ifindex %d (%s) for "
2275 "wireless events", drv
->ifindex2
, ifname
);
2281 int wpa_driver_wext_set_operstate(void *priv
, int state
)
2283 struct wpa_driver_wext_data
*drv
= priv
;
2285 wpa_printf(MSG_DEBUG
, "%s: operstate %d->%d (%s)",
2286 __func__
, drv
->operstate
, state
, state
? "UP" : "DORMANT");
2287 drv
->operstate
= state
;
2288 return wpa_driver_wext_send_oper_ifla(
2289 drv
, -1, state
? IF_OPER_UP
: IF_OPER_DORMANT
);
2293 int wpa_driver_wext_get_version(struct wpa_driver_wext_data
*drv
)
2295 return drv
->we_version_compiled
;
2299 const struct wpa_driver_ops wpa_driver_wext_ops
= {
2301 .desc
= "Linux wireless extensions (generic)",
2302 .get_bssid
= wpa_driver_wext_get_bssid
,
2303 .get_ssid
= wpa_driver_wext_get_ssid
,
2304 .set_wpa
= wpa_driver_wext_set_wpa
,
2305 .set_key
= wpa_driver_wext_set_key
,
2306 .set_countermeasures
= wpa_driver_wext_set_countermeasures
,
2307 .set_drop_unencrypted
= wpa_driver_wext_set_drop_unencrypted
,
2308 .scan
= wpa_driver_wext_scan
,
2309 .get_scan_results2
= wpa_driver_wext_get_scan_results
,
2310 .deauthenticate
= wpa_driver_wext_deauthenticate
,
2311 .disassociate
= wpa_driver_wext_disassociate
,
2312 .set_mode
= wpa_driver_wext_set_mode
,
2313 .associate
= wpa_driver_wext_associate
,
2314 .set_auth_alg
= wpa_driver_wext_set_auth_alg
,
2315 .init
= wpa_driver_wext_init
,
2316 .deinit
= wpa_driver_wext_deinit
,
2317 .add_pmkid
= wpa_driver_wext_add_pmkid
,
2318 .remove_pmkid
= wpa_driver_wext_remove_pmkid
,
2319 .flush_pmkid
= wpa_driver_wext_flush_pmkid
,
2320 .get_capa
= wpa_driver_wext_get_capa
,
2321 .set_operstate
= wpa_driver_wext_set_operstate
,