mac80211: mesh changes to the MLME

This includes support for mesh network scanning. The ugly code in
ieee80211_sta_scan_result() is my approach to work around wext. This has been
tested with wireless tools version 29 and works as expected (the new interface
mode is just not shown).

Signed-off-by: Luis Carlos Cobo <luisca@cozybit.com>
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>

1 files changed, 263 insertions, 59 deletions

diff --git a/net/mac80211/ieee80211_sta.c b/net/mac80211/ieee80211_sta.c
index b4b498ae60f..d2dedcb5a95 100644
--- a/net/mac80211/ieee80211_sta.c
+++ b/net/mac80211/ieee80211_sta.c
@@ -31,12 +31,16 @@
 #include "ieee80211_i.h"
 #include "ieee80211_rate.h"
 #include "ieee80211_led.h"
+#ifdef CONFIG_MAC80211_MESH
+#include "mesh.h"
+#endif
 
 #define IEEE80211_AUTH_TIMEOUT (HZ / 5)
 #define IEEE80211_AUTH_MAX_TRIES 3
 #define IEEE80211_ASSOC_TIMEOUT (HZ / 5)
 #define IEEE80211_ASSOC_MAX_TRIES 3
 #define IEEE80211_MONITORING_INTERVAL (2 * HZ)
+#define IEEE80211_MESH_HOUSEKEEPING_INTERVAL (60 * HZ)
 #define IEEE80211_PROBE_INTERVAL (60 * HZ)
 #define IEEE80211_RETRY_AUTH_INTERVAL (1 * HZ)
 #define IEEE80211_SCAN_INTERVAL (2 * HZ)
@@ -49,6 +53,7 @@
 #define IEEE80211_SCAN_RESULT_EXPIRE (10 * HZ)
 #define IEEE80211_IBSS_MERGE_INTERVAL (30 * HZ)
 #define IEEE80211_IBSS_INACTIVITY_LIMIT (60 * HZ)
+#define IEEE80211_MESH_PEER_INACTIVITY_LIMIT (1800 * HZ)
 
 #define IEEE80211_IBSS_MAX_STA_ENTRIES 128
 
@@ -1891,8 +1896,15 @@ static void __ieee80211_rx_bss_hash_add(struct net_device *dev,
                                         struct ieee80211_sta_bss *bss)
 {
         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
-        bss->hnext = local->sta_bss_hash[STA_HASH(bss->bssid)];
-        local->sta_bss_hash[STA_HASH(bss->bssid)] = bss;
+        u8 hash_idx;
+#ifdef CONFIG_MAC80211_MESH
+        if (bss->mesh_cfg)
+                hash_idx = mesh_id_hash(bss->mesh_id, bss->mesh_id_len);
+        else
+#endif
+                hash_idx = STA_HASH(bss->bssid);
+        bss->hnext = local->sta_bss_hash[hash_idx];
+        local->sta_bss_hash[hash_idx] = bss;
 }
 
 
@@ -1945,7 +1957,6 @@ ieee80211_rx_bss_add(struct net_device *dev, u8 *bssid, int freq,
         return bss;
 }
 
-
 static struct ieee80211_sta_bss *
 ieee80211_rx_bss_get(struct net_device *dev, u8 *bssid, int freq,
                      u8 *ssid, u8 ssid_len)
