1 /* 2 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 3 * Use is subject to license terms. 4 */ 5 6 /* 7 * Copyright (c) 2004, Sam Leffler <sam@errno.com> 8 * Sun elects to license this software under the BSD license. 9 * See README for more details. 10 */ 11 12 #include <stdio.h> 13 #include <stdlib.h> 14 #include <errno.h> 15 #include <stdarg.h> 16 #include <fcntl.h> 17 #include <unistd.h> 18 #include <stropts.h> 19 #include <string.h> 20 #include <stddef.h> 21 22 #include "wpa_impl.h" 23 #include "driver.h" 24 25 #define WPA_STATUS(status) (status == DLADM_STATUS_OK? 0 : -1) 26 27 /* 28 * get_bssid - get the current BSSID 29 * @linkid: linkid of the given interface 30 * @bssid: buffer for BSSID (IEEE80211_ADDR_LEN = 6 bytes) 31 * 32 * Returns: 0 on success, -1 on failure 33 * 34 * Query kernel driver for the current BSSID and copy it to @bssid. 35 * Setting @bssid to 00:00:00:00:00:00 is recommended if the STA is not 36 * associated. 37 */ 38 int 39 wpa_driver_wifi_get_bssid(dladm_handle_t handle, datalink_id_t linkid, 40 char *bssid) 41 { 42 dladm_status_t status; 43 dladm_wlan_linkattr_t attr; 44 dladm_wlan_attr_t *wl_attrp; 45 46 status = dladm_wlan_get_linkattr(handle, linkid, &attr); 47 if (status != DLADM_STATUS_OK) 48 return (-1); 49 50 wl_attrp = &attr.la_wlan_attr; 51 if ((attr.la_valid & DLADM_WLAN_LINKATTR_WLAN) == 0 || 52 (wl_attrp->wa_valid & DLADM_WLAN_ATTR_BSSID) == 0) 53 return (-1); 54 55 (void) memcpy(bssid, wl_attrp->wa_bssid.wb_bytes, DLADM_WLAN_BSSID_LEN); 56 57 wpa_printf(MSG_DEBUG, "wpa_driver_wifi_get_bssid: " MACSTR, 58 MAC2STR((unsigned char *)bssid)); 59 60 return (WPA_STATUS(status)); 61 } 62 63 /* 64 * get_ssid - get the current SSID 65 * @linkid: linkid of the given interface 66 * @ssid: buffer for SSID (at least 32 bytes) 67 * 68 * Returns: length of the SSID on success, -1 on failure 69 * 70 * Query kernel driver for the current SSID and copy it to @ssid. 71 * Returning zero is recommended if the STA is not associated. 72 */ 73 int 74 wpa_driver_wifi_get_ssid(dladm_handle_t handle, datalink_id_t linkid, 75 char *ssid) 76 { 77 int ret; 78 dladm_status_t status; 79 dladm_wlan_linkattr_t attr; 80 dladm_wlan_attr_t *wl_attrp; 81 82 status = dladm_wlan_get_linkattr(handle, linkid, &attr); 83 if (status != DLADM_STATUS_OK) 84 return (-1); 85 86 wl_attrp = &attr.la_wlan_attr; 87 if ((attr.la_valid & DLADM_WLAN_LINKATTR_WLAN) == 0 || 88 (wl_attrp->wa_valid & DLADM_WLAN_ATTR_ESSID) == 0) 89 return (-1); 90 91 (void) memcpy(ssid, wl_attrp->wa_essid.we_bytes, MAX_ESSID_LENGTH); 92 ret = strlen(ssid); 93 94 wpa_printf(MSG_DEBUG, "wpa_driver_wifi_get_ssid: ssid=%s len=%d", 95 ssid, ret); 96 97 return (ret); 98 } 99 100 static int 101 wpa_driver_wifi_set_wpa_ie(dladm_handle_t handle, datalink_id_t linkid, 102 uint8_t *wpa_ie, uint32_t wpa_ie_len) 103 { 104 dladm_status_t status; 105 106 wpa_printf(MSG_DEBUG, "%s", "wpa_driver_wifi_set_wpa_ie"); 107 status = dladm_wlan_wpa_set_ie(handle, linkid, wpa_ie, wpa_ie_len); 108 109 return (WPA_STATUS(status)); 110 } 111 112 /* 113 * set_wpa - enable/disable WPA support 114 * @linkid: linkid of the given interface 115 * @enabled: 1 = enable, 0 = disable 116 * 117 * Returns: 0 on success, -1 on failure 118 * 119 * Configure the kernel driver to enable/disable WPA support. This may 120 * be empty function, if WPA support is always enabled. Common 121 * configuration items are WPA IE (clearing it when WPA support is 122 * disabled), Privacy flag for capability field, roaming mode (need to 123 * allow wpa_supplicant to control roaming). 124 */ 125 static int 126 wpa_driver_wifi_set_wpa(dladm_handle_t handle, datalink_id_t linkid, 127 boolean_t enabled) 128 { 129 dladm_status_t status; 130 131 wpa_printf(MSG_DEBUG, "wpa_driver_wifi_set_wpa: enable=%d", enabled); 132 133 if (!enabled && wpa_driver_wifi_set_wpa_ie(handle, linkid, NULL, 0) < 0) 134 return (-1); 135 136 status = dladm_wlan_wpa_set_wpa(handle, linkid, enabled); 137 138 return (WPA_STATUS(status)); 139 } 140 141 static int 142 wpa_driver_wifi_del_key(dladm_handle_t handle, datalink_id_t linkid, 143 int key_idx, unsigned char *addr) 144 { 145 dladm_status_t status; 146 dladm_wlan_bssid_t bss; 147 148 wpa_printf(MSG_DEBUG, "%s: id=%d", "wpa_driver_wifi_del_key", 149 key_idx); 150 151 (void) memcpy(bss.wb_bytes, addr, DLADM_WLAN_BSSID_LEN); 152 status = dladm_wlan_wpa_del_key(handle, linkid, key_idx, &bss); 153 154 return (WPA_STATUS(status)); 155 } 156 157 /* 158 * set_key - configure encryption key 159 * @linkid: linkid of the given interface 160 * @alg: encryption algorithm (%WPA_ALG_NONE, %WPA_ALG_WEP, 161 * %WPA_ALG_TKIP, %WPA_ALG_CCMP); %WPA_ALG_NONE clears the key. 162 * @addr: address of the peer STA or ff:ff:ff:ff:ff:ff for 163 * broadcast/default keys 164 * @key_idx: key index (0..3), always 0 for unicast keys 165 * @set_tx: configure this key as the default Tx key (only used when 166 * driver does not support separate unicast/individual key 167 * @seq: sequence number/packet number, @seq_len octets, the next 168 * packet number to be used for in replay protection; configured 169 * for Rx keys (in most cases, this is only used with broadcast 170 * keys and set to zero for unicast keys) 171 * @seq_len: length of the @seq, depends on the algorithm: 172 * TKIP: 6 octets, CCMP: 6 octets 173 * @key: key buffer; TKIP: 16-byte temporal key, 8-byte Tx Mic key, 174 * 8-byte Rx Mic Key 175 * @key_len: length of the key buffer in octets (WEP: 5 or 13, 176 * TKIP: 32, CCMP: 16) 177 * 178 * Returns: 0 on success, -1 on failure 179 * 180 * Configure the given key for the kernel driver. If the driver 181 * supports separate individual keys (4 default keys + 1 individual), 182 * @addr can be used to determine whether the key is default or 183 * individual. If only 4 keys are supported, the default key with key 184 * index 0 is used as the individual key. STA must be configured to use 185 * it as the default Tx key (@set_tx is set) and accept Rx for all the 186 * key indexes. In most cases, WPA uses only key indexes 1 and 2 for 187 * broadcast keys, so key index 0 is available for this kind of 188 * configuration. 189 */ 190 static int 191 wpa_driver_wifi_set_key(dladm_handle_t handle, datalink_id_t linkid, 192 wpa_alg alg, unsigned char *addr, int key_idx, boolean_t set_tx, 193 uint8_t *seq, uint32_t seq_len, uint8_t *key, uint32_t key_len) 194 { 195 char *alg_name; 196 dladm_wlan_cipher_t cipher; 197 dladm_wlan_bssid_t bss; 198 dladm_status_t status; 199 200 wpa_printf(MSG_DEBUG, "%s", "wpa_driver_wifi_set_key"); 201 if (alg == WPA_ALG_NONE) 202 return (wpa_driver_wifi_del_key(handle, linkid, key_idx, addr)); 203 204 switch (alg) { 205 case WPA_ALG_WEP: 206 alg_name = "WEP"; 207 cipher = DLADM_WLAN_CIPHER_WEP; 208 break; 209 case WPA_ALG_TKIP: 210 alg_name = "TKIP"; 211 cipher = DLADM_WLAN_CIPHER_TKIP; 212 break; 213 case WPA_ALG_CCMP: 214 alg_name = "CCMP"; 215 cipher = DLADM_WLAN_CIPHER_AES_CCM; 216 break; 217 default: 218 wpa_printf(MSG_DEBUG, "wpa_driver_wifi_set_key:" 219 " unknown/unsupported algorithm %d", alg); 220 return (-1); 221 } 222 223 wpa_printf(MSG_DEBUG, "wpa_driver_wifi_set_key: alg=%s key_idx=%d" 224 " set_tx=%d seq_len=%d seq=%d key_len=%d", 225 alg_name, key_idx, set_tx, 226 seq_len, *(uint64_t *)(uintptr_t)seq, key_len); 227 228 if (seq_len > sizeof (uint64_t)) { 229 wpa_printf(MSG_DEBUG, "wpa_driver_wifi_set_key:" 230 " seq_len %d too big", seq_len); 231 return (-1); 232 } 233 (void) memcpy(bss.wb_bytes, addr, DLADM_WLAN_BSSID_LEN); 234 235 status = dladm_wlan_wpa_set_key(handle, linkid, cipher, &bss, set_tx, 236 *(uint64_t *)(uintptr_t)seq, key_idx, key, key_len); 237 238 return (WPA_STATUS(status)); 239 } 240 241 /* 242 * disassociate - request driver to disassociate 243 * @linkid: linkid of the given interface 244 * @reason_code: 16-bit reason code to be sent in the disassociation 245 * frame 246 * 247 * Return: 0 on success, -1 on failure 248 */ 249 static int 250 wpa_driver_wifi_disassociate(dladm_handle_t handle, datalink_id_t linkid, 251 int reason_code) 252 { 253 dladm_status_t status; 254 255 wpa_printf(MSG_DEBUG, "wpa_driver_wifi_disassociate"); 256 257 status = dladm_wlan_wpa_set_mlme(handle, linkid, 258 DLADM_WLAN_MLME_DISASSOC, reason_code, NULL); 259 260 return (WPA_STATUS(status)); 261 } 262 263 /* 264 * associate - request driver to associate 265 * @linkid: linkid of the given interface 266 * @bssid: BSSID of the selected AP 267 * @wpa_ie: WPA information element to be included in (Re)Association 268 * Request (including information element id and length). Use of 269 * this WPA IE is optional. If the driver generates the WPA IE, it 270 * can use @pairwise_suite, @group_suite, and @key_mgmt_suite 271 * to select proper algorithms. In this case, the driver has to 272 * notify wpa_supplicant about the used WPA IE by generating an 273 * event that the interface code will convert into EVENT_ASSOCINFO 274 * data (see wpa_supplicant.h). When using WPA2/IEEE 802.11i, 275 * @wpa_ie is used for RSN IE instead. The driver can determine 276 * which version is used by looking at the first byte of the IE 277 * (0xdd for WPA, 0x30 for WPA2/RSN). 278 * @wpa_ie_len: length of the @wpa_ie 279 * 280 * Return: 0 on success, -1 on failure 281 */ 282 static int 283 wpa_driver_wifi_associate(dladm_handle_t handle, datalink_id_t linkid, 284 const char *bssid, uint8_t *wpa_ie, uint32_t wpa_ie_len) 285 { 286 dladm_status_t status; 287 dladm_wlan_bssid_t bss; 288 289 wpa_printf(MSG_DEBUG, "wpa_driver_wifi_associate : " 290 MACSTR, MAC2STR(bssid)); 291 292 /* 293 * NB: Don't need to set the freq or cipher-related state as 294 * this is implied by the bssid which is used to locate 295 * the scanned node state which holds it. 296 */ 297 if (wpa_driver_wifi_set_wpa_ie(handle, linkid, wpa_ie, wpa_ie_len) < 0) 298 return (-1); 299 300 (void) memcpy(bss.wb_bytes, bssid, DLADM_WLAN_BSSID_LEN); 301 status = dladm_wlan_wpa_set_mlme(handle, linkid, DLADM_WLAN_MLME_ASSOC, 302 0, &bss); 303 304 return (WPA_STATUS(status)); 305 } 306 307 /* 308 * scan - request the driver to initiate scan 309 * @linkid: linkid of the given interface 310 * 311 * Return: 0 on success, -1 on failure 312 * 313 * Once the scan results are ready, the driver should report scan 314 * results event for wpa_supplicant which will eventually request the 315 * results with wpa_driver_get_scan_results(). 316 */ 317 static int 318 wpa_driver_wifi_scan(dladm_handle_t handle, datalink_id_t linkid) 319 { 320 dladm_status_t status; 321 322 wpa_printf(MSG_DEBUG, "%s", "wpa_driver_wifi_scan"); 323 /* 324 * We force the state to INIT before calling ieee80211_new_state 325 * to get ieee80211_begin_scan called. We really want to scan w/o 326 * altering the current state but that's not possible right now. 327 */ 328 (void) wpa_driver_wifi_disassociate(handle, linkid, 329 DLADM_WLAN_REASON_DISASSOC_LEAVING); 330 331 status = dladm_wlan_scan(handle, linkid, NULL, NULL); 332 333 wpa_printf(MSG_DEBUG, "%s: return", "wpa_driver_wifi_scan"); 334 return (WPA_STATUS(status)); 335 } 336 337 /* 338 * get_scan_results - fetch the latest scan results 339 * @linkid: linkid of the given interface 340 * @results: pointer to buffer for scan results 341 * @max_size: maximum number of entries (buffer size) 342 * 343 * Return: number of scan result entries used on success, -1 on failure 344 * 345 * If scan results include more than @max_size BSSes, @max_size will be 346 * returned and the remaining entries will not be included in the 347 * buffer. 348 */ 349 int 350 wpa_driver_wifi_get_scan_results(dladm_handle_t handle, datalink_id_t linkid, 351 dladm_wlan_ess_t *results, uint32_t max_size) 352 { 353 uint_t ret; 354 355 wpa_printf(MSG_DEBUG, "%s: max size=%d\n", 356 "wpa_driver_wifi_get_scan_results", max_size); 357 358 if (dladm_wlan_wpa_get_sr(handle, linkid, results, max_size, &ret) 359 != DLADM_STATUS_OK) { 360 return (-1); 361 } 362 363 return (ret); 364 } 365 366 struct wpa_driver_ops wpa_driver_wifi_ops = { 367 wpa_driver_wifi_get_bssid, 368 wpa_driver_wifi_get_ssid, 369 wpa_driver_wifi_set_wpa, 370 wpa_driver_wifi_set_key, 371 wpa_driver_wifi_scan, 372 wpa_driver_wifi_get_scan_results, 373 wpa_driver_wifi_disassociate, 374 wpa_driver_wifi_associate 375 }; 376