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 [%pM] "
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
->net_dev
->dev_addr
, 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
);
567 list_for_each_entry_rcu(batman_if
, &if_list
, list
) {
568 if (batman_if
->if_status
!= IF_ACTIVE
)
571 if (batman_if
->soft_iface
!= if_incoming
->soft_iface
)
574 if (compare_orig(ethhdr
->h_source
,
575 batman_if
->net_dev
->dev_addr
))
578 if (compare_orig(batman_packet
->orig
,
579 batman_if
->net_dev
->dev_addr
))
582 if (compare_orig(batman_packet
->prev_sender
,
583 batman_if
->net_dev
->dev_addr
))
586 if (compare_orig(ethhdr
->h_source
, broadcast_addr
))
591 if (batman_packet
->version
!= COMPAT_VERSION
) {
592 bat_dbg(DBG_BATMAN
, bat_priv
,
593 "Drop packet: incompatible batman version (%i)\n",
594 batman_packet
->version
);
599 bat_dbg(DBG_BATMAN
, bat_priv
,
600 "Drop packet: received my own broadcast (sender: %pM"
607 bat_dbg(DBG_BATMAN
, bat_priv
, "Drop packet: "
608 "ignoring all packets with broadcast source addr (sender: %pM"
609 ")\n", ethhdr
->h_source
);
617 orig_neigh_node
= get_orig_node(bat_priv
, ethhdr
->h_source
);
619 if (!orig_neigh_node
)
622 /* neighbor has to indicate direct link and it has to
623 * come via the corresponding interface */
624 /* if received seqno equals last send seqno save new
625 * seqno for bidirectional check */
626 if (has_directlink_flag
&&
627 compare_orig(if_incoming
->net_dev
->dev_addr
,
628 batman_packet
->orig
) &&
629 (batman_packet
->seqno
- if_incoming_seqno
+ 2 == 0)) {
630 offset
= if_incoming
->if_num
* NUM_WORDS
;
631 word
= &(orig_neigh_node
->bcast_own
[offset
]);
633 orig_neigh_node
->bcast_own_sum
[if_incoming
->if_num
] =
634 bit_packet_count(word
);
637 bat_dbg(DBG_BATMAN
, bat_priv
, "Drop packet: "
638 "originator packet from myself (via neighbor)\n");
643 bat_dbg(DBG_BATMAN
, bat_priv
,
644 "Drop packet: ignoring all rebroadcast echos (sender: "
645 "%pM)\n", ethhdr
->h_source
);
649 orig_node
= get_orig_node(bat_priv
, batman_packet
->orig
);
650 if (orig_node
== NULL
)
653 is_duplicate
= count_real_packets(ethhdr
, batman_packet
, if_incoming
);
655 if (is_duplicate
== -1) {
656 bat_dbg(DBG_BATMAN
, bat_priv
,
657 "Drop packet: packet within seqno protection time "
658 "(sender: %pM)\n", ethhdr
->h_source
);
662 if (batman_packet
->tq
== 0) {
663 bat_dbg(DBG_BATMAN
, bat_priv
,
664 "Drop packet: originator packet with tq equal 0\n");
668 /* avoid temporary routing loops */
669 if ((orig_node
->router
) &&
670 (orig_node
->router
->orig_node
->router
) &&
671 (compare_orig(orig_node
->router
->addr
,
672 batman_packet
->prev_sender
)) &&
673 !(compare_orig(batman_packet
->orig
, batman_packet
->prev_sender
)) &&
674 (compare_orig(orig_node
->router
->addr
,
675 orig_node
->router
->orig_node
->router
->addr
))) {
676 bat_dbg(DBG_BATMAN
, bat_priv
,
677 "Drop packet: ignoring all rebroadcast packets that "
678 "may make me loop (sender: %pM)\n", ethhdr
->h_source
);
682 /* if sender is a direct neighbor the sender mac equals
684 orig_neigh_node
= (is_single_hop_neigh
?
686 get_orig_node(bat_priv
, ethhdr
->h_source
));
687 if (orig_neigh_node
== NULL
)
690 /* drop packet if sender is not a direct neighbor and if we
691 * don't route towards it */
692 if (!is_single_hop_neigh
&&
693 (orig_neigh_node
->router
== NULL
)) {
694 bat_dbg(DBG_BATMAN
, bat_priv
,
695 "Drop packet: OGM via unknown neighbor!\n");
699 is_bidirectional
= is_bidirectional_neigh(orig_node
, orig_neigh_node
,
700 batman_packet
, if_incoming
);
702 /* update ranking if it is not a duplicate or has the same
703 * seqno and similar ttl as the non-duplicate */
704 if (is_bidirectional
&&
706 ((orig_node
->last_real_seqno
== batman_packet
->seqno
) &&
707 (orig_node
->last_ttl
- 3 <= batman_packet
->ttl
))))
708 update_orig(bat_priv
, orig_node
, ethhdr
, batman_packet
,
709 if_incoming
, hna_buff
, hna_buff_len
, is_duplicate
);
711 mark_bonding_address(bat_priv
, orig_node
,
712 orig_neigh_node
, batman_packet
);
713 update_bonding_candidates(bat_priv
, orig_node
);
715 /* is single hop (direct) neighbor */
716 if (is_single_hop_neigh
) {
718 /* mark direct link on incoming interface */
719 schedule_forward_packet(orig_node
, ethhdr
, batman_packet
,
720 1, hna_buff_len
, if_incoming
);
722 bat_dbg(DBG_BATMAN
, bat_priv
, "Forwarding packet: "
723 "rebroadcast neighbor packet with direct link flag\n");
727 /* multihop originator */
728 if (!is_bidirectional
) {
729 bat_dbg(DBG_BATMAN
, bat_priv
,
730 "Drop packet: not received via bidirectional link\n");
735 bat_dbg(DBG_BATMAN
, bat_priv
,
736 "Drop packet: duplicate packet received\n");
740 bat_dbg(DBG_BATMAN
, bat_priv
,
741 "Forwarding packet: rebroadcast originator packet\n");
742 schedule_forward_packet(orig_node
, ethhdr
, batman_packet
,
743 0, hna_buff_len
, if_incoming
);
746 int recv_bat_packet(struct sk_buff
*skb
, struct batman_if
*batman_if
)
748 struct bat_priv
*bat_priv
= netdev_priv(batman_if
->soft_iface
);
749 struct ethhdr
*ethhdr
;
752 /* drop packet if it has not necessary minimum size */
753 if (unlikely(!pskb_may_pull(skb
, sizeof(struct batman_packet
))))
756 ethhdr
= (struct ethhdr
*)skb_mac_header(skb
);
758 /* packet with broadcast indication but unicast recipient */
759 if (!is_bcast(ethhdr
->h_dest
))
762 /* packet with broadcast sender address */
763 if (is_bcast(ethhdr
->h_source
))
766 /* create a copy of the skb, if needed, to modify it. */
767 if (skb_cow(skb
, 0) < 0)
770 /* keep skb linear */
771 if (skb_linearize(skb
) < 0)
774 ethhdr
= (struct ethhdr
*)skb_mac_header(skb
);
776 spin_lock_irqsave(&bat_priv
->orig_hash_lock
, flags
);
777 receive_aggr_bat_packet(ethhdr
,
781 spin_unlock_irqrestore(&bat_priv
->orig_hash_lock
, flags
);
784 return NET_RX_SUCCESS
;
787 static int recv_my_icmp_packet(struct bat_priv
*bat_priv
,
788 struct sk_buff
*skb
, size_t icmp_len
)
790 struct orig_node
*orig_node
;
791 struct icmp_packet_rr
*icmp_packet
;
792 struct ethhdr
*ethhdr
;
793 struct batman_if
*batman_if
;
796 uint8_t dstaddr
[ETH_ALEN
];
798 icmp_packet
= (struct icmp_packet_rr
*)skb
->data
;
799 ethhdr
= (struct ethhdr
*)skb_mac_header(skb
);
801 /* add data to device queue */
802 if (icmp_packet
->msg_type
!= ECHO_REQUEST
) {
803 bat_socket_receive_packet(icmp_packet
, icmp_len
);
807 if (!bat_priv
->primary_if
)
810 /* answer echo request (ping) */
811 /* get routing information */
812 spin_lock_irqsave(&bat_priv
->orig_hash_lock
, flags
);
813 orig_node
= ((struct orig_node
*)hash_find(bat_priv
->orig_hash
,
817 if ((orig_node
!= NULL
) &&
818 (orig_node
->router
!= NULL
)) {
820 /* don't lock while sending the packets ... we therefore
821 * copy the required data before sending */
822 batman_if
= orig_node
->router
->if_incoming
;
823 memcpy(dstaddr
, orig_node
->router
->addr
, ETH_ALEN
);
824 spin_unlock_irqrestore(&bat_priv
->orig_hash_lock
, flags
);
826 /* create a copy of the skb, if needed, to modify it. */
827 if (skb_cow(skb
, sizeof(struct ethhdr
)) < 0)
830 icmp_packet
= (struct icmp_packet_rr
*)skb
->data
;
831 ethhdr
= (struct ethhdr
*)skb_mac_header(skb
);
833 memcpy(icmp_packet
->dst
, icmp_packet
->orig
, ETH_ALEN
);
834 memcpy(icmp_packet
->orig
,
835 bat_priv
->primary_if
->net_dev
->dev_addr
, ETH_ALEN
);
836 icmp_packet
->msg_type
= ECHO_REPLY
;
837 icmp_packet
->ttl
= TTL
;
839 send_skb_packet(skb
, batman_if
, dstaddr
);
840 ret
= NET_RX_SUCCESS
;
843 spin_unlock_irqrestore(&bat_priv
->orig_hash_lock
, flags
);
848 static int recv_icmp_ttl_exceeded(struct bat_priv
*bat_priv
,
849 struct sk_buff
*skb
, size_t icmp_len
)
851 struct orig_node
*orig_node
;
852 struct icmp_packet
*icmp_packet
;
853 struct ethhdr
*ethhdr
;
854 struct batman_if
*batman_if
;
857 uint8_t dstaddr
[ETH_ALEN
];
859 icmp_packet
= (struct icmp_packet
*)skb
->data
;
860 ethhdr
= (struct ethhdr
*)skb_mac_header(skb
);
862 /* send TTL exceeded if packet is an echo request (traceroute) */
863 if (icmp_packet
->msg_type
!= ECHO_REQUEST
) {
864 pr_debug("Warning - can't forward icmp packet from %pM to "
865 "%pM: ttl exceeded\n", icmp_packet
->orig
,
870 if (!bat_priv
->primary_if
)
873 /* get routing information */
874 spin_lock_irqsave(&bat_priv
->orig_hash_lock
, flags
);
875 orig_node
= ((struct orig_node
*)
876 hash_find(bat_priv
->orig_hash
, icmp_packet
->orig
));
879 if ((orig_node
!= NULL
) &&
880 (orig_node
->router
!= NULL
)) {
882 /* don't lock while sending the packets ... we therefore
883 * copy the required data before sending */
884 batman_if
= orig_node
->router
->if_incoming
;
885 memcpy(dstaddr
, orig_node
->router
->addr
, ETH_ALEN
);
886 spin_unlock_irqrestore(&bat_priv
->orig_hash_lock
, flags
);
888 /* create a copy of the skb, if needed, to modify it. */
889 if (skb_cow(skb
, sizeof(struct ethhdr
)) < 0)
892 icmp_packet
= (struct icmp_packet
*) skb
->data
;
893 ethhdr
= (struct ethhdr
*)skb_mac_header(skb
);
895 memcpy(icmp_packet
->dst
, icmp_packet
->orig
, ETH_ALEN
);
896 memcpy(icmp_packet
->orig
,
897 bat_priv
->primary_if
->net_dev
->dev_addr
, ETH_ALEN
);
898 icmp_packet
->msg_type
= TTL_EXCEEDED
;
899 icmp_packet
->ttl
= TTL
;
901 send_skb_packet(skb
, batman_if
, dstaddr
);
902 ret
= NET_RX_SUCCESS
;
905 spin_unlock_irqrestore(&bat_priv
->orig_hash_lock
, flags
);
911 int recv_icmp_packet(struct sk_buff
*skb
, struct batman_if
*recv_if
)
913 struct bat_priv
*bat_priv
= netdev_priv(recv_if
->soft_iface
);
914 struct icmp_packet_rr
*icmp_packet
;
915 struct ethhdr
*ethhdr
;
916 struct orig_node
*orig_node
;
917 struct batman_if
*batman_if
;
918 int hdr_size
= sizeof(struct icmp_packet
);
921 uint8_t dstaddr
[ETH_ALEN
];
924 * we truncate all incoming icmp packets if they don't match our size
926 if (skb
->len
>= sizeof(struct icmp_packet_rr
))
927 hdr_size
= sizeof(struct icmp_packet_rr
);
929 /* drop packet if it has not necessary minimum size */
930 if (unlikely(!pskb_may_pull(skb
, hdr_size
)))
933 ethhdr
= (struct ethhdr
*)skb_mac_header(skb
);
935 /* packet with unicast indication but broadcast recipient */
936 if (is_bcast(ethhdr
->h_dest
))
939 /* packet with broadcast sender address */
940 if (is_bcast(ethhdr
->h_source
))
944 if (!is_my_mac(ethhdr
->h_dest
))
947 icmp_packet
= (struct icmp_packet_rr
*)skb
->data
;
949 /* add record route information if not full */
950 if ((hdr_size
== sizeof(struct icmp_packet_rr
)) &&
951 (icmp_packet
->rr_cur
< BAT_RR_LEN
)) {
952 memcpy(&(icmp_packet
->rr
[icmp_packet
->rr_cur
]),
953 ethhdr
->h_dest
, ETH_ALEN
);
954 icmp_packet
->rr_cur
++;
958 if (is_my_mac(icmp_packet
->dst
))
959 return recv_my_icmp_packet(bat_priv
, skb
, hdr_size
);
962 if (icmp_packet
->ttl
< 2)
963 return recv_icmp_ttl_exceeded(bat_priv
, skb
, hdr_size
);
967 /* get routing information */
968 spin_lock_irqsave(&bat_priv
->orig_hash_lock
, flags
);
969 orig_node
= ((struct orig_node
*)
970 hash_find(bat_priv
->orig_hash
, icmp_packet
->dst
));
972 if ((orig_node
!= NULL
) &&
973 (orig_node
->router
!= NULL
)) {
975 /* don't lock while sending the packets ... we therefore
976 * copy the required data before sending */
977 batman_if
= orig_node
->router
->if_incoming
;
978 memcpy(dstaddr
, orig_node
->router
->addr
, ETH_ALEN
);
979 spin_unlock_irqrestore(&bat_priv
->orig_hash_lock
, flags
);
981 /* create a copy of the skb, if needed, to modify it. */
982 if (skb_cow(skb
, sizeof(struct ethhdr
)) < 0)
985 icmp_packet
= (struct icmp_packet_rr
*)skb
->data
;
986 ethhdr
= (struct ethhdr
*)skb_mac_header(skb
);
992 send_skb_packet(skb
, batman_if
, dstaddr
);
993 ret
= NET_RX_SUCCESS
;
996 spin_unlock_irqrestore(&bat_priv
->orig_hash_lock
, flags
);
1001 /* find a suitable router for this originator, and use
1002 * bonding if possible. */
1003 struct neigh_node
*find_router(struct orig_node
*orig_node
,
1004 struct batman_if
*recv_if
)
1006 struct bat_priv
*bat_priv
;
1007 struct orig_node
*primary_orig_node
;
1008 struct orig_node
*router_orig
;
1009 struct neigh_node
*router
, *first_candidate
, *best_router
;
1010 static uint8_t zero_mac
[ETH_ALEN
] = {0, 0, 0, 0, 0, 0};
1011 int bonding_enabled
;
1016 if (!orig_node
->router
)
1019 /* without bonding, the first node should
1020 * always choose the default router. */
1023 return orig_node
->router
;
1025 bat_priv
= netdev_priv(recv_if
->soft_iface
);
1026 bonding_enabled
= atomic_read(&bat_priv
->bonding_enabled
);
1028 if (!bonding_enabled
)
1029 return orig_node
->router
;
1031 router_orig
= orig_node
->router
->orig_node
;
1033 /* if we have something in the primary_addr, we can search
1034 * for a potential bonding candidate. */
1035 if (memcmp(router_orig
->primary_addr
, zero_mac
, ETH_ALEN
) == 0)
1036 return orig_node
->router
;
1038 /* find the orig_node which has the primary interface. might
1039 * even be the same as our router_orig in many cases */
1041 if (memcmp(router_orig
->primary_addr
,
1042 router_orig
->orig
, ETH_ALEN
) == 0) {
1043 primary_orig_node
= router_orig
;
1045 primary_orig_node
= hash_find(bat_priv
->orig_hash
,
1046 router_orig
->primary_addr
);
1048 if (!primary_orig_node
)
1049 return orig_node
->router
;
1052 /* with less than 2 candidates, we can't do any
1053 * bonding and prefer the original router. */
1055 if (primary_orig_node
->bond
.candidates
< 2)
1056 return orig_node
->router
;
1059 /* all nodes between should choose a candidate which
1060 * is is not on the interface where the packet came
1062 first_candidate
= primary_orig_node
->bond
.selected
;
1063 router
= first_candidate
;
1065 if (bonding_enabled
) {
1066 /* in the bonding case, send the packets in a round
1067 * robin fashion over the remaining interfaces. */
1069 /* recv_if == NULL on the first node. */
1070 if (router
->if_incoming
!= recv_if
)
1073 router
= router
->next_bond_candidate
;
1074 } while (router
!= first_candidate
);
1076 primary_orig_node
->bond
.selected
= router
->next_bond_candidate
;
1079 /* if bonding is disabled, use the best of the
1080 * remaining candidates which are not using
1081 * this interface. */
1082 best_router
= first_candidate
;
1085 /* recv_if == NULL on the first node. */
1086 if ((router
->if_incoming
!= recv_if
) &&
1087 (router
->tq_avg
> best_router
->tq_avg
))
1088 best_router
= router
;
1090 router
= router
->next_bond_candidate
;
1091 } while (router
!= first_candidate
);
1093 router
= best_router
;
1099 static int check_unicast_packet(struct sk_buff
*skb
, int hdr_size
)
1101 struct ethhdr
*ethhdr
;
1103 /* drop packet if it has not necessary minimum size */
1104 if (unlikely(!pskb_may_pull(skb
, hdr_size
)))
1107 ethhdr
= (struct ethhdr
*)skb_mac_header(skb
);
1109 /* packet with unicast indication but broadcast recipient */
1110 if (is_bcast(ethhdr
->h_dest
))
1113 /* packet with broadcast sender address */
1114 if (is_bcast(ethhdr
->h_source
))
1118 if (!is_my_mac(ethhdr
->h_dest
))
1124 static int route_unicast_packet(struct sk_buff
*skb
,
1125 struct batman_if
*recv_if
, int hdr_size
)
1127 struct bat_priv
*bat_priv
= netdev_priv(recv_if
->soft_iface
);
1128 struct orig_node
*orig_node
;
1129 struct neigh_node
*router
;
1130 struct batman_if
*batman_if
;
1131 uint8_t dstaddr
[ETH_ALEN
];
1132 unsigned long flags
;
1133 struct unicast_packet
*unicast_packet
;
1134 struct ethhdr
*ethhdr
= (struct ethhdr
*)skb_mac_header(skb
);
1136 unicast_packet
= (struct unicast_packet
*)skb
->data
;
1139 if (is_my_mac(unicast_packet
->dest
)) {
1140 interface_rx(recv_if
->soft_iface
, skb
, hdr_size
);
1141 return NET_RX_SUCCESS
;
1145 if (unicast_packet
->ttl
< 2) {
1146 pr_debug("Warning - can't forward unicast packet from %pM to "
1147 "%pM: ttl exceeded\n", ethhdr
->h_source
,
1148 unicast_packet
->dest
);
1152 /* get routing information */
1153 spin_lock_irqsave(&bat_priv
->orig_hash_lock
, flags
);
1154 orig_node
= ((struct orig_node
*)
1155 hash_find(bat_priv
->orig_hash
, unicast_packet
->dest
));
1157 router
= find_router(orig_node
, recv_if
);
1160 spin_unlock_irqrestore(&bat_priv
->orig_hash_lock
, flags
);
1164 /* don't lock while sending the packets ... we therefore
1165 * copy the required data before sending */
1167 batman_if
= router
->if_incoming
;
1168 memcpy(dstaddr
, router
->addr
, ETH_ALEN
);
1170 spin_unlock_irqrestore(&bat_priv
->orig_hash_lock
, flags
);
1172 /* create a copy of the skb, if needed, to modify it. */
1173 if (skb_cow(skb
, sizeof(struct ethhdr
)) < 0)
1176 unicast_packet
= (struct unicast_packet
*)skb
->data
;
1177 ethhdr
= (struct ethhdr
*)skb_mac_header(skb
);
1180 unicast_packet
->ttl
--;
1183 send_skb_packet(skb
, batman_if
, dstaddr
);
1185 return NET_RX_SUCCESS
;
1188 int recv_unicast_packet(struct sk_buff
*skb
, struct batman_if
*recv_if
)
1190 struct unicast_packet
*unicast_packet
;
1191 int hdr_size
= sizeof(struct unicast_packet
);
1193 if (check_unicast_packet(skb
, hdr_size
) < 0)
1196 unicast_packet
= (struct unicast_packet
*)skb
->data
;
1199 if (is_my_mac(unicast_packet
->dest
)) {
1200 interface_rx(recv_if
->soft_iface
, skb
, hdr_size
);
1201 return NET_RX_SUCCESS
;
1204 return route_unicast_packet(skb
, recv_if
, hdr_size
);
1207 int recv_ucast_frag_packet(struct sk_buff
*skb
, struct batman_if
*recv_if
)
1209 struct bat_priv
*bat_priv
= netdev_priv(recv_if
->soft_iface
);
1210 struct unicast_frag_packet
*unicast_packet
;
1211 struct orig_node
*orig_node
;
1212 struct frag_packet_list_entry
*tmp_frag_entry
;
1213 int hdr_size
= sizeof(struct unicast_frag_packet
);
1214 unsigned long flags
;
1216 if (check_unicast_packet(skb
, hdr_size
) < 0)
1219 unicast_packet
= (struct unicast_frag_packet
*)skb
->data
;
1222 if (is_my_mac(unicast_packet
->dest
)) {
1224 spin_lock_irqsave(&bat_priv
->orig_hash_lock
, flags
);
1225 orig_node
= ((struct orig_node
*)
1226 hash_find(bat_priv
->orig_hash
, unicast_packet
->orig
));
1229 pr_debug("couldn't find orig node for fragmentation\n");
1230 spin_unlock_irqrestore(&bat_priv
->orig_hash_lock
,
1235 orig_node
->last_frag_packet
= jiffies
;
1237 if (list_empty(&orig_node
->frag_list
) &&
1238 create_frag_buffer(&orig_node
->frag_list
)) {
1239 spin_unlock_irqrestore(&bat_priv
->orig_hash_lock
,
1245 search_frag_packet(&orig_node
->frag_list
,
1248 if (!tmp_frag_entry
) {
1249 create_frag_entry(&orig_node
->frag_list
, skb
);
1250 spin_unlock_irqrestore(&bat_priv
->orig_hash_lock
,
1252 return NET_RX_SUCCESS
;
1255 skb
= merge_frag_packet(&orig_node
->frag_list
,
1256 tmp_frag_entry
, skb
);
1257 spin_unlock_irqrestore(&bat_priv
->orig_hash_lock
, flags
);
1261 interface_rx(recv_if
->soft_iface
, skb
, hdr_size
);
1262 return NET_RX_SUCCESS
;
1265 return route_unicast_packet(skb
, recv_if
, hdr_size
);
1269 int recv_bcast_packet(struct sk_buff
*skb
, struct batman_if
*recv_if
)
1271 struct bat_priv
*bat_priv
= netdev_priv(recv_if
->soft_iface
);
1272 struct orig_node
*orig_node
;
1273 struct bcast_packet
*bcast_packet
;
1274 struct ethhdr
*ethhdr
;
1275 int hdr_size
= sizeof(struct bcast_packet
);
1277 unsigned long flags
;
1279 /* drop packet if it has not necessary minimum size */
1280 if (unlikely(!pskb_may_pull(skb
, hdr_size
)))
1283 ethhdr
= (struct ethhdr
*)skb_mac_header(skb
);
1285 /* packet with broadcast indication but unicast recipient */
1286 if (!is_bcast(ethhdr
->h_dest
))
1289 /* packet with broadcast sender address */
1290 if (is_bcast(ethhdr
->h_source
))
1293 /* ignore broadcasts sent by myself */
1294 if (is_my_mac(ethhdr
->h_source
))
1297 bcast_packet
= (struct bcast_packet
*)skb
->data
;
1299 /* ignore broadcasts originated by myself */
1300 if (is_my_mac(bcast_packet
->orig
))
1303 if (bcast_packet
->ttl
< 2)
1306 spin_lock_irqsave(&bat_priv
->orig_hash_lock
, flags
);
1307 orig_node
= ((struct orig_node
*)
1308 hash_find(bat_priv
->orig_hash
, bcast_packet
->orig
));
1310 if (orig_node
== NULL
) {
1311 spin_unlock_irqrestore(&bat_priv
->orig_hash_lock
, flags
);
1315 /* check whether the packet is a duplicate */
1316 if (get_bit_status(orig_node
->bcast_bits
,
1317 orig_node
->last_bcast_seqno
,
1318 ntohl(bcast_packet
->seqno
))) {
1319 spin_unlock_irqrestore(&bat_priv
->orig_hash_lock
, flags
);
1323 seq_diff
= ntohl(bcast_packet
->seqno
) - orig_node
->last_bcast_seqno
;
1325 /* check whether the packet is old and the host just restarted. */
1326 if (window_protected(bat_priv
, seq_diff
,
1327 &orig_node
->bcast_seqno_reset
)) {
1328 spin_unlock_irqrestore(&bat_priv
->orig_hash_lock
, flags
);
1332 /* mark broadcast in flood history, update window position
1334 if (bit_get_packet(bat_priv
, orig_node
->bcast_bits
, seq_diff
, 1))
1335 orig_node
->last_bcast_seqno
= ntohl(bcast_packet
->seqno
);
1337 spin_unlock_irqrestore(&bat_priv
->orig_hash_lock
, flags
);
1338 /* rebroadcast packet */
1339 add_bcast_packet_to_list(bat_priv
, skb
);
1341 /* broadcast for me */
1342 interface_rx(recv_if
->soft_iface
, skb
, hdr_size
);
1344 return NET_RX_SUCCESS
;
1347 int recv_vis_packet(struct sk_buff
*skb
, struct batman_if
*recv_if
)
1349 struct vis_packet
*vis_packet
;
1350 struct ethhdr
*ethhdr
;
1351 struct bat_priv
*bat_priv
= netdev_priv(recv_if
->soft_iface
);
1352 int hdr_size
= sizeof(struct vis_packet
);
1354 /* keep skb linear */
1355 if (skb_linearize(skb
) < 0)
1358 if (unlikely(!pskb_may_pull(skb
, hdr_size
)))
1361 vis_packet
= (struct vis_packet
*)skb
->data
;
1362 ethhdr
= (struct ethhdr
*)skb_mac_header(skb
);
1365 if (!is_my_mac(ethhdr
->h_dest
))
1368 /* ignore own packets */
1369 if (is_my_mac(vis_packet
->vis_orig
))
1372 if (is_my_mac(vis_packet
->sender_orig
))
1375 switch (vis_packet
->vis_type
) {
1376 case VIS_TYPE_SERVER_SYNC
:
1377 receive_server_sync_packet(bat_priv
, vis_packet
,
1381 case VIS_TYPE_CLIENT_UPDATE
:
1382 receive_client_update_packet(bat_priv
, vis_packet
,
1386 default: /* ignore unknown packet */
1390 /* We take a copy of the data in the packet, so we should
1391 always free the skbuf. */