cfg80211: connect/disconnect API

This patch introduces the cfg80211 connect/disconnect API.
The goal here is to run the AUTH and ASSOC steps in one call.
This is needed for some fullmac cards that run both steps
directly from the target, after the host driver sends a
connect command.

Additionally, all the new crypto parameters for connect()
are now also valid for associate() -- although associate
requires the IEs to be used, the information can be useful
for drivers and should be given.

Signed-off-by: Samuel Ortiz <samuel.ortiz@intel.com>
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>

7 files changed, 620 insertions, 12 deletions

diff --git a/net/mac80211/cfg.c b/net/mac80211/cfg.c
index c34c1a41019a..03de4024597a 100644
--- a/net/mac80211/cfg.c
+++ b/net/mac80211/cfg.c
@@ -1262,7 +1262,7 @@ static int ieee80211_assoc(struct wiphy *wiphy, struct net_device *dev,
                 sdata->u.mgd.flags &= ~IEEE80211_STA_MFP_ENABLED;
         }
 
-        if (req->control_port)
+        if (req->crypto.control_port)
                 sdata->u.mgd.flags |= IEEE80211_STA_CONTROL_PORT;
         else
                 sdata->u.mgd.flags &= ~IEEE80211_STA_CONTROL_PORT;
diff --git a/net/wireless/Makefile b/net/wireless/Makefile
index f78c4832a9ca..750c08e31b10 100644
--- a/net/wireless/Makefile
+++ b/net/wireless/Makefile
@@ -5,7 +5,7 @@ obj-$(CONFIG_LIB80211_CRYPT_WEP) += lib80211_crypt_wep.o
 obj-$(CONFIG_LIB80211_CRYPT_CCMP) += lib80211_crypt_ccmp.o
 obj-$(CONFIG_LIB80211_CRYPT_TKIP) += lib80211_crypt_tkip.o
 
-cfg80211-y += core.o sysfs.o radiotap.o util.o reg.o scan.o nl80211.o mlme.o ibss.o
+cfg80211-y += core.o sysfs.o radiotap.o util.o reg.o scan.o nl80211.o mlme.o ibss.o sme.o
 cfg80211-$(CONFIG_CFG80211_DEBUGFS) += debugfs.o
 cfg80211-$(CONFIG_WIRELESS_EXT) += wext-compat.o
 
diff --git a/net/wireless/core.c b/net/wireless/core.c
index d41b7412b212..314e00f70e3b 100644
--- a/net/wireless/core.c
+++ b/net/wireless/core.c
@@ -546,6 +546,7 @@ static int cfg80211_netdev_notifier_call(struct notifier_block * nb,
                                 "symlink to netdev!\n");
                 }
                 wdev->netdev = dev;
+                wdev->sme_state = CFG80211_SME_IDLE;
 #ifdef CONFIG_WIRELESS_EXT
                 wdev->wext.default_key = -1;
                 wdev->wext.default_mgmt_key = -1;