@@ -1956,7 +1967,7 @@ ieee80211_rx_bss_get(struct net_device *dev, u8 *bssid, int freq,
         spin_lock_bh(&local->sta_bss_lock);
         bss = local->sta_bss_hash[STA_HASH(bssid)];
         while (bss) {
-                if (!memcmp(bss->bssid, bssid, ETH_ALEN) &&
+                if (!bss->mesh_cfg && !memcmp(bss->bssid, bssid, ETH_ALEN) &&
                     bss->freq == freq &&
                     bss->ssid_len == ssid_len &&
                     (ssid_len == 0 || !memcmp(bss->ssid, ssid, ssid_len))) {
@@ -1969,6 +1980,72 @@ ieee80211_rx_bss_get(struct net_device *dev, u8 *bssid, int freq,
         return bss;
 }
 
+#ifdef CONFIG_MAC80211_MESH
+static struct ieee80211_sta_bss *
+ieee80211_rx_mesh_bss_get(struct net_device *dev, u8 *mesh_id, int mesh_id_len,
+                          u8 *mesh_cfg, int freq)
+{
+        struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
+        struct ieee80211_sta_bss *bss;
+
+        spin_lock_bh(&local->sta_bss_lock);
+        bss = local->sta_bss_hash[mesh_id_hash(mesh_id, mesh_id_len)];
+        while (bss) {
+                if (bss->mesh_cfg &&
+                    !memcmp(bss->mesh_cfg, mesh_cfg, MESH_CFG_CMP_LEN) &&
+                    bss->freq == freq &&
+                    mesh_id_len == bss->mesh_id_len &&
+                    (mesh_id_len == 0 || !memcmp(bss->mesh_id, mesh_id,
+                                                 mesh_id_len))) {
+                        atomic_inc(&bss->users);
+                        break;
+                }
+                bss = bss->hnext;
+        }
+        spin_unlock_bh(&local->sta_bss_lock);
+        return bss;
+}
+
+static struct ieee80211_sta_bss *
+ieee80211_rx_mesh_bss_add(struct net_device *dev, u8 *mesh_id, int mesh_id_len,
+                          u8 *mesh_cfg, int freq)
+{
+        struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
+        struct ieee80211_sta_bss *bss;
+
+        bss = kzalloc(sizeof(*bss), GFP_ATOMIC);
+        if (!bss)
+                return NULL;
+
+        bss->mesh_cfg = kmalloc(MESH_CFG_CMP_LEN, GFP_ATOMIC);
+        if (!bss->mesh_cfg) {
+                kfree(bss);
+                return NULL;
+        }
+
+        if (mesh_id_len && mesh_id_len <= IEEE80211_MAX_MESH_ID_LEN) {
+                bss->mesh_id = kmalloc(mesh_id_len, GFP_ATOMIC);
+                if (!bss->mesh_id) {
+                        kfree(bss->mesh_cfg);
+                        kfree(bss);
+                        return NULL;
+                }
+                memcpy(bss->mesh_id, mesh_id, mesh_id_len);
+        }
+
+        atomic_inc(&bss->users);
+        atomic_inc(&bss->users);
+        memcpy(bss->mesh_cfg, mesh_cfg, MESH_CFG_CMP_LEN);
+        bss->mesh_id_len = mesh_id_len;
+        bss->freq = freq;
+        spin_lock_bh(&local->sta_bss_lock);
+        /* TODO: order by RSSI? */
+        list_add_tail(&bss->list, &local->sta_bss_list);
+        __ieee80211_rx_bss_hash_add(dev, bss);
+        spin_unlock_bh(&local->sta_bss_lock);
+        return bss;
+}
+#endif
 
 static void ieee80211_rx_bss_free(struct ieee80211_sta_bss *bss)
 {
@@ -1976,6 +2053,10 @@ static void ieee80211_rx_bss_free(struct ieee80211_sta_bss *bss)
         kfree(bss->rsn_ie);
         kfree(bss->wmm_ie);
         kfree(bss->ht_ie);
+#ifdef CONFIG_MAC80211_MESH
+        kfree(bss->mesh_id);
+        kfree(bss->mesh_cfg);
+#endif
         kfree(bss);
 }
 
@@ -2171,6 +2252,42 @@ static int ieee80211_sta_join_ibss(struct net_device *dev,
         return res;
 }
 
+u64 ieee80211_sta_get_rates(struct ieee80211_local *local,
+                            struct ieee802_11_elems *elems,
+                            enum ieee80211_band band)
+{
+        struct ieee80211_supported_band *sband;
+        struct ieee80211_rate *bitrates;
+        size_t num_rates;
+        u64 supp_rates;
+        int i, j;
+        sband = local->hw.wiphy->bands[band];
+
+        if (!sband) {
+                WARN_ON(1);
+                sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
+        }
+
+        bitrates = sband->bitrates;
+        num_rates = sband->n_bitrates;
+        supp_rates = 0;
+        for (i = 0; i < elems->supp_rates_len +
+                     elems->ext_supp_rates_len; i++) {
+                u8 rate = 0;
+                int own_rate;
+                if (i < elems->supp_rates_len)
+                        rate = elems->supp_rates[i];
+                else if (elems->ext_supp_rates)
+                        rate = elems->ext_supp_rates
+                                [i - elems->supp_rates_len];
+                own_rate = 5 * (rate & 0x7f);
+                for (j = 0; j < num_rates; j++)
+                        if (bitrates[j].bitrate == own_rate)
+                                supp_rates |= BIT(j);
+        }
+        return supp_rates;
+}
+
 
 static void ieee80211_rx_bss_info(struct net_device *dev,
                                   struct ieee80211_mgmt *mgmt,
@@ -2205,41 +2322,23 @@ static void ieee80211_rx_bss_info(struct net_device *dev,
         beacon_timestamp = le64_to_cpu(mgmt->u.beacon.timestamp);
         ieee802_11_parse_elems(mgmt->u.beacon.variable, len - baselen, &elems);
 
+#ifdef CONFIG_MAC80211_MESH
+        if (sdata->vif.type == IEEE80211_IF_TYPE_MESH_POINT && elems.mesh_id
+                        && elems.mesh_config)
+                if (mesh_matches_local(&elems, dev)) {
+                        u64 rates = ieee80211_sta_get_rates(local, &elems,
+                                                        rx_status->band);
+                        mesh_neighbour_update(mgmt->sa, rates, dev,
+                                mesh_peer_accepts_plinks(&elems, dev));
+                }
+#endif
+
         if (sdata->vif.type == IEEE80211_IF_TYPE_IBSS && elems.supp_rates &&
             memcmp(mgmt->bssid, sdata->u.sta.bssid, ETH_ALEN) == 0 &&
             (sta = sta_info_get(local, mgmt->sa))) {
-                struct ieee80211_supported_band *sband;
-                struct ieee80211_rate *bitrates;
-                size_t num_rates;
-                u64 supp_rates, prev_rates;
-                int i, j;
-
-                sband = local->hw.wiphy->bands[rx_status->band];
-
-                if (!sband) {
-                        WARN_ON(1);
-                        sband = local->hw.wiphy->bands[
-                                        local->hw.conf.channel->band];
-                }
-
-                bitrates = sband->bitrates;
-                num_rates = sband->n_bitrates;
-
-                supp_rates = 0;
-                for (i = 0; i < elems.supp_rates_len +
-                             elems.ext_supp_rates_len; i++) {
-                        u8 rate = 0;
-                        int own_rate;
-                        if (i < elems.supp_rates_len)
-                                rate = elems.supp_rates[i];
-                        else if (elems.ext_supp_rates)
-                                rate = elems.ext_supp_rates
-                                        [i - elems.supp_rates_len];
-                        own_rate = 5 * (rate & 0x7f);
-                        for (j = 0; j < num_rates; j++)
-                                if (bitrates[j].bitrate == own_rate)
-                                        supp_rates |= BIT(j);
-                }
+                u64 prev_rates;
+                u64 supp_rates = ieee80211_sta_get_rates(local, &elems,
+                                                        rx_status->band);
 
                 prev_rates = sta->supp_rates[rx_status->band];
                 sta->supp_rates[rx_status->band] &= supp_rates;
@@ -2262,19 +2361,28 @@ static void ieee80211_rx_bss_info(struct net_device *dev,
                 sta_info_put(sta);
         }
 
-        if (!elems.ssid)
-                return;
-
         if (elems.ds_params && elems.ds_params_len == 1)
                 freq = ieee80211_channel_to_frequency(elems.ds_params[0]);
         else
                 freq = rx_status->freq;
 
-        bss = ieee80211_rx_bss_get(dev, mgmt->bssid, freq,
-                                   elems.ssid, elems.ssid_len);
-        if (!bss) {
-                bss = ieee80211_rx_bss_add(dev, mgmt->bssid, freq,
+#ifdef CONFIG_MAC80211_MESH
+        if (elems.mesh_config)
+                bss = ieee80211_rx_mesh_bss_get(dev, elems.mesh_id,
+                                elems.mesh_id_len, elems.mesh_config, freq);
+        else
+#endif
+                bss = ieee80211_rx_bss_get(dev, mgmt->bssid, freq,
                                            elems.ssid, elems.ssid_len);
+        if (!bss) {
+#ifdef CONFIG_MAC80211_MESH
+                if (elems.mesh_config)
+                        bss = ieee80211_rx_mesh_bss_add(dev, elems.mesh_id,
+                                elems.mesh_id_len, elems.mesh_config, freq);
+                else
+#endif
+                        bss = ieee80211_rx_bss_add(dev, mgmt->bssid, freq,
+                                                   elems.ssid, elems.ssid_len);
                 if (!bss)
                         return;
         } else {
@@ -2601,8 +2709,13 @@ static void ieee80211_rx_mgmt_probe_req(struct net_device *dev,
 static void ieee80211_rx_mgmt_action(struct net_device *dev,
                                      struct ieee80211_if_sta *ifsta,
                                      struct ieee80211_mgmt *mgmt,
-                                     size_t len)
+                                     size_t len,
+                                     struct ieee80211_rx_status *rx_status)
 {
+#ifdef CONFIG_MAC80211_MESH
+        struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+#endif
+
         if (len < IEEE80211_MIN_ACTION_SIZE)
                 return;
 
@@ -2634,7 +2747,21 @@ static void ieee80211_rx_mgmt_action(struct net_device *dev,
                         break;
                 }
                 break;
+#ifdef CONFIG_MAC80211_MESH
+        case PLINK_CATEGORY:
+                if (sdata->vif.type == IEEE80211_IF_TYPE_MESH_POINT)
+                        mesh_rx_plink_frame(dev, mgmt, len, rx_status);
+                break;
+
+        case MESH_PATH_SEL_CATEGORY:
+                if (sdata->vif.type == IEEE80211_IF_TYPE_MESH_POINT)
+                        mesh_rx_path_sel_frame(dev, mgmt, len);
+                break;
+#endif
         default:
+                if (net_ratelimit())
+                        printk(KERN_DEBUG "%s: Rx unknown action frame - "
+                        "category=%d\n", dev->name, mgmt->u.action.category);
                 break;
         }
 }
@@ -2661,13 +2788,13 @@ void ieee80211_sta_rx_mgmt(struct net_device *dev, struct sk_buff *skb,
         case IEEE80211_STYPE_PROBE_REQ:
         case IEEE80211_STYPE_PROBE_RESP:
         case IEEE80211_STYPE_BEACON:
+        case IEEE80211_STYPE_ACTION:
                 memcpy(skb->cb, rx_status, sizeof(*rx_status));
         case IEEE80211_STYPE_AUTH:
         case IEEE80211_STYPE_ASSOC_RESP:
         case IEEE80211_STYPE_REASSOC_RESP:
         case IEEE80211_STYPE_DEAUTH:
         case IEEE80211_STYPE_DISASSOC:
-        case IEEE80211_STYPE_ACTION:
                 skb_queue_tail(&ifsta->skb_queue, skb);
                 queue_work(local->hw.workqueue, &ifsta->work);
                 return;
@@ -2726,7 +2853,7 @@ static void ieee80211_sta_rx_queued_mgmt(struct net_device *dev,
                 ieee80211_rx_mgmt_disassoc(dev, ifsta, mgmt, skb->len);
                 break;
         case IEEE80211_STYPE_ACTION:
-                ieee80211_rx_mgmt_action(dev, ifsta, mgmt, skb->len);
+                ieee80211_rx_mgmt_action(dev, ifsta, mgmt, skb->len, rx_status);
                 break;
         }
 
@@ -2791,7 +2918,7 @@ static int ieee80211_sta_active_ibss(struct net_device *dev)
 }
 
 
-static void ieee80211_sta_expire(struct net_device *dev)
+static void ieee80211_sta_expire(struct net_device *dev, unsigned long exp_time)
 {
         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
         struct sta_info *sta, *tmp;
@@ -2800,8 +2927,7 @@ static void ieee80211_sta_expire(struct net_device *dev)
 
         write_lock_bh(&local->sta_lock);
         list_for_each_entry_safe(sta, tmp, &local->sta_list, list)
-                if (time_after(jiffies, sta->last_rx +
-                               IEEE80211_IBSS_INACTIVITY_LIMIT)) {
+                if (time_after(jiffies, sta->last_rx + exp_time)) {
                         printk(KERN_DEBUG "%s: expiring inactive STA %s\n",
                                dev->name, print_mac(mac, sta->addr));
                         __sta_info_get(sta);
@@ -2822,7 +2948,7 @@ static void ieee80211_sta_merge_ibss(struct net_device *dev,
 {
         mod_timer(&ifsta->timer, jiffies + IEEE80211_IBSS_MERGE_INTERVAL);
 
-        ieee80211_sta_expire(dev);
+        ieee80211_sta_expire(dev, IEEE80211_IBSS_INACTIVITY_LIMIT);
         if (ieee80211_sta_active_ibss(dev))
                 return;
 
@@ -2832,6 +2958,36 @@ static void ieee80211_sta_merge_ibss(struct net_device *dev,
 }
 
 
+#ifdef CONFIG_MAC80211_MESH
+static void ieee80211_mesh_housekeeping(struct net_device *dev,
+                           struct ieee80211_if_sta *ifsta)
+{
+        struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+        bool free_plinks;
+
+        ieee80211_sta_expire(dev, IEEE80211_MESH_PEER_INACTIVITY_LIMIT);
+        mesh_path_expire(dev);
+
+        free_plinks = mesh_plink_availables(sdata);
+        if (free_plinks != sdata->u.sta.accepting_plinks)
+                ieee80211_if_config_beacon(dev);
+
+        mod_timer(&ifsta->timer, jiffies +
+                        IEEE80211_MESH_HOUSEKEEPING_INTERVAL);
+}
+
+
+void ieee80211_start_mesh(struct net_device *dev)
+{
+        struct ieee80211_if_sta *ifsta;
+        struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+        ifsta = &sdata->u.sta;
+        ifsta->state = IEEE80211_MESH_UP;
+        ieee80211_sta_timer((unsigned long)sdata);
+}
+#endif
+
+
 void ieee80211_sta_timer(unsigned long data)
 {
         struct ieee80211_sub_if_data *sdata =
@@ -2843,7 +2999,6 @@ void ieee80211_sta_timer(unsigned long data)
         queue_work(local->hw.workqueue, &ifsta->work);
 }
 
-
 void ieee80211_sta_work(struct work_struct *work)
 {
         struct ieee80211_sub_if_data *sdata =
@@ -2860,7 +3015,8 @@ void ieee80211_sta_work(struct work_struct *work)
                 return;
 
         if (sdata->vif.type != IEEE80211_IF_TYPE_STA &&
-            sdata->vif.type != IEEE80211_IF_TYPE_IBSS) {
+            sdata->vif.type != IEEE80211_IF_TYPE_IBSS &&
+            sdata->vif.type != IEEE80211_IF_TYPE_MESH_POINT) {
                 printk(KERN_DEBUG "%s: ieee80211_sta_work: non-STA interface "
                        "(type=%d)\n", dev->name, sdata->vif.type);
                 return;
@@ -2870,6 +3026,12 @@ void ieee80211_sta_work(struct work_struct *work)
         while ((skb = skb_dequeue(&ifsta->skb_queue)))
                 ieee80211_sta_rx_queued_mgmt(dev, skb);
 
+#ifdef CONFIG_MAC80211_MESH
+        if (ifsta->preq_queue_len && time_after(jiffies, ifsta->last_preq +
+                msecs_to_jiffies(ifsta->mshcfg.dot11MeshHWMPpreqMinInterval)))
+                mesh_path_start_discovery(dev);
+#endif
+
         if (ifsta->state != IEEE80211_AUTHENTICATE &&
             ifsta->state != IEEE80211_ASSOCIATE &&
             test_and_clear_bit(IEEE80211_STA_REQ_SCAN, &ifsta->request)) {
@@ -2905,6 +3067,11 @@ void ieee80211_sta_work(struct work_struct *work)
         case IEEE80211_IBSS_JOINED:
                 ieee80211_sta_merge_ibss(dev, ifsta);
                 break;
+#ifdef CONFIG_MAC80211_MESH
+        case IEEE80211_MESH_UP:
+                ieee80211_mesh_housekeeping(dev, ifsta);
+                break;
+#endif
         default:
                 printk(KERN_DEBUG "ieee80211_sta_work: Unknown state %d\n",
                        ifsta->state);
@@ -3109,7 +3276,7 @@ static int ieee80211_sta_create_ibss(struct net_device *dev,
         sband = local->hw.wiphy->bands[bss->band];
 
         if (local->hw.conf.beacon_int == 0)
-                local->hw.conf.beacon_int = 100;
+                local->hw.conf.beacon_int = 10000;
         bss->beacon_int = local->hw.conf.beacon_int;
         bss->last_update = jiffies;
         bss->capability = WLAN_CAPABILITY_IBSS;
@@ -3398,6 +3565,9 @@ void ieee80211_scan_completed(struct ieee80211_hw *hw)
                         ieee80211_sta_timer((unsigned long)sdata);
                 }
 
+                if (sdata->vif.type == IEEE80211_IF_TYPE_MESH_POINT)
+                        ieee80211_sta_timer((unsigned long)sdata);
+
                 netif_wake_queue(sdata->dev);
         }
         rcu_read_unlock();
@@ -3640,15 +3810,27 @@ ieee80211_sta_scan_result(struct net_device *dev,
 
         memset(&iwe, 0, sizeof(iwe));
         iwe.cmd = SIOCGIWESSID;
-        iwe.u.data.length = bss->ssid_len;
-        iwe.u.data.flags = 1;
-        current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe,
-                                          bss->ssid);
+        if (bss->mesh_cfg) {
+#ifdef CONFIG_MAC80211_MESH
+                iwe.u.data.length = bss->mesh_id_len;
+                iwe.u.data.flags = 1;
+                current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe,
+                                                  bss->mesh_id);
+#endif
+        } else {
+                iwe.u.data.length = bss->ssid_len;
+                iwe.u.data.flags = 1;
+                current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe,
+                                                  bss->ssid);
+        }
 
-        if (bss->capability & (WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_IBSS)) {
+        if (bss->capability & (WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_IBSS
+            || bss->mesh_cfg)) {
                 memset(&iwe, 0, sizeof(iwe));
                 iwe.cmd = SIOCGIWMODE;
-                if (bss->capability & WLAN_CAPABILITY_ESS)
+                if (bss->mesh_cfg)
+                        iwe.u.mode = IW_MODE_MESH;
+                else if (bss->capability & WLAN_CAPABILITY_ESS)
                         iwe.u.mode = IW_MODE_MASTER;
                 else
                         iwe.u.mode = IW_MODE_ADHOC;
@@ -3737,6 +3919,28 @@ ieee80211_sta_scan_result(struct net_device *dev,
                 }
         }
 
+        if (bss->mesh_cfg) {
+                char *buf;
+                u8 *cfg = bss->mesh_cfg;
+                buf = kmalloc(200, GFP_ATOMIC);
+                if (buf) {
+                        memset(&iwe, 0, sizeof(iwe));
+                        iwe.cmd = IWEVCUSTOM;
+                        sprintf(buf, "Mesh network (version %d)\n"
+                        "\t\t\tPath Selection Protocol ID: 0x%02X%02X%02X%02X\n"
+                        "\t\t\tPath Selection Metric ID: 0x%02X%02X%02X%02X\n"
+                        "\t\t\tCongestion Control Mode ID: 0x%02X%02X%02X%02X\n"
+                        "\t\t\tChannel Precedence: 0x%02X%02X%02X%02X",
+                        cfg[0], cfg[1], cfg[2], cfg[3], cfg[4], cfg[5], cfg[6],
+                        cfg[7], cfg[8], cfg[9], cfg[10], cfg[11], cfg[12],
+                        cfg[13], cfg[14], cfg[15], cfg[16]);
+                        iwe.u.data.length = strlen(buf);
+                        current_ev = iwe_stream_add_point(current_ev, end_buf,
+                                                          &iwe, buf);
+                        kfree(buf);
+                }
+        }
+
         return current_ev;
 }