drivers/staging/rtl8723bs/os_dep/ioctl_linux.c

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