@@ -553,11 +554,20 @@ static int cfg80211_netdev_notifier_call(struct notifier_block * nb,
                 mutex_unlock(&rdev->devlist_mtx);
                 break;
         case NETDEV_GOING_DOWN:
-                if (wdev->iftype != NL80211_IFTYPE_ADHOC)
-                        break;
                 if (!wdev->ssid_len)
                         break;
-                cfg80211_leave_ibss(rdev, dev, true);
+
+                switch (wdev->iftype) {
+                case NL80211_IFTYPE_ADHOC:
+                        cfg80211_leave_ibss(rdev, dev, true);
+                        break;
+                case NL80211_IFTYPE_STATION:
+                        cfg80211_disconnect(rdev, dev,
+                                            WLAN_REASON_DEAUTH_LEAVING);
+                        break;
+                default:
+                        break;
+                }
                 break;
         case NETDEV_UP:
 #ifdef CONFIG_WIRELESS_EXT
diff --git a/net/wireless/core.h b/net/wireless/core.h
index bc084b68865c..f93f96f85d2b 100644
--- a/net/wireless/core.h
+++ b/net/wireless/core.h
@@ -174,6 +174,13 @@ void cfg80211_clear_ibss(struct net_device *dev, bool nowext);
 int cfg80211_leave_ibss(struct cfg80211_registered_device *rdev,
                         struct net_device *dev, bool nowext);
 
+/* SME */
+int cfg80211_connect(struct cfg80211_registered_device *rdev,
+                     struct net_device *dev,
+                     struct cfg80211_connect_params *connect);
+int cfg80211_disconnect(struct cfg80211_registered_device *rdev,
+                        struct net_device *dev, u16 reason);
+
 /* internal helpers */
 int cfg80211_validate_key_settings(struct key_params *params, int key_idx,
                                    const u8 *mac_addr);
diff --git a/net/wireless/nl80211.c b/net/wireless/nl80211.c
index bb8de268a6bf..89dd3793e03c 100644
--- a/net/wireless/nl80211.c
+++ b/net/wireless/nl80211.c
@@ -128,6 +128,9 @@ static struct nla_policy nl80211_policy[NL80211_ATTR_MAX+1] __read_mostly = {
                 .len = sizeof(struct nl80211_sta_flag_update),
         },
         [NL80211_ATTR_CONTROL_PORT] = { .type = NLA_FLAG },
+        [NL80211_ATTR_PRIVACY] = { .type = NLA_FLAG },
+        [NL80211_ATTR_CIPHER_SUITE_GROUP] = { .type = NLA_U32 },
+        [NL80211_ATTR_WPA_VERSIONS] = { .type = NLA_U32 },
 };
 
 /* IE validation */
