5 files changed, 439 insertions, 11 deletions

diff --git a/net/mac80211/cfg.c b/net/mac80211/cfg.c
index 58693e52d458..223e536e8426 100644
--- a/net/mac80211/cfg.c
+++ b/net/mac80211/cfg.c
@@ -1300,6 +1300,142 @@ static int ieee80211_scan(struct wiphy *wiphy,
         return ieee80211_request_scan(sdata, req);
 }
 
+static int ieee80211_auth(struct wiphy *wiphy, struct net_device *dev,
+                          struct cfg80211_auth_request *req)
+{
+        struct ieee80211_sub_if_data *sdata;
+
+        if (!netif_running(dev))
+                return -ENETDOWN;
+
+        sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+
+        if (sdata->vif.type != NL80211_IFTYPE_STATION)
+                return -EOPNOTSUPP;
+
+        switch (req->auth_type) {
+        case NL80211_AUTHTYPE_OPEN_SYSTEM:
+                sdata->u.mgd.auth_algs = IEEE80211_AUTH_ALG_OPEN;
+                break;
+        case NL80211_AUTHTYPE_SHARED_KEY:
+                sdata->u.mgd.auth_algs = IEEE80211_AUTH_ALG_SHARED_KEY;
+                break;
+        case NL80211_AUTHTYPE_FT:
+                sdata->u.mgd.auth_algs = IEEE80211_AUTH_ALG_FT;
+                break;
+        case NL80211_AUTHTYPE_NETWORK_EAP:
+                sdata->u.mgd.auth_algs = IEEE80211_AUTH_ALG_LEAP;
+                break;
+        default:
+                return -EOPNOTSUPP;
+        }
+
+        memcpy(sdata->u.mgd.bssid, req->peer_addr, ETH_ALEN);
+        sdata->u.mgd.flags &= ~IEEE80211_STA_AUTO_BSSID_SEL;
+        sdata->u.mgd.flags |= IEEE80211_STA_BSSID_SET;
+
+        /* TODO: req->chan */
+        sdata->u.mgd.flags |= IEEE80211_STA_AUTO_CHANNEL_SEL;
+
+        if (req->ssid) {
+                sdata->u.mgd.flags |= IEEE80211_STA_SSID_SET;
+                memcpy(sdata->u.mgd.ssid, req->ssid, req->ssid_len);
+                sdata->u.mgd.ssid_len = req->ssid_len;
+                sdata->u.mgd.flags &= ~IEEE80211_STA_AUTO_SSID_SEL;
+        }
+
+        kfree(sdata->u.mgd.sme_auth_ie);
+        sdata->u.mgd.sme_auth_ie = NULL;
+        sdata->u.mgd.sme_auth_ie_len = 0;
+        if (req->ie) {
+                sdata->u.mgd.sme_auth_ie = kmalloc(req->ie_len, GFP_KERNEL);
+                if (sdata->u.mgd.sme_auth_ie == NULL)
+                        return -ENOMEM;
+                memcpy(sdata->u.mgd.sme_auth_ie, req->ie, req->ie_len);
+                sdata->u.mgd.sme_auth_ie_len = req->ie_len;
+        }
+
+        sdata->u.mgd.flags |= IEEE80211_STA_EXT_SME;
+        sdata->u.mgd.state = IEEE80211_STA_MLME_DIRECT_PROBE;
+        ieee80211_sta_req_auth(sdata);
+        return 0;
+}
+
+static int ieee80211_assoc(struct wiphy *wiphy, struct net_device *dev,
+                           struct cfg80211_assoc_request *req)
+{
+        struct ieee80211_sub_if_data *sdata;
+        int ret;
+
+        if (!netif_running(dev))
+                return -ENETDOWN;
+
+        sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+
+        if (sdata->vif.type != NL80211_IFTYPE_STATION)
+                return -EOPNOTSUPP;
+
+        if (memcmp(sdata->u.mgd.bssid, req->peer_addr, ETH_ALEN) != 0 ||
+            !(sdata->u.mgd.flags & IEEE80211_STA_AUTHENTICATED))
+                return -ENOLINK; /* not authenticated */
+
+        sdata->u.mgd.flags &= ~IEEE80211_STA_AUTO_BSSID_SEL;
+        sdata->u.mgd.flags |= IEEE80211_STA_BSSID_SET;
+
+        /* TODO: req->chan */
+        sdata->u.mgd.flags |= IEEE80211_STA_AUTO_CHANNEL_SEL;
+
+        if (req->ssid) {
+                sdata->u.mgd.flags |= IEEE80211_STA_SSID_SET;
+                memcpy(sdata->u.mgd.ssid, req->ssid, req->ssid_len);
+                sdata->u.mgd.ssid_len = req->ssid_len;
+                sdata->u.mgd.flags &= ~IEEE80211_STA_AUTO_SSID_SEL;
+        } else
+                sdata->u.mgd.flags |= IEEE80211_STA_AUTO_SSID_SEL;
+
+        ret = ieee80211_sta_set_extra_ie(sdata, req->ie, req->ie_len);
+        if (ret)
+                return ret;
+
+        sdata->u.mgd.flags |= IEEE80211_STA_EXT_SME;
+        sdata->u.mgd.state = IEEE80211_STA_MLME_ASSOCIATE;
+        ieee80211_sta_req_auth(sdata);
+        return 0;
+}
+
+static int ieee80211_deauth(struct wiphy *wiphy, struct net_device *dev,
+                            struct cfg80211_deauth_request *req)
+{
+        struct ieee80211_sub_if_data *sdata;
+
+        if (!netif_running(dev))
+                return -ENETDOWN;
+
+        sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+        if (sdata->vif.type != NL80211_IFTYPE_STATION)
+                return -EOPNOTSUPP;
+
+        /* TODO: req->ie */
+        return ieee80211_sta_deauthenticate(sdata, req->reason_code);
+}
+
+static int ieee80211_disassoc(struct wiphy *wiphy, struct net_device *dev,
+                              struct cfg80211_disassoc_request *req)
+{
+        struct ieee80211_sub_if_data *sdata;
+
+        if (!netif_running(dev))
+                return -ENETDOWN;
+
+        sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+
+        if (sdata->vif.type != NL80211_IFTYPE_STATION)
+                return -EOPNOTSUPP;
+
+        /* TODO: req->ie */
+        return ieee80211_sta_disassociate(sdata, req->reason_code);
+}
+
 struct cfg80211_ops mac80211_config_ops = {
         .add_virtual_intf = ieee80211_add_iface,
         .del_virtual_intf = ieee80211_del_iface,
@@ -1333,4 +1469,8 @@ struct cfg80211_ops mac80211_config_ops = {
         .suspend = ieee80211_suspend,
         .resume = ieee80211_resume,
         .scan = ieee80211_scan,
+        .auth = ieee80211_auth,
+        .assoc = ieee80211_assoc,
+        .deauth = ieee80211_deauth,
+        .disassoc = ieee80211_disassoc,
 };
diff --git a/net/mac80211/ieee80211_i.h b/net/mac80211/ieee80211_i.h
index ad12c2a03a95..7b96d95f48b1 100644
--- a/net/mac80211/ieee80211_i.h
+++ b/net/mac80211/ieee80211_i.h
@@ -256,6 +256,7 @@ struct mesh_preq_queue {
 #define IEEE80211_STA_TKIP_WEP_USED     BIT(14)
 #define IEEE80211_STA_CSA_RECEIVED      BIT(15)
 #define IEEE80211_STA_MFP_ENABLED       BIT(16)
+#define IEEE80211_STA_EXT_SME           BIT(17)
 /* flags for MLME request */
 #define IEEE80211_STA_REQ_SCAN 0
 #define IEEE80211_STA_REQ_DIRECT_PROBE 1
@@ -266,6 +267,7 @@ struct mesh_preq_queue {
 #define IEEE80211_AUTH_ALG_OPEN BIT(0)
 #define IEEE80211_AUTH_ALG_SHARED_KEY BIT(1)
 #define IEEE80211_AUTH_ALG_LEAP BIT(2)
+#define IEEE80211_AUTH_ALG_FT BIT(3)
 
 struct ieee80211_if_managed {
         struct timer_list timer;
@@ -335,6 +337,9 @@ struct ieee80211_if_managed {
         size_t ie_deauth_len;
         u8 *ie_disassoc;
         size_t ie_disassoc_len;
+
+        u8 *sme_auth_ie;
+        size_t sme_auth_ie_len;
 };
 
 enum ieee80211_ibss_flags {
@@ -970,7 +975,7 @@ ieee80211_scan_rx(struct ieee80211_sub_if_data *sdata,
                   struct sk_buff *skb,
                   struct ieee80211_rx_status *rx_status);
 int ieee80211_sta_set_extra_ie(struct ieee80211_sub_if_data *sdata,
-                               char *ie, size_t len);
+                               const char *ie, size_t len);
 
 void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local);
 void ieee80211_scan_failed(struct ieee80211_local *local);
diff --git a/net/mac80211/mlme.c b/net/mac80211/mlme.c
index 6dc7a61bc18b..d1bcc8438772 100644
--- a/net/mac80211/mlme.c
+++ b/net/mac80211/mlme.c
@@ -730,6 +730,8 @@ static void ieee80211_authenticate(struct ieee80211_sub_if_data *sdata)
 {
         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
         struct ieee80211_local *local = sdata->local;
+        u8 *ies;
+        size_t ies_len;
 
         ifmgd->auth_tries++;
         if (ifmgd->auth_tries > IEEE80211_AUTH_MAX_TRIES) {
@@ -755,7 +757,14 @@ static void ieee80211_authenticate(struct ieee80211_sub_if_data *sdata)
         printk(KERN_DEBUG "%s: authenticate with AP %pM\n",
                sdata->dev->name, ifmgd->bssid);
 
-        ieee80211_send_auth(sdata, 1, ifmgd->auth_alg, NULL, 0,
+        if (ifmgd->flags & IEEE80211_STA_EXT_SME) {
+                ies = ifmgd->sme_auth_ie;
+                ies_len = ifmgd->sme_auth_ie_len;
+        } else {
+                ies = NULL;
+                ies_len = 0;
+        }
+        ieee80211_send_auth(sdata, 1, ifmgd->auth_alg, ies, ies_len,
                             ifmgd->bssid, 0);
         ifmgd->auth_transaction = 2;
 
@@ -870,7 +879,8 @@ static int ieee80211_privacy_mismatch(struct ieee80211_sub_if_data *sdata)
         int wep_privacy;
         int privacy_invoked;
 
-        if (!ifmgd || (ifmgd->flags & IEEE80211_STA_MIXED_CELL))
+        if (!ifmgd || (ifmgd->flags & (IEEE80211_STA_MIXED_CELL |
+                                       IEEE80211_STA_EXT_SME)))
                 return 0;
 
         bss = ieee80211_rx_bss_get(local, ifmgd->bssid,
@@ -998,7 +1008,11 @@ static void ieee80211_auth_completed(struct ieee80211_sub_if_data *sdata)
 
         printk(KERN_DEBUG "%s: authenticated\n", sdata->dev->name);
         ifmgd->flags |= IEEE80211_STA_AUTHENTICATED;
-        ieee80211_associate(sdata);
+        if (ifmgd->flags & IEEE80211_STA_EXT_SME) {
+                /* Wait for SME to request association */
+                ifmgd->state = IEEE80211_STA_MLME_DISABLED;
+        } else
+                ieee80211_associate(sdata);
 }
 
 
@@ -1084,6 +1098,7 @@ static void ieee80211_rx_mgmt_auth(struct ieee80211_sub_if_data *sdata,
         switch (ifmgd->auth_alg) {
         case WLAN_AUTH_OPEN:
         case WLAN_AUTH_LEAP:
+        case WLAN_AUTH_FT:
                 ieee80211_auth_completed(sdata);
                 cfg80211_send_rx_auth(sdata->dev, (u8 *) mgmt, len);
                 break;
@@ -1117,9 +1132,10 @@ static void ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data *sdata,
                 printk(KERN_DEBUG "%s: deauthenticated (Reason: %u)\n",
                                 sdata->dev->name, reason_code);
 
-        if (ifmgd->state == IEEE80211_STA_MLME_AUTHENTICATE ||
-            ifmgd->state == IEEE80211_STA_MLME_ASSOCIATE ||
-            ifmgd->state == IEEE80211_STA_MLME_ASSOCIATED) {
+        if (!(ifmgd->flags & IEEE80211_STA_EXT_SME) &&
+            (ifmgd->state == IEEE80211_STA_MLME_AUTHENTICATE ||
+             ifmgd->state == IEEE80211_STA_MLME_ASSOCIATE ||
+             ifmgd->state == IEEE80211_STA_MLME_ASSOCIATED)) {
                 ifmgd->state = IEEE80211_STA_MLME_DIRECT_PROBE;
                 mod_timer(&ifmgd->timer, jiffies +
                                       IEEE80211_RETRY_AUTH_INTERVAL);
@@ -1150,7 +1166,8 @@ static void ieee80211_rx_mgmt_disassoc(struct ieee80211_sub_if_data *sdata,
                 printk(KERN_DEBUG "%s: disassociated (Reason: %u)\n",
                                 sdata->dev->name, reason_code);
 
-        if (ifmgd->state == IEEE80211_STA_MLME_ASSOCIATED) {
+        if (!(ifmgd->flags & IEEE80211_STA_EXT_SME) &&
+            ifmgd->state == IEEE80211_STA_MLME_ASSOCIATED) {
                 ifmgd->state = IEEE80211_STA_MLME_ASSOCIATE;
                 mod_timer(&ifmgd->timer, jiffies +
                                       IEEE80211_RETRY_AUTH_INTERVAL);
@@ -1664,6 +1681,8 @@ static void ieee80211_sta_reset_auth(struct ieee80211_sub_if_data *sdata)
                 ifmgd->auth_alg = WLAN_AUTH_SHARED_KEY;
         else if (ifmgd->auth_algs & IEEE80211_AUTH_ALG_LEAP)
                 ifmgd->auth_alg = WLAN_AUTH_LEAP;
+        else if (ifmgd->auth_algs & IEEE80211_AUTH_ALG_FT)
+                ifmgd->auth_alg = WLAN_AUTH_FT;
         else
                 ifmgd->auth_alg = WLAN_AUTH_OPEN;
         ifmgd->auth_transaction = -1;
@@ -1687,7 +1706,8 @@ static int ieee80211_sta_config_auth(struct ieee80211_sub_if_data *sdata)
         u16 capa_val = WLAN_CAPABILITY_ESS;
         struct ieee80211_channel *chan = local->oper_channel;
 
-        if (ifmgd->flags & (IEEE80211_STA_AUTO_SSID_SEL |
+        if (!(ifmgd->flags & IEEE80211_STA_EXT_SME) &&
+            ifmgd->flags & (IEEE80211_STA_AUTO_SSID_SEL |
                             IEEE80211_STA_AUTO_BSSID_SEL |
                             IEEE80211_STA_AUTO_CHANNEL_SEL)) {
                 capa_mask |= WLAN_CAPABILITY_PRIVACY;
@@ -1884,7 +1904,11 @@ void ieee80211_sta_req_auth(struct ieee80211_sub_if_data *sdata)
                         ieee80211_set_disassoc(sdata, true, true,
                                                WLAN_REASON_DEAUTH_LEAVING);
 
-                set_bit(IEEE80211_STA_REQ_AUTH, &ifmgd->request);
+                if (!(ifmgd->flags & IEEE80211_STA_EXT_SME) ||
+                    ifmgd->state != IEEE80211_STA_MLME_ASSOCIATE)
+                        set_bit(IEEE80211_STA_REQ_AUTH, &ifmgd->request);
+                else if (ifmgd->flags & IEEE80211_STA_EXT_SME)
+                        set_bit(IEEE80211_STA_REQ_RUN, &ifmgd->request);
                 queue_work(local->hw.workqueue, &ifmgd->work);
         }
 }
@@ -1953,7 +1977,8 @@ int ieee80211_sta_set_bssid(struct ieee80211_sub_if_data *sdata, u8 *bssid)
         return ieee80211_sta_commit(sdata);
 }
 
-int ieee80211_sta_set_extra_ie(struct ieee80211_sub_if_data *sdata, char *ie, size_t len)
+int ieee80211_sta_set_extra_ie(struct ieee80211_sub_if_data *sdata,
+                               const char *ie, size_t len)
 {
         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 
diff --git a/net/mac80211/wext.c b/net/mac80211/wext.c
index e55d2834764c..ce21d66b1023 100644
--- a/net/mac80211/wext.c
+++ b/net/mac80211/wext.c
@@ -137,6 +137,7 @@ static int ieee80211_ioctl_siwgenie(struct net_device *dev,
                 if (ret)
                         return ret;
                 sdata->u.mgd.flags &= ~IEEE80211_STA_AUTO_BSSID_SEL;
+                sdata->u.mgd.flags &= ~IEEE80211_STA_EXT_SME;
                 ieee80211_sta_req_auth(sdata);
                 return 0;
         }
@@ -224,6 +225,7 @@ static int ieee80211_ioctl_siwessid(struct net_device *dev,
                 if (ret)
                         return ret;
 
+                sdata->u.mgd.flags &= ~IEEE80211_STA_EXT_SME;
                 ieee80211_sta_req_auth(sdata);
                 return 0;
         } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
@@ -287,6 +289,7 @@ static int ieee80211_ioctl_siwap(struct net_device *dev,
                 ret = ieee80211_sta_set_bssid(sdata, (u8 *) &ap_addr->sa_data);
                 if (ret)
                         return ret;
+                sdata->u.mgd.flags &= ~IEEE80211_STA_EXT_SME;
                 ieee80211_sta_req_auth(sdata);
                 return 0;
         } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
diff --git a/net/wireless/nl80211.c b/net/wireless/nl80211.c
index c034c2418cb3..9e1318d1d4bb 100644
--- a/net/wireless/nl80211.c
+++ b/net/wireless/nl80211.c
@@ -111,6 +111,11 @@ static struct nla_policy nl80211_policy[NL80211_ATTR_MAX+1] __read_mostly = {
                               .len = IEEE80211_MAX_DATA_LEN },
         [NL80211_ATTR_SCAN_FREQUENCIES] = { .type = NLA_NESTED },
         [NL80211_ATTR_SCAN_SSIDS] = { .type = NLA_NESTED },
+
+        [NL80211_ATTR_SSID] = { .type = NLA_BINARY,
+                                .len = IEEE80211_MAX_SSID_LEN },
+        [NL80211_ATTR_AUTH_TYPE] = { .type = NLA_U32 },
+        [NL80211_ATTR_REASON_CODE] = { .type = NLA_U16 },
 };
 
 /* message building helper */
@@ -265,6 +270,10 @@ static int nl80211_send_wiphy(struct sk_buff *msg, u32 pid, u32 seq, int flags,
         CMD(set_mesh_params, SET_MESH_PARAMS);
         CMD(change_bss, SET_BSS);
         CMD(set_mgmt_extra_ie, SET_MGMT_EXTRA_IE);
+        CMD(auth, AUTHENTICATE);
+        CMD(assoc, ASSOCIATE);
+        CMD(deauth, DEAUTHENTICATE);
+        CMD(disassoc, DISASSOCIATE);
 
 #undef CMD
         nla_nest_end(msg, nl_cmds);
@@ -2646,6 +2655,228 @@ static int nl80211_dump_scan(struct sk_buff *skb,
         return err;
 }
 
+static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
+{
+        struct cfg80211_registered_device *drv;
+        struct net_device *dev;
+        struct cfg80211_auth_request req;
+        struct wiphy *wiphy;
+        int err;
+
+        rtnl_lock();
+
+        err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
+        if (err)
+                goto unlock_rtnl;
+
+        if (!drv->ops->auth) {
+                err = -EOPNOTSUPP;
+                goto out;
+        }
+
+        if (!info->attrs[NL80211_ATTR_MAC]) {
+                err = -EINVAL;
+                goto out;
+        }
+
+        wiphy = &drv->wiphy;
+        memset(&req, 0, sizeof(req));
+
+        req.peer_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
+
+        if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
+                req.chan = ieee80211_get_channel(
+                        wiphy,
+                        nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
+                if (!req.chan) {
+                        err = -EINVAL;
+                        goto out;
+                }
+        }
+
+        if (info->attrs[NL80211_ATTR_SSID]) {
+                req.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
+                req.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
+        }
+
+        if (info->attrs[NL80211_ATTR_IE]) {
+                req.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
+                req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
+        }
+
+        if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
+                req.auth_type =
+                        nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
+        }
+
+        err = drv->ops->auth(&drv->wiphy, dev, &req);
+
+out:
+        cfg80211_put_dev(drv);
+        dev_put(dev);
+unlock_rtnl:
+        rtnl_unlock();
+        return err;
+}
+
+static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
+{
+        struct cfg80211_registered_device *drv;
+        struct net_device *dev;
+        struct cfg80211_assoc_request req;
+        struct wiphy *wiphy;
+        int err;
+
+        rtnl_lock();
+
+        err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
+        if (err)
+                goto unlock_rtnl;
+
+        if (!drv->ops->assoc) {
+                err = -EOPNOTSUPP;
+                goto out;
+        }
+
+        if (!info->attrs[NL80211_ATTR_MAC] ||
+            !info->attrs[NL80211_ATTR_SSID]) {
+                err = -EINVAL;
+                goto out;
+        }
+
+        wiphy = &drv->wiphy;
+        memset(&req, 0, sizeof(req));
+
+        req.peer_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
+
+        if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
+                req.chan = ieee80211_get_channel(
+                        wiphy,
+                        nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
+                if (!req.chan) {
+                        err = -EINVAL;
+                        goto out;
+                }
+        }
+
+        if (nla_len(info->attrs[NL80211_ATTR_SSID]) > IEEE80211_MAX_SSID_LEN) {
+                err = -EINVAL;
+                goto out;
+        }
+        req.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
+        req.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
+
+        if (info->attrs[NL80211_ATTR_IE]) {
+                req.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
+                req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
+        }
+
+        err = drv->ops->assoc(&drv->wiphy, dev, &req);
+
+out:
+        cfg80211_put_dev(drv);
+        dev_put(dev);
+unlock_rtnl:
+        rtnl_unlock();
+        return err;
+}
+
+static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info)
+{
+        struct cfg80211_registered_device *drv;
+        struct net_device *dev;
+        struct cfg80211_deauth_request req;
+        struct wiphy *wiphy;
+        int err;
+
+        rtnl_lock();
+
+        err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
+        if (err)
+                goto unlock_rtnl;
+
+        if (!drv->ops->deauth) {
+                err = -EOPNOTSUPP;
+                goto out;
+        }
+
+        if (!info->attrs[NL80211_ATTR_MAC]) {
+                err = -EINVAL;
+                goto out;
+        }
+
+        wiphy = &drv->wiphy;
+        memset(&req, 0, sizeof(req));
+
+        req.peer_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
+
+        if (info->attrs[NL80211_ATTR_REASON_CODE])
+                req.reason_code =
+                        nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
+
+        if (info->attrs[NL80211_ATTR_IE]) {
+                req.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
+                req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
+        }
+
+        err = drv->ops->deauth(&drv->wiphy, dev, &req);
+
+out:
+        cfg80211_put_dev(drv);
+        dev_put(dev);
+unlock_rtnl:
+        rtnl_unlock();
+        return err;
+}
+
+static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info)
+{
+        struct cfg80211_registered_device *drv;
+        struct net_device *dev;
+        struct cfg80211_disassoc_request req;
+        struct wiphy *wiphy;
+        int err;
+
+        rtnl_lock();
+
+        err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
+        if (err)
+                goto unlock_rtnl;
+
+        if (!drv->ops->disassoc) {
+                err = -EOPNOTSUPP;
+                goto out;
+        }
+
+        if (!info->attrs[NL80211_ATTR_MAC]) {
+                err = -EINVAL;
+                goto out;
+        }
+
+        wiphy = &drv->wiphy;
+        memset(&req, 0, sizeof(req));
+
+        req.peer_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
+
+        if (info->attrs[NL80211_ATTR_REASON_CODE])
+                req.reason_code =
+                        nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
+
+        if (info->attrs[NL80211_ATTR_IE]) {
+                req.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
+                req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
+        }
+
+        err = drv->ops->disassoc(&drv->wiphy, dev, &req);
+
+out:
+        cfg80211_put_dev(drv);
+        dev_put(dev);
+unlock_rtnl:
+        rtnl_unlock();
+        return err;
+}
+
 static struct genl_ops nl80211_ops[] = {
         {
                 .cmd = NL80211_CMD_GET_WIPHY,
@@ -2829,6 +3060,30 @@ static struct genl_ops nl80211_ops[] = {
                 .policy = nl80211_policy,
                 .dumpit = nl80211_dump_scan,
         },
+        {
+                .cmd = NL80211_CMD_AUTHENTICATE,
+                .doit = nl80211_authenticate,
+                .policy = nl80211_policy,
+                .flags = GENL_ADMIN_PERM,
+        },
+        {
+                .cmd = NL80211_CMD_ASSOCIATE,
+                .doit = nl80211_associate,
+                .policy = nl80211_policy,
+                .flags = GENL_ADMIN_PERM,
+        },
+        {
+                .cmd = NL80211_CMD_DEAUTHENTICATE,
+                .doit = nl80211_deauthenticate,
+                .policy = nl80211_policy,
+                .flags = GENL_ADMIN_PERM,
+        },
+        {
+                .cmd = NL80211_CMD_DISASSOCIATE,
+                .doit = nl80211_disassociate,
+                .policy = nl80211_policy,
+                .flags = GENL_ADMIN_PERM,
+        },
 };
 static struct genl_multicast_group nl80211_mlme_mcgrp = {
         .name = "mlme",