blob: e5fbb7cf356250ce75968d8102d4dd87430ef551 [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
Rui Paulo34917072009-11-09 23:46:39 +000016#define MESHCONF_CAPAB_ACCEPT_PLINKS 0x01
17#define MESHCONF_CAPAB_FORWARDING 0x08
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +010018
Johannes Berg5bb644a2009-05-17 11:40:42 +020019#define TMR_RUNNING_HK 0
20#define TMR_RUNNING_MP 1
Rui Pauloe304bfd2009-11-09 23:46:56 +000021#define TMR_RUNNING_MPR 2
Johannes Berg5bb644a2009-05-17 11:40:42 +020022
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +010023int mesh_allocated;
24static struct kmem_cache *rm_cache;
25
Thomas Pedersen25d49e42011-08-11 19:35:15 -070026#ifdef CONFIG_MAC80211_MESH
27bool mesh_action_is_path_sel(struct ieee80211_mgmt *mgmt)
28{
29 return (mgmt->u.action.u.mesh_action.action_code ==
30 WLAN_MESH_ACTION_HWMP_PATH_SELECTION);
31}
32#else
33bool mesh_action_is_path_sel(struct ieee80211_mgmt *mgmt)
34{ return false; }
35#endif
36
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +010037void ieee80211s_init(void)
38{
39 mesh_pathtbl_init();
40 mesh_allocated = 1;
41 rm_cache = kmem_cache_create("mesh_rmc", sizeof(struct rmc_entry),
42 0, 0, NULL);
43}
44
45void ieee80211s_stop(void)
46{
47 mesh_pathtbl_unregister();
48 kmem_cache_destroy(rm_cache);
49}
50
Johannes Berg472dbc42008-09-11 00:01:49 +020051static void ieee80211_mesh_housekeeping_timer(unsigned long data)
52{
53 struct ieee80211_sub_if_data *sdata = (void *) data;
54 struct ieee80211_local *local = sdata->local;
55 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
56
Rui Paulo6b9ac442009-10-20 21:21:48 +010057 set_bit(MESH_WORK_HOUSEKEEPING, &ifmsh->wrkq_flags);
Johannes Berg5bb644a2009-05-17 11:40:42 +020058
59 if (local->quiescing) {
60 set_bit(TMR_RUNNING_HK, &ifmsh->timers_running);
61 return;
62 }
63
Johannes Berg64592c82010-06-10 10:21:31 +020064 ieee80211_queue_work(&local->hw, &sdata->work);
Johannes Berg472dbc42008-09-11 00:01:49 +020065}
66
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +010067/**
68 * mesh_matches_local - check if the config of a mesh point matches ours
69 *
70 * @ie: information elements of a management frame from the mesh peer
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +120071 * @sdata: local mesh subif
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +010072 *
73 * This function checks if the mesh configuration of a mesh point matches the
74 * local mesh configuration, i.e. if both nodes belong to the same mesh network.
75 */
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +120076bool mesh_matches_local(struct ieee802_11_elems *ie, struct ieee80211_sub_if_data *sdata)
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +010077{
Johannes Berg472dbc42008-09-11 00:01:49 +020078 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
Thomas Pedersen739522b2011-10-26 14:47:28 -070079 struct ieee80211_local *local = sdata->local;
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +010080
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +010081 /*
82 * As support for each feature is added, check for matching
83 * - On mesh config capabilities
84 * - Power Save Support En
85 * - Sync support enabled
86 * - Sync support active
87 * - Sync support required from peer
88 * - MDA enabled
89 * - Power management control on fc
90 */
Thomas Pedersen739522b2011-10-26 14:47:28 -070091 if (!(ifmsh->mesh_id_len == ie->mesh_id_len &&
92 memcmp(ifmsh->mesh_id, ie->mesh_id, ie->mesh_id_len) == 0 &&
93 (ifmsh->mesh_pp_id == ie->mesh_config->meshconf_psel) &&
94 (ifmsh->mesh_pm_id == ie->mesh_config->meshconf_pmetric) &&
95 (ifmsh->mesh_cc_id == ie->mesh_config->meshconf_congest) &&
96 (ifmsh->mesh_sp_id == ie->mesh_config->meshconf_synch) &&
97 (ifmsh->mesh_auth_id == ie->mesh_config->meshconf_auth)))
98 goto mismatch;
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +010099
Thomas Pedersen739522b2011-10-26 14:47:28 -0700100 /* disallow peering with mismatched channel types for now */
101 if (ie->ht_info_elem &&
102 (local->_oper_channel_type !=
103 ieee80211_ht_info_to_channel_type(ie->ht_info_elem)))
104 goto mismatch;
105
106 return true;
107mismatch:
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100108 return false;
109}
110
111/**
112 * mesh_peer_accepts_plinks - check if an mp is willing to establish peer links
113 *
114 * @ie: information elements of a management frame from the mesh peer
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100115 */
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200116bool mesh_peer_accepts_plinks(struct ieee802_11_elems *ie)
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100117{
Rui Paulo136cfa22009-11-18 18:40:00 +0000118 return (ie->mesh_config->meshconf_cap &
Rui Paulo34917072009-11-09 23:46:39 +0000119 MESHCONF_CAPAB_ACCEPT_PLINKS) != 0;
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100120}
121
122/**
123 * mesh_accept_plinks_update: update accepting_plink in local mesh beacons
124 *
Johannes Bergd0709a62008-02-25 16:27:46 +0100125 * @sdata: mesh interface in which mesh beacons are going to be updated
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100126 */
Johannes Bergd0709a62008-02-25 16:27:46 +0100127void mesh_accept_plinks_update(struct ieee80211_sub_if_data *sdata)
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100128{
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100129 bool free_plinks;
130
131 /* In case mesh_plink_free_count > 0 and mesh_plinktbl_capacity == 0,
132 * the mesh interface might be able to establish plinks with peers that
Luis Carlos Cobob4e08ea2008-02-29 15:46:08 -0800133 * are already on the table but are not on PLINK_ESTAB state. However,
134 * in general the mesh interface is not accepting peer link requests
135 * from new peers, and that must be reflected in the beacon
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100136 */
137 free_plinks = mesh_plink_availables(sdata);
138
Johannes Berg472dbc42008-09-11 00:01:49 +0200139 if (free_plinks != sdata->u.mesh.accepting_plinks)
140 ieee80211_mesh_housekeeping_timer((unsigned long) sdata);
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100141}
142
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200143int mesh_rmc_init(struct ieee80211_sub_if_data *sdata)
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100144{
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100145 int i;
146
Johannes Berg472dbc42008-09-11 00:01:49 +0200147 sdata->u.mesh.rmc = kmalloc(sizeof(struct mesh_rmc), GFP_KERNEL);
148 if (!sdata->u.mesh.rmc)
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100149 return -ENOMEM;
Johannes Berg472dbc42008-09-11 00:01:49 +0200150 sdata->u.mesh.rmc->idx_mask = RMC_BUCKETS - 1;
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100151 for (i = 0; i < RMC_BUCKETS; i++)
Johannes Berg472dbc42008-09-11 00:01:49 +0200152 INIT_LIST_HEAD(&sdata->u.mesh.rmc->bucket[i].list);
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100153 return 0;
154}
155
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200156void mesh_rmc_free(struct ieee80211_sub_if_data *sdata)
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100157{
Johannes Berg472dbc42008-09-11 00:01:49 +0200158 struct mesh_rmc *rmc = sdata->u.mesh.rmc;
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100159 struct rmc_entry *p, *n;
160 int i;
161
Johannes Berg472dbc42008-09-11 00:01:49 +0200162 if (!sdata->u.mesh.rmc)
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100163 return;
164
165 for (i = 0; i < RMC_BUCKETS; i++)
166 list_for_each_entry_safe(p, n, &rmc->bucket[i].list, list) {
167 list_del(&p->list);
168 kmem_cache_free(rm_cache, p);
169 }
170
171 kfree(rmc);
Johannes Berg472dbc42008-09-11 00:01:49 +0200172 sdata->u.mesh.rmc = NULL;
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100173}
174
175/**
176 * mesh_rmc_check - Check frame in recent multicast cache and add if absent.
177 *
178 * @sa: source address
179 * @mesh_hdr: mesh_header
180 *
181 * Returns: 0 if the frame is not in the cache, nonzero otherwise.
182 *
183 * Checks using the source address and the mesh sequence number if we have
184 * received this frame lately. If the frame is not in the cache, it is added to
185 * it.
186 */
187int mesh_rmc_check(u8 *sa, struct ieee80211s_hdr *mesh_hdr,
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200188 struct ieee80211_sub_if_data *sdata)
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100189{
Johannes Berg472dbc42008-09-11 00:01:49 +0200190 struct mesh_rmc *rmc = sdata->u.mesh.rmc;
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100191 u32 seqnum = 0;
192 int entries = 0;
193 u8 idx;
194 struct rmc_entry *p, *n;
195
196 /* Don't care about endianness since only match matters */
Luis Carlos Cobo51cedda2008-04-23 12:15:29 -0700197 memcpy(&seqnum, &mesh_hdr->seqnum, sizeof(mesh_hdr->seqnum));
198 idx = le32_to_cpu(mesh_hdr->seqnum) & rmc->idx_mask;
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100199 list_for_each_entry_safe(p, n, &rmc->bucket[idx].list, list) {
200 ++entries;
201 if (time_after(jiffies, p->exp_time) ||
202 (entries == RMC_QUEUE_MAX_LEN)) {
203 list_del(&p->list);
204 kmem_cache_free(rm_cache, p);
205 --entries;
Joe Perchesf64f9e72009-11-29 16:55:45 -0800206 } else if ((seqnum == p->seqnum) &&
Felix Fietkau888d04d2012-03-01 15:22:09 +0100207 (compare_ether_addr(sa, p->sa) == 0))
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100208 return -1;
209 }
210
211 p = kmem_cache_alloc(rm_cache, GFP_ATOMIC);
Joe Perchesd15b8452011-08-29 14:17:31 -0700212 if (!p)
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100213 return 0;
Joe Perchesd15b8452011-08-29 14:17:31 -0700214
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100215 p->seqnum = seqnum;
216 p->exp_time = jiffies + RMC_TIMEOUT;
217 memcpy(p->sa, sa, ETH_ALEN);
218 list_add(&p->list, &rmc->bucket[idx].list);
219 return 0;
220}
221
Thomas Pedersen082ebb02011-08-11 19:35:10 -0700222int
223mesh_add_meshconf_ie(struct sk_buff *skb, struct ieee80211_sub_if_data *sdata)
224{
225 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
226 u8 *pos, neighbors;
227 u8 meshconf_len = sizeof(struct ieee80211_meshconf_ie);
228
229 if (skb_tailroom(skb) < 2 + meshconf_len)
230 return -ENOMEM;
231
232 pos = skb_put(skb, 2 + meshconf_len);
233 *pos++ = WLAN_EID_MESH_CONFIG;
234 *pos++ = meshconf_len;
235
236 /* Active path selection protocol ID */
237 *pos++ = ifmsh->mesh_pp_id;
238 /* Active path selection metric ID */
239 *pos++ = ifmsh->mesh_pm_id;
240 /* Congestion control mode identifier */
241 *pos++ = ifmsh->mesh_cc_id;
242 /* Synchronization protocol identifier */
243 *pos++ = ifmsh->mesh_sp_id;
244 /* Authentication Protocol identifier */
245 *pos++ = ifmsh->mesh_auth_id;
246 /* Mesh Formation Info - number of neighbors */
247 neighbors = atomic_read(&ifmsh->mshstats.estab_plinks);
248 /* Number of neighbor mesh STAs or 15 whichever is smaller */
249 neighbors = (neighbors > 15) ? 15 : neighbors;
250 *pos++ = neighbors << 1;
251 /* Mesh capability */
252 ifmsh->accepting_plinks = mesh_plink_availables(sdata);
253 *pos = MESHCONF_CAPAB_FORWARDING;
254 *pos++ |= ifmsh->accepting_plinks ?
255 MESHCONF_CAPAB_ACCEPT_PLINKS : 0x00;
256 *pos++ = 0x00;
257
258 return 0;
259}
260
261int
262mesh_add_meshid_ie(struct sk_buff *skb, struct ieee80211_sub_if_data *sdata)
263{
264 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
265 u8 *pos;
266
267 if (skb_tailroom(skb) < 2 + ifmsh->mesh_id_len)
268 return -ENOMEM;
269
270 pos = skb_put(skb, 2 + ifmsh->mesh_id_len);
271 *pos++ = WLAN_EID_MESH_ID;
272 *pos++ = ifmsh->mesh_id_len;
273 if (ifmsh->mesh_id_len)
274 memcpy(pos, ifmsh->mesh_id, ifmsh->mesh_id_len);
275
276 return 0;
277}
278
279int
280mesh_add_vendor_ies(struct sk_buff *skb, struct ieee80211_sub_if_data *sdata)
281{
282 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
283 u8 offset, len;
284 const u8 *data;
285
286 if (!ifmsh->ie || !ifmsh->ie_len)
287 return 0;
288
289 /* fast-forward to vendor IEs */
290 offset = ieee80211_ie_split_vendor(ifmsh->ie, ifmsh->ie_len, 0);
291
292 if (offset) {
293 len = ifmsh->ie_len - offset;
294 data = ifmsh->ie + offset;
295 if (skb_tailroom(skb) < len)
296 return -ENOMEM;
297 memcpy(skb_put(skb, len), data, len);
298 }
299
300 return 0;
301}
302
303int
304mesh_add_rsn_ie(struct sk_buff *skb, struct ieee80211_sub_if_data *sdata)
305{
306 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
307 u8 len = 0;
308 const u8 *data;
309
310 if (!ifmsh->ie || !ifmsh->ie_len)
311 return 0;
312
313 /* find RSN IE */
314 data = ifmsh->ie;
315 while (data < ifmsh->ie + ifmsh->ie_len) {
316 if (*data == WLAN_EID_RSN) {
317 len = data[1] + 2;
318 break;
319 }
320 data++;
321 }
322
323 if (len) {
324 if (skb_tailroom(skb) < len)
325 return -ENOMEM;
326 memcpy(skb_put(skb, len), data, len);
327 }
328
329 return 0;
330}
331
Thomas Pedersen082ebb02011-08-11 19:35:10 -0700332int mesh_add_ds_params_ie(struct sk_buff *skb,
333 struct ieee80211_sub_if_data *sdata)
334{
335 struct ieee80211_local *local = sdata->local;
336 struct ieee80211_supported_band *sband;
337 u8 *pos;
338
339 if (skb_tailroom(skb) < 3)
340 return -ENOMEM;
341
342 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
Rui Paulobe125c62009-11-09 23:46:54 +0000343 if (sband->band == IEEE80211_BAND_2GHZ) {
344 pos = skb_put(skb, 2 + 1);
345 *pos++ = WLAN_EID_DS_PARAMS;
346 *pos++ = 1;
347 *pos++ = ieee80211_frequency_to_channel(local->hw.conf.channel->center_freq);
348 }
349
Thomas Pedersen082ebb02011-08-11 19:35:10 -0700350 return 0;
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100351}
352
Thomas Pedersen176f3602011-10-26 14:47:27 -0700353int mesh_add_ht_cap_ie(struct sk_buff *skb,
354 struct ieee80211_sub_if_data *sdata)
355{
356 struct ieee80211_local *local = sdata->local;
357 struct ieee80211_supported_band *sband;
358 u8 *pos;
359
360 sband = local->hw.wiphy->bands[local->oper_channel->band];
361 if (!sband->ht_cap.ht_supported ||
362 local->_oper_channel_type == NL80211_CHAN_NO_HT)
363 return 0;
364
365 if (skb_tailroom(skb) < 2 + sizeof(struct ieee80211_ht_cap))
366 return -ENOMEM;
367
368 pos = skb_put(skb, 2 + sizeof(struct ieee80211_ht_cap));
Ben Greearef96a8422011-11-18 11:32:00 -0800369 ieee80211_ie_build_ht_cap(pos, &sband->ht_cap, sband->ht_cap.cap);
Thomas Pedersen176f3602011-10-26 14:47:27 -0700370
371 return 0;
372}
373
374int mesh_add_ht_info_ie(struct sk_buff *skb,
375 struct ieee80211_sub_if_data *sdata)
376{
377 struct ieee80211_local *local = sdata->local;
378 struct ieee80211_channel *channel = local->oper_channel;
379 enum nl80211_channel_type channel_type = local->_oper_channel_type;
380 struct ieee80211_supported_band *sband =
381 local->hw.wiphy->bands[channel->band];
382 struct ieee80211_sta_ht_cap *ht_cap = &sband->ht_cap;
383 u8 *pos;
384
385 if (!ht_cap->ht_supported || channel_type == NL80211_CHAN_NO_HT)
386 return 0;
387
388 if (skb_tailroom(skb) < 2 + sizeof(struct ieee80211_ht_info))
389 return -ENOMEM;
390
391 pos = skb_put(skb, 2 + sizeof(struct ieee80211_ht_info));
392 ieee80211_ie_build_ht_info(pos, ht_cap, channel, channel_type);
393
394 return 0;
395}
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100396static void ieee80211_mesh_path_timer(unsigned long data)
397{
398 struct ieee80211_sub_if_data *sdata =
399 (struct ieee80211_sub_if_data *) data;
Johannes Berg472dbc42008-09-11 00:01:49 +0200400 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
Johannes Berg133b8222008-09-16 14:18:59 +0200401 struct ieee80211_local *local = sdata->local;
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100402
Johannes Berg5bb644a2009-05-17 11:40:42 +0200403 if (local->quiescing) {
404 set_bit(TMR_RUNNING_MP, &ifmsh->timers_running);
405 return;
406 }
407
Johannes Berg64592c82010-06-10 10:21:31 +0200408 ieee80211_queue_work(&local->hw, &sdata->work);
Luis Carlos Cobo2e3c8732008-02-23 15:17:09 +0100409}
410
Rui Pauloe304bfd2009-11-09 23:46:56 +0000411static void ieee80211_mesh_path_root_timer(unsigned long data)
412{
413 struct ieee80211_sub_if_data *sdata =
414 (struct ieee80211_sub_if_data *) data;
415 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
416 struct ieee80211_local *local = sdata->local;
417
418 set_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags);
419
420 if (local->quiescing) {
421 set_bit(TMR_RUNNING_MPR, &ifmsh->timers_running);
422 return;
423 }
424
Johannes Berg64592c82010-06-10 10:21:31 +0200425 ieee80211_queue_work(&local->hw, &sdata->work);
Rui Pauloe304bfd2009-11-09 23:46:56 +0000426}
427
Rui Paulo63c57232009-11-09 23:46:57 +0000428void ieee80211_mesh_root_setup(struct ieee80211_if_mesh *ifmsh)
429{
430 if (ifmsh->mshcfg.dot11MeshHWMPRootMode)
431 set_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags);
432 else {
433 clear_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags);
434 /* stop running timer */
435 del_timer_sync(&ifmsh->mesh_path_root_timer);
436 }
437}
438
Johannes Berg902acc72008-02-23 15:17:19 +0100439/**
Javier Cardona3c5772a2009-08-10 12:15:48 -0700440 * ieee80211_fill_mesh_addresses - fill addresses of a locally originated mesh frame
441 * @hdr: 802.11 frame header
442 * @fc: frame control field
443 * @meshda: destination address in the mesh
444 * @meshsa: source address address in the mesh. Same as TA, as frame is
445 * locally originated.
446 *
447 * Return the length of the 802.11 (does not include a mesh control header)
448 */
Johannes Berg15ff6362009-11-17 13:34:04 +0100449int ieee80211_fill_mesh_addresses(struct ieee80211_hdr *hdr, __le16 *fc,
450 const u8 *meshda, const u8 *meshsa)
451{
Javier Cardona3c5772a2009-08-10 12:15:48 -0700452 if (is_multicast_ether_addr(meshda)) {
453 *fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS);
454 /* DA TA SA */
455 memcpy(hdr->addr1, meshda, ETH_ALEN);
456 memcpy(hdr->addr2, meshsa, ETH_ALEN);
457 memcpy(hdr->addr3, meshsa, ETH_ALEN);
458 return 24;
459 } else {
Javier Cardona2154c812011-09-07 17:49:53 -0700460 *fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS);
Javier Cardona3c5772a2009-08-10 12:15:48 -0700461 /* RA TA DA SA */
462 memset(hdr->addr1, 0, ETH_ALEN); /* RA is resolved later */
463 memcpy(hdr->addr2, meshsa, ETH_ALEN);
464 memcpy(hdr->addr3, meshda, ETH_ALEN);
465 memcpy(hdr->addr4, meshsa, ETH_ALEN);
466 return 30;
467 }
468}
469
470/**
Johannes Berg902acc72008-02-23 15:17:19 +0100471 * ieee80211_new_mesh_header - create a new mesh header
472 * @meshhdr: uninitialized mesh header
473 * @sdata: mesh interface to be used
Javier Cardona61ad5392010-12-16 17:23:34 -0800474 * @addr4or5: 1st address in the ae header, which may correspond to address 4
475 * (if addr6 is NULL) or address 5 (if addr6 is present). It may
476 * be NULL.
477 * @addr6: 2nd address in the ae header, which corresponds to addr6 of the
478 * mesh frame
Johannes Berg902acc72008-02-23 15:17:19 +0100479 *
480 * Return the header length.
481 */
482int ieee80211_new_mesh_header(struct ieee80211s_hdr *meshhdr,
Javier Cardona61ad5392010-12-16 17:23:34 -0800483 struct ieee80211_sub_if_data *sdata, char *addr4or5,
484 char *addr6)
Johannes Berg902acc72008-02-23 15:17:19 +0100485{
Javier Cardona3c5772a2009-08-10 12:15:48 -0700486 int aelen = 0;
Javier Cardona61ad5392010-12-16 17:23:34 -0800487 BUG_ON(!addr4or5 && addr6);
Julia Lawall0c3cee72009-12-09 20:25:59 +0100488 memset(meshhdr, 0, sizeof(*meshhdr));
Johannes Berg472dbc42008-09-11 00:01:49 +0200489 meshhdr->ttl = sdata->u.mesh.mshcfg.dot11MeshTTL;
490 put_unaligned(cpu_to_le32(sdata->u.mesh.mesh_seqnum), &meshhdr->seqnum);
491 sdata->u.mesh.mesh_seqnum++;
Javier Cardona61ad5392010-12-16 17:23:34 -0800492 if (addr4or5 && !addr6) {
Javier Cardona3c5772a2009-08-10 12:15:48 -0700493 meshhdr->flags |= MESH_FLAGS_AE_A4;
494 aelen += ETH_ALEN;
Javier Cardona61ad5392010-12-16 17:23:34 -0800495 memcpy(meshhdr->eaddr1, addr4or5, ETH_ALEN);
496 } else if (addr4or5 && addr6) {
Javier Cardona3c5772a2009-08-10 12:15:48 -0700497 meshhdr->flags |= MESH_FLAGS_AE_A5_A6;
498 aelen += 2 * ETH_ALEN;
Javier Cardona61ad5392010-12-16 17:23:34 -0800499 memcpy(meshhdr->eaddr1, addr4or5, ETH_ALEN);
500 memcpy(meshhdr->eaddr2, addr6, ETH_ALEN);
Javier Cardona3c5772a2009-08-10 12:15:48 -0700501 }
502 return 6 + aelen;
Johannes Berg902acc72008-02-23 15:17:19 +0100503}
504
Johannes Berg472dbc42008-09-11 00:01:49 +0200505static void ieee80211_mesh_housekeeping(struct ieee80211_sub_if_data *sdata,
506 struct ieee80211_if_mesh *ifmsh)
507{
508 bool free_plinks;
509
510#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
511 printk(KERN_DEBUG "%s: running mesh housekeeping\n",
Johannes Berg47846c92009-11-25 17:46:19 +0100512 sdata->name);
Johannes Berg472dbc42008-09-11 00:01:49 +0200513#endif
514
515 ieee80211_sta_expire(sdata, IEEE80211_MESH_PEER_INACTIVITY_LIMIT);
516 mesh_path_expire(sdata);
517
518 free_plinks = mesh_plink_availables(sdata);
519 if (free_plinks != sdata->u.mesh.accepting_plinks)
Johannes Berg2d0ddec2009-04-23 16:13:26 +0200520 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON);
Johannes Berg472dbc42008-09-11 00:01:49 +0200521
Johannes Berg472dbc42008-09-11 00:01:49 +0200522 mod_timer(&ifmsh->housekeeping_timer,
523 round_jiffies(jiffies + IEEE80211_MESH_HOUSEKEEPING_INTERVAL));
524}
525
Rui Pauloe304bfd2009-11-09 23:46:56 +0000526static void ieee80211_mesh_rootpath(struct ieee80211_sub_if_data *sdata)
527{
528 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
529
530 mesh_path_tx_root_frame(sdata);
531 mod_timer(&ifmsh->mesh_path_root_timer,
Thomas Pedersenc61336612011-08-25 10:36:14 -0700532 round_jiffies(TU_TO_EXP_TIME(
533 ifmsh->mshcfg.dot11MeshHWMPRannInterval)));
Rui Pauloe304bfd2009-11-09 23:46:56 +0000534}
535
Johannes Berg5bb644a2009-05-17 11:40:42 +0200536#ifdef CONFIG_PM
537void ieee80211_mesh_quiesce(struct ieee80211_sub_if_data *sdata)
538{
539 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
540
Javier Cardona5ee68e52011-08-09 16:45:08 -0700541 /* use atomic bitops in case all timers fire at the same time */
Johannes Berg5bb644a2009-05-17 11:40:42 +0200542
543 if (del_timer_sync(&ifmsh->housekeeping_timer))
544 set_bit(TMR_RUNNING_HK, &ifmsh->timers_running);
545 if (del_timer_sync(&ifmsh->mesh_path_timer))
546 set_bit(TMR_RUNNING_MP, &ifmsh->timers_running);
Rui Pauloe304bfd2009-11-09 23:46:56 +0000547 if (del_timer_sync(&ifmsh->mesh_path_root_timer))
548 set_bit(TMR_RUNNING_MPR, &ifmsh->timers_running);
Johannes Berg5bb644a2009-05-17 11:40:42 +0200549}
550
551void ieee80211_mesh_restart(struct ieee80211_sub_if_data *sdata)
552{
553 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
554
555 if (test_and_clear_bit(TMR_RUNNING_HK, &ifmsh->timers_running))
556 add_timer(&ifmsh->housekeeping_timer);
557 if (test_and_clear_bit(TMR_RUNNING_MP, &ifmsh->timers_running))
558 add_timer(&ifmsh->mesh_path_timer);
Rui Pauloe304bfd2009-11-09 23:46:56 +0000559 if (test_and_clear_bit(TMR_RUNNING_MPR, &ifmsh->timers_running))
560 add_timer(&ifmsh->mesh_path_root_timer);
Rui Paulo63c57232009-11-09 23:46:57 +0000561 ieee80211_mesh_root_setup(ifmsh);
Johannes Berg5bb644a2009-05-17 11:40:42 +0200562}
563#endif
Johannes Berg472dbc42008-09-11 00:01:49 +0200564
565void ieee80211_start_mesh(struct ieee80211_sub_if_data *sdata)
566{
567 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
568 struct ieee80211_local *local = sdata->local;
569
Johannes Berg09b17472010-12-03 09:20:41 +0100570 local->fif_other_bss++;
571 /* mesh ifaces must set allmulti to forward mcast traffic */
572 atomic_inc(&local->iff_allmultis);
573 ieee80211_configure_filter(local);
574
Javier Cardonac7108a72010-12-16 17:37:50 -0800575 ifmsh->mesh_cc_id = 0; /* Disabled */
576 ifmsh->mesh_sp_id = 0; /* Neighbor Offset */
577 ifmsh->mesh_auth_id = 0; /* Disabled */
Rui Paulo6b9ac442009-10-20 21:21:48 +0100578 set_bit(MESH_WORK_HOUSEKEEPING, &ifmsh->wrkq_flags);
Rui Paulo63c57232009-11-09 23:46:57 +0000579 ieee80211_mesh_root_setup(ifmsh);
Johannes Berg64592c82010-06-10 10:21:31 +0200580 ieee80211_queue_work(&local->hw, &sdata->work);
Javier Cardona5b365832009-08-10 12:15:51 -0700581 sdata->vif.bss_conf.beacon_int = MESH_DEFAULT_BEACON_INTERVAL;
Johannes Berg2d0ddec2009-04-23 16:13:26 +0200582 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON |
Javier Cardona5b365832009-08-10 12:15:51 -0700583 BSS_CHANGED_BEACON_ENABLED |
584 BSS_CHANGED_BEACON_INT);
Johannes Berg472dbc42008-09-11 00:01:49 +0200585}
586
587void ieee80211_stop_mesh(struct ieee80211_sub_if_data *sdata)
588{
Johannes Berg09b17472010-12-03 09:20:41 +0100589 struct ieee80211_local *local = sdata->local;
Johannes Berg29cbe682010-12-03 09:20:44 +0100590 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
591
592 ifmsh->mesh_id_len = 0;
593 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED);
594 sta_info_flush(local, NULL);
Johannes Berg09b17472010-12-03 09:20:41 +0100595
Johannes Berg472dbc42008-09-11 00:01:49 +0200596 del_timer_sync(&sdata->u.mesh.housekeeping_timer);
Rui Pauloe304bfd2009-11-09 23:46:56 +0000597 del_timer_sync(&sdata->u.mesh.mesh_path_root_timer);
Johannes Berg472dbc42008-09-11 00:01:49 +0200598 /*
Johannes Bergb7413432008-09-11 00:01:50 +0200599 * If the timer fired while we waited for it, it will have
600 * requeued the work. Now the work will be running again
601 * but will not rearm the timer again because it checks
602 * whether the interface is running, which, at this point,
603 * it no longer is.
604 */
Johannes Berg64592c82010-06-10 10:21:31 +0200605 cancel_work_sync(&sdata->work);
Johannes Berg09b17472010-12-03 09:20:41 +0100606
607 local->fif_other_bss--;
608 atomic_dec(&local->iff_allmultis);
609 ieee80211_configure_filter(local);
Johannes Berg472dbc42008-09-11 00:01:49 +0200610}
611
612static void ieee80211_mesh_rx_bcn_presp(struct ieee80211_sub_if_data *sdata,
613 u16 stype,
614 struct ieee80211_mgmt *mgmt,
615 size_t len,
616 struct ieee80211_rx_status *rx_status)
617{
Johannes Bergc6a1fa12008-10-07 12:04:32 +0200618 struct ieee80211_local *local = sdata->local;
Johannes Berg472dbc42008-09-11 00:01:49 +0200619 struct ieee802_11_elems elems;
620 struct ieee80211_channel *channel;
Johannes Berg881d9482009-01-21 15:13:48 +0100621 u32 supp_rates = 0;
Johannes Berg472dbc42008-09-11 00:01:49 +0200622 size_t baselen;
623 int freq;
624 enum ieee80211_band band = rx_status->band;
625
626 /* ignore ProbeResp to foreign address */
627 if (stype == IEEE80211_STYPE_PROBE_RESP &&
Johannes Berg47846c92009-11-25 17:46:19 +0100628 compare_ether_addr(mgmt->da, sdata->vif.addr))
Johannes Berg472dbc42008-09-11 00:01:49 +0200629 return;
630
631 baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;
632 if (baselen > len)
633 return;
634
635 ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen,
636 &elems);
637
Javier Cardona5cff5e02011-04-07 15:08:29 -0700638 /* ignore beacons from secure mesh peers if our security is off */
Javier Cardonab130e5c2011-05-03 16:57:07 -0700639 if (elems.rsn_len && sdata->u.mesh.security == IEEE80211_MESH_SEC_NONE)
Javier Cardona5cff5e02011-04-07 15:08:29 -0700640 return;
641
Johannes Berg472dbc42008-09-11 00:01:49 +0200642 if (elems.ds_params && elems.ds_params_len == 1)
Bruno Randolf59eb21a2011-01-17 13:37:28 +0900643 freq = ieee80211_channel_to_frequency(elems.ds_params[0], band);
Johannes Berg472dbc42008-09-11 00:01:49 +0200644 else
645 freq = rx_status->freq;
646
647 channel = ieee80211_get_channel(local->hw.wiphy, freq);
648
649 if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)
650 return;
651
652 if (elems.mesh_id && elems.mesh_config &&
653 mesh_matches_local(&elems, sdata)) {
654 supp_rates = ieee80211_sta_get_rates(local, &elems, band);
Javier Cardona1570ca52011-04-07 15:08:35 -0700655 mesh_neighbour_update(mgmt->sa, supp_rates, sdata, &elems);
Johannes Berg472dbc42008-09-11 00:01:49 +0200656 }
657}
658
659static void ieee80211_mesh_rx_mgmt_action(struct ieee80211_sub_if_data *sdata,
660 struct ieee80211_mgmt *mgmt,
661 size_t len,
662 struct ieee80211_rx_status *rx_status)
663{
664 switch (mgmt->u.action.category) {
Thomas Pedersen8db09852011-08-12 20:01:00 -0700665 case WLAN_CATEGORY_SELF_PROTECTED:
666 switch (mgmt->u.action.u.self_prot.action_code) {
667 case WLAN_SP_MESH_PEERING_OPEN:
668 case WLAN_SP_MESH_PEERING_CLOSE:
669 case WLAN_SP_MESH_PEERING_CONFIRM:
670 mesh_rx_plink_frame(sdata, mgmt, len, rx_status);
671 break;
672 }
Johannes Berg472dbc42008-09-11 00:01:49 +0200673 break;
Thomas Pedersen25d49e42011-08-11 19:35:15 -0700674 case WLAN_CATEGORY_MESH_ACTION:
675 if (mesh_action_is_path_sel(mgmt))
676 mesh_rx_path_sel_frame(sdata, mgmt, len);
Johannes Berg472dbc42008-09-11 00:01:49 +0200677 break;
678 }
679}
680
Johannes Berg1fa57d02010-06-10 10:21:32 +0200681void ieee80211_mesh_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
682 struct sk_buff *skb)
Johannes Berg472dbc42008-09-11 00:01:49 +0200683{
684 struct ieee80211_rx_status *rx_status;
Johannes Berg472dbc42008-09-11 00:01:49 +0200685 struct ieee80211_mgmt *mgmt;
686 u16 stype;
687
Johannes Bergf1d58c22009-06-17 13:13:00 +0200688 rx_status = IEEE80211_SKB_RXCB(skb);
Johannes Berg472dbc42008-09-11 00:01:49 +0200689 mgmt = (struct ieee80211_mgmt *) skb->data;
690 stype = le16_to_cpu(mgmt->frame_control) & IEEE80211_FCTL_STYPE;
691
692 switch (stype) {
693 case IEEE80211_STYPE_PROBE_RESP:
694 case IEEE80211_STYPE_BEACON:
695 ieee80211_mesh_rx_bcn_presp(sdata, stype, mgmt, skb->len,
696 rx_status);
697 break;
698 case IEEE80211_STYPE_ACTION:
699 ieee80211_mesh_rx_mgmt_action(sdata, mgmt, skb->len, rx_status);
700 break;
701 }
Johannes Berg472dbc42008-09-11 00:01:49 +0200702}
703
Johannes Berg1fa57d02010-06-10 10:21:32 +0200704void ieee80211_mesh_work(struct ieee80211_sub_if_data *sdata)
Johannes Berg472dbc42008-09-11 00:01:49 +0200705{
Johannes Berg472dbc42008-09-11 00:01:49 +0200706 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
Johannes Berg472dbc42008-09-11 00:01:49 +0200707
708 if (ifmsh->preq_queue_len &&
709 time_after(jiffies,
710 ifmsh->last_preq + msecs_to_jiffies(ifmsh->mshcfg.dot11MeshHWMPpreqMinInterval)))
711 mesh_path_start_discovery(sdata);
712
Javier Cardona18889232009-08-10 12:15:52 -0700713 if (test_and_clear_bit(MESH_WORK_GROW_MPATH_TABLE, &ifmsh->wrkq_flags))
714 mesh_mpath_table_grow();
715
Nick Ledovskikhdcac9082011-01-11 14:35:12 +0000716 if (test_and_clear_bit(MESH_WORK_GROW_MPP_TABLE, &ifmsh->wrkq_flags))
Javier Cardona18889232009-08-10 12:15:52 -0700717 mesh_mpp_table_grow();
718
719 if (test_and_clear_bit(MESH_WORK_HOUSEKEEPING, &ifmsh->wrkq_flags))
Johannes Berg472dbc42008-09-11 00:01:49 +0200720 ieee80211_mesh_housekeeping(sdata, ifmsh);
Rui Pauloe304bfd2009-11-09 23:46:56 +0000721
722 if (test_and_clear_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags))
723 ieee80211_mesh_rootpath(sdata);
Johannes Berg472dbc42008-09-11 00:01:49 +0200724}
725
726void ieee80211_mesh_notify_scan_completed(struct ieee80211_local *local)
727{
728 struct ieee80211_sub_if_data *sdata;
729
730 rcu_read_lock();
731 list_for_each_entry_rcu(sdata, &local->interfaces, list)
732 if (ieee80211_vif_is_mesh(&sdata->vif))
Johannes Berg64592c82010-06-10 10:21:31 +0200733 ieee80211_queue_work(&local->hw, &sdata->work);
Johannes Berg472dbc42008-09-11 00:01:49 +0200734 rcu_read_unlock();
735}
736
Johannes Berg902acc72008-02-23 15:17:19 +0100737void ieee80211_mesh_init_sdata(struct ieee80211_sub_if_data *sdata)
738{
Johannes Berg472dbc42008-09-11 00:01:49 +0200739 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
Johannes Berg902acc72008-02-23 15:17:19 +0100740
Johannes Berg472dbc42008-09-11 00:01:49 +0200741 setup_timer(&ifmsh->housekeeping_timer,
742 ieee80211_mesh_housekeeping_timer,
743 (unsigned long) sdata);
Johannes Berg472dbc42008-09-11 00:01:49 +0200744
Johannes Berg472dbc42008-09-11 00:01:49 +0200745 ifmsh->accepting_plinks = true;
746 ifmsh->preq_id = 0;
Rui Paulod19b3bf2009-11-09 23:46:55 +0000747 ifmsh->sn = 0;
Javier Cardona5ee68e52011-08-09 16:45:08 -0700748 ifmsh->num_gates = 0;
Johannes Berg472dbc42008-09-11 00:01:49 +0200749 atomic_set(&ifmsh->mpaths, 0);
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200750 mesh_rmc_init(sdata);
Johannes Berg472dbc42008-09-11 00:01:49 +0200751 ifmsh->last_preq = jiffies;
Thomas Pedersendca7e942011-11-24 17:15:24 -0800752 ifmsh->next_perr = jiffies;
Johannes Berg902acc72008-02-23 15:17:19 +0100753 /* Allocate all mesh structures when creating the first mesh interface. */
754 if (!mesh_allocated)
755 ieee80211s_init();
Johannes Berg472dbc42008-09-11 00:01:49 +0200756 setup_timer(&ifmsh->mesh_path_timer,
Johannes Berg902acc72008-02-23 15:17:19 +0100757 ieee80211_mesh_path_timer,
758 (unsigned long) sdata);
Rui Pauloe304bfd2009-11-09 23:46:56 +0000759 setup_timer(&ifmsh->mesh_path_root_timer,
760 ieee80211_mesh_path_root_timer,
761 (unsigned long) sdata);
Johannes Berg472dbc42008-09-11 00:01:49 +0200762 INIT_LIST_HEAD(&ifmsh->preq_queue.list);
763 spin_lock_init(&ifmsh->mesh_preq_queue_lock);
764}