blob: 885a5f6e2c219b5c4e17b6574bd32e4231ed39b1 [file] [log] [blame]
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +01001/*
Rui Paulo264d9b72009-11-09 23:46:58 +00002 * Copyright (c) 2008, 2009 open80211s Ltd.
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +01003 * Authors: Luis Carlos Cobo <luisca@cozybit.com>
4 * Javier Cardona <javier@cozybit.com>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 */
10
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090011#include <linux/slab.h>
Luis Carlos Cobo51cedda2008-04-23 12:15:29 -070012#include <asm/unaligned.h>
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +010013#include "ieee80211_i.h"
14#include "mesh.h"
15
Johannes Bergbf7cd942013-02-15 14:40:31 +010016static int mesh_allocated;
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +010017static struct kmem_cache *rm_cache;
18
Thomas Pedersen25d49e42011-08-11 19:35:15 -070019bool mesh_action_is_path_sel(struct ieee80211_mgmt *mgmt)
20{
21 return (mgmt->u.action.u.mesh_action.action_code ==
22 WLAN_MESH_ACTION_HWMP_PATH_SELECTION);
23}
Thomas Pedersen25d49e42011-08-11 19:35:15 -070024
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +010025void ieee80211s_init(void)
26{
27 mesh_pathtbl_init();
28 mesh_allocated = 1;
29 rm_cache = kmem_cache_create("mesh_rmc", sizeof(struct rmc_entry),
30 0, 0, NULL);
31}
32
33void ieee80211s_stop(void)
34{
Johannes Bergbf7cd942013-02-15 14:40:31 +010035 if (!mesh_allocated)
36 return;
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +010037 mesh_pathtbl_unregister();
38 kmem_cache_destroy(rm_cache);
39}
40
Johannes Berg472dbc42008-09-11 00:01:49 +020041static void ieee80211_mesh_housekeeping_timer(unsigned long data)
42{
43 struct ieee80211_sub_if_data *sdata = (void *) data;
44 struct ieee80211_local *local = sdata->local;
45 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
46
Rui Paulo6b9ac442009-10-20 21:21:48 +010047 set_bit(MESH_WORK_HOUSEKEEPING, &ifmsh->wrkq_flags);
Johannes Berg5bb644a2009-05-17 11:40:42 +020048
Johannes Berg64592c82010-06-10 10:21:31 +020049 ieee80211_queue_work(&local->hw, &sdata->work);
Johannes Berg472dbc42008-09-11 00:01:49 +020050}
51
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +010052/**
53 * mesh_matches_local - check if the config of a mesh point matches ours
54 *
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +120055 * @sdata: local mesh subif
Thomas Pedersenf743ff42012-04-18 19:23:43 -070056 * @ie: information elements of a management frame from the mesh peer
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +010057 *
58 * This function checks if the mesh configuration of a mesh point matches the
59 * local mesh configuration, i.e. if both nodes belong to the same mesh network.
60 */
Thomas Pedersenf743ff42012-04-18 19:23:43 -070061bool mesh_matches_local(struct ieee80211_sub_if_data *sdata,
62 struct ieee802_11_elems *ie)
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +010063{
Johannes Berg472dbc42008-09-11 00:01:49 +020064 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
Thomas Pedersenf743ff42012-04-18 19:23:43 -070065 u32 basic_rates = 0;
Johannes Berg4bf88532012-11-09 11:39:59 +010066 struct cfg80211_chan_def sta_chan_def;
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +010067
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +010068 /*
69 * As support for each feature is added, check for matching
70 * - On mesh config capabilities
71 * - Power Save Support En
72 * - Sync support enabled
73 * - Sync support active
74 * - Sync support required from peer
75 * - MDA enabled
76 * - Power management control on fc
77 */
Thomas Pedersen739522b2011-10-26 14:47:28 -070078 if (!(ifmsh->mesh_id_len == ie->mesh_id_len &&
79 memcmp(ifmsh->mesh_id, ie->mesh_id, ie->mesh_id_len) == 0 &&
80 (ifmsh->mesh_pp_id == ie->mesh_config->meshconf_psel) &&
81 (ifmsh->mesh_pm_id == ie->mesh_config->meshconf_pmetric) &&
82 (ifmsh->mesh_cc_id == ie->mesh_config->meshconf_congest) &&
83 (ifmsh->mesh_sp_id == ie->mesh_config->meshconf_synch) &&
84 (ifmsh->mesh_auth_id == ie->mesh_config->meshconf_auth)))
Johannes Bergbf7cd942013-02-15 14:40:31 +010085 return false;
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +010086
Simon Wunderlich2103dec2013-07-08 16:55:53 +020087 ieee80211_sta_get_rates(sdata, ie, ieee80211_get_sdata_band(sdata),
Thomas Pedersenf743ff42012-04-18 19:23:43 -070088 &basic_rates);
89
Ashok Nagarajanfe40cb62012-04-02 21:21:22 -070090 if (sdata->vif.bss_conf.basic_rates != basic_rates)
Johannes Bergbf7cd942013-02-15 14:40:31 +010091 return false;
Ashok Nagarajanfe40cb62012-04-02 21:21:22 -070092
Johannes Berg4bf88532012-11-09 11:39:59 +010093 ieee80211_ht_oper_to_chandef(sdata->vif.bss_conf.chandef.chan,
94 ie->ht_operation, &sta_chan_def);
Ashok Nagarajanb91e64a2012-04-30 14:20:31 -070095
Johannes Berg4bf88532012-11-09 11:39:59 +010096 if (!cfg80211_chandef_compatible(&sdata->vif.bss_conf.chandef,
97 &sta_chan_def))
Johannes Bergbf7cd942013-02-15 14:40:31 +010098 return false;
Thomas Pedersen739522b2011-10-26 14:47:28 -070099
100 return true;
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100101}
102
103/**
104 * mesh_peer_accepts_plinks - check if an mp is willing to establish peer links
105 *
106 * @ie: information elements of a management frame from the mesh peer
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100107 */
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200108bool mesh_peer_accepts_plinks(struct ieee802_11_elems *ie)
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100109{
Rui Paulo136cfa22009-11-18 18:40:00 +0000110 return (ie->mesh_config->meshconf_cap &
Johannes Bergbf7cd942013-02-15 14:40:31 +0100111 IEEE80211_MESHCONF_CAPAB_ACCEPT_PLINKS) != 0;
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100112}
113
114/**
Ben Hutchings2c530402012-07-10 10:55:09 +0000115 * mesh_accept_plinks_update - update accepting_plink in local mesh beacons
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100116 *
Johannes Bergd0709a62008-02-25 16:27:46 +0100117 * @sdata: mesh interface in which mesh beacons are going to be updated
Marco Porschdf323812012-08-08 07:58:43 +0200118 *
119 * Returns: beacon changed flag if the beacon content changed.
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100120 */
Marco Porschdf323812012-08-08 07:58:43 +0200121u32 mesh_accept_plinks_update(struct ieee80211_sub_if_data *sdata)
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100122{
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100123 bool free_plinks;
Marco Porschdf323812012-08-08 07:58:43 +0200124 u32 changed = 0;
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100125
126 /* In case mesh_plink_free_count > 0 and mesh_plinktbl_capacity == 0,
127 * the mesh interface might be able to establish plinks with peers that
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800128 * are already on the table but are not on PLINK_ESTAB state. However,
129 * in general the mesh interface is not accepting peer link requests
130 * from new peers, and that must be reflected in the beacon
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100131 */
132 free_plinks = mesh_plink_availables(sdata);
133
Marco Porschdf323812012-08-08 07:58:43 +0200134 if (free_plinks != sdata->u.mesh.accepting_plinks) {
135 sdata->u.mesh.accepting_plinks = free_plinks;
136 changed = BSS_CHANGED_BEACON;
137 }
138
139 return changed;
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100140}
141
Thomas Pedersen45b50282013-02-06 10:17:21 -0800142/*
143 * mesh_sta_cleanup - clean up any mesh sta state
144 *
145 * @sta: mesh sta to clean up.
146 */
147void mesh_sta_cleanup(struct sta_info *sta)
148{
149 struct ieee80211_sub_if_data *sdata = sta->sdata;
150 u32 changed;
151
152 /*
153 * maybe userspace handles peer allocation and peering, but in either
154 * case the beacon is still generated by the kernel and we might need
155 * an update.
156 */
157 changed = mesh_accept_plinks_update(sdata);
Thomas Pedersena6dad6a2013-03-04 13:06:12 -0800158 if (!sdata->u.mesh.user_mpm) {
Thomas Pedersen45b50282013-02-06 10:17:21 -0800159 changed |= mesh_plink_deactivate(sta);
160 del_timer_sync(&sta->plink_timer);
161 }
162
Thomas Pedersenf81a9de2013-06-13 15:54:41 -0700163 if (changed)
Thomas Pedersen2b5e1962013-02-14 11:20:13 -0800164 ieee80211_mbss_info_change_notify(sdata, changed);
Thomas Pedersen45b50282013-02-06 10:17:21 -0800165}
166
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200167int mesh_rmc_init(struct ieee80211_sub_if_data *sdata)
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100168{
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100169 int i;
170
Johannes Berg472dbc42008-09-11 00:01:49 +0200171 sdata->u.mesh.rmc = kmalloc(sizeof(struct mesh_rmc), GFP_KERNEL);
172 if (!sdata->u.mesh.rmc)
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100173 return -ENOMEM;
Johannes Berg472dbc42008-09-11 00:01:49 +0200174 sdata->u.mesh.rmc->idx_mask = RMC_BUCKETS - 1;
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100175 for (i = 0; i < RMC_BUCKETS; i++)
Thomas Pedersenb7cfcd12012-12-17 18:41:57 -0800176 INIT_LIST_HEAD(&sdata->u.mesh.rmc->bucket[i]);
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100177 return 0;
178}
179
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200180void mesh_rmc_free(struct ieee80211_sub_if_data *sdata)
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100181{
Johannes Berg472dbc42008-09-11 00:01:49 +0200182 struct mesh_rmc *rmc = sdata->u.mesh.rmc;
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100183 struct rmc_entry *p, *n;
184 int i;
185
Johannes Berg472dbc42008-09-11 00:01:49 +0200186 if (!sdata->u.mesh.rmc)
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100187 return;
188
Johannes Bergbf7cd942013-02-15 14:40:31 +0100189 for (i = 0; i < RMC_BUCKETS; i++) {
Thomas Pedersenb7cfcd12012-12-17 18:41:57 -0800190 list_for_each_entry_safe(p, n, &rmc->bucket[i], list) {
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100191 list_del(&p->list);
192 kmem_cache_free(rm_cache, p);
193 }
Johannes Bergbf7cd942013-02-15 14:40:31 +0100194 }
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100195
196 kfree(rmc);
Johannes Berg472dbc42008-09-11 00:01:49 +0200197 sdata->u.mesh.rmc = NULL;
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100198}
199
200/**
201 * mesh_rmc_check - Check frame in recent multicast cache and add if absent.
202 *
Johannes Bergbf7cd942013-02-15 14:40:31 +0100203 * @sdata: interface
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100204 * @sa: source address
205 * @mesh_hdr: mesh_header
206 *
207 * Returns: 0 if the frame is not in the cache, nonzero otherwise.
208 *
209 * Checks using the source address and the mesh sequence number if we have
210 * received this frame lately. If the frame is not in the cache, it is added to
211 * it.
212 */
Johannes Bergbf7cd942013-02-15 14:40:31 +0100213int mesh_rmc_check(struct ieee80211_sub_if_data *sdata,
214 const u8 *sa, struct ieee80211s_hdr *mesh_hdr)
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100215{
Johannes Berg472dbc42008-09-11 00:01:49 +0200216 struct mesh_rmc *rmc = sdata->u.mesh.rmc;
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100217 u32 seqnum = 0;
218 int entries = 0;
219 u8 idx;
220 struct rmc_entry *p, *n;
221
222 /* Don't care about endianness since only match matters */
Luis Carlos Cobo51cedda2008-04-23 12:15:29 -0700223 memcpy(&seqnum, &mesh_hdr->seqnum, sizeof(mesh_hdr->seqnum));
224 idx = le32_to_cpu(mesh_hdr->seqnum) & rmc->idx_mask;
Thomas Pedersenb7cfcd12012-12-17 18:41:57 -0800225 list_for_each_entry_safe(p, n, &rmc->bucket[idx], list) {
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100226 ++entries;
227 if (time_after(jiffies, p->exp_time) ||
Johannes Bergbf7cd942013-02-15 14:40:31 +0100228 entries == RMC_QUEUE_MAX_LEN) {
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100229 list_del(&p->list);
230 kmem_cache_free(rm_cache, p);
231 --entries;
Johannes Bergbf7cd942013-02-15 14:40:31 +0100232 } else if ((seqnum == p->seqnum) && ether_addr_equal(sa, p->sa))
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100233 return -1;
234 }
235
236 p = kmem_cache_alloc(rm_cache, GFP_ATOMIC);
Joe Perchesd15b8452011-08-29 14:17:31 -0700237 if (!p)
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100238 return 0;
Joe Perchesd15b8452011-08-29 14:17:31 -0700239
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100240 p->seqnum = seqnum;
241 p->exp_time = jiffies + RMC_TIMEOUT;
242 memcpy(p->sa, sa, ETH_ALEN);
Thomas Pedersenb7cfcd12012-12-17 18:41:57 -0800243 list_add(&p->list, &rmc->bucket[idx]);
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100244 return 0;
245}
246
Johannes Bergbf7cd942013-02-15 14:40:31 +0100247int mesh_add_meshconf_ie(struct ieee80211_sub_if_data *sdata,
248 struct sk_buff *skb)
Thomas Pedersen082ebb02011-08-11 19:35:10 -0700249{
250 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
251 u8 *pos, neighbors;
252 u8 meshconf_len = sizeof(struct ieee80211_meshconf_ie);
253
254 if (skb_tailroom(skb) < 2 + meshconf_len)
255 return -ENOMEM;
256
257 pos = skb_put(skb, 2 + meshconf_len);
258 *pos++ = WLAN_EID_MESH_CONFIG;
259 *pos++ = meshconf_len;
260
261 /* Active path selection protocol ID */
262 *pos++ = ifmsh->mesh_pp_id;
263 /* Active path selection metric ID */
264 *pos++ = ifmsh->mesh_pm_id;
265 /* Congestion control mode identifier */
266 *pos++ = ifmsh->mesh_cc_id;
267 /* Synchronization protocol identifier */
268 *pos++ = ifmsh->mesh_sp_id;
269 /* Authentication Protocol identifier */
270 *pos++ = ifmsh->mesh_auth_id;
271 /* Mesh Formation Info - number of neighbors */
Ashok Nagarajan1258d972012-10-09 13:27:47 -0700272 neighbors = atomic_read(&ifmsh->estab_plinks);
Jacob Minshalle05eccc2013-05-29 14:32:36 -0700273 neighbors = min_t(int, neighbors, IEEE80211_MAX_MESH_PEERINGS);
Thomas Pedersen082ebb02011-08-11 19:35:10 -0700274 *pos++ = neighbors << 1;
275 /* Mesh capability */
Chun-Yeow Yeohb60e5272013-07-12 18:55:22 +0800276 *pos = 0x00;
277 *pos |= ifmsh->mshcfg.dot11MeshForwarding ?
278 IEEE80211_MESHCONF_CAPAB_FORWARDING : 0x00;
Javier Cardonadbf498f2012-03-31 11:31:32 -0700279 *pos |= ifmsh->accepting_plinks ?
Johannes Bergbf7cd942013-02-15 14:40:31 +0100280 IEEE80211_MESHCONF_CAPAB_ACCEPT_PLINKS : 0x00;
Marco Porsch3f52b7e2013-01-30 18:14:08 +0100281 /* Mesh PS mode. See IEEE802.11-2012 8.4.2.100.8 */
282 *pos |= ifmsh->ps_peers_deep_sleep ?
Johannes Bergbf7cd942013-02-15 14:40:31 +0100283 IEEE80211_MESHCONF_CAPAB_POWER_SAVE_LEVEL : 0x00;
Javier Cardonadbf498f2012-03-31 11:31:32 -0700284 *pos++ |= ifmsh->adjusting_tbtt ?
Johannes Bergbf7cd942013-02-15 14:40:31 +0100285 IEEE80211_MESHCONF_CAPAB_TBTT_ADJUSTING : 0x00;
Thomas Pedersen082ebb02011-08-11 19:35:10 -0700286 *pos++ = 0x00;
287
288 return 0;
289}
290
Johannes Bergbf7cd942013-02-15 14:40:31 +0100291int mesh_add_meshid_ie(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb)
Thomas Pedersen082ebb02011-08-11 19:35:10 -0700292{
293 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
294 u8 *pos;
295
296 if (skb_tailroom(skb) < 2 + ifmsh->mesh_id_len)
297 return -ENOMEM;
298
299 pos = skb_put(skb, 2 + ifmsh->mesh_id_len);
300 *pos++ = WLAN_EID_MESH_ID;
301 *pos++ = ifmsh->mesh_id_len;
302 if (ifmsh->mesh_id_len)
303 memcpy(pos, ifmsh->mesh_id, ifmsh->mesh_id_len);
304
305 return 0;
306}
307
Johannes Bergbf7cd942013-02-15 14:40:31 +0100308static int mesh_add_awake_window_ie(struct ieee80211_sub_if_data *sdata,
309 struct sk_buff *skb)
Marco Porsch3f52b7e2013-01-30 18:14:08 +0100310{
311 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
312 u8 *pos;
313
314 /* see IEEE802.11-2012 13.14.6 */
315 if (ifmsh->ps_peers_light_sleep == 0 &&
316 ifmsh->ps_peers_deep_sleep == 0 &&
317 ifmsh->nonpeer_pm == NL80211_MESH_POWER_ACTIVE)
318 return 0;
319
320 if (skb_tailroom(skb) < 4)
321 return -ENOMEM;
322
323 pos = skb_put(skb, 2 + 2);
324 *pos++ = WLAN_EID_MESH_AWAKE_WINDOW;
325 *pos++ = 2;
326 put_unaligned_le16(ifmsh->mshcfg.dot11MeshAwakeWindowDuration, pos);
327
328 return 0;
329}
330
Johannes Bergbf7cd942013-02-15 14:40:31 +0100331int mesh_add_vendor_ies(struct ieee80211_sub_if_data *sdata,
332 struct sk_buff *skb)
Thomas Pedersen082ebb02011-08-11 19:35:10 -0700333{
334 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
335 u8 offset, len;
336 const u8 *data;
337
338 if (!ifmsh->ie || !ifmsh->ie_len)
339 return 0;
340
341 /* fast-forward to vendor IEs */
342 offset = ieee80211_ie_split_vendor(ifmsh->ie, ifmsh->ie_len, 0);
343
344 if (offset) {
345 len = ifmsh->ie_len - offset;
346 data = ifmsh->ie + offset;
347 if (skb_tailroom(skb) < len)
348 return -ENOMEM;
349 memcpy(skb_put(skb, len), data, len);
350 }
351
352 return 0;
353}
354
Johannes Bergbf7cd942013-02-15 14:40:31 +0100355int mesh_add_rsn_ie(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb)
Thomas Pedersen082ebb02011-08-11 19:35:10 -0700356{
357 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
358 u8 len = 0;
359 const u8 *data;
360
361 if (!ifmsh->ie || !ifmsh->ie_len)
362 return 0;
363
364 /* find RSN IE */
365 data = ifmsh->ie;
366 while (data < ifmsh->ie + ifmsh->ie_len) {
367 if (*data == WLAN_EID_RSN) {
368 len = data[1] + 2;
369 break;
370 }
371 data++;
372 }
373
374 if (len) {
375 if (skb_tailroom(skb) < len)
376 return -ENOMEM;
377 memcpy(skb_put(skb, len), data, len);
378 }
379
380 return 0;
381}
382
Johannes Bergbf7cd942013-02-15 14:40:31 +0100383static int mesh_add_ds_params_ie(struct ieee80211_sub_if_data *sdata,
384 struct sk_buff *skb)
Thomas Pedersen082ebb02011-08-11 19:35:10 -0700385{
Johannes Berg55de9082012-07-26 17:24:39 +0200386 struct ieee80211_chanctx_conf *chanctx_conf;
387 struct ieee80211_channel *chan;
Thomas Pedersen082ebb02011-08-11 19:35:10 -0700388 u8 *pos;
389
390 if (skb_tailroom(skb) < 3)
391 return -ENOMEM;
392
Johannes Berg55de9082012-07-26 17:24:39 +0200393 rcu_read_lock();
394 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
395 if (WARN_ON(!chanctx_conf)) {
396 rcu_read_unlock();
397 return -EINVAL;
398 }
Johannes Berg4bf88532012-11-09 11:39:59 +0100399 chan = chanctx_conf->def.chan;
Johannes Berg55de9082012-07-26 17:24:39 +0200400 rcu_read_unlock();
401
Emanuel Taube601513a2013-02-06 14:17:17 +0100402 pos = skb_put(skb, 2 + 1);
403 *pos++ = WLAN_EID_DS_PARAMS;
404 *pos++ = 1;
405 *pos++ = ieee80211_frequency_to_channel(chan->center_freq);
Rui Paulobe125c62009-11-09 23:46:54 +0000406
Thomas Pedersen082ebb02011-08-11 19:35:10 -0700407 return 0;
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100408}
409
Johannes Bergbf7cd942013-02-15 14:40:31 +0100410int mesh_add_ht_cap_ie(struct ieee80211_sub_if_data *sdata,
411 struct sk_buff *skb)
Thomas Pedersen176f3602011-10-26 14:47:27 -0700412{
413 struct ieee80211_local *local = sdata->local;
Johannes Berg55de9082012-07-26 17:24:39 +0200414 enum ieee80211_band band = ieee80211_get_sdata_band(sdata);
Thomas Pedersen176f3602011-10-26 14:47:27 -0700415 struct ieee80211_supported_band *sband;
416 u8 *pos;
417
Johannes Berg55de9082012-07-26 17:24:39 +0200418 sband = local->hw.wiphy->bands[band];
Thomas Pedersen176f3602011-10-26 14:47:27 -0700419 if (!sband->ht_cap.ht_supported ||
Simon Wunderlich0418a442013-05-16 13:00:31 +0200420 sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_20_NOHT ||
421 sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_5 ||
422 sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_10)
Thomas Pedersen176f3602011-10-26 14:47:27 -0700423 return 0;
424
425 if (skb_tailroom(skb) < 2 + sizeof(struct ieee80211_ht_cap))
426 return -ENOMEM;
427
428 pos = skb_put(skb, 2 + sizeof(struct ieee80211_ht_cap));
Ben Greearef96a8422011-11-18 11:32:00 -0800429 ieee80211_ie_build_ht_cap(pos, &sband->ht_cap, sband->ht_cap.cap);
Thomas Pedersen176f3602011-10-26 14:47:27 -0700430
431 return 0;
432}
433
Johannes Bergbf7cd942013-02-15 14:40:31 +0100434int mesh_add_ht_oper_ie(struct ieee80211_sub_if_data *sdata,
435 struct sk_buff *skb)
Thomas Pedersen176f3602011-10-26 14:47:27 -0700436{
437 struct ieee80211_local *local = sdata->local;
Johannes Berg55de9082012-07-26 17:24:39 +0200438 struct ieee80211_chanctx_conf *chanctx_conf;
439 struct ieee80211_channel *channel;
Johannes Berg466f3102012-07-25 13:51:49 +0200440 enum nl80211_channel_type channel_type =
Johannes Berg4bf88532012-11-09 11:39:59 +0100441 cfg80211_get_chandef_type(&sdata->vif.bss_conf.chandef);
Johannes Berg55de9082012-07-26 17:24:39 +0200442 struct ieee80211_supported_band *sband;
443 struct ieee80211_sta_ht_cap *ht_cap;
Thomas Pedersen176f3602011-10-26 14:47:27 -0700444 u8 *pos;
445
Johannes Berg55de9082012-07-26 17:24:39 +0200446 rcu_read_lock();
447 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
448 if (WARN_ON(!chanctx_conf)) {
449 rcu_read_unlock();
450 return -EINVAL;
451 }
Johannes Berg4bf88532012-11-09 11:39:59 +0100452 channel = chanctx_conf->def.chan;
Johannes Berg55de9082012-07-26 17:24:39 +0200453 rcu_read_unlock();
454
455 sband = local->hw.wiphy->bands[channel->band];
456 ht_cap = &sband->ht_cap;
457
Thomas Pedersen176f3602011-10-26 14:47:27 -0700458 if (!ht_cap->ht_supported || channel_type == NL80211_CHAN_NO_HT)
459 return 0;
460
Johannes Berg074d46d2012-03-15 19:45:16 +0100461 if (skb_tailroom(skb) < 2 + sizeof(struct ieee80211_ht_operation))
Thomas Pedersen176f3602011-10-26 14:47:27 -0700462 return -ENOMEM;
463
Johannes Berg074d46d2012-03-15 19:45:16 +0100464 pos = skb_put(skb, 2 + sizeof(struct ieee80211_ht_operation));
Johannes Berg4bf88532012-11-09 11:39:59 +0100465 ieee80211_ie_build_ht_oper(pos, ht_cap, &sdata->vif.bss_conf.chandef,
Ashok Nagarajan431e3152012-04-30 14:20:29 -0700466 sdata->vif.bss_conf.ht_operation_mode);
Thomas Pedersen176f3602011-10-26 14:47:27 -0700467
468 return 0;
469}
Johannes Bergbf7cd942013-02-15 14:40:31 +0100470
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100471static void ieee80211_mesh_path_timer(unsigned long data)
472{
473 struct ieee80211_sub_if_data *sdata =
474 (struct ieee80211_sub_if_data *) data;
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100475
Stanislaw Gruszka690205f2013-02-28 10:55:29 +0100476 ieee80211_queue_work(&sdata->local->hw, &sdata->work);
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100477}
478
Rui Pauloe304bfd2009-11-09 23:46:56 +0000479static void ieee80211_mesh_path_root_timer(unsigned long data)
480{
481 struct ieee80211_sub_if_data *sdata =
482 (struct ieee80211_sub_if_data *) data;
483 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
Rui Pauloe304bfd2009-11-09 23:46:56 +0000484
485 set_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags);
486
Stanislaw Gruszka690205f2013-02-28 10:55:29 +0100487 ieee80211_queue_work(&sdata->local->hw, &sdata->work);
Rui Pauloe304bfd2009-11-09 23:46:56 +0000488}
489
Rui Paulo63c57232009-11-09 23:46:57 +0000490void ieee80211_mesh_root_setup(struct ieee80211_if_mesh *ifmsh)
491{
Chun-Yeow Yeohdbb912c2012-06-14 02:06:09 +0800492 if (ifmsh->mshcfg.dot11MeshHWMPRootMode > IEEE80211_ROOTMODE_ROOT)
Rui Paulo63c57232009-11-09 23:46:57 +0000493 set_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags);
494 else {
495 clear_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags);
496 /* stop running timer */
497 del_timer_sync(&ifmsh->mesh_path_root_timer);
498 }
499}
500
Johannes Berg902acc72008-02-23 15:17:19 +0100501/**
Javier Cardona3c5772a2009-08-10 12:15:48 -0700502 * ieee80211_fill_mesh_addresses - fill addresses of a locally originated mesh frame
Johannes Bergbf7cd942013-02-15 14:40:31 +0100503 * @hdr: 802.11 frame header
Javier Cardona3c5772a2009-08-10 12:15:48 -0700504 * @fc: frame control field
505 * @meshda: destination address in the mesh
506 * @meshsa: source address address in the mesh. Same as TA, as frame is
507 * locally originated.
508 *
509 * Return the length of the 802.11 (does not include a mesh control header)
510 */
Johannes Berg15ff6362009-11-17 13:34:04 +0100511int ieee80211_fill_mesh_addresses(struct ieee80211_hdr *hdr, __le16 *fc,
512 const u8 *meshda, const u8 *meshsa)
513{
Javier Cardona3c5772a2009-08-10 12:15:48 -0700514 if (is_multicast_ether_addr(meshda)) {
515 *fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS);
516 /* DA TA SA */
517 memcpy(hdr->addr1, meshda, ETH_ALEN);
518 memcpy(hdr->addr2, meshsa, ETH_ALEN);
519 memcpy(hdr->addr3, meshsa, ETH_ALEN);
520 return 24;
521 } else {
Javier Cardona2154c812011-09-07 17:49:53 -0700522 *fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS);
Javier Cardona3c5772a2009-08-10 12:15:48 -0700523 /* RA TA DA SA */
524 memset(hdr->addr1, 0, ETH_ALEN); /* RA is resolved later */
525 memcpy(hdr->addr2, meshsa, ETH_ALEN);
526 memcpy(hdr->addr3, meshda, ETH_ALEN);
527 memcpy(hdr->addr4, meshsa, ETH_ALEN);
528 return 30;
529 }
530}
531
532/**
Johannes Berg902acc72008-02-23 15:17:19 +0100533 * ieee80211_new_mesh_header - create a new mesh header
Johannes Berg902acc72008-02-23 15:17:19 +0100534 * @sdata: mesh interface to be used
Johannes Bergbf7cd942013-02-15 14:40:31 +0100535 * @meshhdr: uninitialized mesh header
Javier Cardona61ad5392010-12-16 17:23:34 -0800536 * @addr4or5: 1st address in the ae header, which may correspond to address 4
537 * (if addr6 is NULL) or address 5 (if addr6 is present). It may
538 * be NULL.
539 * @addr6: 2nd address in the ae header, which corresponds to addr6 of the
540 * mesh frame
Johannes Berg902acc72008-02-23 15:17:19 +0100541 *
542 * Return the header length.
543 */
Johannes Bergbf7cd942013-02-15 14:40:31 +0100544int ieee80211_new_mesh_header(struct ieee80211_sub_if_data *sdata,
545 struct ieee80211s_hdr *meshhdr,
546 const char *addr4or5, const char *addr6)
Johannes Berg902acc72008-02-23 15:17:19 +0100547{
Johannes Bergbf7cd942013-02-15 14:40:31 +0100548 if (WARN_ON(!addr4or5 && addr6))
549 return 0;
550
Julia Lawall0c3cee72009-12-09 20:25:59 +0100551 memset(meshhdr, 0, sizeof(*meshhdr));
Johannes Bergbf7cd942013-02-15 14:40:31 +0100552
Johannes Berg472dbc42008-09-11 00:01:49 +0200553 meshhdr->ttl = sdata->u.mesh.mshcfg.dot11MeshTTL;
Johannes Bergbf7cd942013-02-15 14:40:31 +0100554
555 /* FIXME: racy -- TX on multiple queues can be concurrent */
Johannes Berg472dbc42008-09-11 00:01:49 +0200556 put_unaligned(cpu_to_le32(sdata->u.mesh.mesh_seqnum), &meshhdr->seqnum);
557 sdata->u.mesh.mesh_seqnum++;
Johannes Bergbf7cd942013-02-15 14:40:31 +0100558
Javier Cardona61ad5392010-12-16 17:23:34 -0800559 if (addr4or5 && !addr6) {
Javier Cardona3c5772a2009-08-10 12:15:48 -0700560 meshhdr->flags |= MESH_FLAGS_AE_A4;
Javier Cardona61ad5392010-12-16 17:23:34 -0800561 memcpy(meshhdr->eaddr1, addr4or5, ETH_ALEN);
Johannes Bergbf7cd942013-02-15 14:40:31 +0100562 return 2 * ETH_ALEN;
Javier Cardona61ad5392010-12-16 17:23:34 -0800563 } else if (addr4or5 && addr6) {
Javier Cardona3c5772a2009-08-10 12:15:48 -0700564 meshhdr->flags |= MESH_FLAGS_AE_A5_A6;
Javier Cardona61ad5392010-12-16 17:23:34 -0800565 memcpy(meshhdr->eaddr1, addr4or5, ETH_ALEN);
566 memcpy(meshhdr->eaddr2, addr6, ETH_ALEN);
Johannes Bergbf7cd942013-02-15 14:40:31 +0100567 return 3 * ETH_ALEN;
Javier Cardona3c5772a2009-08-10 12:15:48 -0700568 }
Johannes Bergbf7cd942013-02-15 14:40:31 +0100569
570 return ETH_ALEN;
Johannes Berg902acc72008-02-23 15:17:19 +0100571}
572
Johannes Bergbf7cd942013-02-15 14:40:31 +0100573static void ieee80211_mesh_housekeeping(struct ieee80211_sub_if_data *sdata)
Johannes Berg472dbc42008-09-11 00:01:49 +0200574{
Johannes Bergbf7cd942013-02-15 14:40:31 +0100575 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
Marco Porschdf323812012-08-08 07:58:43 +0200576 u32 changed;
Johannes Berg472dbc42008-09-11 00:01:49 +0200577
Colleen Twitty66de6712013-06-03 09:53:40 -0700578 ieee80211_sta_expire(sdata, ifmsh->mshcfg.plink_timeout * HZ);
Johannes Berg472dbc42008-09-11 00:01:49 +0200579 mesh_path_expire(sdata);
580
Marco Porschdf323812012-08-08 07:58:43 +0200581 changed = mesh_accept_plinks_update(sdata);
Thomas Pedersen2b5e1962013-02-14 11:20:13 -0800582 ieee80211_mbss_info_change_notify(sdata, changed);
Johannes Berg472dbc42008-09-11 00:01:49 +0200583
Johannes Berg472dbc42008-09-11 00:01:49 +0200584 mod_timer(&ifmsh->housekeeping_timer,
Johannes Bergbf7cd942013-02-15 14:40:31 +0100585 round_jiffies(jiffies +
586 IEEE80211_MESH_HOUSEKEEPING_INTERVAL));
Johannes Berg472dbc42008-09-11 00:01:49 +0200587}
588
Rui Pauloe304bfd2009-11-09 23:46:56 +0000589static void ieee80211_mesh_rootpath(struct ieee80211_sub_if_data *sdata)
590{
591 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
Chun-Yeow Yeoha69cc442012-06-14 02:06:07 +0800592 u32 interval;
Rui Pauloe304bfd2009-11-09 23:46:56 +0000593
594 mesh_path_tx_root_frame(sdata);
Chun-Yeow Yeoha69cc442012-06-14 02:06:07 +0800595
596 if (ifmsh->mshcfg.dot11MeshHWMPRootMode == IEEE80211_PROACTIVE_RANN)
597 interval = ifmsh->mshcfg.dot11MeshHWMPRannInterval;
598 else
599 interval = ifmsh->mshcfg.dot11MeshHWMProotInterval;
600
Rui Pauloe304bfd2009-11-09 23:46:56 +0000601 mod_timer(&ifmsh->mesh_path_root_timer,
Chun-Yeow Yeoha69cc442012-06-14 02:06:07 +0800602 round_jiffies(TU_TO_EXP_TIME(interval)));
Rui Pauloe304bfd2009-11-09 23:46:56 +0000603}
604
Thomas Pedersen2b5e1962013-02-14 11:20:13 -0800605static int
606ieee80211_mesh_build_beacon(struct ieee80211_if_mesh *ifmsh)
607{
608 struct beacon_data *bcn;
609 int head_len, tail_len;
610 struct sk_buff *skb;
611 struct ieee80211_mgmt *mgmt;
612 struct ieee80211_chanctx_conf *chanctx_conf;
613 enum ieee80211_band band;
614 u8 *pos;
615 struct ieee80211_sub_if_data *sdata;
616 int hdr_len = offsetof(struct ieee80211_mgmt, u.beacon) +
617 sizeof(mgmt->u.beacon);
618
619 sdata = container_of(ifmsh, struct ieee80211_sub_if_data, u.mesh);
620 rcu_read_lock();
621 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
622 band = chanctx_conf->def.chan->band;
623 rcu_read_unlock();
624
625 head_len = hdr_len +
626 2 + /* NULL SSID */
627 2 + 8 + /* supported rates */
628 2 + 3; /* DS params */
629 tail_len = 2 + (IEEE80211_MAX_SUPP_RATES - 8) +
630 2 + sizeof(struct ieee80211_ht_cap) +
631 2 + sizeof(struct ieee80211_ht_operation) +
632 2 + ifmsh->mesh_id_len +
633 2 + sizeof(struct ieee80211_meshconf_ie) +
634 2 + sizeof(__le16) + /* awake window */
635 ifmsh->ie_len;
636
637 bcn = kzalloc(sizeof(*bcn) + head_len + tail_len, GFP_KERNEL);
638 /* need an skb for IE builders to operate on */
639 skb = dev_alloc_skb(max(head_len, tail_len));
640
641 if (!bcn || !skb)
642 goto out_free;
643
644 /*
645 * pointers go into the block we allocated,
646 * memory is | beacon_data | head | tail |
647 */
648 bcn->head = ((u8 *) bcn) + sizeof(*bcn);
649
650 /* fill in the head */
651 mgmt = (struct ieee80211_mgmt *) skb_put(skb, hdr_len);
652 memset(mgmt, 0, hdr_len);
653 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
654 IEEE80211_STYPE_BEACON);
655 eth_broadcast_addr(mgmt->da);
656 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
657 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
658 ieee80211_mps_set_frame_flags(sdata, NULL, (void *) mgmt);
659 mgmt->u.beacon.beacon_int =
660 cpu_to_le16(sdata->vif.bss_conf.beacon_int);
661 mgmt->u.beacon.capab_info |= cpu_to_le16(
662 sdata->u.mesh.security ? WLAN_CAPABILITY_PRIVACY : 0);
663
664 pos = skb_put(skb, 2);
665 *pos++ = WLAN_EID_SSID;
666 *pos++ = 0x0;
667
668 if (ieee80211_add_srates_ie(sdata, skb, true, band) ||
Johannes Bergbf7cd942013-02-15 14:40:31 +0100669 mesh_add_ds_params_ie(sdata, skb))
Thomas Pedersen2b5e1962013-02-14 11:20:13 -0800670 goto out_free;
671
672 bcn->head_len = skb->len;
673 memcpy(bcn->head, skb->data, bcn->head_len);
674
675 /* now the tail */
676 skb_trim(skb, 0);
677 bcn->tail = bcn->head + bcn->head_len;
678
679 if (ieee80211_add_ext_srates_ie(sdata, skb, true, band) ||
Johannes Bergbf7cd942013-02-15 14:40:31 +0100680 mesh_add_rsn_ie(sdata, skb) ||
681 mesh_add_ht_cap_ie(sdata, skb) ||
682 mesh_add_ht_oper_ie(sdata, skb) ||
683 mesh_add_meshid_ie(sdata, skb) ||
684 mesh_add_meshconf_ie(sdata, skb) ||
685 mesh_add_awake_window_ie(sdata, skb) ||
686 mesh_add_vendor_ies(sdata, skb))
Thomas Pedersen2b5e1962013-02-14 11:20:13 -0800687 goto out_free;
688
689 bcn->tail_len = skb->len;
690 memcpy(bcn->tail, skb->data, bcn->tail_len);
691
692 dev_kfree_skb(skb);
693 rcu_assign_pointer(ifmsh->beacon, bcn);
694 return 0;
695out_free:
696 kfree(bcn);
697 dev_kfree_skb(skb);
698 return -ENOMEM;
699}
700
701static int
Johannes Berg8d61ffa2013-05-10 12:32:47 +0200702ieee80211_mesh_rebuild_beacon(struct ieee80211_sub_if_data *sdata)
Thomas Pedersen2b5e1962013-02-14 11:20:13 -0800703{
Thomas Pedersen2b5e1962013-02-14 11:20:13 -0800704 struct beacon_data *old_bcn;
705 int ret;
Thomas Pedersen2b5e1962013-02-14 11:20:13 -0800706
Johannes Berg8d61ffa2013-05-10 12:32:47 +0200707 old_bcn = rcu_dereference_protected(sdata->u.mesh.beacon,
708 lockdep_is_held(&sdata->wdev.mtx));
709 ret = ieee80211_mesh_build_beacon(&sdata->u.mesh);
Thomas Pedersen2b5e1962013-02-14 11:20:13 -0800710 if (ret)
711 /* just reuse old beacon */
Johannes Berg8d61ffa2013-05-10 12:32:47 +0200712 return ret;
Thomas Pedersen2b5e1962013-02-14 11:20:13 -0800713
714 if (old_bcn)
715 kfree_rcu(old_bcn, rcu_head);
Johannes Berg8d61ffa2013-05-10 12:32:47 +0200716 return 0;
Thomas Pedersen2b5e1962013-02-14 11:20:13 -0800717}
718
719void ieee80211_mbss_info_change_notify(struct ieee80211_sub_if_data *sdata,
720 u32 changed)
721{
Thomas Pedersenf81a9de2013-06-13 15:54:41 -0700722 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
723 unsigned long bits = changed;
724 u32 bit;
725
726 if (!bits)
727 return;
728
729 /* if we race with running work, worst case this work becomes a noop */
730 for_each_set_bit(bit, &bits, sizeof(changed) * BITS_PER_BYTE)
731 set_bit(bit, &ifmsh->mbss_changed);
732 set_bit(MESH_WORK_MBSS_CHANGED, &ifmsh->wrkq_flags);
733 ieee80211_queue_work(&sdata->local->hw, &sdata->work);
Thomas Pedersen2b5e1962013-02-14 11:20:13 -0800734}
735
736int ieee80211_start_mesh(struct ieee80211_sub_if_data *sdata)
Johannes Berg472dbc42008-09-11 00:01:49 +0200737{
738 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
739 struct ieee80211_local *local = sdata->local;
Chun-Yeow Yeohf4eabc92012-12-13 18:59:57 +0800740 u32 changed = BSS_CHANGED_BEACON |
741 BSS_CHANGED_BEACON_ENABLED |
742 BSS_CHANGED_HT |
743 BSS_CHANGED_BASIC_RATES |
744 BSS_CHANGED_BEACON_INT;
Johannes Berg472dbc42008-09-11 00:01:49 +0200745
Johannes Berg09b17472010-12-03 09:20:41 +0100746 local->fif_other_bss++;
747 /* mesh ifaces must set allmulti to forward mcast traffic */
748 atomic_inc(&local->iff_allmultis);
749 ieee80211_configure_filter(local);
750
Javier Cardonac7108a72010-12-16 17:37:50 -0800751 ifmsh->mesh_cc_id = 0; /* Disabled */
Javier Cardonadbf498f2012-03-31 11:31:32 -0700752 /* register sync ops from extensible synchronization framework */
753 ifmsh->sync_ops = ieee80211_mesh_sync_ops_get(ifmsh->mesh_sp_id);
754 ifmsh->adjusting_tbtt = false;
755 ifmsh->sync_offset_clockdrift_max = 0;
Rui Paulo6b9ac442009-10-20 21:21:48 +0100756 set_bit(MESH_WORK_HOUSEKEEPING, &ifmsh->wrkq_flags);
Rui Paulo63c57232009-11-09 23:46:57 +0000757 ieee80211_mesh_root_setup(ifmsh);
Johannes Berg64592c82010-06-10 10:21:31 +0200758 ieee80211_queue_work(&local->hw, &sdata->work);
Ashok Nagarajan70c33ea2012-04-30 14:20:32 -0700759 sdata->vif.bss_conf.ht_operation_mode =
760 ifmsh->mshcfg.ht_opmode;
Johannes Bergd6a83222012-12-14 14:06:28 +0100761 sdata->vif.bss_conf.enable_beacon = true;
Chun-Yeow Yeohf4eabc92012-12-13 18:59:57 +0800762
Thomas Pedersen39886b62013-02-13 12:14:19 -0800763 changed |= ieee80211_mps_local_status_update(sdata);
Marco Porsch3f52b7e2013-01-30 18:14:08 +0100764
Thomas Pedersen2b5e1962013-02-14 11:20:13 -0800765 if (ieee80211_mesh_build_beacon(ifmsh)) {
766 ieee80211_stop_mesh(sdata);
767 return -ENOMEM;
768 }
769
Chun-Yeow Yeohf4eabc92012-12-13 18:59:57 +0800770 ieee80211_bss_info_change_notify(sdata, changed);
Johannes Bergc405c622012-07-30 19:44:12 +0200771
772 netif_carrier_on(sdata->dev);
Thomas Pedersen2b5e1962013-02-14 11:20:13 -0800773 return 0;
Johannes Berg472dbc42008-09-11 00:01:49 +0200774}
775
776void ieee80211_stop_mesh(struct ieee80211_sub_if_data *sdata)
777{
Johannes Berg09b17472010-12-03 09:20:41 +0100778 struct ieee80211_local *local = sdata->local;
Johannes Berg29cbe682010-12-03 09:20:44 +0100779 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
Thomas Pedersen2b5e1962013-02-14 11:20:13 -0800780 struct beacon_data *bcn;
Johannes Berg29cbe682010-12-03 09:20:44 +0100781
Johannes Bergc405c622012-07-30 19:44:12 +0200782 netif_carrier_off(sdata->dev);
783
Thomas Pedersen0d466b9c2012-08-03 12:21:32 -0700784 /* stop the beacon */
Johannes Berg29cbe682010-12-03 09:20:44 +0100785 ifmsh->mesh_id_len = 0;
Johannes Bergd6a83222012-12-14 14:06:28 +0100786 sdata->vif.bss_conf.enable_beacon = false;
787 clear_bit(SDATA_STATE_OFFCHANNEL_BEACON_STOPPED, &sdata->state);
Johannes Berg29cbe682010-12-03 09:20:44 +0100788 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED);
Thomas Pedersen2b5e1962013-02-14 11:20:13 -0800789 bcn = rcu_dereference_protected(ifmsh->beacon,
Johannes Berg8d61ffa2013-05-10 12:32:47 +0200790 lockdep_is_held(&sdata->wdev.mtx));
Thomas Pedersen2b5e1962013-02-14 11:20:13 -0800791 rcu_assign_pointer(ifmsh->beacon, NULL);
792 kfree_rcu(bcn, rcu_head);
Thomas Pedersen0d466b9c2012-08-03 12:21:32 -0700793
794 /* flush STAs and mpaths on this iface */
Johannes Bergb998e8b2012-12-13 23:07:46 +0100795 sta_info_flush(sdata);
Thomas Pedersen0d466b9c2012-08-03 12:21:32 -0700796 mesh_path_flush_by_iface(sdata);
Johannes Berg09b17472010-12-03 09:20:41 +0100797
Marco Porsch3f52b7e2013-01-30 18:14:08 +0100798 /* free all potentially still buffered group-addressed frames */
799 local->total_ps_buffered -= skb_queue_len(&ifmsh->ps.bc_buf);
800 skb_queue_purge(&ifmsh->ps.bc_buf);
801
Johannes Berg472dbc42008-09-11 00:01:49 +0200802 del_timer_sync(&sdata->u.mesh.housekeeping_timer);
Rui Pauloe304bfd2009-11-09 23:46:56 +0000803 del_timer_sync(&sdata->u.mesh.mesh_path_root_timer);
Johannes Bergdd4c9262012-08-01 21:03:21 +0200804 del_timer_sync(&sdata->u.mesh.mesh_path_timer);
Johannes Berg09b17472010-12-03 09:20:41 +0100805
Thomas Pedersenf81a9de2013-06-13 15:54:41 -0700806 /* clear any mesh work (for next join) we may have accrued */
807 ifmsh->wrkq_flags = 0;
808 ifmsh->mbss_changed = 0;
809
Johannes Berg09b17472010-12-03 09:20:41 +0100810 local->fif_other_bss--;
811 atomic_dec(&local->iff_allmultis);
812 ieee80211_configure_filter(local);
Johannes Berg472dbc42008-09-11 00:01:49 +0200813}
814
Thomas Pedersen9fb04b52013-02-14 11:20:14 -0800815static void
816ieee80211_mesh_rx_probe_req(struct ieee80211_sub_if_data *sdata,
817 struct ieee80211_mgmt *mgmt, size_t len)
818{
819 struct ieee80211_local *local = sdata->local;
820 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
821 struct sk_buff *presp;
822 struct beacon_data *bcn;
823 struct ieee80211_mgmt *hdr;
824 struct ieee802_11_elems elems;
825 size_t baselen;
Johannes Berg511044e2013-03-07 22:47:00 +0100826 u8 *pos;
Thomas Pedersen9fb04b52013-02-14 11:20:14 -0800827
Thomas Pedersen9fb04b52013-02-14 11:20:14 -0800828 pos = mgmt->u.probe_req.variable;
829 baselen = (u8 *) pos - (u8 *) mgmt;
830 if (baselen > len)
831 return;
832
Johannes Bergb2e506b2013-03-26 14:54:16 +0100833 ieee802_11_parse_elems(pos, len - baselen, false, &elems);
Thomas Pedersen9fb04b52013-02-14 11:20:14 -0800834
835 /* 802.11-2012 10.1.4.3.2 */
836 if ((!ether_addr_equal(mgmt->da, sdata->vif.addr) &&
837 !is_broadcast_ether_addr(mgmt->da)) ||
838 elems.ssid_len != 0)
839 return;
840
841 if (elems.mesh_id_len != 0 &&
842 (elems.mesh_id_len != ifmsh->mesh_id_len ||
843 memcmp(elems.mesh_id, ifmsh->mesh_id, ifmsh->mesh_id_len)))
844 return;
845
846 rcu_read_lock();
847 bcn = rcu_dereference(ifmsh->beacon);
848
849 if (!bcn)
850 goto out;
851
852 presp = dev_alloc_skb(local->tx_headroom +
853 bcn->head_len + bcn->tail_len);
854 if (!presp)
855 goto out;
856
857 skb_reserve(presp, local->tx_headroom);
858 memcpy(skb_put(presp, bcn->head_len), bcn->head, bcn->head_len);
859 memcpy(skb_put(presp, bcn->tail_len), bcn->tail, bcn->tail_len);
860 hdr = (struct ieee80211_mgmt *) presp->data;
861 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
862 IEEE80211_STYPE_PROBE_RESP);
863 memcpy(hdr->da, mgmt->sa, ETH_ALEN);
Thomas Pedersen9fb04b52013-02-14 11:20:14 -0800864 IEEE80211_SKB_CB(presp)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
865 ieee80211_tx_skb(sdata, presp);
866out:
867 rcu_read_unlock();
868}
869
Johannes Berg472dbc42008-09-11 00:01:49 +0200870static void ieee80211_mesh_rx_bcn_presp(struct ieee80211_sub_if_data *sdata,
871 u16 stype,
872 struct ieee80211_mgmt *mgmt,
873 size_t len,
874 struct ieee80211_rx_status *rx_status)
875{
Johannes Bergc6a1fa12008-10-07 12:04:32 +0200876 struct ieee80211_local *local = sdata->local;
Javier Cardonadbf498f2012-03-31 11:31:32 -0700877 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
Johannes Berg472dbc42008-09-11 00:01:49 +0200878 struct ieee802_11_elems elems;
879 struct ieee80211_channel *channel;
Johannes Berg472dbc42008-09-11 00:01:49 +0200880 size_t baselen;
881 int freq;
882 enum ieee80211_band band = rx_status->band;
883
884 /* ignore ProbeResp to foreign address */
885 if (stype == IEEE80211_STYPE_PROBE_RESP &&
Joe Perchesb203ca32012-05-08 18:56:52 +0000886 !ether_addr_equal(mgmt->da, sdata->vif.addr))
Johannes Berg472dbc42008-09-11 00:01:49 +0200887 return;
888
889 baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;
890 if (baselen > len)
891 return;
892
893 ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen,
Johannes Bergb2e506b2013-03-26 14:54:16 +0100894 false, &elems);
Johannes Berg472dbc42008-09-11 00:01:49 +0200895
Thomas Pedersen9a90bc82012-10-20 19:03:10 -0700896 /* ignore non-mesh or secure / unsecure mismatch */
897 if ((!elems.mesh_id || !elems.mesh_config) ||
898 (elems.rsn && sdata->u.mesh.security == IEEE80211_MESH_SEC_NONE) ||
899 (!elems.rsn && sdata->u.mesh.security != IEEE80211_MESH_SEC_NONE))
Javier Cardona5cff5e02011-04-07 15:08:29 -0700900 return;
901
Johannes Berg1cd8e882013-03-27 14:30:12 +0100902 if (elems.ds_params)
Bruno Randolf59eb21a2011-01-17 13:37:28 +0900903 freq = ieee80211_channel_to_frequency(elems.ds_params[0], band);
Johannes Berg472dbc42008-09-11 00:01:49 +0200904 else
905 freq = rx_status->freq;
906
907 channel = ieee80211_get_channel(local->hw.wiphy, freq);
908
909 if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)
910 return;
911
Thomas Pedersen9a90bc82012-10-20 19:03:10 -0700912 if (mesh_matches_local(sdata, &elems))
Thomas Pedersenf743ff42012-04-18 19:23:43 -0700913 mesh_neighbour_update(sdata, mgmt->sa, &elems);
Javier Cardonadbf498f2012-03-31 11:31:32 -0700914
915 if (ifmsh->sync_ops)
916 ifmsh->sync_ops->rx_bcn_presp(sdata,
917 stype, mgmt, &elems, rx_status);
Johannes Berg472dbc42008-09-11 00:01:49 +0200918}
919
920static void ieee80211_mesh_rx_mgmt_action(struct ieee80211_sub_if_data *sdata,
921 struct ieee80211_mgmt *mgmt,
922 size_t len,
923 struct ieee80211_rx_status *rx_status)
924{
925 switch (mgmt->u.action.category) {
Thomas Pedersen8db09852011-08-12 20:01:00 -0700926 case WLAN_CATEGORY_SELF_PROTECTED:
927 switch (mgmt->u.action.u.self_prot.action_code) {
928 case WLAN_SP_MESH_PEERING_OPEN:
929 case WLAN_SP_MESH_PEERING_CLOSE:
930 case WLAN_SP_MESH_PEERING_CONFIRM:
931 mesh_rx_plink_frame(sdata, mgmt, len, rx_status);
932 break;
933 }
Johannes Berg472dbc42008-09-11 00:01:49 +0200934 break;
Thomas Pedersen25d49e42011-08-11 19:35:15 -0700935 case WLAN_CATEGORY_MESH_ACTION:
936 if (mesh_action_is_path_sel(mgmt))
937 mesh_rx_path_sel_frame(sdata, mgmt, len);
Johannes Berg472dbc42008-09-11 00:01:49 +0200938 break;
939 }
940}
941
Johannes Berg1fa57d02010-06-10 10:21:32 +0200942void ieee80211_mesh_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
943 struct sk_buff *skb)
Johannes Berg472dbc42008-09-11 00:01:49 +0200944{
945 struct ieee80211_rx_status *rx_status;
Johannes Berg472dbc42008-09-11 00:01:49 +0200946 struct ieee80211_mgmt *mgmt;
947 u16 stype;
948
Thomas Pedersenecccd072013-06-10 13:17:21 -0700949 sdata_lock(sdata);
950
951 /* mesh already went down */
952 if (!sdata->wdev.mesh_id_len)
953 goto out;
954
Johannes Bergf1d58c22009-06-17 13:13:00 +0200955 rx_status = IEEE80211_SKB_RXCB(skb);
Johannes Berg472dbc42008-09-11 00:01:49 +0200956 mgmt = (struct ieee80211_mgmt *) skb->data;
957 stype = le16_to_cpu(mgmt->frame_control) & IEEE80211_FCTL_STYPE;
958
959 switch (stype) {
960 case IEEE80211_STYPE_PROBE_RESP:
961 case IEEE80211_STYPE_BEACON:
962 ieee80211_mesh_rx_bcn_presp(sdata, stype, mgmt, skb->len,
963 rx_status);
964 break;
Thomas Pedersen9fb04b52013-02-14 11:20:14 -0800965 case IEEE80211_STYPE_PROBE_REQ:
966 ieee80211_mesh_rx_probe_req(sdata, mgmt, skb->len);
967 break;
Johannes Berg472dbc42008-09-11 00:01:49 +0200968 case IEEE80211_STYPE_ACTION:
969 ieee80211_mesh_rx_mgmt_action(sdata, mgmt, skb->len, rx_status);
970 break;
971 }
Thomas Pedersenecccd072013-06-10 13:17:21 -0700972out:
973 sdata_unlock(sdata);
Johannes Berg472dbc42008-09-11 00:01:49 +0200974}
975
Thomas Pedersenf81a9de2013-06-13 15:54:41 -0700976static void mesh_bss_info_changed(struct ieee80211_sub_if_data *sdata)
977{
978 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
979 u32 bit, changed = 0;
980
981 for_each_set_bit(bit, &ifmsh->mbss_changed,
982 sizeof(changed) * BITS_PER_BYTE) {
983 clear_bit(bit, &ifmsh->mbss_changed);
984 changed |= BIT(bit);
985 }
986
987 if (sdata->vif.bss_conf.enable_beacon &&
988 (changed & (BSS_CHANGED_BEACON |
989 BSS_CHANGED_HT |
990 BSS_CHANGED_BASIC_RATES |
991 BSS_CHANGED_BEACON_INT)))
992 if (ieee80211_mesh_rebuild_beacon(sdata))
993 return;
994
995 ieee80211_bss_info_change_notify(sdata, changed);
996}
997
Johannes Berg1fa57d02010-06-10 10:21:32 +0200998void ieee80211_mesh_work(struct ieee80211_sub_if_data *sdata)
Johannes Berg472dbc42008-09-11 00:01:49 +0200999{
Johannes Berg472dbc42008-09-11 00:01:49 +02001000 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
Johannes Berg472dbc42008-09-11 00:01:49 +02001001
Thomas Pedersenecccd072013-06-10 13:17:21 -07001002 sdata_lock(sdata);
1003
1004 /* mesh already went down */
1005 if (!sdata->wdev.mesh_id_len)
1006 goto out;
1007
Johannes Berg472dbc42008-09-11 00:01:49 +02001008 if (ifmsh->preq_queue_len &&
1009 time_after(jiffies,
1010 ifmsh->last_preq + msecs_to_jiffies(ifmsh->mshcfg.dot11MeshHWMPpreqMinInterval)))
1011 mesh_path_start_discovery(sdata);
1012
Javier Cardona18889232009-08-10 12:15:52 -07001013 if (test_and_clear_bit(MESH_WORK_GROW_MPATH_TABLE, &ifmsh->wrkq_flags))
1014 mesh_mpath_table_grow();
1015
Nick Ledovskikhdcac9082011-01-11 14:35:12 +00001016 if (test_and_clear_bit(MESH_WORK_GROW_MPP_TABLE, &ifmsh->wrkq_flags))
Javier Cardona18889232009-08-10 12:15:52 -07001017 mesh_mpp_table_grow();
1018
1019 if (test_and_clear_bit(MESH_WORK_HOUSEKEEPING, &ifmsh->wrkq_flags))
Johannes Bergbf7cd942013-02-15 14:40:31 +01001020 ieee80211_mesh_housekeeping(sdata);
Rui Pauloe304bfd2009-11-09 23:46:56 +00001021
1022 if (test_and_clear_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags))
1023 ieee80211_mesh_rootpath(sdata);
Javier Cardonadbf498f2012-03-31 11:31:32 -07001024
1025 if (test_and_clear_bit(MESH_WORK_DRIFT_ADJUST, &ifmsh->wrkq_flags))
1026 mesh_sync_adjust_tbtt(sdata);
Thomas Pedersenecccd072013-06-10 13:17:21 -07001027
Thomas Pedersenf81a9de2013-06-13 15:54:41 -07001028 if (test_and_clear_bit(MESH_WORK_MBSS_CHANGED, &ifmsh->wrkq_flags))
1029 mesh_bss_info_changed(sdata);
Thomas Pedersenecccd072013-06-10 13:17:21 -07001030out:
1031 sdata_unlock(sdata);
Johannes Berg472dbc42008-09-11 00:01:49 +02001032}
1033
1034void ieee80211_mesh_notify_scan_completed(struct ieee80211_local *local)
1035{
1036 struct ieee80211_sub_if_data *sdata;
1037
1038 rcu_read_lock();
1039 list_for_each_entry_rcu(sdata, &local->interfaces, list)
Ben Greear370bd002013-03-19 17:50:50 -07001040 if (ieee80211_vif_is_mesh(&sdata->vif) &&
1041 ieee80211_sdata_running(sdata))
Johannes Berg64592c82010-06-10 10:21:31 +02001042 ieee80211_queue_work(&local->hw, &sdata->work);
Johannes Berg472dbc42008-09-11 00:01:49 +02001043 rcu_read_unlock();
1044}
1045
Johannes Berg902acc72008-02-23 15:17:19 +01001046void ieee80211_mesh_init_sdata(struct ieee80211_sub_if_data *sdata)
1047{
Johannes Berg472dbc42008-09-11 00:01:49 +02001048 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
Johannes Bergad2d2232012-12-14 14:34:25 +01001049 static u8 zero_addr[ETH_ALEN] = {};
Johannes Berg902acc72008-02-23 15:17:19 +01001050
Johannes Berg472dbc42008-09-11 00:01:49 +02001051 setup_timer(&ifmsh->housekeeping_timer,
1052 ieee80211_mesh_housekeeping_timer,
1053 (unsigned long) sdata);
Johannes Berg472dbc42008-09-11 00:01:49 +02001054
Johannes Berg472dbc42008-09-11 00:01:49 +02001055 ifmsh->accepting_plinks = true;
1056 ifmsh->preq_id = 0;
Rui Paulod19b3bf2009-11-09 23:46:55 +00001057 ifmsh->sn = 0;
Javier Cardona5ee68e52011-08-09 16:45:08 -07001058 ifmsh->num_gates = 0;
Johannes Berg472dbc42008-09-11 00:01:49 +02001059 atomic_set(&ifmsh->mpaths, 0);
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +12001060 mesh_rmc_init(sdata);
Johannes Berg472dbc42008-09-11 00:01:49 +02001061 ifmsh->last_preq = jiffies;
Thomas Pedersendca7e942011-11-24 17:15:24 -08001062 ifmsh->next_perr = jiffies;
Johannes Berg902acc72008-02-23 15:17:19 +01001063 /* Allocate all mesh structures when creating the first mesh interface. */
1064 if (!mesh_allocated)
1065 ieee80211s_init();
Johannes Berg472dbc42008-09-11 00:01:49 +02001066 setup_timer(&ifmsh->mesh_path_timer,
Johannes Berg902acc72008-02-23 15:17:19 +01001067 ieee80211_mesh_path_timer,
1068 (unsigned long) sdata);
Rui Pauloe304bfd2009-11-09 23:46:56 +00001069 setup_timer(&ifmsh->mesh_path_root_timer,
1070 ieee80211_mesh_path_root_timer,
1071 (unsigned long) sdata);
Johannes Berg472dbc42008-09-11 00:01:49 +02001072 INIT_LIST_HEAD(&ifmsh->preq_queue.list);
Marco Porsch3f52b7e2013-01-30 18:14:08 +01001073 skb_queue_head_init(&ifmsh->ps.bc_buf);
Johannes Berg472dbc42008-09-11 00:01:49 +02001074 spin_lock_init(&ifmsh->mesh_preq_queue_lock);
Javier Cardonadbf498f2012-03-31 11:31:32 -07001075 spin_lock_init(&ifmsh->sync_offset_lock);
Thomas Pedersen2b5e1962013-02-14 11:20:13 -08001076 RCU_INIT_POINTER(ifmsh->beacon, NULL);
Johannes Bergad2d2232012-12-14 14:34:25 +01001077
1078 sdata->vif.bss_conf.bssid = zero_addr;
Johannes Berg472dbc42008-09-11 00:01:49 +02001079}