blob: d0ed931ad2e7f79ad5866375f3fed1128d58da34 [file] [log] [blame]
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001/*
Sven Eckelmann64afe352011-01-27 10:38:15 +01002 * Copyright (C) 2007-2011 B.A.T.M.A.N. contributors:
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00003 *
4 * Marek Lindner, Simon Wunderlich
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of version 2 of the GNU General Public
8 * License as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
18 * 02110-1301, USA
19 *
20 */
21
22#include "main.h"
23#include "translation-table.h"
24#include "soft-interface.h"
Marek Lindner32ae9b22011-04-20 15:40:58 +020025#include "hard-interface.h"
Antonio Quartullia73105b2011-04-27 14:27:44 +020026#include "send.h"
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000027#include "hash.h"
28#include "originator.h"
Antonio Quartullia73105b2011-04-27 14:27:44 +020029#include "routing.h"
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000030
Antonio Quartullia73105b2011-04-27 14:27:44 +020031#include <linux/crc16.h>
32
33static void _tt_global_del(struct bat_priv *bat_priv,
34 struct tt_global_entry *tt_global_entry,
35 const char *message);
36static void tt_purge(struct work_struct *work);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000037
Marek Lindner7aadf882011-02-18 12:28:09 +000038/* returns 1 if they are the same mac addr */
Sven Eckelmann747e4222011-05-14 23:14:50 +020039static int compare_ltt(const struct hlist_node *node, const void *data2)
Marek Lindner7aadf882011-02-18 12:28:09 +000040{
Sven Eckelmann747e4222011-05-14 23:14:50 +020041 const void *data1 = container_of(node, struct tt_local_entry,
42 hash_entry);
Marek Lindner7aadf882011-02-18 12:28:09 +000043
44 return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0);
45}
46
47/* returns 1 if they are the same mac addr */
Sven Eckelmann747e4222011-05-14 23:14:50 +020048static int compare_gtt(const struct hlist_node *node, const void *data2)
Marek Lindner7aadf882011-02-18 12:28:09 +000049{
Sven Eckelmann747e4222011-05-14 23:14:50 +020050 const void *data1 = container_of(node, struct tt_global_entry,
51 hash_entry);
Marek Lindner7aadf882011-02-18 12:28:09 +000052
53 return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0);
54}
55
Antonio Quartullia73105b2011-04-27 14:27:44 +020056static void tt_start_timer(struct bat_priv *bat_priv)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000057{
Antonio Quartullia73105b2011-04-27 14:27:44 +020058 INIT_DELAYED_WORK(&bat_priv->tt_work, tt_purge);
59 queue_delayed_work(bat_event_workqueue, &bat_priv->tt_work,
60 msecs_to_jiffies(5000));
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000061}
62
Antonio Quartulli2dafb492011-05-05 08:42:45 +020063static struct tt_local_entry *tt_local_hash_find(struct bat_priv *bat_priv,
Sven Eckelmann747e4222011-05-14 23:14:50 +020064 const void *data)
Marek Lindner7aadf882011-02-18 12:28:09 +000065{
Antonio Quartulli2dafb492011-05-05 08:42:45 +020066 struct hashtable_t *hash = bat_priv->tt_local_hash;
Marek Lindner7aadf882011-02-18 12:28:09 +000067 struct hlist_head *head;
68 struct hlist_node *node;
Antonio Quartulli2dafb492011-05-05 08:42:45 +020069 struct tt_local_entry *tt_local_entry, *tt_local_entry_tmp = NULL;
Marek Lindner7aadf882011-02-18 12:28:09 +000070 int index;
71
72 if (!hash)
73 return NULL;
74
75 index = choose_orig(data, hash->size);
76 head = &hash->table[index];
77
78 rcu_read_lock();
Antonio Quartulli2dafb492011-05-05 08:42:45 +020079 hlist_for_each_entry_rcu(tt_local_entry, node, head, hash_entry) {
80 if (!compare_eth(tt_local_entry, data))
Marek Lindner7aadf882011-02-18 12:28:09 +000081 continue;
82
Antonio Quartulli7683fdc2011-04-27 14:28:07 +020083 if (!atomic_inc_not_zero(&tt_local_entry->refcount))
84 continue;
85
Antonio Quartulli2dafb492011-05-05 08:42:45 +020086 tt_local_entry_tmp = tt_local_entry;
Marek Lindner7aadf882011-02-18 12:28:09 +000087 break;
88 }
89 rcu_read_unlock();
90
Antonio Quartulli2dafb492011-05-05 08:42:45 +020091 return tt_local_entry_tmp;
Marek Lindner7aadf882011-02-18 12:28:09 +000092}
93
Antonio Quartulli2dafb492011-05-05 08:42:45 +020094static struct tt_global_entry *tt_global_hash_find(struct bat_priv *bat_priv,
Sven Eckelmann747e4222011-05-14 23:14:50 +020095 const void *data)
Marek Lindner7aadf882011-02-18 12:28:09 +000096{
Antonio Quartulli2dafb492011-05-05 08:42:45 +020097 struct hashtable_t *hash = bat_priv->tt_global_hash;
Marek Lindner7aadf882011-02-18 12:28:09 +000098 struct hlist_head *head;
99 struct hlist_node *node;
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200100 struct tt_global_entry *tt_global_entry;
101 struct tt_global_entry *tt_global_entry_tmp = NULL;
Marek Lindner7aadf882011-02-18 12:28:09 +0000102 int index;
103
104 if (!hash)
105 return NULL;
106
107 index = choose_orig(data, hash->size);
108 head = &hash->table[index];
109
110 rcu_read_lock();
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200111 hlist_for_each_entry_rcu(tt_global_entry, node, head, hash_entry) {
112 if (!compare_eth(tt_global_entry, data))
Marek Lindner7aadf882011-02-18 12:28:09 +0000113 continue;
114
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200115 if (!atomic_inc_not_zero(&tt_global_entry->refcount))
116 continue;
117
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200118 tt_global_entry_tmp = tt_global_entry;
Marek Lindner7aadf882011-02-18 12:28:09 +0000119 break;
120 }
121 rcu_read_unlock();
122
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200123 return tt_global_entry_tmp;
Marek Lindner7aadf882011-02-18 12:28:09 +0000124}
125
Antonio Quartullia73105b2011-04-27 14:27:44 +0200126static bool is_out_of_time(unsigned long starting_time, unsigned long timeout)
127{
128 unsigned long deadline;
129 deadline = starting_time + msecs_to_jiffies(timeout);
130
131 return time_after(jiffies, deadline);
132}
133
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200134static void tt_local_entry_free_ref(struct tt_local_entry *tt_local_entry)
135{
136 if (atomic_dec_and_test(&tt_local_entry->refcount))
137 kfree_rcu(tt_local_entry, rcu);
138}
139
140static void tt_global_entry_free_ref(struct tt_global_entry *tt_global_entry)
141{
142 if (atomic_dec_and_test(&tt_global_entry->refcount))
143 kfree_rcu(tt_global_entry, rcu);
144}
145
Antonio Quartulliff66c972011-06-30 01:14:00 +0200146static void tt_local_event(struct bat_priv *bat_priv, const uint8_t *addr,
147 uint8_t flags)
Antonio Quartullia73105b2011-04-27 14:27:44 +0200148{
149 struct tt_change_node *tt_change_node;
150
151 tt_change_node = kmalloc(sizeof(*tt_change_node), GFP_ATOMIC);
152
153 if (!tt_change_node)
154 return;
155
Antonio Quartulliff66c972011-06-30 01:14:00 +0200156 tt_change_node->change.flags = flags;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200157 memcpy(tt_change_node->change.addr, addr, ETH_ALEN);
158
159 spin_lock_bh(&bat_priv->tt_changes_list_lock);
160 /* track the change in the OGMinterval list */
161 list_add_tail(&tt_change_node->list, &bat_priv->tt_changes_list);
162 atomic_inc(&bat_priv->tt_local_changes);
163 spin_unlock_bh(&bat_priv->tt_changes_list_lock);
164
165 atomic_set(&bat_priv->tt_ogm_append_cnt, 0);
166}
167
168int tt_len(int changes_num)
169{
170 return changes_num * sizeof(struct tt_change);
171}
172
173static int tt_local_init(struct bat_priv *bat_priv)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000174{
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200175 if (bat_priv->tt_local_hash)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000176 return 1;
177
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200178 bat_priv->tt_local_hash = hash_new(1024);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000179
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200180 if (!bat_priv->tt_local_hash)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000181 return 0;
182
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000183 return 1;
184}
185
Antonio Quartullibc279082011-07-07 15:35:35 +0200186void tt_local_add(struct net_device *soft_iface, const uint8_t *addr,
187 int ifindex)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000188{
189 struct bat_priv *bat_priv = netdev_priv(soft_iface);
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200190 struct tt_local_entry *tt_local_entry = NULL;
191 struct tt_global_entry *tt_global_entry = NULL;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000192
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200193 tt_local_entry = tt_local_hash_find(bat_priv, addr);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000194
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200195 if (tt_local_entry) {
196 tt_local_entry->last_seen = jiffies;
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200197 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000198 }
199
Sven Eckelmann704509b2011-05-14 23:14:54 +0200200 tt_local_entry = kmalloc(sizeof(*tt_local_entry), GFP_ATOMIC);
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200201 if (!tt_local_entry)
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200202 goto out;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200203
Antonio Quartullia73105b2011-04-27 14:27:44 +0200204 bat_dbg(DBG_TT, bat_priv,
205 "Creating new local tt entry: %pM (ttvn: %d)\n", addr,
206 (uint8_t)atomic_read(&bat_priv->ttvn));
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000207
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200208 memcpy(tt_local_entry->addr, addr, ETH_ALEN);
209 tt_local_entry->last_seen = jiffies;
Antonio Quartulli5fbc1592011-06-17 16:11:27 +0200210 tt_local_entry->flags = NO_FLAGS;
Antonio Quartullibc279082011-07-07 15:35:35 +0200211 if (is_wifi_iface(ifindex))
212 tt_local_entry->flags |= TT_CLIENT_WIFI;
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200213 atomic_set(&tt_local_entry->refcount, 2);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000214
215 /* the batman interface mac address should never be purged */
Marek Lindner39901e72011-02-18 12:28:08 +0000216 if (compare_eth(addr, soft_iface->dev_addr))
Antonio Quartulli5fbc1592011-06-17 16:11:27 +0200217 tt_local_entry->flags |= TT_CLIENT_NOPURGE;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000218
Antonio Quartulliff66c972011-06-30 01:14:00 +0200219 tt_local_event(bat_priv, addr, tt_local_entry->flags);
220
Antonio Quartulli058d0e22011-07-07 01:40:58 +0200221 /* The local entry has to be marked as NEW to avoid to send it in
222 * a full table response going out before the next ttvn increment
223 * (consistency check) */
224 tt_local_entry->flags |= TT_CLIENT_NEW;
225
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200226 hash_add(bat_priv->tt_local_hash, compare_ltt, choose_orig,
227 tt_local_entry, &tt_local_entry->hash_entry);
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200228
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000229 /* remove address from global hash if present */
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200230 tt_global_entry = tt_global_hash_find(bat_priv, addr);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000231
Antonio Quartullicc47f662011-04-27 14:27:57 +0200232 /* Check whether it is a roaming! */
233 if (tt_global_entry) {
Antonio Quartullicc47f662011-04-27 14:27:57 +0200234 /* This node is probably going to update its tt table */
235 tt_global_entry->orig_node->tt_poss_change = true;
Antonio Quartulli980d55b2011-07-07 01:40:59 +0200236 /* The global entry has to be marked as PENDING and has to be
237 * kept for consistency purpose */
238 tt_global_entry->flags |= TT_CLIENT_PENDING;
Antonio Quartullicc47f662011-04-27 14:27:57 +0200239 send_roam_adv(bat_priv, tt_global_entry->addr,
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200240 tt_global_entry->orig_node);
241 }
242out:
243 if (tt_local_entry)
244 tt_local_entry_free_ref(tt_local_entry);
245 if (tt_global_entry)
246 tt_global_entry_free_ref(tt_global_entry);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000247}
248
Antonio Quartullia73105b2011-04-27 14:27:44 +0200249int tt_changes_fill_buffer(struct bat_priv *bat_priv,
250 unsigned char *buff, int buff_len)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000251{
Antonio Quartullia73105b2011-04-27 14:27:44 +0200252 int count = 0, tot_changes = 0;
253 struct tt_change_node *entry, *safe;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000254
Antonio Quartullia73105b2011-04-27 14:27:44 +0200255 if (buff_len > 0)
256 tot_changes = buff_len / tt_len(1);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000257
Antonio Quartullia73105b2011-04-27 14:27:44 +0200258 spin_lock_bh(&bat_priv->tt_changes_list_lock);
259 atomic_set(&bat_priv->tt_local_changes, 0);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000260
Antonio Quartullia73105b2011-04-27 14:27:44 +0200261 list_for_each_entry_safe(entry, safe, &bat_priv->tt_changes_list,
262 list) {
263 if (count < tot_changes) {
264 memcpy(buff + tt_len(count),
265 &entry->change, sizeof(struct tt_change));
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000266 count++;
267 }
Antonio Quartullia73105b2011-04-27 14:27:44 +0200268 list_del(&entry->list);
269 kfree(entry);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000270 }
Antonio Quartullia73105b2011-04-27 14:27:44 +0200271 spin_unlock_bh(&bat_priv->tt_changes_list_lock);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000272
Antonio Quartullia73105b2011-04-27 14:27:44 +0200273 /* Keep the buffer for possible tt_request */
274 spin_lock_bh(&bat_priv->tt_buff_lock);
275 kfree(bat_priv->tt_buff);
276 bat_priv->tt_buff_len = 0;
277 bat_priv->tt_buff = NULL;
278 /* We check whether this new OGM has no changes due to size
279 * problems */
280 if (buff_len > 0) {
281 /**
282 * if kmalloc() fails we will reply with the full table
283 * instead of providing the diff
284 */
285 bat_priv->tt_buff = kmalloc(buff_len, GFP_ATOMIC);
286 if (bat_priv->tt_buff) {
287 memcpy(bat_priv->tt_buff, buff, buff_len);
288 bat_priv->tt_buff_len = buff_len;
289 }
290 }
291 spin_unlock_bh(&bat_priv->tt_buff_lock);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000292
Antonio Quartullia73105b2011-04-27 14:27:44 +0200293 return tot_changes;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000294}
295
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200296int tt_local_seq_print_text(struct seq_file *seq, void *offset)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000297{
298 struct net_device *net_dev = (struct net_device *)seq->private;
299 struct bat_priv *bat_priv = netdev_priv(net_dev);
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200300 struct hashtable_t *hash = bat_priv->tt_local_hash;
301 struct tt_local_entry *tt_local_entry;
Marek Lindner32ae9b22011-04-20 15:40:58 +0200302 struct hard_iface *primary_if;
Marek Lindner7aadf882011-02-18 12:28:09 +0000303 struct hlist_node *node;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000304 struct hlist_head *head;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000305 size_t buf_size, pos;
306 char *buff;
Marek Lindner32ae9b22011-04-20 15:40:58 +0200307 int i, ret = 0;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000308
Marek Lindner32ae9b22011-04-20 15:40:58 +0200309 primary_if = primary_if_get_selected(bat_priv);
310 if (!primary_if) {
311 ret = seq_printf(seq, "BATMAN mesh %s disabled - "
312 "please specify interfaces to enable it\n",
313 net_dev->name);
314 goto out;
315 }
316
317 if (primary_if->if_status != IF_ACTIVE) {
318 ret = seq_printf(seq, "BATMAN mesh %s disabled - "
319 "primary interface not active\n",
320 net_dev->name);
321 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000322 }
323
324 seq_printf(seq, "Locally retrieved addresses (from %s) "
Antonio Quartullia73105b2011-04-27 14:27:44 +0200325 "announced via TT (TTVN: %u):\n",
326 net_dev->name, (uint8_t)atomic_read(&bat_priv->ttvn));
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000327
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000328 buf_size = 1;
329 /* Estimate length for: " * xx:xx:xx:xx:xx:xx\n" */
330 for (i = 0; i < hash->size; i++) {
331 head = &hash->table[i];
332
Marek Lindner7aadf882011-02-18 12:28:09 +0000333 rcu_read_lock();
334 __hlist_for_each_rcu(node, head)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000335 buf_size += 21;
Marek Lindner7aadf882011-02-18 12:28:09 +0000336 rcu_read_unlock();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000337 }
338
339 buff = kmalloc(buf_size, GFP_ATOMIC);
340 if (!buff) {
Marek Lindner32ae9b22011-04-20 15:40:58 +0200341 ret = -ENOMEM;
342 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000343 }
Marek Lindner7aadf882011-02-18 12:28:09 +0000344
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000345 buff[0] = '\0';
346 pos = 0;
347
348 for (i = 0; i < hash->size; i++) {
349 head = &hash->table[i];
350
Marek Lindner7aadf882011-02-18 12:28:09 +0000351 rcu_read_lock();
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200352 hlist_for_each_entry_rcu(tt_local_entry, node,
Marek Lindner7aadf882011-02-18 12:28:09 +0000353 head, hash_entry) {
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000354 pos += snprintf(buff + pos, 22, " * %pM\n",
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200355 tt_local_entry->addr);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000356 }
Marek Lindner7aadf882011-02-18 12:28:09 +0000357 rcu_read_unlock();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000358 }
359
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000360 seq_printf(seq, "%s", buff);
361 kfree(buff);
Marek Lindner32ae9b22011-04-20 15:40:58 +0200362out:
363 if (primary_if)
364 hardif_free_ref(primary_if);
365 return ret;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000366}
367
Antonio Quartulli058d0e22011-07-07 01:40:58 +0200368static void tt_local_set_pending(struct bat_priv *bat_priv,
369 struct tt_local_entry *tt_local_entry,
370 uint16_t flags)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000371{
Antonio Quartulli058d0e22011-07-07 01:40:58 +0200372 tt_local_event(bat_priv, tt_local_entry->addr,
373 tt_local_entry->flags | flags);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000374
Antonio Quartulli015758d2011-07-09 17:52:13 +0200375 /* The local client has to be marked as "pending to be removed" but has
376 * to be kept in the table in order to send it in a full table
Antonio Quartulli058d0e22011-07-07 01:40:58 +0200377 * response issued before the net ttvn increment (consistency check) */
378 tt_local_entry->flags |= TT_CLIENT_PENDING;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000379}
380
Antonio Quartullia73105b2011-04-27 14:27:44 +0200381void tt_local_remove(struct bat_priv *bat_priv, const uint8_t *addr,
Antonio Quartullicc47f662011-04-27 14:27:57 +0200382 const char *message, bool roaming)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000383{
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200384 struct tt_local_entry *tt_local_entry = NULL;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000385
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200386 tt_local_entry = tt_local_hash_find(bat_priv, addr);
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200387 if (!tt_local_entry)
388 goto out;
389
Antonio Quartulli058d0e22011-07-07 01:40:58 +0200390 tt_local_set_pending(bat_priv, tt_local_entry, TT_CLIENT_DEL |
391 (roaming ? TT_CLIENT_ROAM : NO_FLAGS));
392
393 bat_dbg(DBG_TT, bat_priv, "Local tt entry (%pM) pending to be removed: "
394 "%s\n", tt_local_entry->addr, message);
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200395out:
396 if (tt_local_entry)
397 tt_local_entry_free_ref(tt_local_entry);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000398}
399
Antonio Quartullia73105b2011-04-27 14:27:44 +0200400static void tt_local_purge(struct bat_priv *bat_priv)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000401{
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200402 struct hashtable_t *hash = bat_priv->tt_local_hash;
403 struct tt_local_entry *tt_local_entry;
Marek Lindner7aadf882011-02-18 12:28:09 +0000404 struct hlist_node *node, *node_tmp;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000405 struct hlist_head *head;
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200406 spinlock_t *list_lock; /* protects write access to the hash lists */
Marek Lindner7aadf882011-02-18 12:28:09 +0000407 int i;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000408
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000409 for (i = 0; i < hash->size; i++) {
410 head = &hash->table[i];
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200411 list_lock = &hash->list_locks[i];
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000412
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200413 spin_lock_bh(list_lock);
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200414 hlist_for_each_entry_safe(tt_local_entry, node, node_tmp,
Marek Lindner7aadf882011-02-18 12:28:09 +0000415 head, hash_entry) {
Antonio Quartulli5fbc1592011-06-17 16:11:27 +0200416 if (tt_local_entry->flags & TT_CLIENT_NOPURGE)
Marek Lindner7aadf882011-02-18 12:28:09 +0000417 continue;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000418
Antonio Quartulli058d0e22011-07-07 01:40:58 +0200419 /* entry already marked for deletion */
420 if (tt_local_entry->flags & TT_CLIENT_PENDING)
421 continue;
422
Antonio Quartullia73105b2011-04-27 14:27:44 +0200423 if (!is_out_of_time(tt_local_entry->last_seen,
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200424 TT_LOCAL_TIMEOUT * 1000))
Marek Lindner7aadf882011-02-18 12:28:09 +0000425 continue;
426
Antonio Quartulli058d0e22011-07-07 01:40:58 +0200427 tt_local_set_pending(bat_priv, tt_local_entry,
428 TT_CLIENT_DEL);
429 bat_dbg(DBG_TT, bat_priv, "Local tt entry (%pM) "
430 "pending to be removed: timed out\n",
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200431 tt_local_entry->addr);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000432 }
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200433 spin_unlock_bh(list_lock);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000434 }
435
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000436}
437
Antonio Quartullia73105b2011-04-27 14:27:44 +0200438static void tt_local_table_free(struct bat_priv *bat_priv)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000439{
Antonio Quartullia73105b2011-04-27 14:27:44 +0200440 struct hashtable_t *hash;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200441 spinlock_t *list_lock; /* protects write access to the hash lists */
Antonio Quartullia73105b2011-04-27 14:27:44 +0200442 struct tt_local_entry *tt_local_entry;
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200443 struct hlist_node *node, *node_tmp;
444 struct hlist_head *head;
445 int i;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200446
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200447 if (!bat_priv->tt_local_hash)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000448 return;
449
Antonio Quartullia73105b2011-04-27 14:27:44 +0200450 hash = bat_priv->tt_local_hash;
451
452 for (i = 0; i < hash->size; i++) {
453 head = &hash->table[i];
454 list_lock = &hash->list_locks[i];
455
456 spin_lock_bh(list_lock);
457 hlist_for_each_entry_safe(tt_local_entry, node, node_tmp,
458 head, hash_entry) {
459 hlist_del_rcu(node);
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200460 tt_local_entry_free_ref(tt_local_entry);
Antonio Quartullia73105b2011-04-27 14:27:44 +0200461 }
462 spin_unlock_bh(list_lock);
463 }
464
465 hash_destroy(hash);
466
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200467 bat_priv->tt_local_hash = NULL;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000468}
469
Antonio Quartullia73105b2011-04-27 14:27:44 +0200470static int tt_global_init(struct bat_priv *bat_priv)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000471{
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200472 if (bat_priv->tt_global_hash)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000473 return 1;
474
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200475 bat_priv->tt_global_hash = hash_new(1024);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000476
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200477 if (!bat_priv->tt_global_hash)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000478 return 0;
479
480 return 1;
481}
482
Antonio Quartullia73105b2011-04-27 14:27:44 +0200483static void tt_changes_list_free(struct bat_priv *bat_priv)
484{
485 struct tt_change_node *entry, *safe;
486
487 spin_lock_bh(&bat_priv->tt_changes_list_lock);
488
489 list_for_each_entry_safe(entry, safe, &bat_priv->tt_changes_list,
490 list) {
491 list_del(&entry->list);
492 kfree(entry);
493 }
494
495 atomic_set(&bat_priv->tt_local_changes, 0);
496 spin_unlock_bh(&bat_priv->tt_changes_list_lock);
497}
498
499/* caller must hold orig_node refcount */
500int tt_global_add(struct bat_priv *bat_priv, struct orig_node *orig_node,
Antonio Quartullibc279082011-07-07 15:35:35 +0200501 const unsigned char *tt_addr, uint8_t ttvn, bool roaming,
502 bool wifi)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000503{
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200504 struct tt_global_entry *tt_global_entry;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200505 struct orig_node *orig_node_tmp;
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200506 int ret = 0;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000507
Antonio Quartullia73105b2011-04-27 14:27:44 +0200508 tt_global_entry = tt_global_hash_find(bat_priv, tt_addr);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000509
Antonio Quartullia73105b2011-04-27 14:27:44 +0200510 if (!tt_global_entry) {
511 tt_global_entry =
512 kmalloc(sizeof(*tt_global_entry),
513 GFP_ATOMIC);
514 if (!tt_global_entry)
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200515 goto out;
516
Antonio Quartullia73105b2011-04-27 14:27:44 +0200517 memcpy(tt_global_entry->addr, tt_addr, ETH_ALEN);
518 /* Assign the new orig_node */
519 atomic_inc(&orig_node->refcount);
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200520 tt_global_entry->orig_node = orig_node;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200521 tt_global_entry->ttvn = ttvn;
Antonio Quartullicc47f662011-04-27 14:27:57 +0200522 tt_global_entry->flags = NO_FLAGS;
523 tt_global_entry->roam_at = 0;
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200524 atomic_set(&tt_global_entry->refcount, 2);
525
Antonio Quartullia73105b2011-04-27 14:27:44 +0200526 hash_add(bat_priv->tt_global_hash, compare_gtt,
527 choose_orig, tt_global_entry,
528 &tt_global_entry->hash_entry);
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200529 atomic_inc(&orig_node->tt_size);
Antonio Quartullia73105b2011-04-27 14:27:44 +0200530 } else {
531 if (tt_global_entry->orig_node != orig_node) {
532 atomic_dec(&tt_global_entry->orig_node->tt_size);
533 orig_node_tmp = tt_global_entry->orig_node;
534 atomic_inc(&orig_node->refcount);
535 tt_global_entry->orig_node = orig_node;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200536 orig_node_free_ref(orig_node_tmp);
537 atomic_inc(&orig_node->tt_size);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000538 }
Antonio Quartullicc47f662011-04-27 14:27:57 +0200539 tt_global_entry->ttvn = ttvn;
540 tt_global_entry->flags = NO_FLAGS;
541 tt_global_entry->roam_at = 0;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000542 }
Antonio Quartullia73105b2011-04-27 14:27:44 +0200543
Antonio Quartullibc279082011-07-07 15:35:35 +0200544 if (wifi)
545 tt_global_entry->flags |= TT_CLIENT_WIFI;
546
Antonio Quartullia73105b2011-04-27 14:27:44 +0200547 bat_dbg(DBG_TT, bat_priv,
548 "Creating new global tt entry: %pM (via %pM)\n",
549 tt_global_entry->addr, orig_node->orig);
550
551 /* remove address from local hash if present */
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200552 tt_local_remove(bat_priv, tt_global_entry->addr,
553 "global tt received", roaming);
554 ret = 1;
555out:
556 if (tt_global_entry)
557 tt_global_entry_free_ref(tt_global_entry);
558 return ret;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000559}
560
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200561int tt_global_seq_print_text(struct seq_file *seq, void *offset)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000562{
563 struct net_device *net_dev = (struct net_device *)seq->private;
564 struct bat_priv *bat_priv = netdev_priv(net_dev);
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200565 struct hashtable_t *hash = bat_priv->tt_global_hash;
566 struct tt_global_entry *tt_global_entry;
Marek Lindner32ae9b22011-04-20 15:40:58 +0200567 struct hard_iface *primary_if;
Marek Lindner7aadf882011-02-18 12:28:09 +0000568 struct hlist_node *node;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000569 struct hlist_head *head;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000570 size_t buf_size, pos;
571 char *buff;
Marek Lindner32ae9b22011-04-20 15:40:58 +0200572 int i, ret = 0;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000573
Marek Lindner32ae9b22011-04-20 15:40:58 +0200574 primary_if = primary_if_get_selected(bat_priv);
575 if (!primary_if) {
576 ret = seq_printf(seq, "BATMAN mesh %s disabled - please "
577 "specify interfaces to enable it\n",
578 net_dev->name);
579 goto out;
580 }
581
582 if (primary_if->if_status != IF_ACTIVE) {
583 ret = seq_printf(seq, "BATMAN mesh %s disabled - "
584 "primary interface not active\n",
585 net_dev->name);
586 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000587 }
588
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200589 seq_printf(seq,
590 "Globally announced TT entries received via the mesh %s\n",
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000591 net_dev->name);
Antonio Quartullia73105b2011-04-27 14:27:44 +0200592 seq_printf(seq, " %-13s %s %-15s %s\n",
593 "Client", "(TTVN)", "Originator", "(Curr TTVN)");
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000594
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000595 buf_size = 1;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200596 /* Estimate length for: " * xx:xx:xx:xx:xx:xx (ttvn) via
597 * xx:xx:xx:xx:xx:xx (cur_ttvn)\n"*/
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000598 for (i = 0; i < hash->size; i++) {
599 head = &hash->table[i];
600
Marek Lindner7aadf882011-02-18 12:28:09 +0000601 rcu_read_lock();
602 __hlist_for_each_rcu(node, head)
Antonio Quartullia73105b2011-04-27 14:27:44 +0200603 buf_size += 59;
Marek Lindner7aadf882011-02-18 12:28:09 +0000604 rcu_read_unlock();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000605 }
606
607 buff = kmalloc(buf_size, GFP_ATOMIC);
608 if (!buff) {
Marek Lindner32ae9b22011-04-20 15:40:58 +0200609 ret = -ENOMEM;
610 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000611 }
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200612
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000613 buff[0] = '\0';
614 pos = 0;
615
616 for (i = 0; i < hash->size; i++) {
617 head = &hash->table[i];
618
Marek Lindner7aadf882011-02-18 12:28:09 +0000619 rcu_read_lock();
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200620 hlist_for_each_entry_rcu(tt_global_entry, node,
Marek Lindner7aadf882011-02-18 12:28:09 +0000621 head, hash_entry) {
Antonio Quartullia73105b2011-04-27 14:27:44 +0200622 pos += snprintf(buff + pos, 61,
623 " * %pM (%3u) via %pM (%3u)\n",
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200624 tt_global_entry->addr,
Antonio Quartullia73105b2011-04-27 14:27:44 +0200625 tt_global_entry->ttvn,
626 tt_global_entry->orig_node->orig,
627 (uint8_t) atomic_read(
628 &tt_global_entry->orig_node->
629 last_ttvn));
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000630 }
Marek Lindner7aadf882011-02-18 12:28:09 +0000631 rcu_read_unlock();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000632 }
633
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000634 seq_printf(seq, "%s", buff);
635 kfree(buff);
Marek Lindner32ae9b22011-04-20 15:40:58 +0200636out:
637 if (primary_if)
638 hardif_free_ref(primary_if);
639 return ret;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000640}
641
Antonio Quartullia73105b2011-04-27 14:27:44 +0200642static void _tt_global_del(struct bat_priv *bat_priv,
643 struct tt_global_entry *tt_global_entry,
644 const char *message)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000645{
Antonio Quartullia73105b2011-04-27 14:27:44 +0200646 if (!tt_global_entry)
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200647 goto out;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200648
649 bat_dbg(DBG_TT, bat_priv,
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200650 "Deleting global tt entry %pM (via %pM): %s\n",
651 tt_global_entry->addr, tt_global_entry->orig_node->orig,
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000652 message);
653
Antonio Quartullia73105b2011-04-27 14:27:44 +0200654 atomic_dec(&tt_global_entry->orig_node->tt_size);
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200655
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200656 hash_remove(bat_priv->tt_global_hash, compare_gtt, choose_orig,
657 tt_global_entry->addr);
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200658out:
659 if (tt_global_entry)
660 tt_global_entry_free_ref(tt_global_entry);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000661}
662
Antonio Quartullia73105b2011-04-27 14:27:44 +0200663void tt_global_del(struct bat_priv *bat_priv,
664 struct orig_node *orig_node, const unsigned char *addr,
Antonio Quartullicc47f662011-04-27 14:27:57 +0200665 const char *message, bool roaming)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000666{
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200667 struct tt_global_entry *tt_global_entry = NULL;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000668
Antonio Quartullia73105b2011-04-27 14:27:44 +0200669 tt_global_entry = tt_global_hash_find(bat_priv, addr);
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200670 if (!tt_global_entry)
671 goto out;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200672
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200673 if (tt_global_entry->orig_node == orig_node) {
Antonio Quartullicc47f662011-04-27 14:27:57 +0200674 if (roaming) {
675 tt_global_entry->flags |= TT_CLIENT_ROAM;
676 tt_global_entry->roam_at = jiffies;
677 goto out;
678 }
Antonio Quartullia73105b2011-04-27 14:27:44 +0200679 _tt_global_del(bat_priv, tt_global_entry, message);
680 }
Antonio Quartullicc47f662011-04-27 14:27:57 +0200681out:
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200682 if (tt_global_entry)
683 tt_global_entry_free_ref(tt_global_entry);
Antonio Quartullia73105b2011-04-27 14:27:44 +0200684}
685
686void tt_global_del_orig(struct bat_priv *bat_priv,
687 struct orig_node *orig_node, const char *message)
688{
689 struct tt_global_entry *tt_global_entry;
690 int i;
691 struct hashtable_t *hash = bat_priv->tt_global_hash;
692 struct hlist_node *node, *safe;
693 struct hlist_head *head;
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200694 spinlock_t *list_lock; /* protects write access to the hash lists */
Antonio Quartullia73105b2011-04-27 14:27:44 +0200695
Antonio Quartullia73105b2011-04-27 14:27:44 +0200696 for (i = 0; i < hash->size; i++) {
697 head = &hash->table[i];
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200698 list_lock = &hash->list_locks[i];
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000699
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200700 spin_lock_bh(list_lock);
Antonio Quartullia73105b2011-04-27 14:27:44 +0200701 hlist_for_each_entry_safe(tt_global_entry, node, safe,
702 head, hash_entry) {
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200703 if (tt_global_entry->orig_node == orig_node) {
704 bat_dbg(DBG_TT, bat_priv,
705 "Deleting global tt entry %pM "
706 "(via %pM): originator time out\n",
707 tt_global_entry->addr,
708 tt_global_entry->orig_node->orig);
709 hlist_del_rcu(node);
710 tt_global_entry_free_ref(tt_global_entry);
711 }
Antonio Quartullia73105b2011-04-27 14:27:44 +0200712 }
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200713 spin_unlock_bh(list_lock);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000714 }
Antonio Quartullia73105b2011-04-27 14:27:44 +0200715 atomic_set(&orig_node->tt_size, 0);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000716}
717
Antonio Quartullicc47f662011-04-27 14:27:57 +0200718static void tt_global_roam_purge(struct bat_priv *bat_priv)
719{
720 struct hashtable_t *hash = bat_priv->tt_global_hash;
721 struct tt_global_entry *tt_global_entry;
722 struct hlist_node *node, *node_tmp;
723 struct hlist_head *head;
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200724 spinlock_t *list_lock; /* protects write access to the hash lists */
Antonio Quartullicc47f662011-04-27 14:27:57 +0200725 int i;
726
Antonio Quartullicc47f662011-04-27 14:27:57 +0200727 for (i = 0; i < hash->size; i++) {
728 head = &hash->table[i];
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200729 list_lock = &hash->list_locks[i];
Antonio Quartullicc47f662011-04-27 14:27:57 +0200730
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200731 spin_lock_bh(list_lock);
Antonio Quartullicc47f662011-04-27 14:27:57 +0200732 hlist_for_each_entry_safe(tt_global_entry, node, node_tmp,
733 head, hash_entry) {
734 if (!(tt_global_entry->flags & TT_CLIENT_ROAM))
735 continue;
736 if (!is_out_of_time(tt_global_entry->roam_at,
737 TT_CLIENT_ROAM_TIMEOUT * 1000))
738 continue;
739
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200740 bat_dbg(DBG_TT, bat_priv, "Deleting global "
741 "tt entry (%pM): Roaming timeout\n",
742 tt_global_entry->addr);
743 atomic_dec(&tt_global_entry->orig_node->tt_size);
744 hlist_del_rcu(node);
745 tt_global_entry_free_ref(tt_global_entry);
Antonio Quartullicc47f662011-04-27 14:27:57 +0200746 }
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200747 spin_unlock_bh(list_lock);
Antonio Quartullicc47f662011-04-27 14:27:57 +0200748 }
749
Antonio Quartullicc47f662011-04-27 14:27:57 +0200750}
751
Antonio Quartullia73105b2011-04-27 14:27:44 +0200752static void tt_global_table_free(struct bat_priv *bat_priv)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000753{
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200754 struct hashtable_t *hash;
755 spinlock_t *list_lock; /* protects write access to the hash lists */
756 struct tt_global_entry *tt_global_entry;
757 struct hlist_node *node, *node_tmp;
758 struct hlist_head *head;
759 int i;
760
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200761 if (!bat_priv->tt_global_hash)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000762 return;
763
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200764 hash = bat_priv->tt_global_hash;
765
766 for (i = 0; i < hash->size; i++) {
767 head = &hash->table[i];
768 list_lock = &hash->list_locks[i];
769
770 spin_lock_bh(list_lock);
771 hlist_for_each_entry_safe(tt_global_entry, node, node_tmp,
772 head, hash_entry) {
773 hlist_del_rcu(node);
774 tt_global_entry_free_ref(tt_global_entry);
775 }
776 spin_unlock_bh(list_lock);
777 }
778
779 hash_destroy(hash);
780
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200781 bat_priv->tt_global_hash = NULL;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000782}
783
Antonio Quartulli59b699c2011-07-07 15:35:36 +0200784static bool _is_ap_isolated(struct tt_local_entry *tt_local_entry,
785 struct tt_global_entry *tt_global_entry)
786{
787 bool ret = false;
788
789 if (tt_local_entry->flags & TT_CLIENT_WIFI &&
790 tt_global_entry->flags & TT_CLIENT_WIFI)
791 ret = true;
792
793 return ret;
794}
795
Sven Eckelmann747e4222011-05-14 23:14:50 +0200796struct orig_node *transtable_search(struct bat_priv *bat_priv,
797 const uint8_t *addr)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000798{
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200799 struct tt_global_entry *tt_global_entry;
Marek Lindner7b36e8e2011-02-18 12:28:10 +0000800 struct orig_node *orig_node = NULL;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000801
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200802 tt_global_entry = tt_global_hash_find(bat_priv, addr);
Marek Lindner7aadf882011-02-18 12:28:09 +0000803
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200804 if (!tt_global_entry)
Marek Lindner7b36e8e2011-02-18 12:28:10 +0000805 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000806
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200807 if (!atomic_inc_not_zero(&tt_global_entry->orig_node->refcount))
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200808 goto free_tt;
Marek Lindner7b36e8e2011-02-18 12:28:10 +0000809
Antonio Quartulli980d55b2011-07-07 01:40:59 +0200810 /* A global client marked as PENDING has already moved from that
811 * originator */
812 if (tt_global_entry->flags & TT_CLIENT_PENDING)
813 goto free_tt;
814
Antonio Quartulli2dafb492011-05-05 08:42:45 +0200815 orig_node = tt_global_entry->orig_node;
Marek Lindner7b36e8e2011-02-18 12:28:10 +0000816
Antonio Quartulli7683fdc2011-04-27 14:28:07 +0200817free_tt:
818 tt_global_entry_free_ref(tt_global_entry);
Marek Lindner7b36e8e2011-02-18 12:28:10 +0000819out:
Marek Lindner7b36e8e2011-02-18 12:28:10 +0000820 return orig_node;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000821}
Antonio Quartullia73105b2011-04-27 14:27:44 +0200822
823/* Calculates the checksum of the local table of a given orig_node */
824uint16_t tt_global_crc(struct bat_priv *bat_priv, struct orig_node *orig_node)
825{
826 uint16_t total = 0, total_one;
827 struct hashtable_t *hash = bat_priv->tt_global_hash;
828 struct tt_global_entry *tt_global_entry;
829 struct hlist_node *node;
830 struct hlist_head *head;
831 int i, j;
832
833 for (i = 0; i < hash->size; i++) {
834 head = &hash->table[i];
835
836 rcu_read_lock();
837 hlist_for_each_entry_rcu(tt_global_entry, node,
838 head, hash_entry) {
839 if (compare_eth(tt_global_entry->orig_node,
840 orig_node)) {
Antonio Quartullicc47f662011-04-27 14:27:57 +0200841 /* Roaming clients are in the global table for
842 * consistency only. They don't have to be
843 * taken into account while computing the
844 * global crc */
845 if (tt_global_entry->flags & TT_CLIENT_ROAM)
846 continue;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200847 total_one = 0;
848 for (j = 0; j < ETH_ALEN; j++)
849 total_one = crc16_byte(total_one,
850 tt_global_entry->addr[j]);
851 total ^= total_one;
852 }
853 }
854 rcu_read_unlock();
855 }
856
857 return total;
858}
859
860/* Calculates the checksum of the local table */
861uint16_t tt_local_crc(struct bat_priv *bat_priv)
862{
863 uint16_t total = 0, total_one;
864 struct hashtable_t *hash = bat_priv->tt_local_hash;
865 struct tt_local_entry *tt_local_entry;
866 struct hlist_node *node;
867 struct hlist_head *head;
868 int i, j;
869
870 for (i = 0; i < hash->size; i++) {
871 head = &hash->table[i];
872
873 rcu_read_lock();
874 hlist_for_each_entry_rcu(tt_local_entry, node,
875 head, hash_entry) {
Antonio Quartulli058d0e22011-07-07 01:40:58 +0200876 /* not yet committed clients have not to be taken into
877 * account while computing the CRC */
878 if (tt_local_entry->flags & TT_CLIENT_NEW)
879 continue;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200880 total_one = 0;
881 for (j = 0; j < ETH_ALEN; j++)
882 total_one = crc16_byte(total_one,
883 tt_local_entry->addr[j]);
884 total ^= total_one;
885 }
Antonio Quartullia73105b2011-04-27 14:27:44 +0200886 rcu_read_unlock();
887 }
888
889 return total;
890}
891
892static void tt_req_list_free(struct bat_priv *bat_priv)
893{
894 struct tt_req_node *node, *safe;
895
896 spin_lock_bh(&bat_priv->tt_req_list_lock);
897
898 list_for_each_entry_safe(node, safe, &bat_priv->tt_req_list, list) {
899 list_del(&node->list);
900 kfree(node);
901 }
902
903 spin_unlock_bh(&bat_priv->tt_req_list_lock);
904}
905
906void tt_save_orig_buffer(struct bat_priv *bat_priv, struct orig_node *orig_node,
907 const unsigned char *tt_buff, uint8_t tt_num_changes)
908{
909 uint16_t tt_buff_len = tt_len(tt_num_changes);
910
911 /* Replace the old buffer only if I received something in the
912 * last OGM (the OGM could carry no changes) */
913 spin_lock_bh(&orig_node->tt_buff_lock);
914 if (tt_buff_len > 0) {
915 kfree(orig_node->tt_buff);
916 orig_node->tt_buff_len = 0;
917 orig_node->tt_buff = kmalloc(tt_buff_len, GFP_ATOMIC);
918 if (orig_node->tt_buff) {
919 memcpy(orig_node->tt_buff, tt_buff, tt_buff_len);
920 orig_node->tt_buff_len = tt_buff_len;
921 }
922 }
923 spin_unlock_bh(&orig_node->tt_buff_lock);
924}
925
926static void tt_req_purge(struct bat_priv *bat_priv)
927{
928 struct tt_req_node *node, *safe;
929
930 spin_lock_bh(&bat_priv->tt_req_list_lock);
931 list_for_each_entry_safe(node, safe, &bat_priv->tt_req_list, list) {
932 if (is_out_of_time(node->issued_at,
933 TT_REQUEST_TIMEOUT * 1000)) {
934 list_del(&node->list);
935 kfree(node);
936 }
937 }
938 spin_unlock_bh(&bat_priv->tt_req_list_lock);
939}
940
941/* returns the pointer to the new tt_req_node struct if no request
942 * has already been issued for this orig_node, NULL otherwise */
943static struct tt_req_node *new_tt_req_node(struct bat_priv *bat_priv,
944 struct orig_node *orig_node)
945{
946 struct tt_req_node *tt_req_node_tmp, *tt_req_node = NULL;
947
948 spin_lock_bh(&bat_priv->tt_req_list_lock);
949 list_for_each_entry(tt_req_node_tmp, &bat_priv->tt_req_list, list) {
950 if (compare_eth(tt_req_node_tmp, orig_node) &&
951 !is_out_of_time(tt_req_node_tmp->issued_at,
952 TT_REQUEST_TIMEOUT * 1000))
953 goto unlock;
954 }
955
956 tt_req_node = kmalloc(sizeof(*tt_req_node), GFP_ATOMIC);
957 if (!tt_req_node)
958 goto unlock;
959
960 memcpy(tt_req_node->addr, orig_node->orig, ETH_ALEN);
961 tt_req_node->issued_at = jiffies;
962
963 list_add(&tt_req_node->list, &bat_priv->tt_req_list);
964unlock:
965 spin_unlock_bh(&bat_priv->tt_req_list_lock);
966 return tt_req_node;
967}
968
Antonio Quartulli058d0e22011-07-07 01:40:58 +0200969/* data_ptr is useless here, but has to be kept to respect the prototype */
970static int tt_local_valid_entry(const void *entry_ptr, const void *data_ptr)
971{
972 const struct tt_local_entry *tt_local_entry = entry_ptr;
973
974 if (tt_local_entry->flags & TT_CLIENT_NEW)
975 return 0;
976 return 1;
977}
978
Antonio Quartullia73105b2011-04-27 14:27:44 +0200979static int tt_global_valid_entry(const void *entry_ptr, const void *data_ptr)
980{
981 const struct tt_global_entry *tt_global_entry = entry_ptr;
982 const struct orig_node *orig_node = data_ptr;
983
Antonio Quartullicc47f662011-04-27 14:27:57 +0200984 if (tt_global_entry->flags & TT_CLIENT_ROAM)
985 return 0;
986
Antonio Quartullia73105b2011-04-27 14:27:44 +0200987 return (tt_global_entry->orig_node == orig_node);
988}
989
990static struct sk_buff *tt_response_fill_table(uint16_t tt_len, uint8_t ttvn,
991 struct hashtable_t *hash,
992 struct hard_iface *primary_if,
993 int (*valid_cb)(const void *,
994 const void *),
995 void *cb_data)
996{
997 struct tt_local_entry *tt_local_entry;
998 struct tt_query_packet *tt_response;
999 struct tt_change *tt_change;
1000 struct hlist_node *node;
1001 struct hlist_head *head;
1002 struct sk_buff *skb = NULL;
1003 uint16_t tt_tot, tt_count;
1004 ssize_t tt_query_size = sizeof(struct tt_query_packet);
1005 int i;
1006
1007 if (tt_query_size + tt_len > primary_if->soft_iface->mtu) {
1008 tt_len = primary_if->soft_iface->mtu - tt_query_size;
1009 tt_len -= tt_len % sizeof(struct tt_change);
1010 }
1011 tt_tot = tt_len / sizeof(struct tt_change);
1012
1013 skb = dev_alloc_skb(tt_query_size + tt_len + ETH_HLEN);
1014 if (!skb)
1015 goto out;
1016
1017 skb_reserve(skb, ETH_HLEN);
1018 tt_response = (struct tt_query_packet *)skb_put(skb,
1019 tt_query_size + tt_len);
1020 tt_response->ttvn = ttvn;
1021 tt_response->tt_data = htons(tt_tot);
1022
1023 tt_change = (struct tt_change *)(skb->data + tt_query_size);
1024 tt_count = 0;
1025
1026 rcu_read_lock();
1027 for (i = 0; i < hash->size; i++) {
1028 head = &hash->table[i];
1029
1030 hlist_for_each_entry_rcu(tt_local_entry, node,
1031 head, hash_entry) {
1032 if (tt_count == tt_tot)
1033 break;
1034
1035 if ((valid_cb) && (!valid_cb(tt_local_entry, cb_data)))
1036 continue;
1037
1038 memcpy(tt_change->addr, tt_local_entry->addr, ETH_ALEN);
1039 tt_change->flags = NO_FLAGS;
1040
1041 tt_count++;
1042 tt_change++;
1043 }
1044 }
1045 rcu_read_unlock();
1046
1047out:
1048 return skb;
1049}
1050
1051int send_tt_request(struct bat_priv *bat_priv, struct orig_node *dst_orig_node,
1052 uint8_t ttvn, uint16_t tt_crc, bool full_table)
1053{
1054 struct sk_buff *skb = NULL;
1055 struct tt_query_packet *tt_request;
1056 struct neigh_node *neigh_node = NULL;
1057 struct hard_iface *primary_if;
1058 struct tt_req_node *tt_req_node = NULL;
1059 int ret = 1;
1060
1061 primary_if = primary_if_get_selected(bat_priv);
1062 if (!primary_if)
1063 goto out;
1064
1065 /* The new tt_req will be issued only if I'm not waiting for a
1066 * reply from the same orig_node yet */
1067 tt_req_node = new_tt_req_node(bat_priv, dst_orig_node);
1068 if (!tt_req_node)
1069 goto out;
1070
1071 skb = dev_alloc_skb(sizeof(struct tt_query_packet) + ETH_HLEN);
1072 if (!skb)
1073 goto out;
1074
1075 skb_reserve(skb, ETH_HLEN);
1076
1077 tt_request = (struct tt_query_packet *)skb_put(skb,
1078 sizeof(struct tt_query_packet));
1079
1080 tt_request->packet_type = BAT_TT_QUERY;
1081 tt_request->version = COMPAT_VERSION;
1082 memcpy(tt_request->src, primary_if->net_dev->dev_addr, ETH_ALEN);
1083 memcpy(tt_request->dst, dst_orig_node->orig, ETH_ALEN);
1084 tt_request->ttl = TTL;
1085 tt_request->ttvn = ttvn;
1086 tt_request->tt_data = tt_crc;
1087 tt_request->flags = TT_REQUEST;
1088
1089 if (full_table)
1090 tt_request->flags |= TT_FULL_TABLE;
1091
1092 neigh_node = orig_node_get_router(dst_orig_node);
1093 if (!neigh_node)
1094 goto out;
1095
1096 bat_dbg(DBG_TT, bat_priv, "Sending TT_REQUEST to %pM via %pM "
1097 "[%c]\n", dst_orig_node->orig, neigh_node->addr,
1098 (full_table ? 'F' : '.'));
1099
1100 send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
1101 ret = 0;
1102
1103out:
1104 if (neigh_node)
1105 neigh_node_free_ref(neigh_node);
1106 if (primary_if)
1107 hardif_free_ref(primary_if);
1108 if (ret)
1109 kfree_skb(skb);
1110 if (ret && tt_req_node) {
1111 spin_lock_bh(&bat_priv->tt_req_list_lock);
1112 list_del(&tt_req_node->list);
1113 spin_unlock_bh(&bat_priv->tt_req_list_lock);
1114 kfree(tt_req_node);
1115 }
1116 return ret;
1117}
1118
1119static bool send_other_tt_response(struct bat_priv *bat_priv,
1120 struct tt_query_packet *tt_request)
1121{
1122 struct orig_node *req_dst_orig_node = NULL, *res_dst_orig_node = NULL;
1123 struct neigh_node *neigh_node = NULL;
1124 struct hard_iface *primary_if = NULL;
1125 uint8_t orig_ttvn, req_ttvn, ttvn;
1126 int ret = false;
1127 unsigned char *tt_buff;
1128 bool full_table;
1129 uint16_t tt_len, tt_tot;
1130 struct sk_buff *skb = NULL;
1131 struct tt_query_packet *tt_response;
1132
1133 bat_dbg(DBG_TT, bat_priv,
1134 "Received TT_REQUEST from %pM for "
1135 "ttvn: %u (%pM) [%c]\n", tt_request->src,
1136 tt_request->ttvn, tt_request->dst,
1137 (tt_request->flags & TT_FULL_TABLE ? 'F' : '.'));
1138
1139 /* Let's get the orig node of the REAL destination */
1140 req_dst_orig_node = get_orig_node(bat_priv, tt_request->dst);
1141 if (!req_dst_orig_node)
1142 goto out;
1143
1144 res_dst_orig_node = get_orig_node(bat_priv, tt_request->src);
1145 if (!res_dst_orig_node)
1146 goto out;
1147
1148 neigh_node = orig_node_get_router(res_dst_orig_node);
1149 if (!neigh_node)
1150 goto out;
1151
1152 primary_if = primary_if_get_selected(bat_priv);
1153 if (!primary_if)
1154 goto out;
1155
1156 orig_ttvn = (uint8_t)atomic_read(&req_dst_orig_node->last_ttvn);
1157 req_ttvn = tt_request->ttvn;
1158
Antonio Quartulli015758d2011-07-09 17:52:13 +02001159 /* I don't have the requested data */
Antonio Quartullia73105b2011-04-27 14:27:44 +02001160 if (orig_ttvn != req_ttvn ||
1161 tt_request->tt_data != req_dst_orig_node->tt_crc)
1162 goto out;
1163
Antonio Quartulli015758d2011-07-09 17:52:13 +02001164 /* If the full table has been explicitly requested */
Antonio Quartullia73105b2011-04-27 14:27:44 +02001165 if (tt_request->flags & TT_FULL_TABLE ||
1166 !req_dst_orig_node->tt_buff)
1167 full_table = true;
1168 else
1169 full_table = false;
1170
1171 /* In this version, fragmentation is not implemented, then
1172 * I'll send only one packet with as much TT entries as I can */
1173 if (!full_table) {
1174 spin_lock_bh(&req_dst_orig_node->tt_buff_lock);
1175 tt_len = req_dst_orig_node->tt_buff_len;
1176 tt_tot = tt_len / sizeof(struct tt_change);
1177
1178 skb = dev_alloc_skb(sizeof(struct tt_query_packet) +
1179 tt_len + ETH_HLEN);
1180 if (!skb)
1181 goto unlock;
1182
1183 skb_reserve(skb, ETH_HLEN);
1184 tt_response = (struct tt_query_packet *)skb_put(skb,
1185 sizeof(struct tt_query_packet) + tt_len);
1186 tt_response->ttvn = req_ttvn;
1187 tt_response->tt_data = htons(tt_tot);
1188
1189 tt_buff = skb->data + sizeof(struct tt_query_packet);
1190 /* Copy the last orig_node's OGM buffer */
1191 memcpy(tt_buff, req_dst_orig_node->tt_buff,
1192 req_dst_orig_node->tt_buff_len);
1193
1194 spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
1195 } else {
1196 tt_len = (uint16_t)atomic_read(&req_dst_orig_node->tt_size) *
1197 sizeof(struct tt_change);
1198 ttvn = (uint8_t)atomic_read(&req_dst_orig_node->last_ttvn);
1199
1200 skb = tt_response_fill_table(tt_len, ttvn,
1201 bat_priv->tt_global_hash,
1202 primary_if, tt_global_valid_entry,
1203 req_dst_orig_node);
1204 if (!skb)
1205 goto out;
1206
1207 tt_response = (struct tt_query_packet *)skb->data;
1208 }
1209
1210 tt_response->packet_type = BAT_TT_QUERY;
1211 tt_response->version = COMPAT_VERSION;
1212 tt_response->ttl = TTL;
1213 memcpy(tt_response->src, req_dst_orig_node->orig, ETH_ALEN);
1214 memcpy(tt_response->dst, tt_request->src, ETH_ALEN);
1215 tt_response->flags = TT_RESPONSE;
1216
1217 if (full_table)
1218 tt_response->flags |= TT_FULL_TABLE;
1219
1220 bat_dbg(DBG_TT, bat_priv,
1221 "Sending TT_RESPONSE %pM via %pM for %pM (ttvn: %u)\n",
1222 res_dst_orig_node->orig, neigh_node->addr,
1223 req_dst_orig_node->orig, req_ttvn);
1224
1225 send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
1226 ret = true;
1227 goto out;
1228
1229unlock:
1230 spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
1231
1232out:
1233 if (res_dst_orig_node)
1234 orig_node_free_ref(res_dst_orig_node);
1235 if (req_dst_orig_node)
1236 orig_node_free_ref(req_dst_orig_node);
1237 if (neigh_node)
1238 neigh_node_free_ref(neigh_node);
1239 if (primary_if)
1240 hardif_free_ref(primary_if);
1241 if (!ret)
1242 kfree_skb(skb);
1243 return ret;
1244
1245}
1246static bool send_my_tt_response(struct bat_priv *bat_priv,
1247 struct tt_query_packet *tt_request)
1248{
1249 struct orig_node *orig_node = NULL;
1250 struct neigh_node *neigh_node = NULL;
1251 struct hard_iface *primary_if = NULL;
1252 uint8_t my_ttvn, req_ttvn, ttvn;
1253 int ret = false;
1254 unsigned char *tt_buff;
1255 bool full_table;
1256 uint16_t tt_len, tt_tot;
1257 struct sk_buff *skb = NULL;
1258 struct tt_query_packet *tt_response;
1259
1260 bat_dbg(DBG_TT, bat_priv,
1261 "Received TT_REQUEST from %pM for "
1262 "ttvn: %u (me) [%c]\n", tt_request->src,
1263 tt_request->ttvn,
1264 (tt_request->flags & TT_FULL_TABLE ? 'F' : '.'));
1265
1266
1267 my_ttvn = (uint8_t)atomic_read(&bat_priv->ttvn);
1268 req_ttvn = tt_request->ttvn;
1269
1270 orig_node = get_orig_node(bat_priv, tt_request->src);
1271 if (!orig_node)
1272 goto out;
1273
1274 neigh_node = orig_node_get_router(orig_node);
1275 if (!neigh_node)
1276 goto out;
1277
1278 primary_if = primary_if_get_selected(bat_priv);
1279 if (!primary_if)
1280 goto out;
1281
1282 /* If the full table has been explicitly requested or the gap
1283 * is too big send the whole local translation table */
1284 if (tt_request->flags & TT_FULL_TABLE || my_ttvn != req_ttvn ||
1285 !bat_priv->tt_buff)
1286 full_table = true;
1287 else
1288 full_table = false;
1289
1290 /* In this version, fragmentation is not implemented, then
1291 * I'll send only one packet with as much TT entries as I can */
1292 if (!full_table) {
1293 spin_lock_bh(&bat_priv->tt_buff_lock);
1294 tt_len = bat_priv->tt_buff_len;
1295 tt_tot = tt_len / sizeof(struct tt_change);
1296
1297 skb = dev_alloc_skb(sizeof(struct tt_query_packet) +
1298 tt_len + ETH_HLEN);
1299 if (!skb)
1300 goto unlock;
1301
1302 skb_reserve(skb, ETH_HLEN);
1303 tt_response = (struct tt_query_packet *)skb_put(skb,
1304 sizeof(struct tt_query_packet) + tt_len);
1305 tt_response->ttvn = req_ttvn;
1306 tt_response->tt_data = htons(tt_tot);
1307
1308 tt_buff = skb->data + sizeof(struct tt_query_packet);
1309 memcpy(tt_buff, bat_priv->tt_buff,
1310 bat_priv->tt_buff_len);
1311 spin_unlock_bh(&bat_priv->tt_buff_lock);
1312 } else {
1313 tt_len = (uint16_t)atomic_read(&bat_priv->num_local_tt) *
1314 sizeof(struct tt_change);
1315 ttvn = (uint8_t)atomic_read(&bat_priv->ttvn);
1316
1317 skb = tt_response_fill_table(tt_len, ttvn,
1318 bat_priv->tt_local_hash,
Antonio Quartulli058d0e22011-07-07 01:40:58 +02001319 primary_if, tt_local_valid_entry,
1320 NULL);
Antonio Quartullia73105b2011-04-27 14:27:44 +02001321 if (!skb)
1322 goto out;
1323
1324 tt_response = (struct tt_query_packet *)skb->data;
1325 }
1326
1327 tt_response->packet_type = BAT_TT_QUERY;
1328 tt_response->version = COMPAT_VERSION;
1329 tt_response->ttl = TTL;
1330 memcpy(tt_response->src, primary_if->net_dev->dev_addr, ETH_ALEN);
1331 memcpy(tt_response->dst, tt_request->src, ETH_ALEN);
1332 tt_response->flags = TT_RESPONSE;
1333
1334 if (full_table)
1335 tt_response->flags |= TT_FULL_TABLE;
1336
1337 bat_dbg(DBG_TT, bat_priv,
1338 "Sending TT_RESPONSE to %pM via %pM [%c]\n",
1339 orig_node->orig, neigh_node->addr,
1340 (tt_response->flags & TT_FULL_TABLE ? 'F' : '.'));
1341
1342 send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
1343 ret = true;
1344 goto out;
1345
1346unlock:
1347 spin_unlock_bh(&bat_priv->tt_buff_lock);
1348out:
1349 if (orig_node)
1350 orig_node_free_ref(orig_node);
1351 if (neigh_node)
1352 neigh_node_free_ref(neigh_node);
1353 if (primary_if)
1354 hardif_free_ref(primary_if);
1355 if (!ret)
1356 kfree_skb(skb);
1357 /* This packet was for me, so it doesn't need to be re-routed */
1358 return true;
1359}
1360
1361bool send_tt_response(struct bat_priv *bat_priv,
1362 struct tt_query_packet *tt_request)
1363{
1364 if (is_my_mac(tt_request->dst))
1365 return send_my_tt_response(bat_priv, tt_request);
1366 else
1367 return send_other_tt_response(bat_priv, tt_request);
1368}
1369
1370static void _tt_update_changes(struct bat_priv *bat_priv,
1371 struct orig_node *orig_node,
1372 struct tt_change *tt_change,
1373 uint16_t tt_num_changes, uint8_t ttvn)
1374{
1375 int i;
1376
1377 for (i = 0; i < tt_num_changes; i++) {
Antonio Quartulli5fbc1592011-06-17 16:11:27 +02001378 if ((tt_change + i)->flags & TT_CLIENT_DEL)
Antonio Quartullia73105b2011-04-27 14:27:44 +02001379 tt_global_del(bat_priv, orig_node,
1380 (tt_change + i)->addr,
Antonio Quartullicc47f662011-04-27 14:27:57 +02001381 "tt removed by changes",
1382 (tt_change + i)->flags & TT_CLIENT_ROAM);
Antonio Quartullia73105b2011-04-27 14:27:44 +02001383 else
1384 if (!tt_global_add(bat_priv, orig_node,
Antonio Quartullibc279082011-07-07 15:35:35 +02001385 (tt_change + i)->addr, ttvn, false,
1386 (tt_change + i)->flags &
1387 TT_CLIENT_WIFI))
Antonio Quartullia73105b2011-04-27 14:27:44 +02001388 /* In case of problem while storing a
1389 * global_entry, we stop the updating
1390 * procedure without committing the
1391 * ttvn change. This will avoid to send
1392 * corrupted data on tt_request
1393 */
1394 return;
1395 }
1396}
1397
1398static void tt_fill_gtable(struct bat_priv *bat_priv,
1399 struct tt_query_packet *tt_response)
1400{
1401 struct orig_node *orig_node = NULL;
1402
1403 orig_node = orig_hash_find(bat_priv, tt_response->src);
1404 if (!orig_node)
1405 goto out;
1406
1407 /* Purge the old table first.. */
1408 tt_global_del_orig(bat_priv, orig_node, "Received full table");
1409
1410 _tt_update_changes(bat_priv, orig_node,
1411 (struct tt_change *)(tt_response + 1),
1412 tt_response->tt_data, tt_response->ttvn);
1413
1414 spin_lock_bh(&orig_node->tt_buff_lock);
1415 kfree(orig_node->tt_buff);
1416 orig_node->tt_buff_len = 0;
1417 orig_node->tt_buff = NULL;
1418 spin_unlock_bh(&orig_node->tt_buff_lock);
1419
1420 atomic_set(&orig_node->last_ttvn, tt_response->ttvn);
1421
1422out:
1423 if (orig_node)
1424 orig_node_free_ref(orig_node);
1425}
1426
1427void tt_update_changes(struct bat_priv *bat_priv, struct orig_node *orig_node,
1428 uint16_t tt_num_changes, uint8_t ttvn,
1429 struct tt_change *tt_change)
1430{
1431 _tt_update_changes(bat_priv, orig_node, tt_change, tt_num_changes,
1432 ttvn);
1433
1434 tt_save_orig_buffer(bat_priv, orig_node, (unsigned char *)tt_change,
1435 tt_num_changes);
1436 atomic_set(&orig_node->last_ttvn, ttvn);
1437}
1438
1439bool is_my_client(struct bat_priv *bat_priv, const uint8_t *addr)
1440{
Antonio Quartulli7683fdc2011-04-27 14:28:07 +02001441 struct tt_local_entry *tt_local_entry = NULL;
1442 bool ret = false;
Antonio Quartullia73105b2011-04-27 14:27:44 +02001443
Antonio Quartullia73105b2011-04-27 14:27:44 +02001444 tt_local_entry = tt_local_hash_find(bat_priv, addr);
Antonio Quartulli7683fdc2011-04-27 14:28:07 +02001445 if (!tt_local_entry)
1446 goto out;
Antonio Quartulli058d0e22011-07-07 01:40:58 +02001447 /* Check if the client has been logically deleted (but is kept for
1448 * consistency purpose) */
1449 if (tt_local_entry->flags & TT_CLIENT_PENDING)
1450 goto out;
Antonio Quartulli7683fdc2011-04-27 14:28:07 +02001451 ret = true;
1452out:
Antonio Quartullia73105b2011-04-27 14:27:44 +02001453 if (tt_local_entry)
Antonio Quartulli7683fdc2011-04-27 14:28:07 +02001454 tt_local_entry_free_ref(tt_local_entry);
1455 return ret;
Antonio Quartullia73105b2011-04-27 14:27:44 +02001456}
1457
1458void handle_tt_response(struct bat_priv *bat_priv,
1459 struct tt_query_packet *tt_response)
1460{
1461 struct tt_req_node *node, *safe;
1462 struct orig_node *orig_node = NULL;
1463
1464 bat_dbg(DBG_TT, bat_priv, "Received TT_RESPONSE from %pM for "
1465 "ttvn %d t_size: %d [%c]\n",
1466 tt_response->src, tt_response->ttvn,
1467 tt_response->tt_data,
1468 (tt_response->flags & TT_FULL_TABLE ? 'F' : '.'));
1469
1470 orig_node = orig_hash_find(bat_priv, tt_response->src);
1471 if (!orig_node)
1472 goto out;
1473
1474 if (tt_response->flags & TT_FULL_TABLE)
1475 tt_fill_gtable(bat_priv, tt_response);
1476 else
1477 tt_update_changes(bat_priv, orig_node, tt_response->tt_data,
1478 tt_response->ttvn,
1479 (struct tt_change *)(tt_response + 1));
1480
1481 /* Delete the tt_req_node from pending tt_requests list */
1482 spin_lock_bh(&bat_priv->tt_req_list_lock);
1483 list_for_each_entry_safe(node, safe, &bat_priv->tt_req_list, list) {
1484 if (!compare_eth(node->addr, tt_response->src))
1485 continue;
1486 list_del(&node->list);
1487 kfree(node);
1488 }
1489 spin_unlock_bh(&bat_priv->tt_req_list_lock);
1490
1491 /* Recalculate the CRC for this orig_node and store it */
Antonio Quartullia73105b2011-04-27 14:27:44 +02001492 orig_node->tt_crc = tt_global_crc(bat_priv, orig_node);
Antonio Quartullicc47f662011-04-27 14:27:57 +02001493 /* Roaming phase is over: tables are in sync again. I can
1494 * unset the flag */
1495 orig_node->tt_poss_change = false;
Antonio Quartullia73105b2011-04-27 14:27:44 +02001496out:
1497 if (orig_node)
1498 orig_node_free_ref(orig_node);
1499}
1500
1501int tt_init(struct bat_priv *bat_priv)
1502{
1503 if (!tt_local_init(bat_priv))
1504 return 0;
1505
1506 if (!tt_global_init(bat_priv))
1507 return 0;
1508
1509 tt_start_timer(bat_priv);
1510
1511 return 1;
1512}
1513
Antonio Quartullicc47f662011-04-27 14:27:57 +02001514static void tt_roam_list_free(struct bat_priv *bat_priv)
Antonio Quartullia73105b2011-04-27 14:27:44 +02001515{
Antonio Quartullicc47f662011-04-27 14:27:57 +02001516 struct tt_roam_node *node, *safe;
Antonio Quartullia73105b2011-04-27 14:27:44 +02001517
Antonio Quartullicc47f662011-04-27 14:27:57 +02001518 spin_lock_bh(&bat_priv->tt_roam_list_lock);
Antonio Quartullia73105b2011-04-27 14:27:44 +02001519
Antonio Quartullicc47f662011-04-27 14:27:57 +02001520 list_for_each_entry_safe(node, safe, &bat_priv->tt_roam_list, list) {
1521 list_del(&node->list);
1522 kfree(node);
1523 }
1524
1525 spin_unlock_bh(&bat_priv->tt_roam_list_lock);
1526}
1527
1528static void tt_roam_purge(struct bat_priv *bat_priv)
1529{
1530 struct tt_roam_node *node, *safe;
1531
1532 spin_lock_bh(&bat_priv->tt_roam_list_lock);
1533 list_for_each_entry_safe(node, safe, &bat_priv->tt_roam_list, list) {
1534 if (!is_out_of_time(node->first_time,
1535 ROAMING_MAX_TIME * 1000))
1536 continue;
1537
1538 list_del(&node->list);
1539 kfree(node);
1540 }
1541 spin_unlock_bh(&bat_priv->tt_roam_list_lock);
1542}
1543
1544/* This function checks whether the client already reached the
1545 * maximum number of possible roaming phases. In this case the ROAMING_ADV
1546 * will not be sent.
1547 *
1548 * returns true if the ROAMING_ADV can be sent, false otherwise */
1549static bool tt_check_roam_count(struct bat_priv *bat_priv,
1550 uint8_t *client)
1551{
1552 struct tt_roam_node *tt_roam_node;
1553 bool ret = false;
1554
1555 spin_lock_bh(&bat_priv->tt_roam_list_lock);
1556 /* The new tt_req will be issued only if I'm not waiting for a
1557 * reply from the same orig_node yet */
1558 list_for_each_entry(tt_roam_node, &bat_priv->tt_roam_list, list) {
1559 if (!compare_eth(tt_roam_node->addr, client))
1560 continue;
1561
1562 if (is_out_of_time(tt_roam_node->first_time,
1563 ROAMING_MAX_TIME * 1000))
1564 continue;
1565
1566 if (!atomic_dec_not_zero(&tt_roam_node->counter))
1567 /* Sorry, you roamed too many times! */
1568 goto unlock;
1569 ret = true;
1570 break;
1571 }
1572
1573 if (!ret) {
1574 tt_roam_node = kmalloc(sizeof(*tt_roam_node), GFP_ATOMIC);
1575 if (!tt_roam_node)
1576 goto unlock;
1577
1578 tt_roam_node->first_time = jiffies;
1579 atomic_set(&tt_roam_node->counter, ROAMING_MAX_COUNT - 1);
1580 memcpy(tt_roam_node->addr, client, ETH_ALEN);
1581
1582 list_add(&tt_roam_node->list, &bat_priv->tt_roam_list);
1583 ret = true;
1584 }
1585
1586unlock:
1587 spin_unlock_bh(&bat_priv->tt_roam_list_lock);
1588 return ret;
1589}
1590
1591void send_roam_adv(struct bat_priv *bat_priv, uint8_t *client,
1592 struct orig_node *orig_node)
1593{
1594 struct neigh_node *neigh_node = NULL;
1595 struct sk_buff *skb = NULL;
1596 struct roam_adv_packet *roam_adv_packet;
1597 int ret = 1;
1598 struct hard_iface *primary_if;
1599
1600 /* before going on we have to check whether the client has
1601 * already roamed to us too many times */
1602 if (!tt_check_roam_count(bat_priv, client))
1603 goto out;
1604
1605 skb = dev_alloc_skb(sizeof(struct roam_adv_packet) + ETH_HLEN);
1606 if (!skb)
1607 goto out;
1608
1609 skb_reserve(skb, ETH_HLEN);
1610
1611 roam_adv_packet = (struct roam_adv_packet *)skb_put(skb,
1612 sizeof(struct roam_adv_packet));
1613
1614 roam_adv_packet->packet_type = BAT_ROAM_ADV;
1615 roam_adv_packet->version = COMPAT_VERSION;
1616 roam_adv_packet->ttl = TTL;
1617 primary_if = primary_if_get_selected(bat_priv);
1618 if (!primary_if)
1619 goto out;
1620 memcpy(roam_adv_packet->src, primary_if->net_dev->dev_addr, ETH_ALEN);
1621 hardif_free_ref(primary_if);
1622 memcpy(roam_adv_packet->dst, orig_node->orig, ETH_ALEN);
1623 memcpy(roam_adv_packet->client, client, ETH_ALEN);
1624
1625 neigh_node = orig_node_get_router(orig_node);
1626 if (!neigh_node)
1627 goto out;
1628
1629 bat_dbg(DBG_TT, bat_priv,
1630 "Sending ROAMING_ADV to %pM (client %pM) via %pM\n",
1631 orig_node->orig, client, neigh_node->addr);
1632
1633 send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
1634 ret = 0;
1635
1636out:
1637 if (neigh_node)
1638 neigh_node_free_ref(neigh_node);
1639 if (ret)
1640 kfree_skb(skb);
1641 return;
Antonio Quartullia73105b2011-04-27 14:27:44 +02001642}
1643
1644static void tt_purge(struct work_struct *work)
1645{
1646 struct delayed_work *delayed_work =
1647 container_of(work, struct delayed_work, work);
1648 struct bat_priv *bat_priv =
1649 container_of(delayed_work, struct bat_priv, tt_work);
1650
1651 tt_local_purge(bat_priv);
Antonio Quartullicc47f662011-04-27 14:27:57 +02001652 tt_global_roam_purge(bat_priv);
Antonio Quartullia73105b2011-04-27 14:27:44 +02001653 tt_req_purge(bat_priv);
Antonio Quartullicc47f662011-04-27 14:27:57 +02001654 tt_roam_purge(bat_priv);
Antonio Quartullia73105b2011-04-27 14:27:44 +02001655
1656 tt_start_timer(bat_priv);
1657}
Antonio Quartullicc47f662011-04-27 14:27:57 +02001658
1659void tt_free(struct bat_priv *bat_priv)
1660{
1661 cancel_delayed_work_sync(&bat_priv->tt_work);
1662
1663 tt_local_table_free(bat_priv);
1664 tt_global_table_free(bat_priv);
1665 tt_req_list_free(bat_priv);
1666 tt_changes_list_free(bat_priv);
1667 tt_roam_list_free(bat_priv);
1668
1669 kfree(bat_priv->tt_buff);
1670}
Antonio Quartulli058d0e22011-07-07 01:40:58 +02001671
1672/* This function will reset the specified flags from all the entries in
1673 * the given hash table and will increment num_local_tt for each involved
1674 * entry */
1675static void tt_local_reset_flags(struct bat_priv *bat_priv, uint16_t flags)
1676{
1677 int i;
1678 struct hashtable_t *hash = bat_priv->tt_local_hash;
1679 struct hlist_head *head;
1680 struct hlist_node *node;
1681 struct tt_local_entry *tt_local_entry;
1682
1683 if (!hash)
1684 return;
1685
1686 for (i = 0; i < hash->size; i++) {
1687 head = &hash->table[i];
1688
1689 rcu_read_lock();
1690 hlist_for_each_entry_rcu(tt_local_entry, node,
1691 head, hash_entry) {
1692 tt_local_entry->flags &= ~flags;
1693 atomic_inc(&bat_priv->num_local_tt);
1694 }
1695 rcu_read_unlock();
1696 }
1697
1698}
1699
1700/* Purge out all the tt local entries marked with TT_CLIENT_PENDING */
1701static void tt_local_purge_pending_clients(struct bat_priv *bat_priv)
1702{
1703 struct hashtable_t *hash = bat_priv->tt_local_hash;
1704 struct tt_local_entry *tt_local_entry;
1705 struct hlist_node *node, *node_tmp;
1706 struct hlist_head *head;
1707 spinlock_t *list_lock; /* protects write access to the hash lists */
1708 int i;
1709
1710 if (!hash)
1711 return;
1712
1713 for (i = 0; i < hash->size; i++) {
1714 head = &hash->table[i];
1715 list_lock = &hash->list_locks[i];
1716
1717 spin_lock_bh(list_lock);
1718 hlist_for_each_entry_safe(tt_local_entry, node, node_tmp,
1719 head, hash_entry) {
1720 if (!(tt_local_entry->flags & TT_CLIENT_PENDING))
1721 continue;
1722
1723 bat_dbg(DBG_TT, bat_priv, "Deleting local tt entry "
1724 "(%pM): pending\n", tt_local_entry->addr);
1725
1726 atomic_dec(&bat_priv->num_local_tt);
1727 hlist_del_rcu(node);
1728 tt_local_entry_free_ref(tt_local_entry);
1729 }
1730 spin_unlock_bh(list_lock);
1731 }
1732
1733}
1734
1735void tt_commit_changes(struct bat_priv *bat_priv)
1736{
1737 tt_local_reset_flags(bat_priv, TT_CLIENT_NEW);
1738 tt_local_purge_pending_clients(bat_priv);
1739
1740 /* Increment the TTVN only once per OGM interval */
1741 atomic_inc(&bat_priv->ttvn);
1742 bat_priv->tt_poss_change = false;
1743}
Antonio Quartulli59b699c2011-07-07 15:35:36 +02001744
1745bool is_ap_isolated(struct bat_priv *bat_priv, uint8_t *src, uint8_t *dst)
1746{
1747 struct tt_local_entry *tt_local_entry = NULL;
1748 struct tt_global_entry *tt_global_entry = NULL;
1749 bool ret = true;
1750
1751 if (!atomic_read(&bat_priv->ap_isolation))
1752 return false;
1753
1754 tt_local_entry = tt_local_hash_find(bat_priv, dst);
1755 if (!tt_local_entry)
1756 goto out;
1757
1758 tt_global_entry = tt_global_hash_find(bat_priv, src);
1759 if (!tt_global_entry)
1760 goto out;
1761
1762 if (_is_ap_isolated(tt_local_entry, tt_global_entry))
1763 goto out;
1764
1765 ret = false;
1766
1767out:
1768 if (tt_global_entry)
1769 tt_global_entry_free_ref(tt_global_entry);
1770 if (tt_local_entry)
1771 tt_local_entry_free_ref(tt_local_entry);
1772 return ret;
1773}