@@ -347,6 +350,17 @@ static int nl80211_send_wiphy(struct sk_buff *msg, u32 pid, u32 seq, int flags,
         CMD(join_ibss, JOIN_IBSS);
 
 #undef CMD
+
+        if (dev->ops->connect) {
+                i++;
+                NLA_PUT_U32(msg, i, NL80211_CMD_CONNECT);
+        }
+
+        if (dev->ops->disconnect) {
+                i++;
+                NLA_PUT_U32(msg, i, NL80211_CMD_DISCONNECT);
+        }
+
         nla_nest_end(msg, nl_cmds);
 
         return genlmsg_end(msg, hdr);
@@ -3001,12 +3015,31 @@ static int nl80211_dump_scan(struct sk_buff *skb,
 
 static bool nl80211_valid_auth_type(enum nl80211_auth_type auth_type)
 {
-        return auth_type == NL80211_AUTHTYPE_OPEN_SYSTEM ||
-                auth_type == NL80211_AUTHTYPE_SHARED_KEY ||
-                auth_type == NL80211_AUTHTYPE_FT ||
-                auth_type == NL80211_AUTHTYPE_NETWORK_EAP;
+        return auth_type <= NL80211_AUTHTYPE_MAX;
+}
+
+static bool nl80211_valid_wpa_versions(u32 wpa_versions)
+{
+        return !(wpa_versions & ~(NL80211_WPA_VERSION_1 |
+                                  NL80211_WPA_VERSION_2));
+}
+
+static bool nl80211_valid_akm_suite(u32 akm)
+{
+        return akm == WLAN_AKM_SUITE_8021X ||
+                akm == WLAN_AKM_SUITE_PSK;
+}
+
+static bool nl80211_valid_cipher_suite(u32 cipher)
+{
+        return cipher == WLAN_CIPHER_SUITE_WEP40 ||
+                cipher == WLAN_CIPHER_SUITE_WEP104 ||
+                cipher == WLAN_CIPHER_SUITE_TKIP ||
+                cipher == WLAN_CIPHER_SUITE_CCMP ||
+                cipher == WLAN_CIPHER_SUITE_AES_CMAC;
 }
 
+
 static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
 {
         struct cfg80211_registered_device *drv;
@@ -3086,6 +3119,68 @@ unlock_rtnl:
         return err;
 }
 
+static int nl80211_crypto_settings(struct genl_info *info,
+                                   struct cfg80211_crypto_settings *settings)
+{
+        settings->control_port = info->attrs[NL80211_ATTR_CONTROL_PORT];
+
+        if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) {
+                void *data;
+                int len, i;
+
+                data = nla_data(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
+                len = nla_len(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
+                settings->n_ciphers_pairwise = len / sizeof(u32);
+
+                if (len % sizeof(u32))
+                        return -EINVAL;
+
+                if (settings->n_ciphers_pairwise > NL80211_MAX_NR_CIPHER_SUITES)
+                        return -EINVAL;
+
+                memcpy(settings->ciphers_pairwise, data, len);
+
+                for (i = 0; i < settings->n_ciphers_pairwise; i++)
+                        if (!nl80211_valid_cipher_suite(
+                                        settings->ciphers_pairwise[i]))
+                                return -EINVAL;
+        }
+
+        if (info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]) {
+                settings->cipher_group =
+                        nla_get_u32(info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]);
+                if (!nl80211_valid_cipher_suite(settings->cipher_group))
+                        return -EINVAL;
+        }
+
+        if (info->attrs[NL80211_ATTR_WPA_VERSIONS]) {
+                settings->wpa_versions =
+                        nla_get_u32(info->attrs[NL80211_ATTR_WPA_VERSIONS]);
+                if (!nl80211_valid_wpa_versions(settings->wpa_versions))
+                        return -EINVAL;
+        }
+
+        if (info->attrs[NL80211_ATTR_AKM_SUITES]) {
+                void *data;
+                int len, i;
+
+                data = nla_data(info->attrs[NL80211_ATTR_AKM_SUITES]);
+                len = nla_len(info->attrs[NL80211_ATTR_AKM_SUITES]);
+                settings->n_akm_suites = len / sizeof(u32);
+
+                if (len % sizeof(u32))
+                        return -EINVAL;
+
+                memcpy(settings->akm_suites, data, len);
+
+                for (i = 0; i < settings->n_ciphers_pairwise; i++)
+                        if (!nl80211_valid_akm_suite(settings->akm_suites[i]))
+                                return -EINVAL;
+        }
+
+        return 0;
+}
+
 static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
 {
         struct cfg80211_registered_device *drv;
@@ -3156,9 +3251,9 @@ static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
                 }
         }
 
-        req.control_port = info->attrs[NL80211_ATTR_CONTROL_PORT];
-
-        err = drv->ops->assoc(&drv->wiphy, dev, &req);
+        err = nl80211_crypto_settings(info, &req.crypto);
+        if (!err)
+                err = drv->ops->assoc(&drv->wiphy, dev, &req);
 
 out:
         cfg80211_put_dev(drv);
@@ -3538,6 +3633,130 @@ void cfg80211_testmode_event(struct sk_buff *skb, gfp_t gfp)
 EXPORT_SYMBOL(cfg80211_testmode_event);
 #endif
 
