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