aboutsummaryrefslogtreecommitdiffstats
path: root/net/batman-adv/routing.c
diff options
context:
space:
mode:
Diffstat (limited to 'net/batman-adv/routing.c')
-rw-r--r--net/batman-adv/routing.c501
1 files changed, 271 insertions, 230 deletions
diff --git a/net/batman-adv/routing.c b/net/batman-adv/routing.c
index 015471d801b4..b3fd61c90f32 100644
--- a/net/batman-adv/routing.c
+++ b/net/batman-adv/routing.c
@@ -1,5 +1,4 @@
1/* 1/* Copyright (C) 2007-2012 B.A.T.M.A.N. contributors:
2 * Copyright (C) 2007-2012 B.A.T.M.A.N. contributors:
3 * 2 *
4 * Marek Lindner, Simon Wunderlich 3 * Marek Lindner, Simon Wunderlich
5 * 4 *
@@ -16,7 +15,6 @@
16 * along with this program; if not, write to the Free Software 15 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
18 * 02110-1301, USA 17 * 02110-1301, USA
19 *
20 */ 18 */
21 19
22#include "main.h" 20#include "main.h"
@@ -31,10 +29,10 @@
31#include "unicast.h" 29#include "unicast.h"
32#include "bridge_loop_avoidance.h" 30#include "bridge_loop_avoidance.h"
33 31
34static int route_unicast_packet(struct sk_buff *skb, 32static int batadv_route_unicast_packet(struct sk_buff *skb,
35 struct hard_iface *recv_if); 33 struct hard_iface *recv_if);
36 34
37void slide_own_bcast_window(struct hard_iface *hard_iface) 35void batadv_slide_own_bcast_window(struct hard_iface *hard_iface)
38{ 36{
39 struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface); 37 struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
40 struct hashtable_t *hash = bat_priv->orig_hash; 38 struct hashtable_t *hash = bat_priv->orig_hash;
@@ -44,6 +42,7 @@ void slide_own_bcast_window(struct hard_iface *hard_iface)
44 unsigned long *word; 42 unsigned long *word;
45 uint32_t i; 43 uint32_t i;
46 size_t word_index; 44 size_t word_index;
45 uint8_t *w;
47 46
48 for (i = 0; i < hash->size; i++) { 47 for (i = 0; i < hash->size; i++) {
49 head = &hash->table[i]; 48 head = &hash->table[i];
@@ -51,49 +50,49 @@ void slide_own_bcast_window(struct hard_iface *hard_iface)
51 rcu_read_lock(); 50 rcu_read_lock();
52 hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) { 51 hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
53 spin_lock_bh(&orig_node->ogm_cnt_lock); 52 spin_lock_bh(&orig_node->ogm_cnt_lock);
54 word_index = hard_iface->if_num * NUM_WORDS; 53 word_index = hard_iface->if_num * BATADV_NUM_WORDS;
55 word = &(orig_node->bcast_own[word_index]); 54 word = &(orig_node->bcast_own[word_index]);
56 55
57 bit_get_packet(bat_priv, word, 1, 0); 56 batadv_bit_get_packet(bat_priv, word, 1, 0);
58 orig_node->bcast_own_sum[hard_iface->if_num] = 57 w = &orig_node->bcast_own_sum[hard_iface->if_num];
59 bitmap_weight(word, TQ_LOCAL_WINDOW_SIZE); 58 *w = bitmap_weight(word, BATADV_TQ_LOCAL_WINDOW_SIZE);
60 spin_unlock_bh(&orig_node->ogm_cnt_lock); 59 spin_unlock_bh(&orig_node->ogm_cnt_lock);
61 } 60 }
62 rcu_read_unlock(); 61 rcu_read_unlock();
63 } 62 }
64} 63}
65 64
66static void _update_route(struct bat_priv *bat_priv, 65static void _batadv_update_route(struct bat_priv *bat_priv,
67 struct orig_node *orig_node, 66 struct orig_node *orig_node,
68 struct neigh_node *neigh_node) 67 struct neigh_node *neigh_node)
69{ 68{
70 struct neigh_node *curr_router; 69 struct neigh_node *curr_router;
71 70
72 curr_router = orig_node_get_router(orig_node); 71 curr_router = batadv_orig_node_get_router(orig_node);
73 72
74 /* route deleted */ 73 /* route deleted */
75 if ((curr_router) && (!neigh_node)) { 74 if ((curr_router) && (!neigh_node)) {
76 bat_dbg(DBG_ROUTES, bat_priv, "Deleting route towards: %pM\n", 75 batadv_dbg(DBG_ROUTES, bat_priv, "Deleting route towards: %pM\n",
77 orig_node->orig); 76 orig_node->orig);
78 tt_global_del_orig(bat_priv, orig_node, 77 batadv_tt_global_del_orig(bat_priv, orig_node,
79 "Deleted route towards originator"); 78 "Deleted route towards originator");
80 79
81 /* route added */ 80 /* route added */
82 } else if ((!curr_router) && (neigh_node)) { 81 } else if ((!curr_router) && (neigh_node)) {
83 82
84 bat_dbg(DBG_ROUTES, bat_priv, 83 batadv_dbg(DBG_ROUTES, bat_priv,
85 "Adding route towards: %pM (via %pM)\n", 84 "Adding route towards: %pM (via %pM)\n",
86 orig_node->orig, neigh_node->addr); 85 orig_node->orig, neigh_node->addr);
87 /* route changed */ 86 /* route changed */
88 } else if (neigh_node && curr_router) { 87 } else if (neigh_node && curr_router) {
89 bat_dbg(DBG_ROUTES, bat_priv, 88 batadv_dbg(DBG_ROUTES, bat_priv,
90 "Changing route towards: %pM (now via %pM - was via %pM)\n", 89 "Changing route towards: %pM (now via %pM - was via %pM)\n",
91 orig_node->orig, neigh_node->addr, 90 orig_node->orig, neigh_node->addr,
92 curr_router->addr); 91 curr_router->addr);
93 } 92 }
94 93
95 if (curr_router) 94 if (curr_router)
96 neigh_node_free_ref(curr_router); 95 batadv_neigh_node_free_ref(curr_router);
97 96
98 /* increase refcount of new best neighbor */ 97 /* increase refcount of new best neighbor */
99 if (neigh_node && !atomic_inc_not_zero(&neigh_node->refcount)) 98 if (neigh_node && !atomic_inc_not_zero(&neigh_node->refcount))
@@ -105,30 +104,30 @@ static void _update_route(struct bat_priv *bat_priv,
105 104
106 /* decrease refcount of previous best neighbor */ 105 /* decrease refcount of previous best neighbor */
107 if (curr_router) 106 if (curr_router)
108 neigh_node_free_ref(curr_router); 107 batadv_neigh_node_free_ref(curr_router);
109} 108}
110 109
111void update_route(struct bat_priv *bat_priv, struct orig_node *orig_node, 110void batadv_update_route(struct bat_priv *bat_priv, struct orig_node *orig_node,
112 struct neigh_node *neigh_node) 111 struct neigh_node *neigh_node)
113{ 112{
114 struct neigh_node *router = NULL; 113 struct neigh_node *router = NULL;
115 114
116 if (!orig_node) 115 if (!orig_node)
117 goto out; 116 goto out;
118 117
119 router = orig_node_get_router(orig_node); 118 router = batadv_orig_node_get_router(orig_node);
120 119
121 if (router != neigh_node) 120 if (router != neigh_node)
122 _update_route(bat_priv, orig_node, neigh_node); 121 _batadv_update_route(bat_priv, orig_node, neigh_node);
123 122
124out: 123out:
125 if (router) 124 if (router)
126 neigh_node_free_ref(router); 125 batadv_neigh_node_free_ref(router);
127} 126}
128 127
129/* caller must hold the neigh_list_lock */ 128/* caller must hold the neigh_list_lock */
130void bonding_candidate_del(struct orig_node *orig_node, 129void batadv_bonding_candidate_del(struct orig_node *orig_node,
131 struct neigh_node *neigh_node) 130 struct neigh_node *neigh_node)
132{ 131{
133 /* this neighbor is not part of our candidate list */ 132 /* this neighbor is not part of our candidate list */
134 if (list_empty(&neigh_node->bonding_list)) 133 if (list_empty(&neigh_node->bonding_list))
@@ -136,15 +135,15 @@ void bonding_candidate_del(struct orig_node *orig_node,
136 135
137 list_del_rcu(&neigh_node->bonding_list); 136 list_del_rcu(&neigh_node->bonding_list);
138 INIT_LIST_HEAD(&neigh_node->bonding_list); 137 INIT_LIST_HEAD(&neigh_node->bonding_list);
139 neigh_node_free_ref(neigh_node); 138 batadv_neigh_node_free_ref(neigh_node);
140 atomic_dec(&orig_node->bond_candidates); 139 atomic_dec(&orig_node->bond_candidates);
141 140
142out: 141out:
143 return; 142 return;
144} 143}
145 144
146void bonding_candidate_add(struct orig_node *orig_node, 145void batadv_bonding_candidate_add(struct orig_node *orig_node,
147 struct neigh_node *neigh_node) 146 struct neigh_node *neigh_node)
148{ 147{
149 struct hlist_node *node; 148 struct hlist_node *node;
150 struct neigh_node *tmp_neigh_node, *router = NULL; 149 struct neigh_node *tmp_neigh_node, *router = NULL;
@@ -153,20 +152,19 @@ void bonding_candidate_add(struct orig_node *orig_node,
153 spin_lock_bh(&orig_node->neigh_list_lock); 152 spin_lock_bh(&orig_node->neigh_list_lock);
154 153
155 /* only consider if it has the same primary address ... */ 154 /* only consider if it has the same primary address ... */
156 if (!compare_eth(orig_node->orig, 155 if (!batadv_compare_eth(orig_node->orig,
157 neigh_node->orig_node->primary_addr)) 156 neigh_node->orig_node->primary_addr))
158 goto candidate_del; 157 goto candidate_del;
159 158
160 router = orig_node_get_router(orig_node); 159 router = batadv_orig_node_get_router(orig_node);
161 if (!router) 160 if (!router)
162 goto candidate_del; 161 goto candidate_del;
163 162
164 /* ... and is good enough to be considered */ 163 /* ... and is good enough to be considered */
165 if (neigh_node->tq_avg < router->tq_avg - BONDING_TQ_THRESHOLD) 164 if (neigh_node->tq_avg < router->tq_avg - BATADV_BONDING_TQ_THRESHOLD)
166 goto candidate_del; 165 goto candidate_del;
167 166
168 /** 167 /* check if we have another candidate with the same mac address or
169 * check if we have another candidate with the same mac address or
170 * interface. If we do, we won't select this candidate because of 168 * interface. If we do, we won't select this candidate because of
171 * possible interference. 169 * possible interference.
172 */ 170 */
@@ -177,12 +175,14 @@ void bonding_candidate_add(struct orig_node *orig_node,
177 continue; 175 continue;
178 176
179 /* we only care if the other candidate is even 177 /* we only care if the other candidate is even
180 * considered as candidate. */ 178 * considered as candidate.
179 */
181 if (list_empty(&tmp_neigh_node->bonding_list)) 180 if (list_empty(&tmp_neigh_node->bonding_list))
182 continue; 181 continue;
183 182
184 if ((neigh_node->if_incoming == tmp_neigh_node->if_incoming) || 183 if ((neigh_node->if_incoming == tmp_neigh_node->if_incoming) ||
185 (compare_eth(neigh_node->addr, tmp_neigh_node->addr))) { 184 (batadv_compare_eth(neigh_node->addr,
185 tmp_neigh_node->addr))) {
186 interference_candidate = 1; 186 interference_candidate = 1;
187 break; 187 break;
188 } 188 }
@@ -204,19 +204,20 @@ void bonding_candidate_add(struct orig_node *orig_node,
204 goto out; 204 goto out;
205 205
206candidate_del: 206candidate_del:
207 bonding_candidate_del(orig_node, neigh_node); 207 batadv_bonding_candidate_del(orig_node, neigh_node);
208 208
209out: 209out:
210 spin_unlock_bh(&orig_node->neigh_list_lock); 210 spin_unlock_bh(&orig_node->neigh_list_lock);
211 211
212 if (router) 212 if (router)
213 neigh_node_free_ref(router); 213 batadv_neigh_node_free_ref(router);
214} 214}
215 215
216/* copy primary address for bonding */ 216/* copy primary address for bonding */
217void bonding_save_primary(const struct orig_node *orig_node, 217void
218 struct orig_node *orig_neigh_node, 218batadv_bonding_save_primary(const struct orig_node *orig_node,
219 const struct batman_ogm_packet *batman_ogm_packet) 219 struct orig_node *orig_neigh_node,
220 const struct batman_ogm_packet *batman_ogm_packet)
220{ 221{
221 if (!(batman_ogm_packet->flags & PRIMARIES_FIRST_HOP)) 222 if (!(batman_ogm_packet->flags & PRIMARIES_FIRST_HOP))
222 return; 223 return;
@@ -229,25 +230,26 @@ void bonding_save_primary(const struct orig_node *orig_node,
229 * 0 if the packet is to be accepted 230 * 0 if the packet is to be accepted
230 * 1 if the packet is to be ignored. 231 * 1 if the packet is to be ignored.
231 */ 232 */
232int window_protected(struct bat_priv *bat_priv, int32_t seq_num_diff, 233int batadv_window_protected(struct bat_priv *bat_priv, int32_t seq_num_diff,
233 unsigned long *last_reset) 234 unsigned long *last_reset)
234{ 235{
235 if ((seq_num_diff <= -TQ_LOCAL_WINDOW_SIZE) || 236 if (seq_num_diff <= -BATADV_TQ_LOCAL_WINDOW_SIZE ||
236 (seq_num_diff >= EXPECTED_SEQNO_RANGE)) { 237 seq_num_diff >= BATADV_EXPECTED_SEQNO_RANGE) {
237 if (!has_timed_out(*last_reset, RESET_PROTECTION_MS)) 238 if (!batadv_has_timed_out(*last_reset,
239 BATADV_RESET_PROTECTION_MS))
238 return 1; 240 return 1;
239 241
240 *last_reset = jiffies; 242 *last_reset = jiffies;
241 bat_dbg(DBG_BATMAN, bat_priv, 243 batadv_dbg(DBG_BATMAN, bat_priv,
242 "old packet received, start protection\n"); 244 "old packet received, start protection\n");
243 } 245 }
244 246
245 return 0; 247 return 0;
246} 248}
247 249
248bool check_management_packet(struct sk_buff *skb, 250bool batadv_check_management_packet(struct sk_buff *skb,
249 struct hard_iface *hard_iface, 251 struct hard_iface *hard_iface,
250 int header_len) 252 int header_len)
251{ 253{
252 struct ethhdr *ethhdr; 254 struct ethhdr *ethhdr;
253 255
@@ -276,8 +278,8 @@ bool check_management_packet(struct sk_buff *skb,
276 return true; 278 return true;
277} 279}
278 280
279static int recv_my_icmp_packet(struct bat_priv *bat_priv, 281static int batadv_recv_my_icmp_packet(struct bat_priv *bat_priv,
280 struct sk_buff *skb, size_t icmp_len) 282 struct sk_buff *skb, size_t icmp_len)
281{ 283{
282 struct hard_iface *primary_if = NULL; 284 struct hard_iface *primary_if = NULL;
283 struct orig_node *orig_node = NULL; 285 struct orig_node *orig_node = NULL;
@@ -289,21 +291,21 @@ static int recv_my_icmp_packet(struct bat_priv *bat_priv,
289 291
290 /* add data to device queue */ 292 /* add data to device queue */
291 if (icmp_packet->msg_type != ECHO_REQUEST) { 293 if (icmp_packet->msg_type != ECHO_REQUEST) {
292 bat_socket_receive_packet(icmp_packet, icmp_len); 294 batadv_socket_receive_packet(icmp_packet, icmp_len);
293 goto out; 295 goto out;
294 } 296 }
295 297
296 primary_if = primary_if_get_selected(bat_priv); 298 primary_if = batadv_primary_if_get_selected(bat_priv);
297 if (!primary_if) 299 if (!primary_if)
298 goto out; 300 goto out;
299 301
300 /* answer echo request (ping) */ 302 /* answer echo request (ping) */
301 /* get routing information */ 303 /* get routing information */
302 orig_node = orig_hash_find(bat_priv, icmp_packet->orig); 304 orig_node = batadv_orig_hash_find(bat_priv, icmp_packet->orig);
303 if (!orig_node) 305 if (!orig_node)
304 goto out; 306 goto out;
305 307
306 router = orig_node_get_router(orig_node); 308 router = batadv_orig_node_get_router(orig_node);
307 if (!router) 309 if (!router)
308 goto out; 310 goto out;
309 311
@@ -316,23 +318,23 @@ static int recv_my_icmp_packet(struct bat_priv *bat_priv,
316 memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN); 318 memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN);
317 memcpy(icmp_packet->orig, primary_if->net_dev->dev_addr, ETH_ALEN); 319 memcpy(icmp_packet->orig, primary_if->net_dev->dev_addr, ETH_ALEN);
318 icmp_packet->msg_type = ECHO_REPLY; 320 icmp_packet->msg_type = ECHO_REPLY;
319 icmp_packet->header.ttl = TTL; 321 icmp_packet->header.ttl = BATADV_TTL;
320 322
321 send_skb_packet(skb, router->if_incoming, router->addr); 323 batadv_send_skb_packet(skb, router->if_incoming, router->addr);
322 ret = NET_RX_SUCCESS; 324 ret = NET_RX_SUCCESS;
323 325
324out: 326out:
325 if (primary_if) 327 if (primary_if)
326 hardif_free_ref(primary_if); 328 batadv_hardif_free_ref(primary_if);
327 if (router) 329 if (router)
328 neigh_node_free_ref(router); 330 batadv_neigh_node_free_ref(router);
329 if (orig_node) 331 if (orig_node)
330 orig_node_free_ref(orig_node); 332 batadv_orig_node_free_ref(orig_node);
331 return ret; 333 return ret;
332} 334}
333 335
334static int recv_icmp_ttl_exceeded(struct bat_priv *bat_priv, 336static int batadv_recv_icmp_ttl_exceeded(struct bat_priv *bat_priv,
335 struct sk_buff *skb) 337 struct sk_buff *skb)
336{ 338{
337 struct hard_iface *primary_if = NULL; 339 struct hard_iface *primary_if = NULL;
338 struct orig_node *orig_node = NULL; 340 struct orig_node *orig_node = NULL;
@@ -349,16 +351,16 @@ static int recv_icmp_ttl_exceeded(struct bat_priv *bat_priv,
349 goto out; 351 goto out;
350 } 352 }
351 353
352 primary_if = primary_if_get_selected(bat_priv); 354 primary_if = batadv_primary_if_get_selected(bat_priv);
353 if (!primary_if) 355 if (!primary_if)
354 goto out; 356 goto out;
355 357
356 /* get routing information */ 358 /* get routing information */
357 orig_node = orig_hash_find(bat_priv, icmp_packet->orig); 359 orig_node = batadv_orig_hash_find(bat_priv, icmp_packet->orig);
358 if (!orig_node) 360 if (!orig_node)
359 goto out; 361 goto out;
360 362
361 router = orig_node_get_router(orig_node); 363 router = batadv_orig_node_get_router(orig_node);
362 if (!router) 364 if (!router)
363 goto out; 365 goto out;
364 366
@@ -371,23 +373,23 @@ static int recv_icmp_ttl_exceeded(struct bat_priv *bat_priv,
371 memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN); 373 memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN);
372 memcpy(icmp_packet->orig, primary_if->net_dev->dev_addr, ETH_ALEN); 374 memcpy(icmp_packet->orig, primary_if->net_dev->dev_addr, ETH_ALEN);
373 icmp_packet->msg_type = TTL_EXCEEDED; 375 icmp_packet->msg_type = TTL_EXCEEDED;
374 icmp_packet->header.ttl = TTL; 376 icmp_packet->header.ttl = BATADV_TTL;
375 377
376 send_skb_packet(skb, router->if_incoming, router->addr); 378 batadv_send_skb_packet(skb, router->if_incoming, router->addr);
377 ret = NET_RX_SUCCESS; 379 ret = NET_RX_SUCCESS;
378 380
379out: 381out:
380 if (primary_if) 382 if (primary_if)
381 hardif_free_ref(primary_if); 383 batadv_hardif_free_ref(primary_if);
382 if (router) 384 if (router)
383 neigh_node_free_ref(router); 385 batadv_neigh_node_free_ref(router);
384 if (orig_node) 386 if (orig_node)
385 orig_node_free_ref(orig_node); 387 batadv_orig_node_free_ref(orig_node);
386 return ret; 388 return ret;
387} 389}
388 390
389 391
390int recv_icmp_packet(struct sk_buff *skb, struct hard_iface *recv_if) 392int batadv_recv_icmp_packet(struct sk_buff *skb, struct hard_iface *recv_if)
391{ 393{
392 struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); 394 struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
393 struct icmp_packet_rr *icmp_packet; 395 struct icmp_packet_rr *icmp_packet;
@@ -397,9 +399,7 @@ int recv_icmp_packet(struct sk_buff *skb, struct hard_iface *recv_if)
397 int hdr_size = sizeof(struct icmp_packet); 399 int hdr_size = sizeof(struct icmp_packet);
398 int ret = NET_RX_DROP; 400 int ret = NET_RX_DROP;
399 401
400 /** 402 /* we truncate all incoming icmp packets if they don't match our size */
401 * we truncate all incoming icmp packets if they don't match our size
402 */
403 if (skb->len >= sizeof(struct icmp_packet_rr)) 403 if (skb->len >= sizeof(struct icmp_packet_rr))
404 hdr_size = sizeof(struct icmp_packet_rr); 404 hdr_size = sizeof(struct icmp_packet_rr);
405 405
@@ -418,33 +418,33 @@ int recv_icmp_packet(struct sk_buff *skb, struct hard_iface *recv_if)
418 goto out; 418 goto out;
419 419
420 /* not for me */ 420 /* not for me */
421 if (!is_my_mac(ethhdr->h_dest)) 421 if (!batadv_is_my_mac(ethhdr->h_dest))
422 goto out; 422 goto out;
423 423
424 icmp_packet = (struct icmp_packet_rr *)skb->data; 424 icmp_packet = (struct icmp_packet_rr *)skb->data;
425 425
426 /* add record route information if not full */ 426 /* add record route information if not full */
427 if ((hdr_size == sizeof(struct icmp_packet_rr)) && 427 if ((hdr_size == sizeof(struct icmp_packet_rr)) &&
428 (icmp_packet->rr_cur < BAT_RR_LEN)) { 428 (icmp_packet->rr_cur < BATADV_RR_LEN)) {
429 memcpy(&(icmp_packet->rr[icmp_packet->rr_cur]), 429 memcpy(&(icmp_packet->rr[icmp_packet->rr_cur]),
430 ethhdr->h_dest, ETH_ALEN); 430 ethhdr->h_dest, ETH_ALEN);
431 icmp_packet->rr_cur++; 431 icmp_packet->rr_cur++;
432 } 432 }
433 433
434 /* packet for me */ 434 /* packet for me */
435 if (is_my_mac(icmp_packet->dst)) 435 if (batadv_is_my_mac(icmp_packet->dst))
436 return recv_my_icmp_packet(bat_priv, skb, hdr_size); 436 return batadv_recv_my_icmp_packet(bat_priv, skb, hdr_size);
437 437
438 /* TTL exceeded */ 438 /* TTL exceeded */
439 if (icmp_packet->header.ttl < 2) 439 if (icmp_packet->header.ttl < 2)
440 return recv_icmp_ttl_exceeded(bat_priv, skb); 440 return batadv_recv_icmp_ttl_exceeded(bat_priv, skb);
441 441
442 /* get routing information */ 442 /* get routing information */
443 orig_node = orig_hash_find(bat_priv, icmp_packet->dst); 443 orig_node = batadv_orig_hash_find(bat_priv, icmp_packet->dst);
444 if (!orig_node) 444 if (!orig_node)
445 goto out; 445 goto out;
446 446
447 router = orig_node_get_router(orig_node); 447 router = batadv_orig_node_get_router(orig_node);
448 if (!router) 448 if (!router)
449 goto out; 449 goto out;
450 450
@@ -458,14 +458,14 @@ int recv_icmp_packet(struct sk_buff *skb, struct hard_iface *recv_if)
458 icmp_packet->header.ttl--; 458 icmp_packet->header.ttl--;
459 459
460 /* route it */ 460 /* route it */
461 send_skb_packet(skb, router->if_incoming, router->addr); 461 batadv_send_skb_packet(skb, router->if_incoming, router->addr);
462 ret = NET_RX_SUCCESS; 462 ret = NET_RX_SUCCESS;
463 463
464out: 464out:
465 if (router) 465 if (router)
466 neigh_node_free_ref(router); 466 batadv_neigh_node_free_ref(router);
467 if (orig_node) 467 if (orig_node)
468 orig_node_free_ref(orig_node); 468 batadv_orig_node_free_ref(orig_node);
469 return ret; 469 return ret;
470} 470}
471 471
@@ -473,9 +473,11 @@ out:
473 * robin fashion over the remaining interfaces. 473 * robin fashion over the remaining interfaces.
474 * 474 *
475 * This method rotates the bonding list and increases the 475 * This method rotates the bonding list and increases the
476 * returned router's refcount. */ 476 * returned router's refcount.
477static struct neigh_node *find_bond_router(struct orig_node *primary_orig, 477 */
478 const struct hard_iface *recv_if) 478static struct neigh_node *
479batadv_find_bond_router(struct orig_node *primary_orig,
480 const struct hard_iface *recv_if)
479{ 481{
480 struct neigh_node *tmp_neigh_node; 482 struct neigh_node *tmp_neigh_node;
481 struct neigh_node *router = NULL, *first_candidate = NULL; 483 struct neigh_node *router = NULL, *first_candidate = NULL;
@@ -506,10 +508,12 @@ static struct neigh_node *find_bond_router(struct orig_node *primary_orig,
506 goto out; 508 goto out;
507 509
508 /* selected should point to the next element 510 /* selected should point to the next element
509 * after the current router */ 511 * after the current router
512 */
510 spin_lock_bh(&primary_orig->neigh_list_lock); 513 spin_lock_bh(&primary_orig->neigh_list_lock);
511 /* this is a list_move(), which unfortunately 514 /* this is a list_move(), which unfortunately
512 * does not exist as rcu version */ 515 * does not exist as rcu version
516 */
513 list_del_rcu(&primary_orig->bond_list); 517 list_del_rcu(&primary_orig->bond_list);
514 list_add_rcu(&primary_orig->bond_list, 518 list_add_rcu(&primary_orig->bond_list,
515 &router->bonding_list); 519 &router->bonding_list);
@@ -524,9 +528,11 @@ out:
524 * remaining candidates which are not using 528 * remaining candidates which are not using
525 * this interface. 529 * this interface.
526 * 530 *
527 * Increases the returned router's refcount */ 531 * Increases the returned router's refcount
528static struct neigh_node *find_ifalter_router(struct orig_node *primary_orig, 532 */
529 const struct hard_iface *recv_if) 533static struct neigh_node *
534batadv_find_ifalter_router(struct orig_node *primary_orig,
535 const struct hard_iface *recv_if)
530{ 536{
531 struct neigh_node *tmp_neigh_node; 537 struct neigh_node *tmp_neigh_node;
532 struct neigh_node *router = NULL, *first_candidate = NULL; 538 struct neigh_node *router = NULL, *first_candidate = NULL;
@@ -545,19 +551,21 @@ static struct neigh_node *find_ifalter_router(struct orig_node *primary_orig,
545 continue; 551 continue;
546 552
547 /* if we don't have a router yet 553 /* if we don't have a router yet
548 * or this one is better, choose it. */ 554 * or this one is better, choose it.
555 */
549 if ((!router) || 556 if ((!router) ||
550 (tmp_neigh_node->tq_avg > router->tq_avg)) { 557 (tmp_neigh_node->tq_avg > router->tq_avg)) {
551 /* decrement refcount of 558 /* decrement refcount of
552 * previously selected router */ 559 * previously selected router
560 */
553 if (router) 561 if (router)
554 neigh_node_free_ref(router); 562 batadv_neigh_node_free_ref(router);
555 563
556 router = tmp_neigh_node; 564 router = tmp_neigh_node;
557 atomic_inc_not_zero(&router->refcount); 565 atomic_inc_not_zero(&router->refcount);
558 } 566 }
559 567
560 neigh_node_free_ref(tmp_neigh_node); 568 batadv_neigh_node_free_ref(tmp_neigh_node);
561 } 569 }
562 570
563 /* use the first candidate if nothing was found. */ 571 /* use the first candidate if nothing was found. */
@@ -569,12 +577,13 @@ static struct neigh_node *find_ifalter_router(struct orig_node *primary_orig,
569 return router; 577 return router;
570} 578}
571 579
572int recv_tt_query(struct sk_buff *skb, struct hard_iface *recv_if) 580int batadv_recv_tt_query(struct sk_buff *skb, struct hard_iface *recv_if)
573{ 581{
574 struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); 582 struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
575 struct tt_query_packet *tt_query; 583 struct tt_query_packet *tt_query;
576 uint16_t tt_len; 584 uint16_t tt_size;
577 struct ethhdr *ethhdr; 585 struct ethhdr *ethhdr;
586 char tt_flag;
578 587
579 /* drop packet if it has not necessary minimum size */ 588 /* drop packet if it has not necessary minimum size */
580 if (unlikely(!pskb_may_pull(skb, sizeof(struct tt_query_packet)))) 589 if (unlikely(!pskb_may_pull(skb, sizeof(struct tt_query_packet))))
@@ -596,45 +605,49 @@ int recv_tt_query(struct sk_buff *skb, struct hard_iface *recv_if)
596 605
597 tt_query = (struct tt_query_packet *)skb->data; 606 tt_query = (struct tt_query_packet *)skb->data;
598 607
599 tt_query->tt_data = ntohs(tt_query->tt_data); 608 switch (tt_query->flags & BATADV_TT_QUERY_TYPE_MASK) {
600
601 switch (tt_query->flags & TT_QUERY_TYPE_MASK) {
602 case TT_REQUEST: 609 case TT_REQUEST:
610 batadv_inc_counter(bat_priv, BAT_CNT_TT_REQUEST_RX);
611
603 /* If we cannot provide an answer the tt_request is 612 /* If we cannot provide an answer the tt_request is
604 * forwarded */ 613 * forwarded
605 if (!send_tt_response(bat_priv, tt_query)) { 614 */
606 bat_dbg(DBG_TT, bat_priv, 615 if (!batadv_send_tt_response(bat_priv, tt_query)) {
607 "Routing TT_REQUEST to %pM [%c]\n", 616 tt_flag = tt_query->flags & TT_FULL_TABLE ? 'F' : '.';
608 tt_query->dst, 617 batadv_dbg(DBG_TT, bat_priv,
609 (tt_query->flags & TT_FULL_TABLE ? 'F' : '.')); 618 "Routing TT_REQUEST to %pM [%c]\n",
610 tt_query->tt_data = htons(tt_query->tt_data); 619 tt_query->dst,
611 return route_unicast_packet(skb, recv_if); 620 tt_flag);
621 return batadv_route_unicast_packet(skb, recv_if);
612 } 622 }
613 break; 623 break;
614 case TT_RESPONSE: 624 case TT_RESPONSE:
615 if (is_my_mac(tt_query->dst)) { 625 batadv_inc_counter(bat_priv, BAT_CNT_TT_RESPONSE_RX);
626
627 if (batadv_is_my_mac(tt_query->dst)) {
616 /* packet needs to be linearized to access the TT 628 /* packet needs to be linearized to access the TT
617 * changes */ 629 * changes
630 */
618 if (skb_linearize(skb) < 0) 631 if (skb_linearize(skb) < 0)
619 goto out; 632 goto out;
620 /* skb_linearize() possibly changed skb->data */ 633 /* skb_linearize() possibly changed skb->data */
621 tt_query = (struct tt_query_packet *)skb->data; 634 tt_query = (struct tt_query_packet *)skb->data;
622 635
623 tt_len = tt_query->tt_data * sizeof(struct tt_change); 636 tt_size = batadv_tt_len(ntohs(tt_query->tt_data));
624 637
625 /* Ensure we have all the claimed data */ 638 /* Ensure we have all the claimed data */
626 if (unlikely(skb_headlen(skb) < 639 if (unlikely(skb_headlen(skb) <
627 sizeof(struct tt_query_packet) + tt_len)) 640 sizeof(struct tt_query_packet) + tt_size))
628 goto out; 641 goto out;
629 642
630 handle_tt_response(bat_priv, tt_query); 643 batadv_handle_tt_response(bat_priv, tt_query);
631 } else { 644 } else {
632 bat_dbg(DBG_TT, bat_priv, 645 tt_flag = tt_query->flags & TT_FULL_TABLE ? 'F' : '.';
633 "Routing TT_RESPONSE to %pM [%c]\n", 646 batadv_dbg(DBG_TT, bat_priv,
634 tt_query->dst, 647 "Routing TT_RESPONSE to %pM [%c]\n",
635 (tt_query->flags & TT_FULL_TABLE ? 'F' : '.')); 648 tt_query->dst,
636 tt_query->tt_data = htons(tt_query->tt_data); 649 tt_flag);
637 return route_unicast_packet(skb, recv_if); 650 return batadv_route_unicast_packet(skb, recv_if);
638 } 651 }
639 break; 652 break;
640 } 653 }
@@ -644,7 +657,7 @@ out:
644 return NET_RX_DROP; 657 return NET_RX_DROP;
645} 658}
646 659
647int recv_roam_adv(struct sk_buff *skb, struct hard_iface *recv_if) 660int batadv_recv_roam_adv(struct sk_buff *skb, struct hard_iface *recv_if)
648{ 661{
649 struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); 662 struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
650 struct roam_adv_packet *roam_adv_packet; 663 struct roam_adv_packet *roam_adv_packet;
@@ -665,35 +678,39 @@ int recv_roam_adv(struct sk_buff *skb, struct hard_iface *recv_if)
665 if (is_broadcast_ether_addr(ethhdr->h_source)) 678 if (is_broadcast_ether_addr(ethhdr->h_source))
666 goto out; 679 goto out;
667 680
681 batadv_inc_counter(bat_priv, BAT_CNT_TT_ROAM_ADV_RX);
682
668 roam_adv_packet = (struct roam_adv_packet *)skb->data; 683 roam_adv_packet = (struct roam_adv_packet *)skb->data;
669 684
670 if (!is_my_mac(roam_adv_packet->dst)) 685 if (!batadv_is_my_mac(roam_adv_packet->dst))
671 return route_unicast_packet(skb, recv_if); 686 return batadv_route_unicast_packet(skb, recv_if);
672 687
673 /* check if it is a backbone gateway. we don't accept 688 /* check if it is a backbone gateway. we don't accept
674 * roaming advertisement from it, as it has the same 689 * roaming advertisement from it, as it has the same
675 * entries as we have. 690 * entries as we have.
676 */ 691 */
677 if (bla_is_backbone_gw_orig(bat_priv, roam_adv_packet->src)) 692 if (batadv_bla_is_backbone_gw_orig(bat_priv, roam_adv_packet->src))
678 goto out; 693 goto out;
679 694
680 orig_node = orig_hash_find(bat_priv, roam_adv_packet->src); 695 orig_node = batadv_orig_hash_find(bat_priv, roam_adv_packet->src);
681 if (!orig_node) 696 if (!orig_node)
682 goto out; 697 goto out;
683 698
684 bat_dbg(DBG_TT, bat_priv, 699 batadv_dbg(DBG_TT, bat_priv,
685 "Received ROAMING_ADV from %pM (client %pM)\n", 700 "Received ROAMING_ADV from %pM (client %pM)\n",
686 roam_adv_packet->src, roam_adv_packet->client); 701 roam_adv_packet->src, roam_adv_packet->client);
687 702
688 tt_global_add(bat_priv, orig_node, roam_adv_packet->client, 703 batadv_tt_global_add(bat_priv, orig_node, roam_adv_packet->client,
689 atomic_read(&orig_node->last_ttvn) + 1, true, false); 704 TT_CLIENT_ROAM,
705 atomic_read(&orig_node->last_ttvn) + 1);
690 706
691 /* Roaming phase starts: I have new information but the ttvn has not 707 /* Roaming phase starts: I have new information but the ttvn has not
692 * been incremented yet. This flag will make me check all the incoming 708 * been incremented yet. This flag will make me check all the incoming
693 * packets for the correct destination. */ 709 * packets for the correct destination.
710 */
694 bat_priv->tt_poss_change = true; 711 bat_priv->tt_poss_change = true;
695 712
696 orig_node_free_ref(orig_node); 713 batadv_orig_node_free_ref(orig_node);
697out: 714out:
698 /* returning NET_RX_DROP will make the caller function kfree the skb */ 715 /* returning NET_RX_DROP will make the caller function kfree the skb */
699 return NET_RX_DROP; 716 return NET_RX_DROP;
@@ -701,26 +718,29 @@ out:
701 718
702/* find a suitable router for this originator, and use 719/* find a suitable router for this originator, and use
703 * bonding if possible. increases the found neighbors 720 * bonding if possible. increases the found neighbors
704 * refcount.*/ 721 * refcount.
705struct neigh_node *find_router(struct bat_priv *bat_priv, 722 */
706 struct orig_node *orig_node, 723struct neigh_node *batadv_find_router(struct bat_priv *bat_priv,
707 const struct hard_iface *recv_if) 724 struct orig_node *orig_node,
725 const struct hard_iface *recv_if)
708{ 726{
709 struct orig_node *primary_orig_node; 727 struct orig_node *primary_orig_node;
710 struct orig_node *router_orig; 728 struct orig_node *router_orig;
711 struct neigh_node *router; 729 struct neigh_node *router;
712 static uint8_t zero_mac[ETH_ALEN] = {0, 0, 0, 0, 0, 0}; 730 static uint8_t zero_mac[ETH_ALEN] = {0, 0, 0, 0, 0, 0};
713 int bonding_enabled; 731 int bonding_enabled;
732 uint8_t *primary_addr;
714 733
715 if (!orig_node) 734 if (!orig_node)
716 return NULL; 735 return NULL;
717 736
718 router = orig_node_get_router(orig_node); 737 router = batadv_orig_node_get_router(orig_node);
719 if (!router) 738 if (!router)
720 goto err; 739 goto err;
721 740
722 /* without bonding, the first node should 741 /* without bonding, the first node should
723 * always choose the default router. */ 742 * always choose the default router.
743 */
724 bonding_enabled = atomic_read(&bat_priv->bonding); 744 bonding_enabled = atomic_read(&bat_priv->bonding);
725 745
726 rcu_read_lock(); 746 rcu_read_lock();
@@ -732,40 +752,44 @@ struct neigh_node *find_router(struct bat_priv *bat_priv,
732 if ((!recv_if) && (!bonding_enabled)) 752 if ((!recv_if) && (!bonding_enabled))
733 goto return_router; 753 goto return_router;
734 754
755 primary_addr = router_orig->primary_addr;
756
735 /* if we have something in the primary_addr, we can search 757 /* if we have something in the primary_addr, we can search
736 * for a potential bonding candidate. */ 758 * for a potential bonding candidate.
737 if (compare_eth(router_orig->primary_addr, zero_mac)) 759 */
760 if (batadv_compare_eth(primary_addr, zero_mac))
738 goto return_router; 761 goto return_router;
739 762
740 /* find the orig_node which has the primary interface. might 763 /* find the orig_node which has the primary interface. might
741 * even be the same as our router_orig in many cases */ 764 * even be the same as our router_orig in many cases
742 765 */
743 if (compare_eth(router_orig->primary_addr, router_orig->orig)) { 766 if (batadv_compare_eth(primary_addr, router_orig->orig)) {
744 primary_orig_node = router_orig; 767 primary_orig_node = router_orig;
745 } else { 768 } else {
746 primary_orig_node = orig_hash_find(bat_priv, 769 primary_orig_node = batadv_orig_hash_find(bat_priv,
747 router_orig->primary_addr); 770 primary_addr);
748 if (!primary_orig_node) 771 if (!primary_orig_node)
749 goto return_router; 772 goto return_router;
750 773
751 orig_node_free_ref(primary_orig_node); 774 batadv_orig_node_free_ref(primary_orig_node);
752 } 775 }
753 776
754 /* with less than 2 candidates, we can't do any 777 /* with less than 2 candidates, we can't do any
755 * bonding and prefer the original router. */ 778 * bonding and prefer the original router.
779 */
756 if (atomic_read(&primary_orig_node->bond_candidates) < 2) 780 if (atomic_read(&primary_orig_node->bond_candidates) < 2)
757 goto return_router; 781 goto return_router;
758 782
759 /* all nodes between should choose a candidate which 783 /* all nodes between should choose a candidate which
760 * is is not on the interface where the packet came 784 * is is not on the interface where the packet came
761 * in. */ 785 * in.
762 786 */
763 neigh_node_free_ref(router); 787 batadv_neigh_node_free_ref(router);
764 788
765 if (bonding_enabled) 789 if (bonding_enabled)
766 router = find_bond_router(primary_orig_node, recv_if); 790 router = batadv_find_bond_router(primary_orig_node, recv_if);
767 else 791 else
768 router = find_ifalter_router(primary_orig_node, recv_if); 792 router = batadv_find_ifalter_router(primary_orig_node, recv_if);
769 793
770return_router: 794return_router:
771 if (router && router->if_incoming->if_status != IF_ACTIVE) 795 if (router && router->if_incoming->if_status != IF_ACTIVE)
@@ -777,11 +801,11 @@ err_unlock:
777 rcu_read_unlock(); 801 rcu_read_unlock();
778err: 802err:
779 if (router) 803 if (router)
780 neigh_node_free_ref(router); 804 batadv_neigh_node_free_ref(router);
781 return NULL; 805 return NULL;
782} 806}
783 807
784static int check_unicast_packet(struct sk_buff *skb, int hdr_size) 808static int batadv_check_unicast_packet(struct sk_buff *skb, int hdr_size)
785{ 809{
786 struct ethhdr *ethhdr; 810 struct ethhdr *ethhdr;
787 811
@@ -800,13 +824,14 @@ static int check_unicast_packet(struct sk_buff *skb, int hdr_size)
800 return -1; 824 return -1;
801 825
802 /* not for me */ 826 /* not for me */
803 if (!is_my_mac(ethhdr->h_dest)) 827 if (!batadv_is_my_mac(ethhdr->h_dest))
804 return -1; 828 return -1;
805 829
806 return 0; 830 return 0;
807} 831}
808 832
809static int route_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if) 833static int batadv_route_unicast_packet(struct sk_buff *skb,
834 struct hard_iface *recv_if)
810{ 835{
811 struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); 836 struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
812 struct orig_node *orig_node = NULL; 837 struct orig_node *orig_node = NULL;
@@ -826,13 +851,13 @@ static int route_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if)
826 } 851 }
827 852
828 /* get routing information */ 853 /* get routing information */
829 orig_node = orig_hash_find(bat_priv, unicast_packet->dest); 854 orig_node = batadv_orig_hash_find(bat_priv, unicast_packet->dest);
830 855
831 if (!orig_node) 856 if (!orig_node)
832 goto out; 857 goto out;
833 858
834 /* find_router() increases neigh_nodes refcount if found. */ 859 /* find_router() increases neigh_nodes refcount if found. */
835 neigh_node = find_router(bat_priv, orig_node, recv_if); 860 neigh_node = batadv_find_router(bat_priv, orig_node, recv_if);
836 861
837 if (!neigh_node) 862 if (!neigh_node)
838 goto out; 863 goto out;
@@ -846,15 +871,17 @@ static int route_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if)
846 if (unicast_packet->header.packet_type == BAT_UNICAST && 871 if (unicast_packet->header.packet_type == BAT_UNICAST &&
847 atomic_read(&bat_priv->fragmentation) && 872 atomic_read(&bat_priv->fragmentation) &&
848 skb->len > neigh_node->if_incoming->net_dev->mtu) { 873 skb->len > neigh_node->if_incoming->net_dev->mtu) {
849 ret = frag_send_skb(skb, bat_priv, 874 ret = batadv_frag_send_skb(skb, bat_priv,
850 neigh_node->if_incoming, neigh_node->addr); 875 neigh_node->if_incoming,
876 neigh_node->addr);
851 goto out; 877 goto out;
852 } 878 }
853 879
854 if (unicast_packet->header.packet_type == BAT_UNICAST_FRAG && 880 if (unicast_packet->header.packet_type == BAT_UNICAST_FRAG &&
855 frag_can_reassemble(skb, neigh_node->if_incoming->net_dev->mtu)) { 881 batadv_frag_can_reassemble(skb,
882 neigh_node->if_incoming->net_dev->mtu)) {
856 883
857 ret = frag_reassemble_skb(skb, bat_priv, &new_skb); 884 ret = batadv_frag_reassemble_skb(skb, bat_priv, &new_skb);
858 885
859 if (ret == NET_RX_DROP) 886 if (ret == NET_RX_DROP)
860 goto out; 887 goto out;
@@ -872,26 +899,32 @@ static int route_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if)
872 /* decrement ttl */ 899 /* decrement ttl */
873 unicast_packet->header.ttl--; 900 unicast_packet->header.ttl--;
874 901
902 /* Update stats counter */
903 batadv_inc_counter(bat_priv, BAT_CNT_FORWARD);
904 batadv_add_counter(bat_priv, BAT_CNT_FORWARD_BYTES,
905 skb->len + ETH_HLEN);
906
875 /* route it */ 907 /* route it */
876 send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr); 908 batadv_send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
877 ret = NET_RX_SUCCESS; 909 ret = NET_RX_SUCCESS;
878 910
879out: 911out:
880 if (neigh_node) 912 if (neigh_node)
881 neigh_node_free_ref(neigh_node); 913 batadv_neigh_node_free_ref(neigh_node);
882 if (orig_node) 914 if (orig_node)
883 orig_node_free_ref(orig_node); 915 batadv_orig_node_free_ref(orig_node);
884 return ret; 916 return ret;
885} 917}
886 918
887static int check_unicast_ttvn(struct bat_priv *bat_priv, 919static int batadv_check_unicast_ttvn(struct bat_priv *bat_priv,
888 struct sk_buff *skb) { 920 struct sk_buff *skb) {
889 uint8_t curr_ttvn; 921 uint8_t curr_ttvn;
890 struct orig_node *orig_node; 922 struct orig_node *orig_node;
891 struct ethhdr *ethhdr; 923 struct ethhdr *ethhdr;
892 struct hard_iface *primary_if; 924 struct hard_iface *primary_if;
893 struct unicast_packet *unicast_packet; 925 struct unicast_packet *unicast_packet;
894 bool tt_poss_change; 926 bool tt_poss_change;
927 int is_old_ttvn;
895 928
896 /* I could need to modify it */ 929 /* I could need to modify it */
897 if (skb_cow(skb, sizeof(struct unicast_packet)) < 0) 930 if (skb_cow(skb, sizeof(struct unicast_packet)) < 0)
@@ -899,22 +932,24 @@ static int check_unicast_ttvn(struct bat_priv *bat_priv,
899 932
900 unicast_packet = (struct unicast_packet *)skb->data; 933 unicast_packet = (struct unicast_packet *)skb->data;
901 934
902 if (is_my_mac(unicast_packet->dest)) { 935 if (batadv_is_my_mac(unicast_packet->dest)) {
903 tt_poss_change = bat_priv->tt_poss_change; 936 tt_poss_change = bat_priv->tt_poss_change;
904 curr_ttvn = (uint8_t)atomic_read(&bat_priv->ttvn); 937 curr_ttvn = (uint8_t)atomic_read(&bat_priv->ttvn);
905 } else { 938 } else {
906 orig_node = orig_hash_find(bat_priv, unicast_packet->dest); 939 orig_node = batadv_orig_hash_find(bat_priv,
940 unicast_packet->dest);
907 941
908 if (!orig_node) 942 if (!orig_node)
909 return 0; 943 return 0;
910 944
911 curr_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn); 945 curr_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);
912 tt_poss_change = orig_node->tt_poss_change; 946 tt_poss_change = orig_node->tt_poss_change;
913 orig_node_free_ref(orig_node); 947 batadv_orig_node_free_ref(orig_node);
914 } 948 }
915 949
916 /* Check whether I have to reroute the packet */ 950 /* Check whether I have to reroute the packet */
917 if (seq_before(unicast_packet->ttvn, curr_ttvn) || tt_poss_change) { 951 is_old_ttvn = batadv_seq_before(unicast_packet->ttvn, curr_ttvn);
952 if (is_old_ttvn || tt_poss_change) {
918 /* check if there is enough data before accessing it */ 953 /* check if there is enough data before accessing it */
919 if (pskb_may_pull(skb, sizeof(struct unicast_packet) + 954 if (pskb_may_pull(skb, sizeof(struct unicast_packet) +
920 ETH_HLEN) < 0) 955 ETH_HLEN) < 0)
@@ -926,62 +961,66 @@ static int check_unicast_ttvn(struct bat_priv *bat_priv,
926 /* we don't have an updated route for this client, so we should 961 /* we don't have an updated route for this client, so we should
927 * not try to reroute the packet!! 962 * not try to reroute the packet!!
928 */ 963 */
929 if (tt_global_client_is_roaming(bat_priv, ethhdr->h_dest)) 964 if (batadv_tt_global_client_is_roaming(bat_priv,
965 ethhdr->h_dest))
930 return 1; 966 return 1;
931 967
932 orig_node = transtable_search(bat_priv, NULL, ethhdr->h_dest); 968 orig_node = batadv_transtable_search(bat_priv, NULL,
969 ethhdr->h_dest);
933 970
934 if (!orig_node) { 971 if (!orig_node) {
935 if (!is_my_client(bat_priv, ethhdr->h_dest)) 972 if (!batadv_is_my_client(bat_priv, ethhdr->h_dest))
936 return 0; 973 return 0;
937 primary_if = primary_if_get_selected(bat_priv); 974 primary_if = batadv_primary_if_get_selected(bat_priv);
938 if (!primary_if) 975 if (!primary_if)
939 return 0; 976 return 0;
940 memcpy(unicast_packet->dest, 977 memcpy(unicast_packet->dest,
941 primary_if->net_dev->dev_addr, ETH_ALEN); 978 primary_if->net_dev->dev_addr, ETH_ALEN);
942 hardif_free_ref(primary_if); 979 batadv_hardif_free_ref(primary_if);
943 } else { 980 } else {
944 memcpy(unicast_packet->dest, orig_node->orig, 981 memcpy(unicast_packet->dest, orig_node->orig,
945 ETH_ALEN); 982 ETH_ALEN);
946 curr_ttvn = (uint8_t) 983 curr_ttvn = (uint8_t)
947 atomic_read(&orig_node->last_ttvn); 984 atomic_read(&orig_node->last_ttvn);
948 orig_node_free_ref(orig_node); 985 batadv_orig_node_free_ref(orig_node);
949 } 986 }
950 987
951 bat_dbg(DBG_ROUTES, bat_priv, 988 batadv_dbg(DBG_ROUTES, bat_priv,
952 "TTVN mismatch (old_ttvn %u new_ttvn %u)! Rerouting unicast packet (for %pM) to %pM\n", 989 "TTVN mismatch (old_ttvn %u new_ttvn %u)! Rerouting unicast packet (for %pM) to %pM\n",
953 unicast_packet->ttvn, curr_ttvn, ethhdr->h_dest, 990 unicast_packet->ttvn, curr_ttvn, ethhdr->h_dest,
954 unicast_packet->dest); 991 unicast_packet->dest);
955 992
956 unicast_packet->ttvn = curr_ttvn; 993 unicast_packet->ttvn = curr_ttvn;
957 } 994 }
958 return 1; 995 return 1;
959} 996}
960 997
961int recv_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if) 998int batadv_recv_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if)
962{ 999{
963 struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); 1000 struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
964 struct unicast_packet *unicast_packet; 1001 struct unicast_packet *unicast_packet;
965 int hdr_size = sizeof(*unicast_packet); 1002 int hdr_size = sizeof(*unicast_packet);
966 1003
967 if (check_unicast_packet(skb, hdr_size) < 0) 1004 if (batadv_check_unicast_packet(skb, hdr_size) < 0)
968 return NET_RX_DROP; 1005 return NET_RX_DROP;
969 1006
970 if (!check_unicast_ttvn(bat_priv, skb)) 1007 if (!batadv_check_unicast_ttvn(bat_priv, skb))
971 return NET_RX_DROP; 1008 return NET_RX_DROP;
972 1009
973 unicast_packet = (struct unicast_packet *)skb->data; 1010 unicast_packet = (struct unicast_packet *)skb->data;
974 1011
975 /* packet for me */ 1012 /* packet for me */
976 if (is_my_mac(unicast_packet->dest)) { 1013 if (batadv_is_my_mac(unicast_packet->dest)) {
977 interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size); 1014 batadv_interface_rx(recv_if->soft_iface, skb, recv_if,
1015 hdr_size);
978 return NET_RX_SUCCESS; 1016 return NET_RX_SUCCESS;
979 } 1017 }
980 1018
981 return route_unicast_packet(skb, recv_if); 1019 return batadv_route_unicast_packet(skb, recv_if);
982} 1020}
983 1021
984int recv_ucast_frag_packet(struct sk_buff *skb, struct hard_iface *recv_if) 1022int batadv_recv_ucast_frag_packet(struct sk_buff *skb,
1023 struct hard_iface *recv_if)
985{ 1024{
986 struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); 1025 struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
987 struct unicast_frag_packet *unicast_packet; 1026 struct unicast_frag_packet *unicast_packet;
@@ -989,18 +1028,18 @@ int recv_ucast_frag_packet(struct sk_buff *skb, struct hard_iface *recv_if)
989 struct sk_buff *new_skb = NULL; 1028 struct sk_buff *new_skb = NULL;
990 int ret; 1029 int ret;
991 1030
992 if (check_unicast_packet(skb, hdr_size) < 0) 1031 if (batadv_check_unicast_packet(skb, hdr_size) < 0)
993 return NET_RX_DROP; 1032 return NET_RX_DROP;
994 1033
995 if (!check_unicast_ttvn(bat_priv, skb)) 1034 if (!batadv_check_unicast_ttvn(bat_priv, skb))
996 return NET_RX_DROP; 1035 return NET_RX_DROP;
997 1036
998 unicast_packet = (struct unicast_frag_packet *)skb->data; 1037 unicast_packet = (struct unicast_frag_packet *)skb->data;
999 1038
1000 /* packet for me */ 1039 /* packet for me */
1001 if (is_my_mac(unicast_packet->dest)) { 1040 if (batadv_is_my_mac(unicast_packet->dest)) {
1002 1041
1003 ret = frag_reassemble_skb(skb, bat_priv, &new_skb); 1042 ret = batadv_frag_reassemble_skb(skb, bat_priv, &new_skb);
1004 1043
1005 if (ret == NET_RX_DROP) 1044 if (ret == NET_RX_DROP)
1006 return NET_RX_DROP; 1045 return NET_RX_DROP;
@@ -1009,16 +1048,16 @@ int recv_ucast_frag_packet(struct sk_buff *skb, struct hard_iface *recv_if)
1009 if (!new_skb) 1048 if (!new_skb)
1010 return NET_RX_SUCCESS; 1049 return NET_RX_SUCCESS;
1011 1050
1012 interface_rx(recv_if->soft_iface, new_skb, recv_if, 1051 batadv_interface_rx(recv_if->soft_iface, new_skb, recv_if,
1013 sizeof(struct unicast_packet)); 1052 sizeof(struct unicast_packet));
1014 return NET_RX_SUCCESS; 1053 return NET_RX_SUCCESS;
1015 } 1054 }
1016 1055
1017 return route_unicast_packet(skb, recv_if); 1056 return batadv_route_unicast_packet(skb, recv_if);
1018} 1057}
1019 1058
1020 1059
1021int recv_bcast_packet(struct sk_buff *skb, struct hard_iface *recv_if) 1060int batadv_recv_bcast_packet(struct sk_buff *skb, struct hard_iface *recv_if)
1022{ 1061{
1023 struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); 1062 struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1024 struct orig_node *orig_node = NULL; 1063 struct orig_node *orig_node = NULL;
@@ -1043,19 +1082,19 @@ int recv_bcast_packet(struct sk_buff *skb, struct hard_iface *recv_if)
1043 goto out; 1082 goto out;
1044 1083
1045 /* ignore broadcasts sent by myself */ 1084 /* ignore broadcasts sent by myself */
1046 if (is_my_mac(ethhdr->h_source)) 1085 if (batadv_is_my_mac(ethhdr->h_source))
1047 goto out; 1086 goto out;
1048 1087
1049 bcast_packet = (struct bcast_packet *)skb->data; 1088 bcast_packet = (struct bcast_packet *)skb->data;
1050 1089
1051 /* ignore broadcasts originated by myself */ 1090 /* ignore broadcasts originated by myself */
1052 if (is_my_mac(bcast_packet->orig)) 1091 if (batadv_is_my_mac(bcast_packet->orig))
1053 goto out; 1092 goto out;
1054 1093
1055 if (bcast_packet->header.ttl < 2) 1094 if (bcast_packet->header.ttl < 2)
1056 goto out; 1095 goto out;
1057 1096
1058 orig_node = orig_hash_find(bat_priv, bcast_packet->orig); 1097 orig_node = batadv_orig_hash_find(bat_priv, bcast_packet->orig);
1059 1098
1060 if (!orig_node) 1099 if (!orig_node)
1061 goto out; 1100 goto out;
@@ -1063,39 +1102,40 @@ int recv_bcast_packet(struct sk_buff *skb, struct hard_iface *recv_if)
1063 spin_lock_bh(&orig_node->bcast_seqno_lock); 1102 spin_lock_bh(&orig_node->bcast_seqno_lock);
1064 1103
1065 /* check whether the packet is a duplicate */ 1104 /* check whether the packet is a duplicate */
1066 if (bat_test_bit(orig_node->bcast_bits, orig_node->last_bcast_seqno, 1105 if (batadv_test_bit(orig_node->bcast_bits, orig_node->last_bcast_seqno,
1067 ntohl(bcast_packet->seqno))) 1106 ntohl(bcast_packet->seqno)))
1068 goto spin_unlock; 1107 goto spin_unlock;
1069 1108
1070 seq_diff = ntohl(bcast_packet->seqno) - orig_node->last_bcast_seqno; 1109 seq_diff = ntohl(bcast_packet->seqno) - orig_node->last_bcast_seqno;
1071 1110
1072 /* check whether the packet is old and the host just restarted. */ 1111 /* check whether the packet is old and the host just restarted. */
1073 if (window_protected(bat_priv, seq_diff, 1112 if (batadv_window_protected(bat_priv, seq_diff,
1074 &orig_node->bcast_seqno_reset)) 1113 &orig_node->bcast_seqno_reset))
1075 goto spin_unlock; 1114 goto spin_unlock;
1076 1115
1077 /* mark broadcast in flood history, update window position 1116 /* mark broadcast in flood history, update window position
1078 * if required. */ 1117 * if required.
1079 if (bit_get_packet(bat_priv, orig_node->bcast_bits, seq_diff, 1)) 1118 */
1119 if (batadv_bit_get_packet(bat_priv, orig_node->bcast_bits, seq_diff, 1))
1080 orig_node->last_bcast_seqno = ntohl(bcast_packet->seqno); 1120 orig_node->last_bcast_seqno = ntohl(bcast_packet->seqno);
1081 1121
1082 spin_unlock_bh(&orig_node->bcast_seqno_lock); 1122 spin_unlock_bh(&orig_node->bcast_seqno_lock);
1083 1123
1084 /* check whether this has been sent by another originator before */ 1124 /* check whether this has been sent by another originator before */
1085 if (bla_check_bcast_duplist(bat_priv, bcast_packet, hdr_size)) 1125 if (batadv_bla_check_bcast_duplist(bat_priv, bcast_packet, hdr_size))
1086 goto out; 1126 goto out;
1087 1127
1088 /* rebroadcast packet */ 1128 /* rebroadcast packet */
1089 add_bcast_packet_to_list(bat_priv, skb, 1); 1129 batadv_add_bcast_packet_to_list(bat_priv, skb, 1);
1090 1130
1091 /* don't hand the broadcast up if it is from an originator 1131 /* don't hand the broadcast up if it is from an originator
1092 * from the same backbone. 1132 * from the same backbone.
1093 */ 1133 */
1094 if (bla_is_backbone_gw(skb, orig_node, hdr_size)) 1134 if (batadv_bla_is_backbone_gw(skb, orig_node, hdr_size))
1095 goto out; 1135 goto out;
1096 1136
1097 /* broadcast for me */ 1137 /* broadcast for me */
1098 interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size); 1138 batadv_interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size);
1099 ret = NET_RX_SUCCESS; 1139 ret = NET_RX_SUCCESS;
1100 goto out; 1140 goto out;
1101 1141
@@ -1103,11 +1143,11 @@ spin_unlock:
1103 spin_unlock_bh(&orig_node->bcast_seqno_lock); 1143 spin_unlock_bh(&orig_node->bcast_seqno_lock);
1104out: 1144out:
1105 if (orig_node) 1145 if (orig_node)
1106 orig_node_free_ref(orig_node); 1146 batadv_orig_node_free_ref(orig_node);
1107 return ret; 1147 return ret;
1108} 1148}
1109 1149
1110int recv_vis_packet(struct sk_buff *skb, struct hard_iface *recv_if) 1150int batadv_recv_vis_packet(struct sk_buff *skb, struct hard_iface *recv_if)
1111{ 1151{
1112 struct vis_packet *vis_packet; 1152 struct vis_packet *vis_packet;
1113 struct ethhdr *ethhdr; 1153 struct ethhdr *ethhdr;
@@ -1125,25 +1165,25 @@ int recv_vis_packet(struct sk_buff *skb, struct hard_iface *recv_if)
1125 ethhdr = (struct ethhdr *)skb_mac_header(skb); 1165 ethhdr = (struct ethhdr *)skb_mac_header(skb);
1126 1166
1127 /* not for me */ 1167 /* not for me */
1128 if (!is_my_mac(ethhdr->h_dest)) 1168 if (!batadv_is_my_mac(ethhdr->h_dest))
1129 return NET_RX_DROP; 1169 return NET_RX_DROP;
1130 1170
1131 /* ignore own packets */ 1171 /* ignore own packets */
1132 if (is_my_mac(vis_packet->vis_orig)) 1172 if (batadv_is_my_mac(vis_packet->vis_orig))
1133 return NET_RX_DROP; 1173 return NET_RX_DROP;
1134 1174
1135 if (is_my_mac(vis_packet->sender_orig)) 1175 if (batadv_is_my_mac(vis_packet->sender_orig))
1136 return NET_RX_DROP; 1176 return NET_RX_DROP;
1137 1177
1138 switch (vis_packet->vis_type) { 1178 switch (vis_packet->vis_type) {
1139 case VIS_TYPE_SERVER_SYNC: 1179 case VIS_TYPE_SERVER_SYNC:
1140 receive_server_sync_packet(bat_priv, vis_packet, 1180 batadv_receive_server_sync_packet(bat_priv, vis_packet,
1141 skb_headlen(skb)); 1181 skb_headlen(skb));
1142 break; 1182 break;
1143 1183
1144 case VIS_TYPE_CLIENT_UPDATE: 1184 case VIS_TYPE_CLIENT_UPDATE:
1145 receive_client_update_packet(bat_priv, vis_packet, 1185 batadv_receive_client_update_packet(bat_priv, vis_packet,
1146 skb_headlen(skb)); 1186 skb_headlen(skb));
1147 break; 1187 break;
1148 1188
1149 default: /* ignore unknown packet */ 1189 default: /* ignore unknown packet */
@@ -1151,6 +1191,7 @@ int recv_vis_packet(struct sk_buff *skb, struct hard_iface *recv_if)
1151 } 1191 }
1152 1192
1153 /* We take a copy of the data in the packet, so we should 1193 /* We take a copy of the data in the packet, so we should
1154 always free the skbuf. */ 1194 * always free the skbuf.
1195 */
1155 return NET_RX_DROP; 1196 return NET_RX_DROP;
1156} 1197}