+static int nl80211_connect(struct sk_buff *skb, struct genl_info *info)
+{
+        struct cfg80211_registered_device *drv;
+        struct net_device *dev;
+        struct cfg80211_connect_params connect;
+        struct wiphy *wiphy;
+        int err;
+
+        memset(&connect, 0, sizeof(connect));
+
+        if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
+                return -EINVAL;
+
+        if (!info->attrs[NL80211_ATTR_SSID] ||
+            !nla_len(info->attrs[NL80211_ATTR_SSID]))
+                return -EINVAL;
+
+        if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
+                connect.auth_type =
+                        nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
+                if (!nl80211_valid_auth_type(connect.auth_type))
+                        return -EINVAL;
+        } else
+                connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
+
+        connect.privacy = info->attrs[NL80211_ATTR_PRIVACY];
+
+        err = nl80211_crypto_settings(info, &connect.crypto);
+        if (err)
+                return err;
+        rtnl_lock();
+
+        err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
+        if (err)
+                goto unlock_rtnl;
+
+        if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
+                err = -EOPNOTSUPP;
+                goto out;
+        }
+
+        if (!netif_running(dev)) {
+                err = -ENETDOWN;
+                goto out;
+        }
+
+        wiphy = &drv->wiphy;
+
+        connect.bssid = NULL;
+        connect.channel = NULL;
+        connect.auth_type = NL80211_AUTHTYPE_OPEN_SYSTEM;
+
+        if (info->attrs[NL80211_ATTR_MAC])
+                connect.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
+        connect.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
+        connect.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
+
+        if (info->attrs[NL80211_ATTR_IE]) {
+                connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
+                connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
+        }
+
+        if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
+                connect.channel =
+                        ieee80211_get_channel(wiphy,
+                            nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
+                if (!connect.channel ||
+                    connect.channel->flags & IEEE80211_CHAN_DISABLED) {
+                        err = -EINVAL;
+                        goto out;
+                }
+        }
+
+        err = cfg80211_connect(drv, dev, &connect);
+
+out:
+        cfg80211_put_dev(drv);
+        dev_put(dev);
+unlock_rtnl:
+        rtnl_unlock();
+        return err;
+}
+
+static int nl80211_disconnect(struct sk_buff *skb, struct genl_info *info)
+{
+        struct cfg80211_registered_device *drv;
+        struct net_device *dev;
+        int err;
+        u16 reason;
+
+        if (!info->attrs[NL80211_ATTR_REASON_CODE])
+                reason = WLAN_REASON_DEAUTH_LEAVING;
+        else
+                reason = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
+
+        if (reason == 0)
+                return -EINVAL;
+
+        rtnl_lock();
+
+        err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
+        if (err)
+                goto unlock_rtnl;
+
+        if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
+                err = -EOPNOTSUPP;
+                goto out;
+        }
+
+        if (!netif_running(dev)) {
+                err = -ENETDOWN;
+                goto out;
+        }
+
+        err = cfg80211_disconnect(drv, dev, reason);
+
+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,
@@ -3759,6 +3978,18 @@ static struct genl_ops nl80211_ops[] = {
                 .flags = GENL_ADMIN_PERM,
         },
 #endif
+        {
+                .cmd = NL80211_CMD_CONNECT,
+                .doit = nl80211_connect,
+                .policy = nl80211_policy,
+                .flags = GENL_ADMIN_PERM,
+        },
+        {
+                .cmd = NL80211_CMD_DISCONNECT,
+                .doit = nl80211_disconnect,
+                .policy = nl80211_policy,
+                .flags = GENL_ADMIN_PERM,
+        },
 };
 static struct genl_multicast_group nl80211_mlme_mcgrp = {
         .name = "mlme",
@@ -4077,6 +4308,129 @@ void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
                                   addr, gfp);
 }
 
