2 * Copyright (C) 2007-2010 B.A.T.M.A.N. contributors:
4 * Marek Lindner, Simon Wunderlich
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.
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.
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
26 #include "soft-interface.h"
27 #include "hard-interface.h"
28 #include "icmp_socket.h"
29 #include "translation-table.h"
30 #include "originator.h"
32 #include "ring_buffer.h"
34 #include "aggregation.h"
37 void slide_own_bcast_window(struct batman_if *batman_if)
39 struct bat_priv *bat_priv = netdev_priv(batman_if->soft_iface);
41 struct orig_node *orig_node;
45 spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
47 while (hash_iterate(bat_priv->orig_hash, &hashit)) {
48 orig_node = hashit.bucket->data;
49 word = &(orig_node->bcast_own[batman_if->if_num * NUM_WORDS]);
51 bit_get_packet(bat_priv, word, 1, 0);
52 orig_node->bcast_own_sum[batman_if->if_num] =
53 bit_packet_count(word);
56 spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
59 static void update_HNA(struct bat_priv *bat_priv, struct orig_node *orig_node,
60 unsigned char *hna_buff, int hna_buff_len)
62 if ((hna_buff_len != orig_node->hna_buff_len) ||
63 ((hna_buff_len > 0) &&
64 (orig_node->hna_buff_len > 0) &&
65 (memcmp(orig_node->hna_buff, hna_buff, hna_buff_len) != 0))) {
67 if (orig_node->hna_buff_len > 0)
68 hna_global_del_orig(bat_priv, orig_node,
69 "originator changed hna");
71 if ((hna_buff_len > 0) && (hna_buff != NULL))
72 hna_global_add_orig(bat_priv, orig_node,
73 hna_buff, hna_buff_len);
77 static void update_route(struct bat_priv *bat_priv,
78 struct orig_node *orig_node,
79 struct neigh_node *neigh_node,
80 unsigned char *hna_buff, int hna_buff_len)
83 if ((orig_node->router != NULL) && (neigh_node == NULL)) {
85 bat_dbg(DBG_ROUTES, bat_priv, "Deleting route towards: %pM\n",
87 hna_global_del_orig(bat_priv, orig_node,
88 "originator timed out");
91 } else if ((orig_node->router == NULL) && (neigh_node != NULL)) {
93 bat_dbg(DBG_ROUTES, bat_priv,
94 "Adding route towards: %pM (via %pM)\n",
95 orig_node->orig, neigh_node->addr);
96 hna_global_add_orig(bat_priv, orig_node,
97 hna_buff, hna_buff_len);
101 bat_dbg(DBG_ROUTES, bat_priv,
102 "Changing route towards: %pM "
103 "(now via %pM - was via %pM)\n",
104 orig_node->orig, neigh_node->addr,
105 orig_node->router->addr);
108 orig_node->router = neigh_node;
112 void update_routes(struct bat_priv *bat_priv, struct orig_node *orig_node,
113 struct neigh_node *neigh_node, unsigned char *hna_buff,
117 if (orig_node == NULL)
120 if (orig_node->router != neigh_node)
121 update_route(bat_priv, orig_node, neigh_node,
122 hna_buff, hna_buff_len);
123 /* may be just HNA changed */
125 update_HNA(bat_priv, orig_node, hna_buff, hna_buff_len);
128 static int is_bidirectional_neigh(struct orig_node *orig_node,
129 struct orig_node *orig_neigh_node,
130 struct batman_packet *batman_packet,
131 struct batman_if *if_incoming)
133 struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
134 struct neigh_node *neigh_node = NULL, *tmp_neigh_node = NULL;
135 unsigned char total_count;
137 if (orig_node == orig_neigh_node) {
138 list_for_each_entry(tmp_neigh_node,
139 &orig_node->neigh_list,
142 if (compare_orig(tmp_neigh_node->addr,
143 orig_neigh_node->orig) &&
144 (tmp_neigh_node->if_incoming == if_incoming))
145 neigh_node = tmp_neigh_node;
149 neigh_node = create_neighbor(orig_node,
151 orig_neigh_node->orig,
153 /* create_neighbor failed, return 0 */
157 neigh_node->last_valid = jiffies;
159 /* find packet count of corresponding one hop neighbor */
160 list_for_each_entry(tmp_neigh_node,
161 &orig_neigh_node->neigh_list, list) {
163 if (compare_orig(tmp_neigh_node->addr,
164 orig_neigh_node->orig) &&
165 (tmp_neigh_node->if_incoming == if_incoming))
166 neigh_node = tmp_neigh_node;
170 neigh_node = create_neighbor(orig_neigh_node,
172 orig_neigh_node->orig,
174 /* create_neighbor failed, return 0 */
179 orig_node->last_valid = jiffies;
181 /* pay attention to not get a value bigger than 100 % */
182 total_count = (orig_neigh_node->bcast_own_sum[if_incoming->if_num] >
183 neigh_node->real_packet_count ?
184 neigh_node->real_packet_count :
185 orig_neigh_node->bcast_own_sum[if_incoming->if_num]);
187 /* if we have too few packets (too less data) we set tq_own to zero */
188 /* if we receive too few packets it is not considered bidirectional */
189 if ((total_count < TQ_LOCAL_BIDRECT_SEND_MINIMUM) ||
190 (neigh_node->real_packet_count < TQ_LOCAL_BIDRECT_RECV_MINIMUM))
191 orig_neigh_node->tq_own = 0;
193 /* neigh_node->real_packet_count is never zero as we
194 * only purge old information when getting new
196 orig_neigh_node->tq_own = (TQ_MAX_VALUE * total_count) /
197 neigh_node->real_packet_count;
200 * 1 - ((1-x) ** 3), normalized to TQ_MAX_VALUE this does
201 * affect the nearly-symmetric links only a little, but
202 * punishes asymmetric links more. This will give a value
203 * between 0 and TQ_MAX_VALUE
205 orig_neigh_node->tq_asym_penalty =
208 (TQ_LOCAL_WINDOW_SIZE - neigh_node->real_packet_count) *
209 (TQ_LOCAL_WINDOW_SIZE - neigh_node->real_packet_count) *
210 (TQ_LOCAL_WINDOW_SIZE - neigh_node->real_packet_count)) /
211 (TQ_LOCAL_WINDOW_SIZE *
212 TQ_LOCAL_WINDOW_SIZE *
213 TQ_LOCAL_WINDOW_SIZE);
215 batman_packet->tq = ((batman_packet->tq *
216 orig_neigh_node->tq_own *
217 orig_neigh_node->tq_asym_penalty) /
218 (TQ_MAX_VALUE * TQ_MAX_VALUE));
220 bat_dbg(DBG_BATMAN, bat_priv,
222 "orig = %-15pM neigh = %-15pM => own_bcast = %2i, "
223 "real recv = %2i, local tq: %3i, asym_penalty: %3i, "
225 orig_node->orig, orig_neigh_node->orig, total_count,
226 neigh_node->real_packet_count, orig_neigh_node->tq_own,
227 orig_neigh_node->tq_asym_penalty, batman_packet->tq);
229 /* if link has the minimum required transmission quality
230 * consider it bidirectional */
231 if (batman_packet->tq >= TQ_TOTAL_BIDRECT_LIMIT)
237 static void update_orig(struct bat_priv *bat_priv,
238 struct orig_node *orig_node,
239 struct ethhdr *ethhdr,
240 struct batman_packet *batman_packet,
241 struct batman_if *if_incoming,
242 unsigned char *hna_buff, int hna_buff_len,
245 struct neigh_node *neigh_node = NULL, *tmp_neigh_node = NULL;
246 int tmp_hna_buff_len;
248 bat_dbg(DBG_BATMAN, bat_priv, "update_originator(): "
249 "Searching and updating originator entry of received packet\n");
251 list_for_each_entry(tmp_neigh_node, &orig_node->neigh_list, list) {
252 if (compare_orig(tmp_neigh_node->addr, ethhdr->h_source) &&
253 (tmp_neigh_node->if_incoming == if_incoming)) {
254 neigh_node = tmp_neigh_node;
261 ring_buffer_set(tmp_neigh_node->tq_recv,
262 &tmp_neigh_node->tq_index, 0);
263 tmp_neigh_node->tq_avg =
264 ring_buffer_avg(tmp_neigh_node->tq_recv);
268 struct orig_node *orig_tmp;
270 orig_tmp = get_orig_node(bat_priv, ethhdr->h_source);
274 neigh_node = create_neighbor(orig_node, orig_tmp,
275 ethhdr->h_source, if_incoming);
279 bat_dbg(DBG_BATMAN, bat_priv,
280 "Updating existing last-hop neighbor of originator\n");
282 orig_node->flags = batman_packet->flags;
283 neigh_node->last_valid = jiffies;
285 ring_buffer_set(neigh_node->tq_recv,
286 &neigh_node->tq_index,
288 neigh_node->tq_avg = ring_buffer_avg(neigh_node->tq_recv);
291 orig_node->last_ttl = batman_packet->ttl;
292 neigh_node->last_ttl = batman_packet->ttl;
295 tmp_hna_buff_len = (hna_buff_len > batman_packet->num_hna * ETH_ALEN ?
296 batman_packet->num_hna * ETH_ALEN : hna_buff_len);
298 /* if this neighbor already is our next hop there is nothing
300 if (orig_node->router == neigh_node)
303 /* if this neighbor does not offer a better TQ we won't consider it */
304 if ((orig_node->router) &&
305 (orig_node->router->tq_avg > neigh_node->tq_avg))
308 /* if the TQ is the same and the link not more symetric we
309 * won't consider it either */
310 if ((orig_node->router) &&
311 ((neigh_node->tq_avg == orig_node->router->tq_avg) &&
312 (orig_node->router->orig_node->bcast_own_sum[if_incoming->if_num]
313 >= neigh_node->orig_node->bcast_own_sum[if_incoming->if_num])))
316 update_routes(bat_priv, orig_node, neigh_node,
317 hna_buff, tmp_hna_buff_len);
321 update_routes(bat_priv, orig_node, orig_node->router,
322 hna_buff, tmp_hna_buff_len);
325 /* checks whether the host restarted and is in the protection time.
327 * 0 if the packet is to be accepted
328 * 1 if the packet is to be ignored.
330 static int window_protected(struct bat_priv *bat_priv,
331 int32_t seq_num_diff,
332 unsigned long *last_reset)
334 if ((seq_num_diff <= -TQ_LOCAL_WINDOW_SIZE)
335 || (seq_num_diff >= EXPECTED_SEQNO_RANGE)) {
336 if (time_after(jiffies, *last_reset +
337 msecs_to_jiffies(RESET_PROTECTION_MS))) {
339 *last_reset = jiffies;
340 bat_dbg(DBG_BATMAN, bat_priv,
341 "old packet received, start protection\n");
350 /* processes a batman packet for all interfaces, adjusts the sequence number and
351 * finds out whether it is a duplicate.
353 * 1 the packet is a duplicate
354 * 0 the packet has not yet been received
355 * -1 the packet is old and has been received while the seqno window
356 * was protected. Caller should drop it.
358 static char count_real_packets(struct ethhdr *ethhdr,
359 struct batman_packet *batman_packet,
360 struct batman_if *if_incoming)
362 struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
363 struct orig_node *orig_node;
364 struct neigh_node *tmp_neigh_node;
365 char is_duplicate = 0;
370 orig_node = get_orig_node(bat_priv, batman_packet->orig);
371 if (orig_node == NULL)
374 seq_diff = batman_packet->seqno - orig_node->last_real_seqno;
376 /* signalize caller that the packet is to be dropped. */
377 if (window_protected(bat_priv, seq_diff,
378 &orig_node->batman_seqno_reset))
381 list_for_each_entry(tmp_neigh_node, &orig_node->neigh_list, list) {
383 is_duplicate |= get_bit_status(tmp_neigh_node->real_bits,
384 orig_node->last_real_seqno,
385 batman_packet->seqno);
387 if (compare_orig(tmp_neigh_node->addr, ethhdr->h_source) &&
388 (tmp_neigh_node->if_incoming == if_incoming))
393 /* if the window moved, set the update flag. */
394 need_update |= bit_get_packet(bat_priv,
395 tmp_neigh_node->real_bits,
398 tmp_neigh_node->real_packet_count =
399 bit_packet_count(tmp_neigh_node->real_bits);
403 bat_dbg(DBG_BATMAN, bat_priv,
404 "updating last_seqno: old %d, new %d\n",
405 orig_node->last_real_seqno, batman_packet->seqno);
406 orig_node->last_real_seqno = batman_packet->seqno;
412 /* copy primary address for bonding */
413 static void mark_bonding_address(struct bat_priv *bat_priv,
414 struct orig_node *orig_node,
415 struct orig_node *orig_neigh_node,
416 struct batman_packet *batman_packet)
419 if (batman_packet->flags & PRIMARIES_FIRST_HOP)
420 memcpy(orig_neigh_node->primary_addr,
421 orig_node->orig, ETH_ALEN);
426 /* mark possible bond.candidates in the neighbor list */
427 void update_bonding_candidates(struct bat_priv *bat_priv,
428 struct orig_node *orig_node)
431 int interference_candidate;
433 struct neigh_node *tmp_neigh_node, *tmp_neigh_node2;
434 struct neigh_node *first_candidate, *last_candidate;
436 /* update the candidates for this originator */
437 if (!orig_node->router) {
438 orig_node->bond.candidates = 0;
442 best_tq = orig_node->router->tq_avg;
444 /* update bond.candidates */
448 /* mark other nodes which also received "PRIMARIES FIRST HOP" packets
449 * as "bonding partner" */
451 /* first, zero the list */
452 list_for_each_entry(tmp_neigh_node, &orig_node->neigh_list, list) {
453 tmp_neigh_node->next_bond_candidate = NULL;
456 first_candidate = NULL;
457 last_candidate = NULL;
458 list_for_each_entry(tmp_neigh_node, &orig_node->neigh_list, list) {
460 /* only consider if it has the same primary address ... */
461 if (memcmp(orig_node->orig,
462 tmp_neigh_node->orig_node->primary_addr,
466 /* ... and is good enough to be considered */
467 if (tmp_neigh_node->tq_avg < best_tq - BONDING_TQ_THRESHOLD)
470 /* check if we have another candidate with the same
471 * mac address or interface. If we do, we won't
472 * select this candidate because of possible interference. */
474 interference_candidate = 0;
475 list_for_each_entry(tmp_neigh_node2,
476 &orig_node->neigh_list, list) {
478 if (tmp_neigh_node2 == tmp_neigh_node)
481 /* we only care if the other candidate is even
482 * considered as candidate. */
483 if (tmp_neigh_node2->next_bond_candidate == NULL)
487 if ((tmp_neigh_node->if_incoming ==
488 tmp_neigh_node2->if_incoming)
489 || (memcmp(tmp_neigh_node->addr,
490 tmp_neigh_node2->addr, ETH_ALEN) == 0)) {
492 interference_candidate = 1;
496 /* don't care further if it is an interference candidate */
497 if (interference_candidate)
500 if (first_candidate == NULL) {
501 first_candidate = tmp_neigh_node;
502 tmp_neigh_node->next_bond_candidate = first_candidate;
504 tmp_neigh_node->next_bond_candidate = last_candidate;
506 last_candidate = tmp_neigh_node;
511 if (candidates > 0) {
512 first_candidate->next_bond_candidate = last_candidate;
513 orig_node->bond.selected = first_candidate;
516 orig_node->bond.candidates = candidates;
519 void receive_bat_packet(struct ethhdr *ethhdr,
520 struct batman_packet *batman_packet,
521 unsigned char *hna_buff, int hna_buff_len,
522 struct batman_if *if_incoming)
524 struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
525 struct batman_if *batman_if;
526 struct orig_node *orig_neigh_node, *orig_node;
527 char has_directlink_flag;
528 char is_my_addr = 0, is_my_orig = 0, is_my_oldorig = 0;
529 char is_broadcast = 0, is_bidirectional, is_single_hop_neigh;
531 uint32_t if_incoming_seqno;
533 /* Silently drop when the batman packet is actually not a
536 * This might happen if a packet is padded (e.g. Ethernet has a
537 * minimum frame length of 64 byte) and the aggregation interprets
538 * it as an additional length.
540 * TODO: A more sane solution would be to have a bit in the
541 * batman_packet to detect whether the packet is the last
542 * packet in an aggregation. Here we expect that the padding
543 * is always zero (or not 0x01)
545 if (batman_packet->packet_type != BAT_PACKET)
548 /* could be changed by schedule_own_packet() */
549 if_incoming_seqno = atomic_read(&if_incoming->seqno);
551 has_directlink_flag = (batman_packet->flags & DIRECTLINK ? 1 : 0);
553 is_single_hop_neigh = (compare_orig(ethhdr->h_source,
554 batman_packet->orig) ? 1 : 0);
556 bat_dbg(DBG_BATMAN, bat_priv,
557 "Received BATMAN packet via NB: %pM, IF: %s [%s] "
558 "(from OG: %pM, via prev OG: %pM, seqno %d, tq %d, "
559 "TTL %d, V %d, IDF %d)\n",
560 ethhdr->h_source, if_incoming->net_dev->name,
561 if_incoming->addr_str, batman_packet->orig,
562 batman_packet->prev_sender, batman_packet->seqno,
563 batman_packet->tq, batman_packet->ttl, batman_packet->version,
564 has_directlink_flag);
566 list_for_each_entry_rcu(batman_if, &if_list, list) {
567 if (batman_if->if_status != IF_ACTIVE)
570 if (batman_if->soft_iface != if_incoming->soft_iface)
573 if (compare_orig(ethhdr->h_source,
574 batman_if->net_dev->dev_addr))
577 if (compare_orig(batman_packet->orig,
578 batman_if->net_dev->dev_addr))
581 if (compare_orig(batman_packet->prev_sender,
582 batman_if->net_dev->dev_addr))
585 if (compare_orig(ethhdr->h_source, broadcast_addr))
589 if (batman_packet->version != COMPAT_VERSION) {
590 bat_dbg(DBG_BATMAN, bat_priv,
591 "Drop packet: incompatible batman version (%i)\n",
592 batman_packet->version);
597 bat_dbg(DBG_BATMAN, bat_priv,
598 "Drop packet: received my own broadcast (sender: %pM"
605 bat_dbg(DBG_BATMAN, bat_priv, "Drop packet: "
606 "ignoring all packets with broadcast source addr (sender: %pM"
607 ")\n", ethhdr->h_source);
615 orig_neigh_node = get_orig_node(bat_priv, ethhdr->h_source);
617 if (!orig_neigh_node)
620 /* neighbor has to indicate direct link and it has to
621 * come via the corresponding interface */
622 /* if received seqno equals last send seqno save new
623 * seqno for bidirectional check */
624 if (has_directlink_flag &&
625 compare_orig(if_incoming->net_dev->dev_addr,
626 batman_packet->orig) &&
627 (batman_packet->seqno - if_incoming_seqno + 2 == 0)) {
628 offset = if_incoming->if_num * NUM_WORDS;
629 word = &(orig_neigh_node->bcast_own[offset]);
631 orig_neigh_node->bcast_own_sum[if_incoming->if_num] =
632 bit_packet_count(word);
635 bat_dbg(DBG_BATMAN, bat_priv, "Drop packet: "
636 "originator packet from myself (via neighbor)\n");
641 bat_dbg(DBG_BATMAN, bat_priv,
642 "Drop packet: ignoring all rebroadcast echos (sender: "
643 "%pM)\n", ethhdr->h_source);
647 orig_node = get_orig_node(bat_priv, batman_packet->orig);
648 if (orig_node == NULL)
651 is_duplicate = count_real_packets(ethhdr, batman_packet, if_incoming);
653 if (is_duplicate == -1) {
654 bat_dbg(DBG_BATMAN, bat_priv,
655 "Drop packet: packet within seqno protection time "
656 "(sender: %pM)\n", ethhdr->h_source);
660 if (batman_packet->tq == 0) {
661 bat_dbg(DBG_BATMAN, bat_priv,
662 "Drop packet: originator packet with tq equal 0\n");
666 /* avoid temporary routing loops */
667 if ((orig_node->router) &&
668 (orig_node->router->orig_node->router) &&
669 (compare_orig(orig_node->router->addr,
670 batman_packet->prev_sender)) &&
671 !(compare_orig(batman_packet->orig, batman_packet->prev_sender)) &&
672 (compare_orig(orig_node->router->addr,
673 orig_node->router->orig_node->router->addr))) {
674 bat_dbg(DBG_BATMAN, bat_priv,
675 "Drop packet: ignoring all rebroadcast packets that "
676 "may make me loop (sender: %pM)\n", ethhdr->h_source);
680 /* if sender is a direct neighbor the sender mac equals
682 orig_neigh_node = (is_single_hop_neigh ?
684 get_orig_node(bat_priv, ethhdr->h_source));
685 if (orig_neigh_node == NULL)
688 /* drop packet if sender is not a direct neighbor and if we
689 * don't route towards it */
690 if (!is_single_hop_neigh &&
691 (orig_neigh_node->router == NULL)) {
692 bat_dbg(DBG_BATMAN, bat_priv,
693 "Drop packet: OGM via unknown neighbor!\n");
697 is_bidirectional = is_bidirectional_neigh(orig_node, orig_neigh_node,
698 batman_packet, if_incoming);
700 /* update ranking if it is not a duplicate or has the same
701 * seqno and similar ttl as the non-duplicate */
702 if (is_bidirectional &&
704 ((orig_node->last_real_seqno == batman_packet->seqno) &&
705 (orig_node->last_ttl - 3 <= batman_packet->ttl))))
706 update_orig(bat_priv, orig_node, ethhdr, batman_packet,
707 if_incoming, hna_buff, hna_buff_len, is_duplicate);
709 mark_bonding_address(bat_priv, orig_node,
710 orig_neigh_node, batman_packet);
711 update_bonding_candidates(bat_priv, orig_node);
713 /* is single hop (direct) neighbor */
714 if (is_single_hop_neigh) {
716 /* mark direct link on incoming interface */
717 schedule_forward_packet(orig_node, ethhdr, batman_packet,
718 1, hna_buff_len, if_incoming);
720 bat_dbg(DBG_BATMAN, bat_priv, "Forwarding packet: "
721 "rebroadcast neighbor packet with direct link flag\n");
725 /* multihop originator */
726 if (!is_bidirectional) {
727 bat_dbg(DBG_BATMAN, bat_priv,
728 "Drop packet: not received via bidirectional link\n");
733 bat_dbg(DBG_BATMAN, bat_priv,
734 "Drop packet: duplicate packet received\n");
738 bat_dbg(DBG_BATMAN, bat_priv,
739 "Forwarding packet: rebroadcast originator packet\n");
740 schedule_forward_packet(orig_node, ethhdr, batman_packet,
741 0, hna_buff_len, if_incoming);
744 int recv_bat_packet(struct sk_buff *skb, struct batman_if *batman_if)
746 struct bat_priv *bat_priv = netdev_priv(batman_if->soft_iface);
747 struct ethhdr *ethhdr;
750 /* drop packet if it has not necessary minimum size */
751 if (unlikely(!pskb_may_pull(skb, sizeof(struct batman_packet))))
754 ethhdr = (struct ethhdr *)skb_mac_header(skb);
756 /* packet with broadcast indication but unicast recipient */
757 if (!is_bcast(ethhdr->h_dest))
760 /* packet with broadcast sender address */
761 if (is_bcast(ethhdr->h_source))
764 /* create a copy of the skb, if needed, to modify it. */
765 if (skb_cow(skb, 0) < 0)
768 /* keep skb linear */
769 if (skb_linearize(skb) < 0)
772 ethhdr = (struct ethhdr *)skb_mac_header(skb);
774 spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
775 receive_aggr_bat_packet(ethhdr,
779 spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
782 return NET_RX_SUCCESS;
785 static int recv_my_icmp_packet(struct bat_priv *bat_priv,
786 struct sk_buff *skb, size_t icmp_len)
788 struct orig_node *orig_node;
789 struct icmp_packet_rr *icmp_packet;
790 struct ethhdr *ethhdr;
791 struct batman_if *batman_if;
794 uint8_t dstaddr[ETH_ALEN];
796 icmp_packet = (struct icmp_packet_rr *)skb->data;
797 ethhdr = (struct ethhdr *)skb_mac_header(skb);
799 /* add data to device queue */
800 if (icmp_packet->msg_type != ECHO_REQUEST) {
801 bat_socket_receive_packet(icmp_packet, icmp_len);
805 if (!bat_priv->primary_if)
808 /* answer echo request (ping) */
809 /* get routing information */
810 spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
811 orig_node = ((struct orig_node *)hash_find(bat_priv->orig_hash,
815 if ((orig_node != NULL) &&
816 (orig_node->router != NULL)) {
818 /* don't lock while sending the packets ... we therefore
819 * copy the required data before sending */
820 batman_if = orig_node->router->if_incoming;
821 memcpy(dstaddr, orig_node->router->addr, ETH_ALEN);
822 spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
824 /* create a copy of the skb, if needed, to modify it. */
825 if (skb_cow(skb, sizeof(struct ethhdr)) < 0)
828 icmp_packet = (struct icmp_packet_rr *)skb->data;
829 ethhdr = (struct ethhdr *)skb_mac_header(skb);
831 memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN);
832 memcpy(icmp_packet->orig,
833 bat_priv->primary_if->net_dev->dev_addr, ETH_ALEN);
834 icmp_packet->msg_type = ECHO_REPLY;
835 icmp_packet->ttl = TTL;
837 send_skb_packet(skb, batman_if, dstaddr);
838 ret = NET_RX_SUCCESS;
841 spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
846 static int recv_icmp_ttl_exceeded(struct bat_priv *bat_priv,
847 struct sk_buff *skb, size_t icmp_len)
849 struct orig_node *orig_node;
850 struct icmp_packet *icmp_packet;
851 struct ethhdr *ethhdr;
852 struct batman_if *batman_if;
855 uint8_t dstaddr[ETH_ALEN];
857 icmp_packet = (struct icmp_packet *)skb->data;
858 ethhdr = (struct ethhdr *)skb_mac_header(skb);
860 /* send TTL exceeded if packet is an echo request (traceroute) */
861 if (icmp_packet->msg_type != ECHO_REQUEST) {
862 pr_debug("Warning - can't forward icmp packet from %pM to "
863 "%pM: ttl exceeded\n", icmp_packet->orig,
868 if (!bat_priv->primary_if)
871 /* get routing information */
872 spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
873 orig_node = ((struct orig_node *)
874 hash_find(bat_priv->orig_hash, icmp_packet->orig));
877 if ((orig_node != NULL) &&
878 (orig_node->router != NULL)) {
880 /* don't lock while sending the packets ... we therefore
881 * copy the required data before sending */
882 batman_if = orig_node->router->if_incoming;
883 memcpy(dstaddr, orig_node->router->addr, ETH_ALEN);
884 spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
886 /* create a copy of the skb, if needed, to modify it. */
887 if (skb_cow(skb, sizeof(struct ethhdr)) < 0)
890 icmp_packet = (struct icmp_packet *) skb->data;
891 ethhdr = (struct ethhdr *)skb_mac_header(skb);
893 memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN);
894 memcpy(icmp_packet->orig,
895 bat_priv->primary_if->net_dev->dev_addr, ETH_ALEN);
896 icmp_packet->msg_type = TTL_EXCEEDED;
897 icmp_packet->ttl = TTL;
899 send_skb_packet(skb, batman_if, dstaddr);
900 ret = NET_RX_SUCCESS;
903 spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
909 int recv_icmp_packet(struct sk_buff *skb, struct batman_if *recv_if)
911 struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
912 struct icmp_packet_rr *icmp_packet;
913 struct ethhdr *ethhdr;
914 struct orig_node *orig_node;
915 struct batman_if *batman_if;
916 int hdr_size = sizeof(struct icmp_packet);
919 uint8_t dstaddr[ETH_ALEN];
922 * we truncate all incoming icmp packets if they don't match our size
924 if (skb->len >= sizeof(struct icmp_packet_rr))
925 hdr_size = sizeof(struct icmp_packet_rr);
927 /* drop packet if it has not necessary minimum size */
928 if (unlikely(!pskb_may_pull(skb, hdr_size)))
931 ethhdr = (struct ethhdr *)skb_mac_header(skb);
933 /* packet with unicast indication but broadcast recipient */
934 if (is_bcast(ethhdr->h_dest))
937 /* packet with broadcast sender address */
938 if (is_bcast(ethhdr->h_source))
942 if (!is_my_mac(ethhdr->h_dest))
945 icmp_packet = (struct icmp_packet_rr *)skb->data;
947 /* add record route information if not full */
948 if ((hdr_size == sizeof(struct icmp_packet_rr)) &&
949 (icmp_packet->rr_cur < BAT_RR_LEN)) {
950 memcpy(&(icmp_packet->rr[icmp_packet->rr_cur]),
951 ethhdr->h_dest, ETH_ALEN);
952 icmp_packet->rr_cur++;
956 if (is_my_mac(icmp_packet->dst))
957 return recv_my_icmp_packet(bat_priv, skb, hdr_size);
960 if (icmp_packet->ttl < 2)
961 return recv_icmp_ttl_exceeded(bat_priv, skb, hdr_size);
965 /* get routing information */
966 spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
967 orig_node = ((struct orig_node *)
968 hash_find(bat_priv->orig_hash, icmp_packet->dst));
970 if ((orig_node != NULL) &&
971 (orig_node->router != NULL)) {
973 /* don't lock while sending the packets ... we therefore
974 * copy the required data before sending */
975 batman_if = orig_node->router->if_incoming;
976 memcpy(dstaddr, orig_node->router->addr, ETH_ALEN);
977 spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
979 /* create a copy of the skb, if needed, to modify it. */
980 if (skb_cow(skb, sizeof(struct ethhdr)) < 0)
983 icmp_packet = (struct icmp_packet_rr *)skb->data;
984 ethhdr = (struct ethhdr *)skb_mac_header(skb);
990 send_skb_packet(skb, batman_if, dstaddr);
991 ret = NET_RX_SUCCESS;
994 spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
999 /* find a suitable router for this originator, and use
1000 * bonding if possible. */
1001 struct neigh_node *find_router(struct orig_node *orig_node,
1002 struct batman_if *recv_if)
1004 struct bat_priv *bat_priv;
1005 struct orig_node *primary_orig_node;
1006 struct orig_node *router_orig;
1007 struct neigh_node *router, *first_candidate, *best_router;
1008 static uint8_t zero_mac[ETH_ALEN] = {0, 0, 0, 0, 0, 0};
1009 int bonding_enabled;
1014 if (!orig_node->router)
1017 /* without bonding, the first node should
1018 * always choose the default router. */
1021 return orig_node->router;
1023 bat_priv = netdev_priv(recv_if->soft_iface);
1024 bonding_enabled = atomic_read(&bat_priv->bonding_enabled);
1026 if (!bonding_enabled)
1027 return orig_node->router;
1029 router_orig = orig_node->router->orig_node;
1031 /* if we have something in the primary_addr, we can search
1032 * for a potential bonding candidate. */
1033 if (memcmp(router_orig->primary_addr, zero_mac, ETH_ALEN) == 0)
1034 return orig_node->router;
1036 /* find the orig_node which has the primary interface. might
1037 * even be the same as our router_orig in many cases */
1039 if (memcmp(router_orig->primary_addr,
1040 router_orig->orig, ETH_ALEN) == 0) {
1041 primary_orig_node = router_orig;
1043 primary_orig_node = hash_find(bat_priv->orig_hash,
1044 router_orig->primary_addr);
1046 if (!primary_orig_node)
1047 return orig_node->router;
1050 /* with less than 2 candidates, we can't do any
1051 * bonding and prefer the original router. */
1053 if (primary_orig_node->bond.candidates < 2)
1054 return orig_node->router;
1057 /* all nodes between should choose a candidate which
1058 * is is not on the interface where the packet came
1060 first_candidate = primary_orig_node->bond.selected;
1061 router = first_candidate;
1063 if (bonding_enabled) {
1064 /* in the bonding case, send the packets in a round
1065 * robin fashion over the remaining interfaces. */
1067 /* recv_if == NULL on the first node. */
1068 if (router->if_incoming != recv_if)
1071 router = router->next_bond_candidate;
1072 } while (router != first_candidate);
1074 primary_orig_node->bond.selected = router->next_bond_candidate;
1077 /* if bonding is disabled, use the best of the
1078 * remaining candidates which are not using
1079 * this interface. */
1080 best_router = first_candidate;
1083 /* recv_if == NULL on the first node. */
1084 if ((router->if_incoming != recv_if) &&
1085 (router->tq_avg > best_router->tq_avg))
1086 best_router = router;
1088 router = router->next_bond_candidate;
1089 } while (router != first_candidate);
1091 router = best_router;
1097 static int check_unicast_packet(struct sk_buff *skb, int hdr_size)
1099 struct ethhdr *ethhdr;
1101 /* drop packet if it has not necessary minimum size */
1102 if (unlikely(!pskb_may_pull(skb, hdr_size)))
1105 ethhdr = (struct ethhdr *)skb_mac_header(skb);
1107 /* packet with unicast indication but broadcast recipient */
1108 if (is_bcast(ethhdr->h_dest))
1111 /* packet with broadcast sender address */
1112 if (is_bcast(ethhdr->h_source))
1116 if (!is_my_mac(ethhdr->h_dest))
1122 static int route_unicast_packet(struct sk_buff *skb,
1123 struct batman_if *recv_if, int hdr_size)
1125 struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1126 struct orig_node *orig_node;
1127 struct neigh_node *router;
1128 struct batman_if *batman_if;
1129 uint8_t dstaddr[ETH_ALEN];
1130 unsigned long flags;
1131 struct unicast_packet *unicast_packet;
1132 struct ethhdr *ethhdr = (struct ethhdr *)skb_mac_header(skb);
1134 unicast_packet = (struct unicast_packet *)skb->data;
1137 if (is_my_mac(unicast_packet->dest)) {
1138 interface_rx(recv_if->soft_iface, skb, hdr_size);
1139 return NET_RX_SUCCESS;
1143 if (unicast_packet->ttl < 2) {
1144 pr_debug("Warning - can't forward unicast packet from %pM to "
1145 "%pM: ttl exceeded\n", ethhdr->h_source,
1146 unicast_packet->dest);
1150 /* get routing information */
1151 spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
1152 orig_node = ((struct orig_node *)
1153 hash_find(bat_priv->orig_hash, unicast_packet->dest));
1155 router = find_router(orig_node, recv_if);
1158 spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
1162 /* don't lock while sending the packets ... we therefore
1163 * copy the required data before sending */
1165 batman_if = router->if_incoming;
1166 memcpy(dstaddr, router->addr, ETH_ALEN);
1168 spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
1170 /* create a copy of the skb, if needed, to modify it. */
1171 if (skb_cow(skb, sizeof(struct ethhdr)) < 0)
1174 unicast_packet = (struct unicast_packet *)skb->data;
1175 ethhdr = (struct ethhdr *)skb_mac_header(skb);
1178 unicast_packet->ttl--;
1181 send_skb_packet(skb, batman_if, dstaddr);
1183 return NET_RX_SUCCESS;
1186 int recv_unicast_packet(struct sk_buff *skb, struct batman_if *recv_if)
1188 struct unicast_packet *unicast_packet;
1189 int hdr_size = sizeof(struct unicast_packet);
1191 if (check_unicast_packet(skb, hdr_size) < 0)
1194 unicast_packet = (struct unicast_packet *)skb->data;
1197 if (is_my_mac(unicast_packet->dest)) {
1198 interface_rx(recv_if->soft_iface, skb, hdr_size);
1199 return NET_RX_SUCCESS;
1202 return route_unicast_packet(skb, recv_if, hdr_size);
1205 int recv_ucast_frag_packet(struct sk_buff *skb, struct batman_if *recv_if)
1207 struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1208 struct unicast_frag_packet *unicast_packet;
1209 struct orig_node *orig_node;
1210 struct frag_packet_list_entry *tmp_frag_entry;
1211 int hdr_size = sizeof(struct unicast_frag_packet);
1212 unsigned long flags;
1214 if (check_unicast_packet(skb, hdr_size) < 0)
1217 unicast_packet = (struct unicast_frag_packet *)skb->data;
1220 if (is_my_mac(unicast_packet->dest)) {
1222 spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
1223 orig_node = ((struct orig_node *)
1224 hash_find(bat_priv->orig_hash, unicast_packet->orig));
1227 pr_debug("couldn't find orig node for fragmentation\n");
1228 spin_unlock_irqrestore(&bat_priv->orig_hash_lock,
1233 orig_node->last_frag_packet = jiffies;
1235 if (list_empty(&orig_node->frag_list) &&
1236 create_frag_buffer(&orig_node->frag_list)) {
1237 spin_unlock_irqrestore(&bat_priv->orig_hash_lock,
1243 search_frag_packet(&orig_node->frag_list,
1246 if (!tmp_frag_entry) {
1247 create_frag_entry(&orig_node->frag_list, skb);
1248 spin_unlock_irqrestore(&bat_priv->orig_hash_lock,
1250 return NET_RX_SUCCESS;
1253 skb = merge_frag_packet(&orig_node->frag_list,
1254 tmp_frag_entry, skb);
1255 spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
1259 interface_rx(recv_if->soft_iface, skb, hdr_size);
1260 return NET_RX_SUCCESS;
1263 return route_unicast_packet(skb, recv_if, hdr_size);
1267 int recv_bcast_packet(struct sk_buff *skb, struct batman_if *recv_if)
1269 struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1270 struct orig_node *orig_node;
1271 struct bcast_packet *bcast_packet;
1272 struct ethhdr *ethhdr;
1273 int hdr_size = sizeof(struct bcast_packet);
1275 unsigned long flags;
1277 /* drop packet if it has not necessary minimum size */
1278 if (unlikely(!pskb_may_pull(skb, hdr_size)))
1281 ethhdr = (struct ethhdr *)skb_mac_header(skb);
1283 /* packet with broadcast indication but unicast recipient */
1284 if (!is_bcast(ethhdr->h_dest))
1287 /* packet with broadcast sender address */
1288 if (is_bcast(ethhdr->h_source))
1291 /* ignore broadcasts sent by myself */
1292 if (is_my_mac(ethhdr->h_source))
1295 bcast_packet = (struct bcast_packet *)skb->data;
1297 /* ignore broadcasts originated by myself */
1298 if (is_my_mac(bcast_packet->orig))
1301 if (bcast_packet->ttl < 2)
1304 spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
1305 orig_node = ((struct orig_node *)
1306 hash_find(bat_priv->orig_hash, bcast_packet->orig));
1308 if (orig_node == NULL) {
1309 spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
1313 /* check whether the packet is a duplicate */
1314 if (get_bit_status(orig_node->bcast_bits,
1315 orig_node->last_bcast_seqno,
1316 ntohl(bcast_packet->seqno))) {
1317 spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
1321 seq_diff = ntohl(bcast_packet->seqno) - orig_node->last_bcast_seqno;
1323 /* check whether the packet is old and the host just restarted. */
1324 if (window_protected(bat_priv, seq_diff,
1325 &orig_node->bcast_seqno_reset)) {
1326 spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
1330 /* mark broadcast in flood history, update window position
1332 if (bit_get_packet(bat_priv, orig_node->bcast_bits, seq_diff, 1))
1333 orig_node->last_bcast_seqno = ntohl(bcast_packet->seqno);
1335 spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
1336 /* rebroadcast packet */
1337 add_bcast_packet_to_list(bat_priv, skb);
1339 /* broadcast for me */
1340 interface_rx(recv_if->soft_iface, skb, hdr_size);
1342 return NET_RX_SUCCESS;
1345 int recv_vis_packet(struct sk_buff *skb, struct batman_if *recv_if)
1347 struct vis_packet *vis_packet;
1348 struct ethhdr *ethhdr;
1349 struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1350 int hdr_size = sizeof(struct vis_packet);
1352 /* keep skb linear */
1353 if (skb_linearize(skb) < 0)
1356 if (unlikely(!pskb_may_pull(skb, hdr_size)))
1359 vis_packet = (struct vis_packet *)skb->data;
1360 ethhdr = (struct ethhdr *)skb_mac_header(skb);
1363 if (!is_my_mac(ethhdr->h_dest))
1366 /* ignore own packets */
1367 if (is_my_mac(vis_packet->vis_orig))
1370 if (is_my_mac(vis_packet->sender_orig))
1373 switch (vis_packet->vis_type) {
1374 case VIS_TYPE_SERVER_SYNC:
1375 receive_server_sync_packet(bat_priv, vis_packet,
1379 case VIS_TYPE_CLIENT_UPDATE:
1380 receive_client_update_packet(bat_priv, vis_packet,
1384 default: /* ignore unknown packet */
1388 /* We take a copy of the data in the packet, so we should
1389 always free the skbuf. */