1 // SPDX-License-Identifier: GPL-2.0 2 /****************************************************************************** 3 * 4 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved. 5 * 6 ******************************************************************************/ 7 8 #include <linux/etherdevice.h> 9 #include <drv_types.h> 10 #include <rtw_debug.h> 11 #include <rtw_mp.h> 12 #include <hal_btcoex.h> 13 #include <linux/jiffies.h> 14 #include <linux/kernel.h> 15 16 #define RTL_IOCTL_WPA_SUPPLICANT (SIOCIWFIRSTPRIV+30) 17 18 static int wpa_set_auth_algs(struct net_device *dev, u32 value) 19 { 20 struct adapter *padapter = rtw_netdev_priv(dev); 21 int ret = 0; 22 23 if ((value & IW_AUTH_ALG_SHARED_KEY) && (value & IW_AUTH_ALG_OPEN_SYSTEM)) { 24 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled; 25 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeAutoSwitch; 26 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Auto; 27 } else if (value & IW_AUTH_ALG_SHARED_KEY) { 28 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled; 29 30 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeShared; 31 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Shared; 32 } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) { 33 /* padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled; */ 34 if (padapter->securitypriv.ndisauthtype < Ndis802_11AuthModeWPAPSK) { 35 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeOpen; 36 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open; 37 } 38 } else { 39 ret = -EINVAL; 40 } 41 42 return ret; 43 44 } 45 46 static int wpa_set_encryption(struct net_device *dev, struct ieee_param *param, u32 param_len) 47 { 48 int ret = 0; 49 u8 max_idx; 50 u32 wep_key_idx, wep_key_len, wep_total_len; 51 struct ndis_802_11_wep *pwep = NULL; 52 struct adapter *padapter = rtw_netdev_priv(dev); 53 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 54 struct security_priv *psecuritypriv = &padapter->securitypriv; 55 56 param->u.crypt.err = 0; 57 param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0'; 58 59 if (param_len < (u32)((u8 *)param->u.crypt.key - (u8 *)param) + param->u.crypt.key_len) { 60 ret = -EINVAL; 61 goto exit; 62 } 63 64 if (param->sta_addr[0] != 0xff || param->sta_addr[1] != 0xff || 65 param->sta_addr[2] != 0xff || param->sta_addr[3] != 0xff || 66 param->sta_addr[4] != 0xff || param->sta_addr[5] != 0xff) { 67 ret = -EINVAL; 68 goto exit; 69 } 70 71 if (strcmp(param->u.crypt.alg, "WEP") == 0) 72 max_idx = WEP_KEYS - 1; 73 else 74 max_idx = BIP_MAX_KEYID; 75 76 if (param->u.crypt.idx > max_idx) { 77 netdev_err(dev, "Error crypt.idx %d > %d\n", param->u.crypt.idx, max_idx); 78 ret = -EINVAL; 79 goto exit; 80 } 81 82 if (strcmp(param->u.crypt.alg, "WEP") == 0) { 83 84 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled; 85 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_; 86 padapter->securitypriv.dot118021XGrpPrivacy = _WEP40_; 87 88 wep_key_idx = param->u.crypt.idx; 89 wep_key_len = param->u.crypt.key_len; 90 91 if (wep_key_len > 0) { 92 wep_key_len = wep_key_len <= 5 ? 5 : 13; 93 wep_total_len = wep_key_len + FIELD_OFFSET(struct ndis_802_11_wep, key_material); 94 /* Allocate a full structure to avoid potentially running off the end. */ 95 pwep = kzalloc(sizeof(*pwep), GFP_KERNEL); 96 if (!pwep) { 97 ret = -ENOMEM; 98 goto exit; 99 } 100 101 pwep->key_length = wep_key_len; 102 pwep->length = wep_total_len; 103 104 if (wep_key_len == 13) { 105 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP104_; 106 padapter->securitypriv.dot118021XGrpPrivacy = _WEP104_; 107 } 108 } else { 109 ret = -EINVAL; 110 goto exit; 111 } 112 113 pwep->key_index = wep_key_idx; 114 pwep->key_index |= 0x80000000; 115 116 memcpy(pwep->key_material, param->u.crypt.key, pwep->key_length); 117 118 if (param->u.crypt.set_tx) { 119 if (rtw_set_802_11_add_wep(padapter, pwep) == (u8)_FAIL) 120 ret = -EOPNOTSUPP; 121 } else { 122 /* don't update "psecuritypriv->dot11PrivacyAlgrthm" and */ 123 /* psecuritypriv->dot11PrivacyKeyIndex =keyid", but can rtw_set_key to fw/cam */ 124 125 if (wep_key_idx >= WEP_KEYS) { 126 ret = -EOPNOTSUPP; 127 goto exit; 128 } 129 130 memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), pwep->key_material, pwep->key_length); 131 psecuritypriv->dot11DefKeylen[wep_key_idx] = pwep->key_length; 132 rtw_set_key(padapter, psecuritypriv, wep_key_idx, 0, true); 133 } 134 135 goto exit; 136 } 137 138 if (padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) { /* 802_1x */ 139 struct sta_info *psta, *pbcmc_sta; 140 struct sta_priv *pstapriv = &padapter->stapriv; 141 142 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE | WIFI_MP_STATE) == true) { /* sta mode */ 143 psta = rtw_get_stainfo(pstapriv, get_bssid(pmlmepriv)); 144 if (!psta) { 145 /* DEBUG_ERR(("Set wpa_set_encryption: Obtain Sta_info fail\n")); */ 146 } else { 147 /* Jeff: don't disable ieee8021x_blocked while clearing key */ 148 if (strcmp(param->u.crypt.alg, "none") != 0) 149 psta->ieee8021x_blocked = false; 150 151 if ((padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption2Enabled) || 152 (padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption3Enabled)) { 153 psta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm; 154 } 155 156 if (param->u.crypt.set_tx == 1) { /* pairwise key */ 157 memcpy(psta->dot118021x_UncstKey.skey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 158 159 if (strcmp(param->u.crypt.alg, "TKIP") == 0) { /* set mic key */ 160 /* DEBUG_ERR(("\nset key length :param->u.crypt.key_len =%d\n", param->u.crypt.key_len)); */ 161 memcpy(psta->dot11tkiptxmickey.skey, &(param->u.crypt.key[16]), 8); 162 memcpy(psta->dot11tkiprxmickey.skey, &(param->u.crypt.key[24]), 8); 163 164 padapter->securitypriv.busetkipkey = false; 165 /* _set_timer(&padapter->securitypriv.tkip_timer, 50); */ 166 } 167 168 rtw_setstakey_cmd(padapter, psta, true, true); 169 } else { /* group key */ 170 if (strcmp(param->u.crypt.alg, "TKIP") == 0 || strcmp(param->u.crypt.alg, "CCMP") == 0) { 171 memcpy(padapter->securitypriv.dot118021XGrpKey[param->u.crypt.idx].skey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 172 /* only TKIP group key need to install this */ 173 if (param->u.crypt.key_len > 16) { 174 memcpy(padapter->securitypriv.dot118021XGrptxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[16]), 8); 175 memcpy(padapter->securitypriv.dot118021XGrprxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[24]), 8); 176 } 177 padapter->securitypriv.binstallGrpkey = true; 178 179 padapter->securitypriv.dot118021XGrpKeyid = param->u.crypt.idx; 180 181 rtw_set_key(padapter, &padapter->securitypriv, param->u.crypt.idx, 1, true); 182 } else if (strcmp(param->u.crypt.alg, "BIP") == 0) { 183 /* printk("BIP key_len =%d , index =%d @@@@@@@@@@@@@@@@@@\n", param->u.crypt.key_len, param->u.crypt.idx); */ 184 /* save the IGTK key, length 16 bytes */ 185 memcpy(padapter->securitypriv.dot11wBIPKey[param->u.crypt.idx].skey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 186 /*printk("IGTK key below:\n"); 187 for (no = 0;no<16;no++) 188 printk(" %02x ", padapter->securitypriv.dot11wBIPKey[param->u.crypt.idx].skey[no]); 189 printk("\n");*/ 190 padapter->securitypriv.dot11wBIPKeyid = param->u.crypt.idx; 191 padapter->securitypriv.binstallBIPkey = true; 192 } 193 } 194 } 195 196 pbcmc_sta = rtw_get_bcmc_stainfo(padapter); 197 if (!pbcmc_sta) { 198 /* DEBUG_ERR(("Set OID_802_11_ADD_KEY: bcmc stainfo is null\n")); */ 199 } else { 200 /* Jeff: don't disable ieee8021x_blocked while clearing key */ 201 if (strcmp(param->u.crypt.alg, "none") != 0) 202 pbcmc_sta->ieee8021x_blocked = false; 203 204 if ((padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption2Enabled) || 205 (padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption3Enabled)) { 206 pbcmc_sta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm; 207 } 208 } 209 } else if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) { 210 /* adhoc mode */ 211 } 212 } 213 214 exit: 215 216 kfree(pwep); 217 return ret; 218 } 219 220 static int rtw_set_wpa_ie(struct adapter *padapter, char *pie, unsigned short ielen) 221 { 222 u8 *buf = NULL; 223 int group_cipher = 0, pairwise_cipher = 0; 224 int ret = 0; 225 u8 null_addr[] = {0, 0, 0, 0, 0, 0}; 226 227 if (ielen > MAX_WPA_IE_LEN || !pie) { 228 _clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS); 229 if (!pie) 230 return ret; 231 else 232 return -EINVAL; 233 } 234 235 if (ielen) { 236 buf = rtw_zmalloc(ielen); 237 if (!buf) { 238 ret = -ENOMEM; 239 goto exit; 240 } 241 242 memcpy(buf, pie, ielen); 243 244 if (ielen < RSN_HEADER_LEN) { 245 ret = -1; 246 goto exit; 247 } 248 249 if (rtw_parse_wpa_ie(buf, ielen, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS) { 250 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X; 251 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPAPSK; 252 memcpy(padapter->securitypriv.supplicant_ie, &buf[0], ielen); 253 } 254 255 if (rtw_parse_wpa2_ie(buf, ielen, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS) { 256 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X; 257 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPA2PSK; 258 memcpy(padapter->securitypriv.supplicant_ie, &buf[0], ielen); 259 } 260 261 if (group_cipher == 0) 262 group_cipher = WPA_CIPHER_NONE; 263 if (pairwise_cipher == 0) 264 pairwise_cipher = WPA_CIPHER_NONE; 265 266 switch (group_cipher) { 267 case WPA_CIPHER_NONE: 268 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_; 269 padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled; 270 break; 271 case WPA_CIPHER_WEP40: 272 padapter->securitypriv.dot118021XGrpPrivacy = _WEP40_; 273 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled; 274 break; 275 case WPA_CIPHER_TKIP: 276 padapter->securitypriv.dot118021XGrpPrivacy = _TKIP_; 277 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled; 278 break; 279 case WPA_CIPHER_CCMP: 280 padapter->securitypriv.dot118021XGrpPrivacy = _AES_; 281 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled; 282 break; 283 case WPA_CIPHER_WEP104: 284 padapter->securitypriv.dot118021XGrpPrivacy = _WEP104_; 285 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled; 286 break; 287 } 288 289 switch (pairwise_cipher) { 290 case WPA_CIPHER_NONE: 291 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_; 292 padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled; 293 break; 294 case WPA_CIPHER_WEP40: 295 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_; 296 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled; 297 break; 298 case WPA_CIPHER_TKIP: 299 padapter->securitypriv.dot11PrivacyAlgrthm = _TKIP_; 300 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled; 301 break; 302 case WPA_CIPHER_CCMP: 303 padapter->securitypriv.dot11PrivacyAlgrthm = _AES_; 304 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled; 305 break; 306 case WPA_CIPHER_WEP104: 307 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP104_; 308 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled; 309 break; 310 } 311 312 _clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS); 313 {/* set wps_ie */ 314 u16 cnt = 0; 315 u8 eid, wps_oui[4] = {0x0, 0x50, 0xf2, 0x04}; 316 317 while (cnt < ielen) { 318 eid = buf[cnt]; 319 320 if ((eid == WLAN_EID_VENDOR_SPECIFIC) && (!memcmp(&buf[cnt+2], wps_oui, 4))) { 321 padapter->securitypriv.wps_ie_len = ((buf[cnt+1]+2) < MAX_WPS_IE_LEN) ? (buf[cnt+1]+2):MAX_WPS_IE_LEN; 322 323 memcpy(padapter->securitypriv.wps_ie, &buf[cnt], padapter->securitypriv.wps_ie_len); 324 325 set_fwstate(&padapter->mlmepriv, WIFI_UNDER_WPS); 326 327 cnt += buf[cnt+1]+2; 328 329 break; 330 } else { 331 cnt += buf[cnt+1]+2; /* goto next */ 332 } 333 } 334 } 335 } 336 337 /* TKIP and AES disallow multicast packets until installing group key */ 338 if (padapter->securitypriv.dot11PrivacyAlgrthm == _TKIP_ || 339 padapter->securitypriv.dot11PrivacyAlgrthm == _TKIP_WTMIC_ || 340 padapter->securitypriv.dot11PrivacyAlgrthm == _AES_) 341 /* WPS open need to enable multicast */ 342 /* check_fwstate(&padapter->mlmepriv, WIFI_UNDER_WPS) == true) */ 343 rtw_hal_set_hwreg(padapter, HW_VAR_OFF_RCR_AM, null_addr); 344 345 exit: 346 347 kfree(buf); 348 349 return ret; 350 } 351 352 static int wpa_set_param(struct net_device *dev, u8 name, u32 value) 353 { 354 uint ret = 0; 355 struct adapter *padapter = rtw_netdev_priv(dev); 356 357 switch (name) { 358 case IEEE_PARAM_WPA_ENABLED: 359 360 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X; /* 802.1x */ 361 362 /* ret = ieee80211_wpa_enable(ieee, value); */ 363 364 switch ((value)&0xff) { 365 case 1: /* WPA */ 366 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPAPSK; /* WPA_PSK */ 367 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled; 368 break; 369 case 2: /* WPA2 */ 370 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPA2PSK; /* WPA2_PSK */ 371 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled; 372 break; 373 } 374 375 break; 376 377 case IEEE_PARAM_TKIP_COUNTERMEASURES: 378 /* ieee->tkip_countermeasures =value; */ 379 break; 380 381 case IEEE_PARAM_DROP_UNENCRYPTED: 382 { 383 /* HACK: 384 * 385 * wpa_supplicant calls set_wpa_enabled when the driver 386 * is loaded and unloaded, regardless of if WPA is being 387 * used. No other calls are made which can be used to 388 * determine if encryption will be used or not prior to 389 * association being expected. If encryption is not being 390 * used, drop_unencrypted is set to false, else true -- we 391 * can use this to determine if the CAP_PRIVACY_ON bit should 392 * be set. 393 */ 394 break; 395 396 } 397 case IEEE_PARAM_PRIVACY_INVOKED: 398 399 /* ieee->privacy_invoked =value; */ 400 401 break; 402 403 case IEEE_PARAM_AUTH_ALGS: 404 405 ret = wpa_set_auth_algs(dev, value); 406 407 break; 408 409 case IEEE_PARAM_IEEE_802_1X: 410 411 /* ieee->ieee802_1x =value; */ 412 413 break; 414 415 case IEEE_PARAM_WPAX_SELECT: 416 417 /* added for WPA2 mixed mode */ 418 /* 419 spin_lock_irqsave(&ieee->wpax_suitlist_lock, flags); 420 ieee->wpax_type_set = 1; 421 ieee->wpax_type_notify = value; 422 spin_unlock_irqrestore(&ieee->wpax_suitlist_lock, flags); 423 */ 424 425 break; 426 427 default: 428 429 430 431 ret = -EOPNOTSUPP; 432 433 434 break; 435 436 } 437 438 return ret; 439 440 } 441 442 static int wpa_mlme(struct net_device *dev, u32 command, u32 reason) 443 { 444 int ret = 0; 445 struct adapter *padapter = rtw_netdev_priv(dev); 446 447 switch (command) { 448 case IEEE_MLME_STA_DEAUTH: 449 450 if (!rtw_set_802_11_disassociate(padapter)) 451 ret = -1; 452 453 break; 454 455 case IEEE_MLME_STA_DISASSOC: 456 457 if (!rtw_set_802_11_disassociate(padapter)) 458 ret = -1; 459 460 break; 461 462 default: 463 ret = -EOPNOTSUPP; 464 break; 465 } 466 467 return ret; 468 469 } 470 471 static int wpa_supplicant_ioctl(struct net_device *dev, struct iw_point *p) 472 { 473 struct ieee_param *param; 474 uint ret = 0; 475 476 /* down(&ieee->wx_sem); */ 477 478 if (!p->pointer || p->length != sizeof(struct ieee_param)) 479 return -EINVAL; 480 481 param = rtw_malloc(p->length); 482 if (!param) 483 return -ENOMEM; 484 485 if (copy_from_user(param, p->pointer, p->length)) { 486 kfree(param); 487 return -EFAULT; 488 } 489 490 switch (param->cmd) { 491 492 case IEEE_CMD_SET_WPA_PARAM: 493 ret = wpa_set_param(dev, param->u.wpa_param.name, param->u.wpa_param.value); 494 break; 495 496 case IEEE_CMD_SET_WPA_IE: 497 /* ret = wpa_set_wpa_ie(dev, param, p->length); */ 498 ret = rtw_set_wpa_ie(rtw_netdev_priv(dev), (char *)param->u.wpa_ie.data, (u16)param->u.wpa_ie.len); 499 break; 500 501 case IEEE_CMD_SET_ENCRYPTION: 502 ret = wpa_set_encryption(dev, param, p->length); 503 break; 504 505 case IEEE_CMD_MLME: 506 ret = wpa_mlme(dev, param->u.mlme.command, param->u.mlme.reason_code); 507 break; 508 509 default: 510 ret = -EOPNOTSUPP; 511 break; 512 513 } 514 515 if (ret == 0 && copy_to_user(p->pointer, param, p->length)) 516 ret = -EFAULT; 517 518 kfree(param); 519 520 /* up(&ieee->wx_sem); */ 521 return ret; 522 } 523 524 static int rtw_set_encryption(struct net_device *dev, struct ieee_param *param, u32 param_len) 525 { 526 int ret = 0; 527 u32 wep_key_idx, wep_key_len, wep_total_len; 528 struct ndis_802_11_wep *pwep = NULL; 529 struct sta_info *psta = NULL, *pbcmc_sta = NULL; 530 struct adapter *padapter = rtw_netdev_priv(dev); 531 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 532 struct security_priv *psecuritypriv = &(padapter->securitypriv); 533 struct sta_priv *pstapriv = &padapter->stapriv; 534 char *txkey = padapter->securitypriv.dot118021XGrptxmickey[param->u.crypt.idx].skey; 535 char *rxkey = padapter->securitypriv.dot118021XGrprxmickey[param->u.crypt.idx].skey; 536 char *grpkey = psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey; 537 538 param->u.crypt.err = 0; 539 param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0'; 540 541 /* sizeof(struct ieee_param) = 64 bytes; */ 542 /* if (param_len != (u32) ((u8 *) param->u.crypt.key - (u8 *) param) + param->u.crypt.key_len) */ 543 if (param_len != sizeof(struct ieee_param) + param->u.crypt.key_len) { 544 ret = -EINVAL; 545 goto exit; 546 } 547 548 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff && 549 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff && 550 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) { 551 if (param->u.crypt.idx >= WEP_KEYS) { 552 ret = -EINVAL; 553 goto exit; 554 } 555 } else { 556 psta = rtw_get_stainfo(pstapriv, param->sta_addr); 557 if (!psta) 558 /* ret = -EINVAL; */ 559 goto exit; 560 } 561 562 if (strcmp(param->u.crypt.alg, "none") == 0 && !psta) { 563 /* todo:clear default encryption keys */ 564 565 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open; 566 psecuritypriv->ndisencryptstatus = Ndis802_11EncryptionDisabled; 567 psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_; 568 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_; 569 570 goto exit; 571 } 572 573 574 if (strcmp(param->u.crypt.alg, "WEP") == 0 && !psta) { 575 wep_key_idx = param->u.crypt.idx; 576 wep_key_len = param->u.crypt.key_len; 577 578 if ((wep_key_idx >= WEP_KEYS) || (wep_key_len <= 0)) { 579 ret = -EINVAL; 580 goto exit; 581 } 582 583 584 if (wep_key_len > 0) { 585 wep_key_len = wep_key_len <= 5 ? 5 : 13; 586 wep_total_len = wep_key_len + FIELD_OFFSET(struct ndis_802_11_wep, key_material); 587 /* Allocate a full structure to avoid potentially running off the end. */ 588 pwep = kzalloc(sizeof(*pwep), GFP_KERNEL); 589 if (!pwep) 590 goto exit; 591 592 pwep->key_length = wep_key_len; 593 pwep->length = wep_total_len; 594 595 } 596 597 pwep->key_index = wep_key_idx; 598 599 memcpy(pwep->key_material, param->u.crypt.key, pwep->key_length); 600 601 if (param->u.crypt.set_tx) { 602 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Auto; 603 psecuritypriv->ndisencryptstatus = Ndis802_11Encryption1Enabled; 604 psecuritypriv->dot11PrivacyAlgrthm = _WEP40_; 605 psecuritypriv->dot118021XGrpPrivacy = _WEP40_; 606 607 if (pwep->key_length == 13) { 608 psecuritypriv->dot11PrivacyAlgrthm = _WEP104_; 609 psecuritypriv->dot118021XGrpPrivacy = _WEP104_; 610 } 611 612 613 psecuritypriv->dot11PrivacyKeyIndex = wep_key_idx; 614 615 memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), pwep->key_material, pwep->key_length); 616 617 psecuritypriv->dot11DefKeylen[wep_key_idx] = pwep->key_length; 618 619 rtw_ap_set_wep_key(padapter, pwep->key_material, pwep->key_length, wep_key_idx, 1); 620 } else { 621 /* don't update "psecuritypriv->dot11PrivacyAlgrthm" and */ 622 /* psecuritypriv->dot11PrivacyKeyIndex =keyid", but can rtw_set_key to cam */ 623 624 memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), pwep->key_material, pwep->key_length); 625 626 psecuritypriv->dot11DefKeylen[wep_key_idx] = pwep->key_length; 627 628 rtw_ap_set_wep_key(padapter, pwep->key_material, pwep->key_length, wep_key_idx, 0); 629 } 630 631 goto exit; 632 633 } 634 635 636 if (!psta && check_fwstate(pmlmepriv, WIFI_AP_STATE)) { /* group key */ 637 if (param->u.crypt.set_tx == 1) { 638 if (strcmp(param->u.crypt.alg, "WEP") == 0) { 639 memcpy(grpkey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 640 641 psecuritypriv->dot118021XGrpPrivacy = _WEP40_; 642 if (param->u.crypt.key_len == 13) 643 psecuritypriv->dot118021XGrpPrivacy = _WEP104_; 644 645 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) { 646 psecuritypriv->dot118021XGrpPrivacy = _TKIP_; 647 648 memcpy(grpkey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 649 650 /* DEBUG_ERR("set key length :param->u.crypt.key_len =%d\n", param->u.crypt.key_len); */ 651 /* set mic key */ 652 memcpy(txkey, &(param->u.crypt.key[16]), 8); 653 memcpy(psecuritypriv->dot118021XGrprxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[24]), 8); 654 655 psecuritypriv->busetkipkey = true; 656 657 } 658 else if (strcmp(param->u.crypt.alg, "CCMP") == 0) { 659 psecuritypriv->dot118021XGrpPrivacy = _AES_; 660 661 memcpy(grpkey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 662 } else { 663 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_; 664 } 665 666 psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx; 667 668 psecuritypriv->binstallGrpkey = true; 669 670 psecuritypriv->dot11PrivacyAlgrthm = psecuritypriv->dot118021XGrpPrivacy;/* */ 671 672 rtw_ap_set_group_key(padapter, param->u.crypt.key, psecuritypriv->dot118021XGrpPrivacy, param->u.crypt.idx); 673 674 pbcmc_sta = rtw_get_bcmc_stainfo(padapter); 675 if (pbcmc_sta) { 676 pbcmc_sta->ieee8021x_blocked = false; 677 pbcmc_sta->dot118021XPrivacy = psecuritypriv->dot118021XGrpPrivacy;/* rx will use bmc_sta's dot118021XPrivacy */ 678 } 679 } 680 681 goto exit; 682 683 } 684 685 if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X && psta) { /* psk/802_1x */ 686 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) { 687 if (param->u.crypt.set_tx == 1) { 688 memcpy(psta->dot118021x_UncstKey.skey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 689 690 if (strcmp(param->u.crypt.alg, "WEP") == 0) { 691 psta->dot118021XPrivacy = _WEP40_; 692 if (param->u.crypt.key_len == 13) 693 psta->dot118021XPrivacy = _WEP104_; 694 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) { 695 psta->dot118021XPrivacy = _TKIP_; 696 697 /* DEBUG_ERR("set key length :param->u.crypt.key_len =%d\n", param->u.crypt.key_len); */ 698 /* set mic key */ 699 memcpy(psta->dot11tkiptxmickey.skey, &(param->u.crypt.key[16]), 8); 700 memcpy(psta->dot11tkiprxmickey.skey, &(param->u.crypt.key[24]), 8); 701 702 psecuritypriv->busetkipkey = true; 703 704 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) { 705 706 psta->dot118021XPrivacy = _AES_; 707 } else { 708 psta->dot118021XPrivacy = _NO_PRIVACY_; 709 } 710 711 rtw_ap_set_pairwise_key(padapter, psta); 712 713 psta->ieee8021x_blocked = false; 714 715 } else { /* group key??? */ 716 if (strcmp(param->u.crypt.alg, "WEP") == 0) { 717 memcpy(grpkey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 718 719 psecuritypriv->dot118021XGrpPrivacy = _WEP40_; 720 if (param->u.crypt.key_len == 13) 721 psecuritypriv->dot118021XGrpPrivacy = _WEP104_; 722 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) { 723 psecuritypriv->dot118021XGrpPrivacy = _TKIP_; 724 725 memcpy(grpkey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 726 727 /* DEBUG_ERR("set key length :param->u.crypt.key_len =%d\n", param->u.crypt.key_len); */ 728 /* set mic key */ 729 memcpy(txkey, &(param->u.crypt.key[16]), 8); 730 memcpy(rxkey, &(param->u.crypt.key[24]), 8); 731 732 psecuritypriv->busetkipkey = true; 733 734 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) { 735 psecuritypriv->dot118021XGrpPrivacy = _AES_; 736 737 memcpy(grpkey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 738 } else { 739 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_; 740 } 741 742 psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx; 743 744 psecuritypriv->binstallGrpkey = true; 745 746 psecuritypriv->dot11PrivacyAlgrthm = psecuritypriv->dot118021XGrpPrivacy;/* */ 747 748 rtw_ap_set_group_key(padapter, param->u.crypt.key, psecuritypriv->dot118021XGrpPrivacy, param->u.crypt.idx); 749 750 pbcmc_sta = rtw_get_bcmc_stainfo(padapter); 751 if (pbcmc_sta) { 752 pbcmc_sta->ieee8021x_blocked = false; 753 pbcmc_sta->dot118021XPrivacy = psecuritypriv->dot118021XGrpPrivacy;/* rx will use bmc_sta's dot118021XPrivacy */ 754 } 755 } 756 } 757 } 758 759 exit: 760 kfree(pwep); 761 762 return ret; 763 764 } 765 766 static int rtw_set_beacon(struct net_device *dev, struct ieee_param *param, int len) 767 { 768 int ret = 0; 769 struct adapter *padapter = rtw_netdev_priv(dev); 770 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 771 struct sta_priv *pstapriv = &padapter->stapriv; 772 unsigned char *pbuf = param->u.bcn_ie.buf; 773 774 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true) 775 return -EINVAL; 776 777 memcpy(&pstapriv->max_num_sta, param->u.bcn_ie.reserved, 2); 778 779 if ((pstapriv->max_num_sta > NUM_STA) || (pstapriv->max_num_sta <= 0)) 780 pstapriv->max_num_sta = NUM_STA; 781 782 783 if (rtw_check_beacon_data(padapter, pbuf, (len-12-2)) == _SUCCESS)/* 12 = param header, 2:no packed */ 784 ret = 0; 785 else 786 ret = -EINVAL; 787 788 789 return ret; 790 791 } 792 793 static void rtw_hostapd_sta_flush(struct net_device *dev) 794 { 795 /* _irqL irqL; */ 796 /* struct list_head *phead, *plist; */ 797 /* struct sta_info *psta = NULL; */ 798 struct adapter *padapter = rtw_netdev_priv(dev); 799 /* struct sta_priv *pstapriv = &padapter->stapriv; */ 800 801 flush_all_cam_entry(padapter); /* clear CAM */ 802 803 rtw_sta_flush(padapter); 804 } 805 806 static int rtw_add_sta(struct net_device *dev, struct ieee_param *param) 807 { 808 int ret = 0; 809 struct sta_info *psta = NULL; 810 struct adapter *padapter = rtw_netdev_priv(dev); 811 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 812 struct sta_priv *pstapriv = &padapter->stapriv; 813 814 if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true) 815 return -EINVAL; 816 817 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff && 818 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff && 819 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) { 820 return -EINVAL; 821 } 822 823 /* 824 psta = rtw_get_stainfo(pstapriv, param->sta_addr); 825 if (psta) 826 { 827 rtw_free_stainfo(padapter, psta); 828 829 psta = NULL; 830 } 831 */ 832 /* psta = rtw_alloc_stainfo(pstapriv, param->sta_addr); */ 833 psta = rtw_get_stainfo(pstapriv, param->sta_addr); 834 if (psta) { 835 int flags = param->u.add_sta.flags; 836 837 psta->aid = param->u.add_sta.aid;/* aid = 1~2007 */ 838 839 memcpy(psta->bssrateset, param->u.add_sta.tx_supp_rates, 16); 840 841 842 /* check wmm cap. */ 843 if (WLAN_STA_WME&flags) 844 psta->qos_option = 1; 845 else 846 psta->qos_option = 0; 847 848 if (pmlmepriv->qospriv.qos_option == 0) 849 psta->qos_option = 0; 850 851 /* chec 802.11n ht cap. */ 852 if (WLAN_STA_HT&flags) { 853 psta->htpriv.ht_option = true; 854 psta->qos_option = 1; 855 memcpy((void *)&psta->htpriv.ht_cap, (void *)¶m->u.add_sta.ht_cap, sizeof(struct ieee80211_ht_cap)); 856 } else { 857 psta->htpriv.ht_option = false; 858 } 859 860 if (pmlmepriv->htpriv.ht_option == false) 861 psta->htpriv.ht_option = false; 862 863 update_sta_info_apmode(padapter, psta); 864 865 866 } else { 867 ret = -ENOMEM; 868 } 869 870 return ret; 871 872 } 873 874 static int rtw_del_sta(struct net_device *dev, struct ieee_param *param) 875 { 876 int ret = 0; 877 struct sta_info *psta = NULL; 878 struct adapter *padapter = rtw_netdev_priv(dev); 879 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 880 struct sta_priv *pstapriv = &padapter->stapriv; 881 882 if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true) 883 return -EINVAL; 884 885 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff && 886 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff && 887 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) { 888 return -EINVAL; 889 } 890 891 psta = rtw_get_stainfo(pstapriv, param->sta_addr); 892 if (psta) { 893 u8 updated = false; 894 895 spin_lock_bh(&pstapriv->asoc_list_lock); 896 if (list_empty(&psta->asoc_list) == false) { 897 list_del_init(&psta->asoc_list); 898 pstapriv->asoc_list_cnt--; 899 updated = ap_free_sta(padapter, psta, true, WLAN_REASON_DEAUTH_LEAVING); 900 901 } 902 spin_unlock_bh(&pstapriv->asoc_list_lock); 903 904 associated_clients_update(padapter, updated); 905 906 psta = NULL; 907 908 } 909 910 return ret; 911 912 } 913 914 static int rtw_ioctl_get_sta_data(struct net_device *dev, struct ieee_param *param, int len) 915 { 916 int ret = 0; 917 struct sta_info *psta = NULL; 918 struct adapter *padapter = rtw_netdev_priv(dev); 919 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 920 struct sta_priv *pstapriv = &padapter->stapriv; 921 struct ieee_param_ex *param_ex = (struct ieee_param_ex *)param; 922 struct sta_data *psta_data = (struct sta_data *)param_ex->data; 923 924 if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true) 925 return -EINVAL; 926 927 if (param_ex->sta_addr[0] == 0xff && param_ex->sta_addr[1] == 0xff && 928 param_ex->sta_addr[2] == 0xff && param_ex->sta_addr[3] == 0xff && 929 param_ex->sta_addr[4] == 0xff && param_ex->sta_addr[5] == 0xff) { 930 return -EINVAL; 931 } 932 933 psta = rtw_get_stainfo(pstapriv, param_ex->sta_addr); 934 if (psta) { 935 psta_data->aid = (u16)psta->aid; 936 psta_data->capability = psta->capability; 937 psta_data->flags = psta->flags; 938 939 /* 940 nonerp_set : BIT(0) 941 no_short_slot_time_set : BIT(1) 942 no_short_preamble_set : BIT(2) 943 no_ht_gf_set : BIT(3) 944 no_ht_set : BIT(4) 945 ht_20mhz_set : BIT(5) 946 */ 947 948 psta_data->sta_set = ((psta->nonerp_set) | 949 (psta->no_short_slot_time_set << 1) | 950 (psta->no_short_preamble_set << 2) | 951 (psta->no_ht_gf_set << 3) | 952 (psta->no_ht_set << 4) | 953 (psta->ht_20mhz_set << 5)); 954 955 psta_data->tx_supp_rates_len = psta->bssratelen; 956 memcpy(psta_data->tx_supp_rates, psta->bssrateset, psta->bssratelen); 957 memcpy(&psta_data->ht_cap, &psta->htpriv.ht_cap, sizeof(struct ieee80211_ht_cap)); 958 psta_data->rx_pkts = psta->sta_stats.rx_data_pkts; 959 psta_data->rx_bytes = psta->sta_stats.rx_bytes; 960 psta_data->rx_drops = psta->sta_stats.rx_drops; 961 962 psta_data->tx_pkts = psta->sta_stats.tx_pkts; 963 psta_data->tx_bytes = psta->sta_stats.tx_bytes; 964 psta_data->tx_drops = psta->sta_stats.tx_drops; 965 966 967 } else { 968 ret = -1; 969 } 970 971 return ret; 972 973 } 974 975 static int rtw_get_sta_wpaie(struct net_device *dev, struct ieee_param *param) 976 { 977 int ret = 0; 978 struct sta_info *psta = NULL; 979 struct adapter *padapter = rtw_netdev_priv(dev); 980 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 981 struct sta_priv *pstapriv = &padapter->stapriv; 982 983 if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true) 984 return -EINVAL; 985 986 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff && 987 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff && 988 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) { 989 return -EINVAL; 990 } 991 992 psta = rtw_get_stainfo(pstapriv, param->sta_addr); 993 if (psta) { 994 if ((psta->wpa_ie[0] == WLAN_EID_RSN) || (psta->wpa_ie[0] == WLAN_EID_VENDOR_SPECIFIC)) { 995 int wpa_ie_len; 996 int copy_len; 997 998 wpa_ie_len = psta->wpa_ie[1]; 999 1000 copy_len = ((wpa_ie_len+2) > sizeof(psta->wpa_ie)) ? (sizeof(psta->wpa_ie)):(wpa_ie_len+2); 1001 1002 param->u.wpa_ie.len = copy_len; 1003 1004 memcpy(param->u.wpa_ie.reserved, psta->wpa_ie, copy_len); 1005 } 1006 } else { 1007 ret = -1; 1008 } 1009 1010 return ret; 1011 1012 } 1013 1014 static int rtw_set_wps_beacon(struct net_device *dev, struct ieee_param *param, int len) 1015 { 1016 int ret = 0; 1017 unsigned char wps_oui[4] = {0x0, 0x50, 0xf2, 0x04}; 1018 struct adapter *padapter = rtw_netdev_priv(dev); 1019 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1020 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv); 1021 int ie_len; 1022 1023 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true) 1024 return -EINVAL; 1025 1026 ie_len = len-12-2;/* 12 = param header, 2:no packed */ 1027 1028 1029 kfree(pmlmepriv->wps_beacon_ie); 1030 pmlmepriv->wps_beacon_ie = NULL; 1031 1032 if (ie_len > 0) { 1033 pmlmepriv->wps_beacon_ie = rtw_malloc(ie_len); 1034 pmlmepriv->wps_beacon_ie_len = ie_len; 1035 if (!pmlmepriv->wps_beacon_ie) 1036 return -EINVAL; 1037 1038 memcpy(pmlmepriv->wps_beacon_ie, param->u.bcn_ie.buf, ie_len); 1039 1040 update_beacon(padapter, WLAN_EID_VENDOR_SPECIFIC, wps_oui, true); 1041 1042 pmlmeext->bstart_bss = true; 1043 } 1044 1045 1046 return ret; 1047 1048 } 1049 1050 static int rtw_set_wps_probe_resp(struct net_device *dev, struct ieee_param *param, int len) 1051 { 1052 int ret = 0; 1053 struct adapter *padapter = rtw_netdev_priv(dev); 1054 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1055 int ie_len; 1056 1057 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true) 1058 return -EINVAL; 1059 1060 ie_len = len-12-2;/* 12 = param header, 2:no packed */ 1061 1062 1063 kfree(pmlmepriv->wps_probe_resp_ie); 1064 pmlmepriv->wps_probe_resp_ie = NULL; 1065 1066 if (ie_len > 0) { 1067 pmlmepriv->wps_probe_resp_ie = rtw_malloc(ie_len); 1068 pmlmepriv->wps_probe_resp_ie_len = ie_len; 1069 if (!pmlmepriv->wps_probe_resp_ie) 1070 return -EINVAL; 1071 1072 memcpy(pmlmepriv->wps_probe_resp_ie, param->u.bcn_ie.buf, ie_len); 1073 } 1074 1075 1076 return ret; 1077 1078 } 1079 1080 static int rtw_set_wps_assoc_resp(struct net_device *dev, struct ieee_param *param, int len) 1081 { 1082 int ret = 0; 1083 struct adapter *padapter = rtw_netdev_priv(dev); 1084 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1085 int ie_len; 1086 1087 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true) 1088 return -EINVAL; 1089 1090 ie_len = len-12-2;/* 12 = param header, 2:no packed */ 1091 1092 1093 kfree(pmlmepriv->wps_assoc_resp_ie); 1094 pmlmepriv->wps_assoc_resp_ie = NULL; 1095 1096 if (ie_len > 0) { 1097 pmlmepriv->wps_assoc_resp_ie = rtw_malloc(ie_len); 1098 pmlmepriv->wps_assoc_resp_ie_len = ie_len; 1099 if (!pmlmepriv->wps_assoc_resp_ie) 1100 return -EINVAL; 1101 1102 memcpy(pmlmepriv->wps_assoc_resp_ie, param->u.bcn_ie.buf, ie_len); 1103 } 1104 1105 1106 return ret; 1107 1108 } 1109 1110 static int rtw_set_hidden_ssid(struct net_device *dev, struct ieee_param *param, int len) 1111 { 1112 int ret = 0; 1113 struct adapter *adapter = rtw_netdev_priv(dev); 1114 struct mlme_priv *mlmepriv = &(adapter->mlmepriv); 1115 struct mlme_ext_priv *mlmeext = &(adapter->mlmeextpriv); 1116 struct mlme_ext_info *mlmeinfo = &(mlmeext->mlmext_info); 1117 int ie_len; 1118 u8 *ssid_ie; 1119 char ssid[NDIS_802_11_LENGTH_SSID + 1]; 1120 signed int ssid_len; 1121 u8 ignore_broadcast_ssid; 1122 1123 if (check_fwstate(mlmepriv, WIFI_AP_STATE) != true) 1124 return -EPERM; 1125 1126 if (param->u.bcn_ie.reserved[0] != 0xea) 1127 return -EINVAL; 1128 1129 mlmeinfo->hidden_ssid_mode = ignore_broadcast_ssid = param->u.bcn_ie.reserved[1]; 1130 1131 ie_len = len-12-2;/* 12 = param header, 2:no packed */ 1132 ssid_ie = rtw_get_ie(param->u.bcn_ie.buf, WLAN_EID_SSID, &ssid_len, ie_len); 1133 1134 if (ssid_ie && ssid_len > 0 && ssid_len <= NDIS_802_11_LENGTH_SSID) { 1135 struct wlan_bssid_ex *pbss_network = &mlmepriv->cur_network.network; 1136 struct wlan_bssid_ex *pbss_network_ext = &mlmeinfo->network; 1137 1138 memcpy(ssid, ssid_ie+2, ssid_len); 1139 ssid[ssid_len] = 0x0; 1140 1141 memcpy(pbss_network->ssid.ssid, (void *)ssid, ssid_len); 1142 pbss_network->ssid.ssid_length = ssid_len; 1143 memcpy(pbss_network_ext->ssid.ssid, (void *)ssid, ssid_len); 1144 pbss_network_ext->ssid.ssid_length = ssid_len; 1145 } 1146 1147 return ret; 1148 } 1149 1150 static int rtw_ioctl_acl_remove_sta(struct net_device *dev, struct ieee_param *param, int len) 1151 { 1152 struct adapter *padapter = rtw_netdev_priv(dev); 1153 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1154 1155 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true) 1156 return -EINVAL; 1157 1158 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff && 1159 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff && 1160 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) { 1161 return -EINVAL; 1162 } 1163 1164 rtw_acl_remove_sta(padapter, param->sta_addr); 1165 return 0; 1166 1167 } 1168 1169 static int rtw_ioctl_acl_add_sta(struct net_device *dev, struct ieee_param *param, int len) 1170 { 1171 struct adapter *padapter = rtw_netdev_priv(dev); 1172 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1173 1174 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true) 1175 return -EINVAL; 1176 1177 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff && 1178 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff && 1179 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) { 1180 return -EINVAL; 1181 } 1182 1183 return rtw_acl_add_sta(padapter, param->sta_addr); 1184 1185 } 1186 1187 static int rtw_ioctl_set_macaddr_acl(struct net_device *dev, struct ieee_param *param, int len) 1188 { 1189 int ret = 0; 1190 struct adapter *padapter = rtw_netdev_priv(dev); 1191 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1192 1193 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true) 1194 return -EINVAL; 1195 1196 rtw_set_macaddr_acl(padapter, param->u.mlme.command); 1197 1198 return ret; 1199 } 1200 1201 static int rtw_hostapd_ioctl(struct net_device *dev, struct iw_point *p) 1202 { 1203 struct ieee_param *param; 1204 int ret = 0; 1205 struct adapter *padapter = rtw_netdev_priv(dev); 1206 1207 /* 1208 * this function is expect to call in master mode, which allows no power saving 1209 * so, we just check hw_init_completed 1210 */ 1211 1212 if (!padapter->hw_init_completed) 1213 return -EPERM; 1214 1215 if (!p->pointer || p->length != sizeof(*param)) 1216 return -EINVAL; 1217 1218 param = rtw_malloc(p->length); 1219 if (!param) 1220 return -ENOMEM; 1221 1222 if (copy_from_user(param, p->pointer, p->length)) { 1223 kfree(param); 1224 return -EFAULT; 1225 } 1226 1227 switch (param->cmd) { 1228 case RTL871X_HOSTAPD_FLUSH: 1229 1230 rtw_hostapd_sta_flush(dev); 1231 1232 break; 1233 1234 case RTL871X_HOSTAPD_ADD_STA: 1235 1236 ret = rtw_add_sta(dev, param); 1237 1238 break; 1239 1240 case RTL871X_HOSTAPD_REMOVE_STA: 1241 1242 ret = rtw_del_sta(dev, param); 1243 1244 break; 1245 1246 case RTL871X_HOSTAPD_SET_BEACON: 1247 1248 ret = rtw_set_beacon(dev, param, p->length); 1249 1250 break; 1251 1252 case RTL871X_SET_ENCRYPTION: 1253 1254 ret = rtw_set_encryption(dev, param, p->length); 1255 1256 break; 1257 1258 case RTL871X_HOSTAPD_GET_WPAIE_STA: 1259 1260 ret = rtw_get_sta_wpaie(dev, param); 1261 1262 break; 1263 1264 case RTL871X_HOSTAPD_SET_WPS_BEACON: 1265 1266 ret = rtw_set_wps_beacon(dev, param, p->length); 1267 1268 break; 1269 1270 case RTL871X_HOSTAPD_SET_WPS_PROBE_RESP: 1271 1272 ret = rtw_set_wps_probe_resp(dev, param, p->length); 1273 1274 break; 1275 1276 case RTL871X_HOSTAPD_SET_WPS_ASSOC_RESP: 1277 1278 ret = rtw_set_wps_assoc_resp(dev, param, p->length); 1279 1280 break; 1281 1282 case RTL871X_HOSTAPD_SET_HIDDEN_SSID: 1283 1284 ret = rtw_set_hidden_ssid(dev, param, p->length); 1285 1286 break; 1287 1288 case RTL871X_HOSTAPD_GET_INFO_STA: 1289 1290 ret = rtw_ioctl_get_sta_data(dev, param, p->length); 1291 1292 break; 1293 1294 case RTL871X_HOSTAPD_SET_MACADDR_ACL: 1295 1296 ret = rtw_ioctl_set_macaddr_acl(dev, param, p->length); 1297 1298 break; 1299 1300 case RTL871X_HOSTAPD_ACL_ADD_STA: 1301 1302 ret = rtw_ioctl_acl_add_sta(dev, param, p->length); 1303 1304 break; 1305 1306 case RTL871X_HOSTAPD_ACL_REMOVE_STA: 1307 1308 ret = rtw_ioctl_acl_remove_sta(dev, param, p->length); 1309 1310 break; 1311 1312 default: 1313 ret = -EOPNOTSUPP; 1314 break; 1315 1316 } 1317 1318 if (ret == 0 && copy_to_user(p->pointer, param, p->length)) 1319 ret = -EFAULT; 1320 1321 kfree(param); 1322 return ret; 1323 } 1324 1325 /* copy from net/wireless/wext.c end */ 1326 1327 int rtw_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 1328 { 1329 struct iwreq *wrq = (struct iwreq *)rq; 1330 int ret = 0; 1331 1332 switch (cmd) { 1333 case RTL_IOCTL_WPA_SUPPLICANT: 1334 ret = wpa_supplicant_ioctl(dev, &wrq->u.data); 1335 break; 1336 case RTL_IOCTL_HOSTAPD: 1337 ret = rtw_hostapd_ioctl(dev, &wrq->u.data); 1338 break; 1339 default: 1340 ret = -EOPNOTSUPP; 1341 break; 1342 } 1343 1344 return ret; 1345 } 1346