+void nl80211_send_connect_result(struct cfg80211_registered_device *rdev,
+                                 struct net_device *netdev, const u8 *bssid,
+                                 const u8 *req_ie, size_t req_ie_len,
+                                 const u8 *resp_ie, size_t resp_ie_len,
+                                 u16 status, gfp_t gfp)
+{
+        struct sk_buff *msg;
+        void *hdr;
+
+        msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
+        if (!msg)
+                return;
+
+        hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONNECT);
+        if (!hdr) {
+                nlmsg_free(msg);
+                return;
+        }
+
+        NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
+        NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
+        if (bssid)
+                NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid);
+        NLA_PUT_U16(msg, NL80211_ATTR_STATUS_CODE, status);
+        if (req_ie)
+                NLA_PUT(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie);
+        if (resp_ie)
+                NLA_PUT(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie);
+
+        if (genlmsg_end(msg, hdr) < 0) {
+                nlmsg_free(msg);
+                return;
+        }
+
+        genlmsg_multicast(msg, 0, nl80211_mlme_mcgrp.id, gfp);
+        return;
+
+ nla_put_failure:
+        genlmsg_cancel(msg, hdr);
+        nlmsg_free(msg);
+
+}
+
+void nl80211_send_roamed(struct cfg80211_registered_device *rdev,
+                         struct net_device *netdev, const u8 *bssid,
+                         const u8 *req_ie, size_t req_ie_len,
+                         const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp)
+{
+        struct sk_buff *msg;
+        void *hdr;
+
+        msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
+        if (!msg)
+                return;
+
+        hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ROAM);
+        if (!hdr) {
+                nlmsg_free(msg);
+                return;
+        }
+
+        NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
+        NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
+        NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid);
+        if (req_ie)
+                NLA_PUT(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie);
+        if (resp_ie)
+                NLA_PUT(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie);
+
+        if (genlmsg_end(msg, hdr) < 0) {
+                nlmsg_free(msg);
+                return;
+        }
+
+        genlmsg_multicast(msg, 0, nl80211_mlme_mcgrp.id, gfp);
+        return;
+
+ nla_put_failure:
+        genlmsg_cancel(msg, hdr);
+        nlmsg_free(msg);
+
+}
+
+void nl80211_send_disconnected(struct cfg80211_registered_device *rdev,
+                               struct net_device *netdev, u16 reason,
+                               u8 *ie, size_t ie_len, bool from_ap, gfp_t gfp)
+{
+        struct sk_buff *msg;
+        void *hdr;
+
+        msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
+        if (!msg)
+                return;
+
+        hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DISCONNECT);
+        if (!hdr) {
+                nlmsg_free(msg);
+                return;
+        }
+
+        NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
+        NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
+        if (from_ap && reason)
+                NLA_PUT_U16(msg, NL80211_ATTR_REASON_CODE, reason);
+        if (from_ap)
+                NLA_PUT_FLAG(msg, NL80211_ATTR_DISCONNECTED_BY_AP);
+        if (ie)
+                NLA_PUT(msg, NL80211_ATTR_IE, ie_len, ie);
+
+        if (genlmsg_end(msg, hdr) < 0) {
+                nlmsg_free(msg);
+                return;
+        }
+
+        genlmsg_multicast(msg, 0, nl80211_mlme_mcgrp.id, gfp);
+        return;
+
+ nla_put_failure:
+        genlmsg_cancel(msg, hdr);
+        nlmsg_free(msg);
+
+}
+
 void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev,
                              struct net_device *netdev, const u8 *bssid,
                              gfp_t gfp)
diff --git a/net/wireless/nl80211.h b/net/wireless/nl80211.h
index 662c216e8d4f..cf3708b48c29 100644
--- a/net/wireless/nl80211.h
+++ b/net/wireless/nl80211.h
@@ -31,6 +31,19 @@ void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev,
 void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
                                 struct net_device *netdev,
                                 const u8 *addr, gfp_t gfp);
+void nl80211_send_connect_result(struct cfg80211_registered_device *rdev,
+                                 struct net_device *netdev, const u8 *bssid,
+                                 const u8 *req_ie, size_t req_ie_len,
+                                 const u8 *resp_ie, size_t resp_ie_len,
+                                 u16 status, gfp_t gfp);
+void nl80211_send_roamed(struct cfg80211_registered_device *rdev,
+                         struct net_device *netdev, const u8 *bssid,
+                         const u8 *req_ie, size_t req_ie_len,
+                         const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp);
+void nl80211_send_disconnected(struct cfg80211_registered_device *rdev,
+                               struct net_device *netdev, u16 reason,
+                               u8 *ie, size_t ie_len, bool from_ap, gfp_t gfp);
+
 void
 nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
                             struct net_device *netdev, const u8 *addr,
