Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
routing.c
Go to the documentation of this file.
1 /* Copyright (C) 2007-2012 B.A.T.M.A.N. contributors:
2  *
3  * Marek Lindner, Simon Wunderlich
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of version 2 of the GNU General Public
7  * License as published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17  * 02110-1301, USA
18  */
19 
20 #include "main.h"
21 #include "routing.h"
22 #include "send.h"
23 #include "soft-interface.h"
24 #include "hard-interface.h"
25 #include "icmp_socket.h"
26 #include "translation-table.h"
27 #include "originator.h"
28 #include "vis.h"
29 #include "unicast.h"
30 #include "bridge_loop_avoidance.h"
31 
32 static int batadv_route_unicast_packet(struct sk_buff *skb,
33  struct batadv_hard_iface *recv_if);
34 
36 {
37  struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
38  struct batadv_hashtable *hash = bat_priv->orig_hash;
39  struct hlist_node *node;
40  struct hlist_head *head;
41  struct batadv_orig_node *orig_node;
42  unsigned long *word;
43  uint32_t i;
44  size_t word_index;
45  uint8_t *w;
46 
47  for (i = 0; i < hash->size; i++) {
48  head = &hash->table[i];
49 
50  rcu_read_lock();
51  hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
52  spin_lock_bh(&orig_node->ogm_cnt_lock);
53  word_index = hard_iface->if_num * BATADV_NUM_WORDS;
54  word = &(orig_node->bcast_own[word_index]);
55 
56  batadv_bit_get_packet(bat_priv, word, 1, 0);
57  w = &orig_node->bcast_own_sum[hard_iface->if_num];
58  *w = bitmap_weight(word, BATADV_TQ_LOCAL_WINDOW_SIZE);
59  spin_unlock_bh(&orig_node->ogm_cnt_lock);
60  }
61  rcu_read_unlock();
62  }
63 }
64 
65 static void _batadv_update_route(struct batadv_priv *bat_priv,
66  struct batadv_orig_node *orig_node,
67  struct batadv_neigh_node *neigh_node)
68 {
69  struct batadv_neigh_node *curr_router;
70 
71  curr_router = batadv_orig_node_get_router(orig_node);
72 
73  /* route deleted */
74  if ((curr_router) && (!neigh_node)) {
75  batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
76  "Deleting route towards: %pM\n", orig_node->orig);
77  batadv_tt_global_del_orig(bat_priv, orig_node,
78  "Deleted route towards originator");
79 
80  /* route added */
81  } else if ((!curr_router) && (neigh_node)) {
82 
83  batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
84  "Adding route towards: %pM (via %pM)\n",
85  orig_node->orig, neigh_node->addr);
86  /* route changed */
87  } else if (neigh_node && curr_router) {
88  batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
89  "Changing route towards: %pM (now via %pM - was via %pM)\n",
90  orig_node->orig, neigh_node->addr,
91  curr_router->addr);
92  }
93 
94  if (curr_router)
95  batadv_neigh_node_free_ref(curr_router);
96 
97  /* increase refcount of new best neighbor */
98  if (neigh_node && !atomic_inc_not_zero(&neigh_node->refcount))
99  neigh_node = NULL;
100 
101  spin_lock_bh(&orig_node->neigh_list_lock);
102  rcu_assign_pointer(orig_node->router, neigh_node);
103  spin_unlock_bh(&orig_node->neigh_list_lock);
104 
105  /* decrease refcount of previous best neighbor */
106  if (curr_router)
107  batadv_neigh_node_free_ref(curr_router);
108 }
109 
110 void batadv_update_route(struct batadv_priv *bat_priv,
111  struct batadv_orig_node *orig_node,
112  struct batadv_neigh_node *neigh_node)
113 {
114  struct batadv_neigh_node *router = NULL;
115 
116  if (!orig_node)
117  goto out;
118 
119  router = batadv_orig_node_get_router(orig_node);
120 
121  if (router != neigh_node)
122  _batadv_update_route(bat_priv, orig_node, neigh_node);
123 
124 out:
125  if (router)
127 }
128 
129 /* caller must hold the neigh_list_lock */
131  struct batadv_neigh_node *neigh_node)
132 {
133  /* this neighbor is not part of our candidate list */
134  if (list_empty(&neigh_node->bonding_list))
135  goto out;
136 
137  list_del_rcu(&neigh_node->bonding_list);
138  INIT_LIST_HEAD(&neigh_node->bonding_list);
139  batadv_neigh_node_free_ref(neigh_node);
140  atomic_dec(&orig_node->bond_candidates);
141 
142 out:
143  return;
144 }
145 
147  struct batadv_neigh_node *neigh_node)
148 {
149  struct hlist_node *node;
150  struct batadv_neigh_node *tmp_neigh_node, *router = NULL;
151  uint8_t interference_candidate = 0;
152 
153  spin_lock_bh(&orig_node->neigh_list_lock);
154 
155  /* only consider if it has the same primary address ... */
156  if (!batadv_compare_eth(orig_node->orig,
157  neigh_node->orig_node->primary_addr))
158  goto candidate_del;
159 
160  router = batadv_orig_node_get_router(orig_node);
161  if (!router)
162  goto candidate_del;
163 
164  /* ... and is good enough to be considered */
165  if (neigh_node->tq_avg < router->tq_avg - BATADV_BONDING_TQ_THRESHOLD)
166  goto candidate_del;
167 
168  /* check if we have another candidate with the same mac address or
169  * interface. If we do, we won't select this candidate because of
170  * possible interference.
171  */
172  hlist_for_each_entry_rcu(tmp_neigh_node, node,
173  &orig_node->neigh_list, list) {
174 
175  if (tmp_neigh_node == neigh_node)
176  continue;
177 
178  /* we only care if the other candidate is even
179  * considered as candidate.
180  */
181  if (list_empty(&tmp_neigh_node->bonding_list))
182  continue;
183 
184  if ((neigh_node->if_incoming == tmp_neigh_node->if_incoming) ||
185  (batadv_compare_eth(neigh_node->addr,
186  tmp_neigh_node->addr))) {
187  interference_candidate = 1;
188  break;
189  }
190  }
191 
192  /* don't care further if it is an interference candidate */
193  if (interference_candidate)
194  goto candidate_del;
195 
196  /* this neighbor already is part of our candidate list */
197  if (!list_empty(&neigh_node->bonding_list))
198  goto out;
199 
200  if (!atomic_inc_not_zero(&neigh_node->refcount))
201  goto out;
202 
203  list_add_rcu(&neigh_node->bonding_list, &orig_node->bond_list);
204  atomic_inc(&orig_node->bond_candidates);
205  goto out;
206 
207 candidate_del:
208  batadv_bonding_candidate_del(orig_node, neigh_node);
209 
210 out:
211  spin_unlock_bh(&orig_node->neigh_list_lock);
212 
213  if (router)
215 }
216 
217 /* copy primary address for bonding */
218 void
220  struct batadv_orig_node *orig_neigh_node,
221  const struct batadv_ogm_packet *batman_ogm_packet)
222 {
223  if (!(batman_ogm_packet->flags & BATADV_PRIMARIES_FIRST_HOP))
224  return;
225 
226  memcpy(orig_neigh_node->primary_addr, orig_node->orig, ETH_ALEN);
227 }
228 
229 /* checks whether the host restarted and is in the protection time.
230  * returns:
231  * 0 if the packet is to be accepted
232  * 1 if the packet is to be ignored.
233  */
234 int batadv_window_protected(struct batadv_priv *bat_priv, int32_t seq_num_diff,
235  unsigned long *last_reset)
236 {
237  if (seq_num_diff <= -BATADV_TQ_LOCAL_WINDOW_SIZE ||
238  seq_num_diff >= BATADV_EXPECTED_SEQNO_RANGE) {
239  if (!batadv_has_timed_out(*last_reset,
241  return 1;
242 
243  *last_reset = jiffies;
244  batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
245  "old packet received, start protection\n");
246  }
247 
248  return 0;
249 }
250 
252  struct batadv_hard_iface *hard_iface,
253  int header_len)
254 {
255  struct ethhdr *ethhdr;
256 
257  /* drop packet if it has not necessary minimum size */
258  if (unlikely(!pskb_may_pull(skb, header_len)))
259  return false;
260 
261  ethhdr = (struct ethhdr *)skb_mac_header(skb);
262 
263  /* packet with broadcast indication but unicast recipient */
264  if (!is_broadcast_ether_addr(ethhdr->h_dest))
265  return false;
266 
267  /* packet with broadcast sender address */
268  if (is_broadcast_ether_addr(ethhdr->h_source))
269  return false;
270 
271  /* create a copy of the skb, if needed, to modify it. */
272  if (skb_cow(skb, 0) < 0)
273  return false;
274 
275  /* keep skb linear */
276  if (skb_linearize(skb) < 0)
277  return false;
278 
279  return true;
280 }
281 
282 static int batadv_recv_my_icmp_packet(struct batadv_priv *bat_priv,
283  struct sk_buff *skb, size_t icmp_len)
284 {
285  struct batadv_hard_iface *primary_if = NULL;
286  struct batadv_orig_node *orig_node = NULL;
287  struct batadv_neigh_node *router = NULL;
288  struct batadv_icmp_packet_rr *icmp_packet;
289  int ret = NET_RX_DROP;
290 
291  icmp_packet = (struct batadv_icmp_packet_rr *)skb->data;
292 
293  /* add data to device queue */
294  if (icmp_packet->msg_type != BATADV_ECHO_REQUEST) {
295  batadv_socket_receive_packet(icmp_packet, icmp_len);
296  goto out;
297  }
298 
299  primary_if = batadv_primary_if_get_selected(bat_priv);
300  if (!primary_if)
301  goto out;
302 
303  /* answer echo request (ping) */
304  /* get routing information */
305  orig_node = batadv_orig_hash_find(bat_priv, icmp_packet->orig);
306  if (!orig_node)
307  goto out;
308 
309  router = batadv_orig_node_get_router(orig_node);
310  if (!router)
311  goto out;
312 
313  /* create a copy of the skb, if needed, to modify it. */
314  if (skb_cow(skb, ETH_HLEN) < 0)
315  goto out;
316 
317  icmp_packet = (struct batadv_icmp_packet_rr *)skb->data;
318 
319  memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN);
320  memcpy(icmp_packet->orig, primary_if->net_dev->dev_addr, ETH_ALEN);
321  icmp_packet->msg_type = BATADV_ECHO_REPLY;
322  icmp_packet->header.ttl = BATADV_TTL;
323 
324  batadv_send_skb_packet(skb, router->if_incoming, router->addr);
325  ret = NET_RX_SUCCESS;
326 
327 out:
328  if (primary_if)
329  batadv_hardif_free_ref(primary_if);
330  if (router)
332  if (orig_node)
333  batadv_orig_node_free_ref(orig_node);
334  return ret;
335 }
336 
337 static int batadv_recv_icmp_ttl_exceeded(struct batadv_priv *bat_priv,
338  struct sk_buff *skb)
339 {
340  struct batadv_hard_iface *primary_if = NULL;
341  struct batadv_orig_node *orig_node = NULL;
342  struct batadv_neigh_node *router = NULL;
343  struct batadv_icmp_packet *icmp_packet;
344  int ret = NET_RX_DROP;
345 
346  icmp_packet = (struct batadv_icmp_packet *)skb->data;
347 
348  /* send TTL exceeded if packet is an echo request (traceroute) */
349  if (icmp_packet->msg_type != BATADV_ECHO_REQUEST) {
350  pr_debug("Warning - can't forward icmp packet from %pM to %pM: ttl exceeded\n",
351  icmp_packet->orig, icmp_packet->dst);
352  goto out;
353  }
354 
355  primary_if = batadv_primary_if_get_selected(bat_priv);
356  if (!primary_if)
357  goto out;
358 
359  /* get routing information */
360  orig_node = batadv_orig_hash_find(bat_priv, icmp_packet->orig);
361  if (!orig_node)
362  goto out;
363 
364  router = batadv_orig_node_get_router(orig_node);
365  if (!router)
366  goto out;
367 
368  /* create a copy of the skb, if needed, to modify it. */
369  if (skb_cow(skb, ETH_HLEN) < 0)
370  goto out;
371 
372  icmp_packet = (struct batadv_icmp_packet *)skb->data;
373 
374  memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN);
375  memcpy(icmp_packet->orig, primary_if->net_dev->dev_addr, ETH_ALEN);
376  icmp_packet->msg_type = BATADV_TTL_EXCEEDED;
377  icmp_packet->header.ttl = BATADV_TTL;
378 
379  batadv_send_skb_packet(skb, router->if_incoming, router->addr);
380  ret = NET_RX_SUCCESS;
381 
382 out:
383  if (primary_if)
384  batadv_hardif_free_ref(primary_if);
385  if (router)
387  if (orig_node)
388  batadv_orig_node_free_ref(orig_node);
389  return ret;
390 }
391 
392 
394  struct batadv_hard_iface *recv_if)
395 {
396  struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
397  struct batadv_icmp_packet_rr *icmp_packet;
398  struct ethhdr *ethhdr;
399  struct batadv_orig_node *orig_node = NULL;
400  struct batadv_neigh_node *router = NULL;
401  int hdr_size = sizeof(struct batadv_icmp_packet);
402  int ret = NET_RX_DROP;
403 
404  /* we truncate all incoming icmp packets if they don't match our size */
405  if (skb->len >= sizeof(struct batadv_icmp_packet_rr))
406  hdr_size = sizeof(struct batadv_icmp_packet_rr);
407 
408  /* drop packet if it has not necessary minimum size */
409  if (unlikely(!pskb_may_pull(skb, hdr_size)))
410  goto out;
411 
412  ethhdr = (struct ethhdr *)skb_mac_header(skb);
413 
414  /* packet with unicast indication but broadcast recipient */
415  if (is_broadcast_ether_addr(ethhdr->h_dest))
416  goto out;
417 
418  /* packet with broadcast sender address */
419  if (is_broadcast_ether_addr(ethhdr->h_source))
420  goto out;
421 
422  /* not for me */
423  if (!batadv_is_my_mac(ethhdr->h_dest))
424  goto out;
425 
426  icmp_packet = (struct batadv_icmp_packet_rr *)skb->data;
427 
428  /* add record route information if not full */
429  if ((hdr_size == sizeof(struct batadv_icmp_packet_rr)) &&
430  (icmp_packet->rr_cur < BATADV_RR_LEN)) {
431  memcpy(&(icmp_packet->rr[icmp_packet->rr_cur]),
432  ethhdr->h_dest, ETH_ALEN);
433  icmp_packet->rr_cur++;
434  }
435 
436  /* packet for me */
437  if (batadv_is_my_mac(icmp_packet->dst))
438  return batadv_recv_my_icmp_packet(bat_priv, skb, hdr_size);
439 
440  /* TTL exceeded */
441  if (icmp_packet->header.ttl < 2)
442  return batadv_recv_icmp_ttl_exceeded(bat_priv, skb);
443 
444  /* get routing information */
445  orig_node = batadv_orig_hash_find(bat_priv, icmp_packet->dst);
446  if (!orig_node)
447  goto out;
448 
449  router = batadv_orig_node_get_router(orig_node);
450  if (!router)
451  goto out;
452 
453  /* create a copy of the skb, if needed, to modify it. */
454  if (skb_cow(skb, ETH_HLEN) < 0)
455  goto out;
456 
457  icmp_packet = (struct batadv_icmp_packet_rr *)skb->data;
458 
459  /* decrement ttl */
460  icmp_packet->header.ttl--;
461 
462  /* route it */
463  batadv_send_skb_packet(skb, router->if_incoming, router->addr);
464  ret = NET_RX_SUCCESS;
465 
466 out:
467  if (router)
469  if (orig_node)
470  batadv_orig_node_free_ref(orig_node);
471  return ret;
472 }
473 
474 /* In the bonding case, send the packets in a round
475  * robin fashion over the remaining interfaces.
476  *
477  * This method rotates the bonding list and increases the
478  * returned router's refcount.
479  */
480 static struct batadv_neigh_node *
481 batadv_find_bond_router(struct batadv_orig_node *primary_orig,
482  const struct batadv_hard_iface *recv_if)
483 {
484  struct batadv_neigh_node *tmp_neigh_node;
485  struct batadv_neigh_node *router = NULL, *first_candidate = NULL;
486 
487  rcu_read_lock();
488  list_for_each_entry_rcu(tmp_neigh_node, &primary_orig->bond_list,
489  bonding_list) {
490  if (!first_candidate)
491  first_candidate = tmp_neigh_node;
492 
493  /* recv_if == NULL on the first node. */
494  if (tmp_neigh_node->if_incoming == recv_if)
495  continue;
496 
497  if (!atomic_inc_not_zero(&tmp_neigh_node->refcount))
498  continue;
499 
500  router = tmp_neigh_node;
501  break;
502  }
503 
504  /* use the first candidate if nothing was found. */
505  if (!router && first_candidate &&
506  atomic_inc_not_zero(&first_candidate->refcount))
507  router = first_candidate;
508 
509  if (!router)
510  goto out;
511 
512  /* selected should point to the next element
513  * after the current router
514  */
515  spin_lock_bh(&primary_orig->neigh_list_lock);
516  /* this is a list_move(), which unfortunately
517  * does not exist as rcu version
518  */
519  list_del_rcu(&primary_orig->bond_list);
520  list_add_rcu(&primary_orig->bond_list,
521  &router->bonding_list);
522  spin_unlock_bh(&primary_orig->neigh_list_lock);
523 
524 out:
525  rcu_read_unlock();
526  return router;
527 }
528 
529 /* Interface Alternating: Use the best of the
530  * remaining candidates which are not using
531  * this interface.
532  *
533  * Increases the returned router's refcount
534  */
535 static struct batadv_neigh_node *
536 batadv_find_ifalter_router(struct batadv_orig_node *primary_orig,
537  const struct batadv_hard_iface *recv_if)
538 {
539  struct batadv_neigh_node *tmp_neigh_node;
540  struct batadv_neigh_node *router = NULL, *first_candidate = NULL;
541 
542  rcu_read_lock();
543  list_for_each_entry_rcu(tmp_neigh_node, &primary_orig->bond_list,
544  bonding_list) {
545  if (!first_candidate)
546  first_candidate = tmp_neigh_node;
547 
548  /* recv_if == NULL on the first node. */
549  if (tmp_neigh_node->if_incoming == recv_if)
550  continue;
551 
552  if (!atomic_inc_not_zero(&tmp_neigh_node->refcount))
553  continue;
554 
555  /* if we don't have a router yet
556  * or this one is better, choose it.
557  */
558  if ((!router) ||
559  (tmp_neigh_node->tq_avg > router->tq_avg)) {
560  /* decrement refcount of
561  * previously selected router
562  */
563  if (router)
565 
566  router = tmp_neigh_node;
567  atomic_inc_not_zero(&router->refcount);
568  }
569 
570  batadv_neigh_node_free_ref(tmp_neigh_node);
571  }
572 
573  /* use the first candidate if nothing was found. */
574  if (!router && first_candidate &&
575  atomic_inc_not_zero(&first_candidate->refcount))
576  router = first_candidate;
577 
578  rcu_read_unlock();
579  return router;
580 }
581 
582 static int batadv_check_unicast_packet(struct sk_buff *skb, int hdr_size)
583 {
584  struct ethhdr *ethhdr;
585 
586  /* drop packet if it has not necessary minimum size */
587  if (unlikely(!pskb_may_pull(skb, hdr_size)))
588  return -1;
589 
590  ethhdr = (struct ethhdr *)skb_mac_header(skb);
591 
592  /* packet with unicast indication but broadcast recipient */
593  if (is_broadcast_ether_addr(ethhdr->h_dest))
594  return -1;
595 
596  /* packet with broadcast sender address */
597  if (is_broadcast_ether_addr(ethhdr->h_source))
598  return -1;
599 
600  /* not for me */
601  if (!batadv_is_my_mac(ethhdr->h_dest))
602  return -1;
603 
604  return 0;
605 }
606 
607 int batadv_recv_tt_query(struct sk_buff *skb, struct batadv_hard_iface *recv_if)
608 {
609  struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
610  struct batadv_tt_query_packet *tt_query;
611  uint16_t tt_size;
612  int hdr_size = sizeof(*tt_query);
613  char tt_flag;
614  size_t packet_size;
615 
616  if (batadv_check_unicast_packet(skb, hdr_size) < 0)
617  return NET_RX_DROP;
618 
619  /* I could need to modify it */
620  if (skb_cow(skb, sizeof(struct batadv_tt_query_packet)) < 0)
621  goto out;
622 
623  tt_query = (struct batadv_tt_query_packet *)skb->data;
624 
625  switch (tt_query->flags & BATADV_TT_QUERY_TYPE_MASK) {
626  case BATADV_TT_REQUEST:
628 
629  /* If we cannot provide an answer the tt_request is
630  * forwarded
631  */
632  if (!batadv_send_tt_response(bat_priv, tt_query)) {
633  if (tt_query->flags & BATADV_TT_FULL_TABLE)
634  tt_flag = 'F';
635  else
636  tt_flag = '.';
637 
638  batadv_dbg(BATADV_DBG_TT, bat_priv,
639  "Routing TT_REQUEST to %pM [%c]\n",
640  tt_query->dst,
641  tt_flag);
642  return batadv_route_unicast_packet(skb, recv_if);
643  }
644  break;
645  case BATADV_TT_RESPONSE:
647 
648  if (batadv_is_my_mac(tt_query->dst)) {
649  /* packet needs to be linearized to access the TT
650  * changes
651  */
652  if (skb_linearize(skb) < 0)
653  goto out;
654  /* skb_linearize() possibly changed skb->data */
655  tt_query = (struct batadv_tt_query_packet *)skb->data;
656 
657  tt_size = batadv_tt_len(ntohs(tt_query->tt_data));
658 
659  /* Ensure we have all the claimed data */
660  packet_size = sizeof(struct batadv_tt_query_packet);
661  packet_size += tt_size;
662  if (unlikely(skb_headlen(skb) < packet_size))
663  goto out;
664 
665  batadv_handle_tt_response(bat_priv, tt_query);
666  } else {
667  if (tt_query->flags & BATADV_TT_FULL_TABLE)
668  tt_flag = 'F';
669  else
670  tt_flag = '.';
671  batadv_dbg(BATADV_DBG_TT, bat_priv,
672  "Routing TT_RESPONSE to %pM [%c]\n",
673  tt_query->dst,
674  tt_flag);
675  return batadv_route_unicast_packet(skb, recv_if);
676  }
677  break;
678  }
679 
680 out:
681  /* returning NET_RX_DROP will make the caller function kfree the skb */
682  return NET_RX_DROP;
683 }
684 
685 int batadv_recv_roam_adv(struct sk_buff *skb, struct batadv_hard_iface *recv_if)
686 {
687  struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
688  struct batadv_roam_adv_packet *roam_adv_packet;
689  struct batadv_orig_node *orig_node;
690  struct ethhdr *ethhdr;
691 
692  /* drop packet if it has not necessary minimum size */
693  if (unlikely(!pskb_may_pull(skb,
694  sizeof(struct batadv_roam_adv_packet))))
695  goto out;
696 
697  ethhdr = (struct ethhdr *)skb_mac_header(skb);
698 
699  /* packet with unicast indication but broadcast recipient */
700  if (is_broadcast_ether_addr(ethhdr->h_dest))
701  goto out;
702 
703  /* packet with broadcast sender address */
704  if (is_broadcast_ether_addr(ethhdr->h_source))
705  goto out;
706 
708 
709  roam_adv_packet = (struct batadv_roam_adv_packet *)skb->data;
710 
711  if (!batadv_is_my_mac(roam_adv_packet->dst))
712  return batadv_route_unicast_packet(skb, recv_if);
713 
714  /* check if it is a backbone gateway. we don't accept
715  * roaming advertisement from it, as it has the same
716  * entries as we have.
717  */
718  if (batadv_bla_is_backbone_gw_orig(bat_priv, roam_adv_packet->src))
719  goto out;
720 
721  orig_node = batadv_orig_hash_find(bat_priv, roam_adv_packet->src);
722  if (!orig_node)
723  goto out;
724 
725  batadv_dbg(BATADV_DBG_TT, bat_priv,
726  "Received ROAMING_ADV from %pM (client %pM)\n",
727  roam_adv_packet->src, roam_adv_packet->client);
728 
729  batadv_tt_global_add(bat_priv, orig_node, roam_adv_packet->client,
731  atomic_read(&orig_node->last_ttvn) + 1);
732 
733  /* Roaming phase starts: I have new information but the ttvn has not
734  * been incremented yet. This flag will make me check all the incoming
735  * packets for the correct destination.
736  */
737  bat_priv->tt.poss_change = true;
738 
739  batadv_orig_node_free_ref(orig_node);
740 out:
741  /* returning NET_RX_DROP will make the caller function kfree the skb */
742  return NET_RX_DROP;
743 }
744 
745 /* find a suitable router for this originator, and use
746  * bonding if possible. increases the found neighbors
747  * refcount.
748  */
749 struct batadv_neigh_node *
751  struct batadv_orig_node *orig_node,
752  const struct batadv_hard_iface *recv_if)
753 {
754  struct batadv_orig_node *primary_orig_node;
755  struct batadv_orig_node *router_orig;
756  struct batadv_neigh_node *router;
757  static uint8_t zero_mac[ETH_ALEN] = {0, 0, 0, 0, 0, 0};
758  int bonding_enabled;
759  uint8_t *primary_addr;
760 
761  if (!orig_node)
762  return NULL;
763 
764  router = batadv_orig_node_get_router(orig_node);
765  if (!router)
766  goto err;
767 
768  /* without bonding, the first node should
769  * always choose the default router.
770  */
771  bonding_enabled = atomic_read(&bat_priv->bonding);
772 
773  rcu_read_lock();
774  /* select default router to output */
775  router_orig = router->orig_node;
776  if (!router_orig)
777  goto err_unlock;
778 
779  if ((!recv_if) && (!bonding_enabled))
780  goto return_router;
781 
782  primary_addr = router_orig->primary_addr;
783 
784  /* if we have something in the primary_addr, we can search
785  * for a potential bonding candidate.
786  */
787  if (batadv_compare_eth(primary_addr, zero_mac))
788  goto return_router;
789 
790  /* find the orig_node which has the primary interface. might
791  * even be the same as our router_orig in many cases
792  */
793  if (batadv_compare_eth(primary_addr, router_orig->orig)) {
794  primary_orig_node = router_orig;
795  } else {
796  primary_orig_node = batadv_orig_hash_find(bat_priv,
797  primary_addr);
798  if (!primary_orig_node)
799  goto return_router;
800 
801  batadv_orig_node_free_ref(primary_orig_node);
802  }
803 
804  /* with less than 2 candidates, we can't do any
805  * bonding and prefer the original router.
806  */
807  if (atomic_read(&primary_orig_node->bond_candidates) < 2)
808  goto return_router;
809 
810  /* all nodes between should choose a candidate which
811  * is is not on the interface where the packet came
812  * in.
813  */
815 
816  if (bonding_enabled)
817  router = batadv_find_bond_router(primary_orig_node, recv_if);
818  else
819  router = batadv_find_ifalter_router(primary_orig_node, recv_if);
820 
821 return_router:
822  if (router && router->if_incoming->if_status != BATADV_IF_ACTIVE)
823  goto err_unlock;
824 
825  rcu_read_unlock();
826  return router;
827 err_unlock:
828  rcu_read_unlock();
829 err:
830  if (router)
832  return NULL;
833 }
834 
835 static int batadv_route_unicast_packet(struct sk_buff *skb,
836  struct batadv_hard_iface *recv_if)
837 {
838  struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
839  struct batadv_orig_node *orig_node = NULL;
840  struct batadv_neigh_node *neigh_node = NULL;
841  struct batadv_unicast_packet *unicast_packet;
842  struct ethhdr *ethhdr = (struct ethhdr *)skb_mac_header(skb);
843  int ret = NET_RX_DROP;
844  struct sk_buff *new_skb;
845 
846  unicast_packet = (struct batadv_unicast_packet *)skb->data;
847 
848  /* TTL exceeded */
849  if (unicast_packet->header.ttl < 2) {
850  pr_debug("Warning - can't forward unicast packet from %pM to %pM: ttl exceeded\n",
851  ethhdr->h_source, unicast_packet->dest);
852  goto out;
853  }
854 
855  /* get routing information */
856  orig_node = batadv_orig_hash_find(bat_priv, unicast_packet->dest);
857 
858  if (!orig_node)
859  goto out;
860 
861  /* find_router() increases neigh_nodes refcount if found. */
862  neigh_node = batadv_find_router(bat_priv, orig_node, recv_if);
863 
864  if (!neigh_node)
865  goto out;
866 
867  /* create a copy of the skb, if needed, to modify it. */
868  if (skb_cow(skb, ETH_HLEN) < 0)
869  goto out;
870 
871  unicast_packet = (struct batadv_unicast_packet *)skb->data;
872 
873  if (unicast_packet->header.packet_type == BATADV_UNICAST &&
874  atomic_read(&bat_priv->fragmentation) &&
875  skb->len > neigh_node->if_incoming->net_dev->mtu) {
876  ret = batadv_frag_send_skb(skb, bat_priv,
877  neigh_node->if_incoming,
878  neigh_node->addr);
879  goto out;
880  }
881 
882  if (unicast_packet->header.packet_type == BATADV_UNICAST_FRAG &&
883  batadv_frag_can_reassemble(skb,
884  neigh_node->if_incoming->net_dev->mtu)) {
885 
886  ret = batadv_frag_reassemble_skb(skb, bat_priv, &new_skb);
887 
888  if (ret == NET_RX_DROP)
889  goto out;
890 
891  /* packet was buffered for late merge */
892  if (!new_skb) {
893  ret = NET_RX_SUCCESS;
894  goto out;
895  }
896 
897  skb = new_skb;
898  unicast_packet = (struct batadv_unicast_packet *)skb->data;
899  }
900 
901  /* decrement ttl */
902  unicast_packet->header.ttl--;
903 
904  /* Update stats counter */
906  batadv_add_counter(bat_priv, BATADV_CNT_FORWARD_BYTES,
907  skb->len + ETH_HLEN);
908 
909  /* route it */
910  batadv_send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
911  ret = NET_RX_SUCCESS;
912 
913 out:
914  if (neigh_node)
915  batadv_neigh_node_free_ref(neigh_node);
916  if (orig_node)
917  batadv_orig_node_free_ref(orig_node);
918  return ret;
919 }
920 
921 static int batadv_check_unicast_ttvn(struct batadv_priv *bat_priv,
922  struct sk_buff *skb) {
923  uint8_t curr_ttvn;
924  struct batadv_orig_node *orig_node;
925  struct ethhdr *ethhdr;
926  struct batadv_hard_iface *primary_if;
927  struct batadv_unicast_packet *unicast_packet;
928  bool tt_poss_change;
929  int is_old_ttvn;
930 
931  /* I could need to modify it */
932  if (skb_cow(skb, sizeof(struct batadv_unicast_packet)) < 0)
933  return 0;
934 
935  unicast_packet = (struct batadv_unicast_packet *)skb->data;
936 
937  if (batadv_is_my_mac(unicast_packet->dest)) {
938  tt_poss_change = bat_priv->tt.poss_change;
939  curr_ttvn = (uint8_t)atomic_read(&bat_priv->tt.vn);
940  } else {
941  orig_node = batadv_orig_hash_find(bat_priv,
942  unicast_packet->dest);
943 
944  if (!orig_node)
945  return 0;
946 
947  curr_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);
948  tt_poss_change = orig_node->tt_poss_change;
949  batadv_orig_node_free_ref(orig_node);
950  }
951 
952  /* Check whether I have to reroute the packet */
953  is_old_ttvn = batadv_seq_before(unicast_packet->ttvn, curr_ttvn);
954  if (is_old_ttvn || tt_poss_change) {
955  /* check if there is enough data before accessing it */
956  if (pskb_may_pull(skb, sizeof(struct batadv_unicast_packet) +
957  ETH_HLEN) < 0)
958  return 0;
959 
960  ethhdr = (struct ethhdr *)(skb->data + sizeof(*unicast_packet));
961 
962  /* we don't have an updated route for this client, so we should
963  * not try to reroute the packet!!
964  */
966  ethhdr->h_dest))
967  return 1;
968 
969  orig_node = batadv_transtable_search(bat_priv, NULL,
970  ethhdr->h_dest);
971 
972  if (!orig_node) {
973  if (!batadv_is_my_client(bat_priv, ethhdr->h_dest))
974  return 0;
975  primary_if = batadv_primary_if_get_selected(bat_priv);
976  if (!primary_if)
977  return 0;
978  memcpy(unicast_packet->dest,
979  primary_if->net_dev->dev_addr, ETH_ALEN);
980  batadv_hardif_free_ref(primary_if);
981  } else {
982  memcpy(unicast_packet->dest, orig_node->orig,
983  ETH_ALEN);
984  curr_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);
985  batadv_orig_node_free_ref(orig_node);
986  }
987 
988  batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
989  "TTVN mismatch (old_ttvn %u new_ttvn %u)! Rerouting unicast packet (for %pM) to %pM\n",
990  unicast_packet->ttvn, curr_ttvn, ethhdr->h_dest,
991  unicast_packet->dest);
992 
993  unicast_packet->ttvn = curr_ttvn;
994  }
995  return 1;
996 }
997 
999  struct batadv_hard_iface *recv_if)
1000 {
1001  struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1002  struct batadv_unicast_packet *unicast_packet;
1003  int hdr_size = sizeof(*unicast_packet);
1004 
1005  if (batadv_check_unicast_packet(skb, hdr_size) < 0)
1006  return NET_RX_DROP;
1007 
1008  if (!batadv_check_unicast_ttvn(bat_priv, skb))
1009  return NET_RX_DROP;
1010 
1011  unicast_packet = (struct batadv_unicast_packet *)skb->data;
1012 
1013  /* packet for me */
1014  if (batadv_is_my_mac(unicast_packet->dest)) {
1015  batadv_interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size,
1016  NULL);
1017 
1018  return NET_RX_SUCCESS;
1019  }
1020 
1021  return batadv_route_unicast_packet(skb, recv_if);
1022 }
1023 
1025  struct batadv_hard_iface *recv_if)
1026 {
1027  struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1028  struct batadv_unicast_frag_packet *unicast_packet;
1029  int hdr_size = sizeof(*unicast_packet);
1030  struct sk_buff *new_skb = NULL;
1031  int ret;
1032 
1033  if (batadv_check_unicast_packet(skb, hdr_size) < 0)
1034  return NET_RX_DROP;
1035 
1036  if (!batadv_check_unicast_ttvn(bat_priv, skb))
1037  return NET_RX_DROP;
1038 
1039  unicast_packet = (struct batadv_unicast_frag_packet *)skb->data;
1040 
1041  /* packet for me */
1042  if (batadv_is_my_mac(unicast_packet->dest)) {
1043 
1044  ret = batadv_frag_reassemble_skb(skb, bat_priv, &new_skb);
1045 
1046  if (ret == NET_RX_DROP)
1047  return NET_RX_DROP;
1048 
1049  /* packet was buffered for late merge */
1050  if (!new_skb)
1051  return NET_RX_SUCCESS;
1052 
1053  batadv_interface_rx(recv_if->soft_iface, new_skb, recv_if,
1054  sizeof(struct batadv_unicast_packet), NULL);
1055  return NET_RX_SUCCESS;
1056  }
1057 
1058  return batadv_route_unicast_packet(skb, recv_if);
1059 }
1060 
1061 
1063  struct batadv_hard_iface *recv_if)
1064 {
1065  struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1066  struct batadv_orig_node *orig_node = NULL;
1067  struct batadv_bcast_packet *bcast_packet;
1068  struct ethhdr *ethhdr;
1069  int hdr_size = sizeof(*bcast_packet);
1070  int ret = NET_RX_DROP;
1071  int32_t seq_diff;
1072 
1073  /* drop packet if it has not necessary minimum size */
1074  if (unlikely(!pskb_may_pull(skb, hdr_size)))
1075  goto out;
1076 
1077  ethhdr = (struct ethhdr *)skb_mac_header(skb);
1078 
1079  /* packet with broadcast indication but unicast recipient */
1080  if (!is_broadcast_ether_addr(ethhdr->h_dest))
1081  goto out;
1082 
1083  /* packet with broadcast sender address */
1084  if (is_broadcast_ether_addr(ethhdr->h_source))
1085  goto out;
1086 
1087  /* ignore broadcasts sent by myself */
1088  if (batadv_is_my_mac(ethhdr->h_source))
1089  goto out;
1090 
1091  bcast_packet = (struct batadv_bcast_packet *)skb->data;
1092 
1093  /* ignore broadcasts originated by myself */
1094  if (batadv_is_my_mac(bcast_packet->orig))
1095  goto out;
1096 
1097  if (bcast_packet->header.ttl < 2)
1098  goto out;
1099 
1100  orig_node = batadv_orig_hash_find(bat_priv, bcast_packet->orig);
1101 
1102  if (!orig_node)
1103  goto out;
1104 
1105  spin_lock_bh(&orig_node->bcast_seqno_lock);
1106 
1107  /* check whether the packet is a duplicate */
1108  if (batadv_test_bit(orig_node->bcast_bits, orig_node->last_bcast_seqno,
1109  ntohl(bcast_packet->seqno)))
1110  goto spin_unlock;
1111 
1112  seq_diff = ntohl(bcast_packet->seqno) - orig_node->last_bcast_seqno;
1113 
1114  /* check whether the packet is old and the host just restarted. */
1115  if (batadv_window_protected(bat_priv, seq_diff,
1116  &orig_node->bcast_seqno_reset))
1117  goto spin_unlock;
1118 
1119  /* mark broadcast in flood history, update window position
1120  * if required.
1121  */
1122  if (batadv_bit_get_packet(bat_priv, orig_node->bcast_bits, seq_diff, 1))
1123  orig_node->last_bcast_seqno = ntohl(bcast_packet->seqno);
1124 
1125  spin_unlock_bh(&orig_node->bcast_seqno_lock);
1126 
1127  /* keep skb linear for crc calculation */
1128  if (skb_linearize(skb) < 0)
1129  goto out;
1130 
1131  bcast_packet = (struct batadv_bcast_packet *)skb->data;
1132 
1133  /* check whether this has been sent by another originator before */
1134  if (batadv_bla_check_bcast_duplist(bat_priv, bcast_packet, skb->len))
1135  goto out;
1136 
1137  /* rebroadcast packet */
1138  batadv_add_bcast_packet_to_list(bat_priv, skb, 1);
1139 
1140  /* don't hand the broadcast up if it is from an originator
1141  * from the same backbone.
1142  */
1143  if (batadv_bla_is_backbone_gw(skb, orig_node, hdr_size))
1144  goto out;
1145 
1146  /* broadcast for me */
1147  batadv_interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size,
1148  orig_node);
1149  ret = NET_RX_SUCCESS;
1150  goto out;
1151 
1152 spin_unlock:
1153  spin_unlock_bh(&orig_node->bcast_seqno_lock);
1154 out:
1155  if (orig_node)
1156  batadv_orig_node_free_ref(orig_node);
1157  return ret;
1158 }
1159 
1161  struct batadv_hard_iface *recv_if)
1162 {
1163  struct batadv_vis_packet *vis_packet;
1164  struct ethhdr *ethhdr;
1165  struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1166  int hdr_size = sizeof(*vis_packet);
1167 
1168  /* keep skb linear */
1169  if (skb_linearize(skb) < 0)
1170  return NET_RX_DROP;
1171 
1172  if (unlikely(!pskb_may_pull(skb, hdr_size)))
1173  return NET_RX_DROP;
1174 
1175  vis_packet = (struct batadv_vis_packet *)skb->data;
1176  ethhdr = (struct ethhdr *)skb_mac_header(skb);
1177 
1178  /* not for me */
1179  if (!batadv_is_my_mac(ethhdr->h_dest))
1180  return NET_RX_DROP;
1181 
1182  /* ignore own packets */
1183  if (batadv_is_my_mac(vis_packet->vis_orig))
1184  return NET_RX_DROP;
1185 
1186  if (batadv_is_my_mac(vis_packet->sender_orig))
1187  return NET_RX_DROP;
1188 
1189  switch (vis_packet->vis_type) {
1191  batadv_receive_server_sync_packet(bat_priv, vis_packet,
1192  skb_headlen(skb));
1193  break;
1194 
1196  batadv_receive_client_update_packet(bat_priv, vis_packet,
1197  skb_headlen(skb));
1198  break;
1199 
1200  default: /* ignore unknown packet */
1201  break;
1202  }
1203 
1204  /* We take a copy of the data in the packet, so we should
1205  * always free the skbuf.
1206  */
1207  return NET_RX_DROP;
1208 }