diff --git a/net/wireless/sme.c b/net/wireless/sme.c
new file mode 100644
index 000000000000..fc117031d0bb
--- /dev/null
+++ b/net/wireless/sme.c
@@ -0,0 +1,224 @@
+/*
+ * SME code for cfg80211's connect emulation.
+ *
+ * Copyright 2009       Johannes Berg <johannes@sipsolutions.net>
+ * Copyright (C) 2009   Intel Corporation. All rights reserved.
+ */
+
+#include <linux/etherdevice.h>
+#include <linux/if_arp.h>
+#include <linux/workqueue.h>
+#include <net/cfg80211.h>
+#include <net/rtnetlink.h>
+#include "nl80211.h"
+
+
+void cfg80211_connect_result(struct net_device *dev, const u8 *bssid,
+                             const u8 *req_ie, size_t req_ie_len,
+                             const u8 *resp_ie, size_t resp_ie_len,
+                             u16 status, gfp_t gfp)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        struct cfg80211_bss *bss;
+#ifdef CONFIG_WIRELESS_EXT
+        union iwreq_data wrqu;
+#endif
+
+        if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
+                return;
+
+        if (WARN_ON(wdev->sme_state != CFG80211_SME_CONNECTING))
+                return;
+
+        if (wdev->current_bss) {
+                cfg80211_unhold_bss(wdev->current_bss);
+                cfg80211_put_bss(wdev->current_bss);
+                wdev->current_bss = NULL;
+        }
+
+        if (status == WLAN_STATUS_SUCCESS) {
+                bss = cfg80211_get_bss(wdev->wiphy, NULL, bssid,
+                                       wdev->ssid, wdev->ssid_len,
+                                       WLAN_CAPABILITY_ESS,
+                                       WLAN_CAPABILITY_ESS);
+
+                if (WARN_ON(!bss))
+                        return;
+
+                cfg80211_hold_bss(bss);
+                wdev->current_bss = bss;
+
+                wdev->sme_state = CFG80211_SME_CONNECTED;
+        } else {
+                wdev->sme_state = CFG80211_SME_IDLE;
+        }
+
+        nl80211_send_connect_result(wiphy_to_dev(wdev->wiphy), dev, bssid,
+                                    req_ie, req_ie_len, resp_ie, resp_ie_len,
+                                    status, gfp);
+
+#ifdef CONFIG_WIRELESS_EXT
+        if (req_ie && status == WLAN_STATUS_SUCCESS) {
+                memset(&wrqu, 0, sizeof(wrqu));
+                wrqu.data.length = req_ie_len;
+                wireless_send_event(dev, IWEVASSOCRESPIE, &wrqu, req_ie);
+        }
+
+        if (resp_ie && status == WLAN_STATUS_SUCCESS) {
+                memset(&wrqu, 0, sizeof(wrqu));
+                wrqu.data.length = resp_ie_len;
+                wireless_send_event(dev, IWEVASSOCRESPIE, &wrqu, resp_ie);
+        }
+
+        memset(&wrqu, 0, sizeof(wrqu));
+        wrqu.ap_addr.sa_family = ARPHRD_ETHER;
+        if (bssid)
+                memcpy(wrqu.ap_addr.sa_data, bssid, ETH_ALEN);
+        wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
+#endif
+}
+EXPORT_SYMBOL(cfg80211_connect_result);
+
+void cfg80211_roamed(struct net_device *dev, const u8 *bssid,
+                     const u8 *req_ie, size_t req_ie_len,
+                     const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+        struct cfg80211_bss *bss;
+#ifdef CONFIG_WIRELESS_EXT
+        union iwreq_data wrqu;
+#endif
+
+        if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
+                return;
+
+        if (WARN_ON(wdev->sme_state != CFG80211_SME_CONNECTED))
+                return;
+
+        /* internal error -- how did we get to CONNECTED w/o BSS? */
+        if (WARN_ON(!wdev->current_bss)) {
+                return;
+        }
+
+        cfg80211_unhold_bss(wdev->current_bss);
+        cfg80211_put_bss(wdev->current_bss);
+        wdev->current_bss = NULL;
+
+        bss = cfg80211_get_bss(wdev->wiphy, NULL, bssid,
+                               wdev->ssid, wdev->ssid_len,
+                               WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
+
+        if (WARN_ON(!bss))
+                return;
+
+        cfg80211_hold_bss(bss);
+        wdev->current_bss = bss;
+
+        nl80211_send_roamed(wiphy_to_dev(wdev->wiphy), dev, bssid,
+                            req_ie, req_ie_len, resp_ie, resp_ie_len, gfp);
+
+#ifdef CONFIG_WIRELESS_EXT
+        if (req_ie) {
+                memset(&wrqu, 0, sizeof(wrqu));
+                wrqu.data.length = req_ie_len;
+                wireless_send_event(dev, IWEVASSOCRESPIE, &wrqu, req_ie);
+        }
+
+        if (resp_ie) {
+                memset(&wrqu, 0, sizeof(wrqu));
+                wrqu.data.length = resp_ie_len;
+                wireless_send_event(dev, IWEVASSOCRESPIE, &wrqu, resp_ie);
+        }
+
+        memset(&wrqu, 0, sizeof(wrqu));
+        wrqu.ap_addr.sa_family = ARPHRD_ETHER;
+        memcpy(wrqu.ap_addr.sa_data, bssid, ETH_ALEN);
+        wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
+#endif
+}
+EXPORT_SYMBOL(cfg80211_roamed);
+
+static void __cfg80211_disconnected(struct net_device *dev, gfp_t gfp,
+                                    u8 *ie, size_t ie_len, u16 reason,
+                                    bool from_ap)
+{
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+#ifdef CONFIG_WIRELESS_EXT
+        union iwreq_data wrqu;
+#endif
+
+        if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
+                return;
+
+        if (WARN_ON(wdev->sme_state != CFG80211_SME_CONNECTED))
+                return;
+
+        if (wdev->current_bss) {
+                cfg80211_unhold_bss(wdev->current_bss);
+                cfg80211_put_bss(wdev->current_bss);
+        }
+
+        wdev->current_bss = NULL;
+        wdev->sme_state = CFG80211_SME_IDLE;
+
+        nl80211_send_disconnected(wiphy_to_dev(wdev->wiphy), dev,
+                                  reason, ie, ie_len, from_ap, gfp);
+
+#ifdef CONFIG_WIRELESS_EXT
+        memset(&wrqu, 0, sizeof(wrqu));
+        wrqu.ap_addr.sa_family = ARPHRD_ETHER;
+        wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
+#endif
+}
+
+void cfg80211_disconnected(struct net_device *dev, u16 reason,
+                           u8 *ie, size_t ie_len, gfp_t gfp)
+{
+        __cfg80211_disconnected(dev, reason, ie, ie_len, true, gfp);
+}
+EXPORT_SYMBOL(cfg80211_disconnected);
+
+int cfg80211_connect(struct cfg80211_registered_device *rdev,
+                     struct net_device *dev,
+                     struct cfg80211_connect_params *connect)
+{
+        int err;
+        struct wireless_dev *wdev = dev->ieee80211_ptr;
+
+        if (wdev->sme_state != CFG80211_SME_IDLE)
+                return -EALREADY;
+
+        if (!rdev->ops->connect) {
+                return -EOPNOTSUPP;
+        } else {
+                wdev->sme_state = CFG80211_SME_CONNECTING;
+                err = rdev->ops->connect(&rdev->wiphy, dev, connect);
+                if (err) {
+                        wdev->sme_state = CFG80211_SME_IDLE;
+                        return err;
+                }
+        }
+
+        memcpy(wdev->ssid, connect->ssid, connect->ssid_len);
+        wdev->ssid_len = connect->ssid_len;
+
+        return 0;
+}
+
+int cfg80211_disconnect(struct cfg80211_registered_device *rdev,
+                        struct net_device *dev, u16 reason)
+{
+        int err;
+
+        if (!rdev->ops->disconnect) {
+                return -EOPNOTSUPP;
+        } else {
+                err = rdev->ops->disconnect(&rdev->wiphy, dev, reason);
+                if (err)
+                        return err;
+        }
+
+        __cfg80211_disconnected(dev, 0, NULL, 0, false, GFP_KERNEL);
+
+        return 0;
+}