]>
Commit | Line | Data |
---|---|---|
fc957275 ML |
1 | /* |
2 | * Copyright (C) 2007-2011 B.A.T.M.A.N. contributors: | |
3 | * | |
4 | * Marek Lindner, Simon Wunderlich | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or | |
7 | * modify it under the terms of version 2 of the GNU General Public | |
8 | * License as published by the Free Software Foundation. | |
9 | * | |
10 | * This program is distributed in the hope that it will be useful, but | |
11 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
13 | * General Public License for more details. | |
14 | * | |
15 | * You should have received a copy of the GNU General Public License | |
16 | * along with this program; if not, write to the Free Software | |
17 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA | |
18 | * 02110-1301, USA | |
19 | * | |
20 | */ | |
21 | ||
22 | #include "main.h" | |
23 | #include "bat_ogm.h" | |
24 | #include "translation-table.h" | |
25 | #include "ring_buffer.h" | |
26 | #include "originator.h" | |
27 | #include "routing.h" | |
28 | #include "gateway_common.h" | |
29 | #include "gateway_client.h" | |
30 | #include "hard-interface.h" | |
31 | #include "send.h" | |
32 | ||
d0b9fd89 ML |
33 | void bat_ogm_init(struct hard_iface *hard_iface) |
34 | { | |
35 | struct batman_ogm_packet *batman_ogm_packet; | |
36 | ||
37 | hard_iface->packet_len = BATMAN_OGM_LEN; | |
38 | hard_iface->packet_buff = kmalloc(hard_iface->packet_len, GFP_ATOMIC); | |
39 | ||
40 | batman_ogm_packet = (struct batman_ogm_packet *)hard_iface->packet_buff; | |
41 | batman_ogm_packet->packet_type = BAT_OGM; | |
42 | batman_ogm_packet->version = COMPAT_VERSION; | |
43 | batman_ogm_packet->flags = NO_FLAGS; | |
44 | batman_ogm_packet->ttl = 2; | |
45 | batman_ogm_packet->tq = TQ_MAX_VALUE; | |
46 | batman_ogm_packet->tt_num_changes = 0; | |
47 | batman_ogm_packet->ttvn = 0; | |
48 | } | |
49 | ||
50 | void bat_ogm_init_primary(struct hard_iface *hard_iface) | |
51 | { | |
52 | struct batman_ogm_packet *batman_ogm_packet; | |
53 | ||
54 | batman_ogm_packet = (struct batman_ogm_packet *)hard_iface->packet_buff; | |
55 | batman_ogm_packet->flags = PRIMARIES_FIRST_HOP; | |
56 | batman_ogm_packet->ttl = TTL; | |
57 | } | |
58 | ||
59 | void bat_ogm_update_mac(struct hard_iface *hard_iface) | |
60 | { | |
61 | struct batman_ogm_packet *batman_ogm_packet; | |
62 | ||
63 | batman_ogm_packet = (struct batman_ogm_packet *)hard_iface->packet_buff; | |
64 | memcpy(batman_ogm_packet->orig, | |
65 | hard_iface->net_dev->dev_addr, ETH_ALEN); | |
66 | memcpy(batman_ogm_packet->prev_sender, | |
67 | hard_iface->net_dev->dev_addr, ETH_ALEN); | |
68 | } | |
69 | ||
b9dacc52 ML |
70 | /* when do we schedule our own ogm to be sent */ |
71 | static unsigned long bat_ogm_emit_send_time(const struct bat_priv *bat_priv) | |
72 | { | |
73 | return jiffies + msecs_to_jiffies( | |
74 | atomic_read(&bat_priv->orig_interval) - | |
75 | JITTER + (random32() % 2*JITTER)); | |
76 | } | |
77 | ||
78 | /* when do we schedule a ogm packet to be sent */ | |
79 | static unsigned long bat_ogm_fwd_send_time(void) | |
80 | { | |
81 | return jiffies + msecs_to_jiffies(random32() % (JITTER/2)); | |
82 | } | |
83 | ||
84 | /* apply hop penalty for a normal link */ | |
85 | static uint8_t hop_penalty(uint8_t tq, const struct bat_priv *bat_priv) | |
86 | { | |
87 | int hop_penalty = atomic_read(&bat_priv->hop_penalty); | |
88 | return (tq * (TQ_MAX_VALUE - hop_penalty)) / (TQ_MAX_VALUE); | |
89 | } | |
90 | ||
fc957275 ML |
91 | /* is there another aggregated packet here? */ |
92 | static int bat_ogm_aggr_packet(int buff_pos, int packet_len, | |
93 | int tt_num_changes) | |
94 | { | |
95 | int next_buff_pos = buff_pos + BATMAN_OGM_LEN + tt_len(tt_num_changes); | |
96 | ||
97 | return (next_buff_pos <= packet_len) && | |
98 | (next_buff_pos <= MAX_AGGREGATION_BYTES); | |
99 | } | |
100 | ||
b9dacc52 ML |
101 | /* send a batman ogm to a given interface */ |
102 | static void bat_ogm_send_to_if(struct forw_packet *forw_packet, | |
103 | struct hard_iface *hard_iface) | |
104 | { | |
105 | struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface); | |
106 | char *fwd_str; | |
107 | uint8_t packet_num; | |
108 | int16_t buff_pos; | |
109 | struct batman_ogm_packet *batman_ogm_packet; | |
110 | struct sk_buff *skb; | |
111 | ||
112 | if (hard_iface->if_status != IF_ACTIVE) | |
113 | return; | |
114 | ||
115 | packet_num = 0; | |
116 | buff_pos = 0; | |
117 | batman_ogm_packet = (struct batman_ogm_packet *)forw_packet->skb->data; | |
118 | ||
119 | /* adjust all flags and log packets */ | |
120 | while (bat_ogm_aggr_packet(buff_pos, forw_packet->packet_len, | |
121 | batman_ogm_packet->tt_num_changes)) { | |
122 | ||
123 | /* we might have aggregated direct link packets with an | |
124 | * ordinary base packet */ | |
125 | if ((forw_packet->direct_link_flags & (1 << packet_num)) && | |
126 | (forw_packet->if_incoming == hard_iface)) | |
127 | batman_ogm_packet->flags |= DIRECTLINK; | |
128 | else | |
129 | batman_ogm_packet->flags &= ~DIRECTLINK; | |
130 | ||
131 | fwd_str = (packet_num > 0 ? "Forwarding" : (forw_packet->own ? | |
132 | "Sending own" : | |
133 | "Forwarding")); | |
134 | bat_dbg(DBG_BATMAN, bat_priv, | |
135 | "%s %spacket (originator %pM, seqno %d, TQ %d, TTL %d," | |
136 | " IDF %s, ttvn %d) on interface %s [%pM]\n", | |
137 | fwd_str, (packet_num > 0 ? "aggregated " : ""), | |
138 | batman_ogm_packet->orig, | |
139 | ntohl(batman_ogm_packet->seqno), | |
140 | batman_ogm_packet->tq, batman_ogm_packet->ttl, | |
141 | (batman_ogm_packet->flags & DIRECTLINK ? | |
142 | "on" : "off"), | |
143 | batman_ogm_packet->ttvn, hard_iface->net_dev->name, | |
144 | hard_iface->net_dev->dev_addr); | |
145 | ||
146 | buff_pos += BATMAN_OGM_LEN + | |
147 | tt_len(batman_ogm_packet->tt_num_changes); | |
148 | packet_num++; | |
149 | batman_ogm_packet = (struct batman_ogm_packet *) | |
150 | (forw_packet->skb->data + buff_pos); | |
151 | } | |
152 | ||
153 | /* create clone because function is called more than once */ | |
154 | skb = skb_clone(forw_packet->skb, GFP_ATOMIC); | |
155 | if (skb) | |
156 | send_skb_packet(skb, hard_iface, broadcast_addr); | |
157 | } | |
158 | ||
159 | /* send a batman ogm packet */ | |
160 | void bat_ogm_emit(struct forw_packet *forw_packet) | |
161 | { | |
162 | struct hard_iface *hard_iface; | |
163 | struct net_device *soft_iface; | |
164 | struct bat_priv *bat_priv; | |
165 | struct hard_iface *primary_if = NULL; | |
166 | struct batman_ogm_packet *batman_ogm_packet; | |
167 | unsigned char directlink; | |
168 | ||
169 | batman_ogm_packet = (struct batman_ogm_packet *) | |
170 | (forw_packet->skb->data); | |
171 | directlink = (batman_ogm_packet->flags & DIRECTLINK ? 1 : 0); | |
172 | ||
173 | if (!forw_packet->if_incoming) { | |
174 | pr_err("Error - can't forward packet: incoming iface not " | |
175 | "specified\n"); | |
176 | goto out; | |
177 | } | |
178 | ||
179 | soft_iface = forw_packet->if_incoming->soft_iface; | |
180 | bat_priv = netdev_priv(soft_iface); | |
181 | ||
182 | if (forw_packet->if_incoming->if_status != IF_ACTIVE) | |
183 | goto out; | |
184 | ||
185 | primary_if = primary_if_get_selected(bat_priv); | |
186 | if (!primary_if) | |
187 | goto out; | |
188 | ||
189 | /* multihomed peer assumed */ | |
190 | /* non-primary OGMs are only broadcasted on their interface */ | |
191 | if ((directlink && (batman_ogm_packet->ttl == 1)) || | |
192 | (forw_packet->own && (forw_packet->if_incoming != primary_if))) { | |
193 | ||
194 | /* FIXME: what about aggregated packets ? */ | |
195 | bat_dbg(DBG_BATMAN, bat_priv, | |
196 | "%s packet (originator %pM, seqno %d, TTL %d) " | |
197 | "on interface %s [%pM]\n", | |
198 | (forw_packet->own ? "Sending own" : "Forwarding"), | |
199 | batman_ogm_packet->orig, | |
200 | ntohl(batman_ogm_packet->seqno), | |
201 | batman_ogm_packet->ttl, | |
202 | forw_packet->if_incoming->net_dev->name, | |
203 | forw_packet->if_incoming->net_dev->dev_addr); | |
204 | ||
205 | /* skb is only used once and than forw_packet is free'd */ | |
206 | send_skb_packet(forw_packet->skb, forw_packet->if_incoming, | |
207 | broadcast_addr); | |
208 | forw_packet->skb = NULL; | |
209 | ||
210 | goto out; | |
211 | } | |
212 | ||
213 | /* broadcast on every interface */ | |
214 | rcu_read_lock(); | |
215 | list_for_each_entry_rcu(hard_iface, &hardif_list, list) { | |
216 | if (hard_iface->soft_iface != soft_iface) | |
217 | continue; | |
218 | ||
219 | bat_ogm_send_to_if(forw_packet, hard_iface); | |
220 | } | |
221 | rcu_read_unlock(); | |
222 | ||
223 | out: | |
224 | if (primary_if) | |
225 | hardif_free_ref(primary_if); | |
226 | } | |
227 | ||
228 | /* return true if new_packet can be aggregated with forw_packet */ | |
229 | static bool bat_ogm_can_aggregate(const struct batman_ogm_packet | |
230 | *new_batman_ogm_packet, | |
231 | struct bat_priv *bat_priv, | |
232 | int packet_len, unsigned long send_time, | |
233 | bool directlink, | |
234 | const struct hard_iface *if_incoming, | |
235 | const struct forw_packet *forw_packet) | |
236 | { | |
237 | struct batman_ogm_packet *batman_ogm_packet; | |
238 | int aggregated_bytes = forw_packet->packet_len + packet_len; | |
239 | struct hard_iface *primary_if = NULL; | |
240 | bool res = false; | |
241 | ||
242 | batman_ogm_packet = (struct batman_ogm_packet *)forw_packet->skb->data; | |
243 | ||
244 | /** | |
245 | * we can aggregate the current packet to this aggregated packet | |
246 | * if: | |
247 | * | |
248 | * - the send time is within our MAX_AGGREGATION_MS time | |
249 | * - the resulting packet wont be bigger than | |
250 | * MAX_AGGREGATION_BYTES | |
251 | */ | |
252 | ||
253 | if (time_before(send_time, forw_packet->send_time) && | |
254 | time_after_eq(send_time + msecs_to_jiffies(MAX_AGGREGATION_MS), | |
255 | forw_packet->send_time) && | |
256 | (aggregated_bytes <= MAX_AGGREGATION_BYTES)) { | |
257 | ||
258 | /** | |
259 | * check aggregation compatibility | |
260 | * -> direct link packets are broadcasted on | |
261 | * their interface only | |
262 | * -> aggregate packet if the current packet is | |
263 | * a "global" packet as well as the base | |
264 | * packet | |
265 | */ | |
266 | ||
267 | primary_if = primary_if_get_selected(bat_priv); | |
268 | if (!primary_if) | |
269 | goto out; | |
270 | ||
271 | /* packets without direct link flag and high TTL | |
272 | * are flooded through the net */ | |
273 | if ((!directlink) && | |
274 | (!(batman_ogm_packet->flags & DIRECTLINK)) && | |
275 | (batman_ogm_packet->ttl != 1) && | |
276 | ||
277 | /* own packets originating non-primary | |
278 | * interfaces leave only that interface */ | |
279 | ((!forw_packet->own) || | |
280 | (forw_packet->if_incoming == primary_if))) { | |
281 | res = true; | |
282 | goto out; | |
283 | } | |
284 | ||
285 | /* if the incoming packet is sent via this one | |
286 | * interface only - we still can aggregate */ | |
287 | if ((directlink) && | |
288 | (new_batman_ogm_packet->ttl == 1) && | |
289 | (forw_packet->if_incoming == if_incoming) && | |
290 | ||
291 | /* packets from direct neighbors or | |
292 | * own secondary interface packets | |
293 | * (= secondary interface packets in general) */ | |
294 | (batman_ogm_packet->flags & DIRECTLINK || | |
295 | (forw_packet->own && | |
296 | forw_packet->if_incoming != primary_if))) { | |
297 | res = true; | |
298 | goto out; | |
299 | } | |
300 | } | |
301 | ||
302 | out: | |
303 | if (primary_if) | |
304 | hardif_free_ref(primary_if); | |
305 | return res; | |
306 | } | |
307 | ||
308 | /* create a new aggregated packet and add this packet to it */ | |
309 | static void bat_ogm_aggregate_new(const unsigned char *packet_buff, | |
310 | int packet_len, unsigned long send_time, | |
311 | bool direct_link, | |
312 | struct hard_iface *if_incoming, | |
313 | int own_packet) | |
314 | { | |
315 | struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface); | |
316 | struct forw_packet *forw_packet_aggr; | |
317 | unsigned char *skb_buff; | |
318 | ||
319 | if (!atomic_inc_not_zero(&if_incoming->refcount)) | |
320 | return; | |
321 | ||
322 | /* own packet should always be scheduled */ | |
323 | if (!own_packet) { | |
324 | if (!atomic_dec_not_zero(&bat_priv->batman_queue_left)) { | |
325 | bat_dbg(DBG_BATMAN, bat_priv, | |
326 | "batman packet queue full\n"); | |
327 | goto out; | |
328 | } | |
329 | } | |
330 | ||
331 | forw_packet_aggr = kmalloc(sizeof(*forw_packet_aggr), GFP_ATOMIC); | |
332 | if (!forw_packet_aggr) { | |
333 | if (!own_packet) | |
334 | atomic_inc(&bat_priv->batman_queue_left); | |
335 | goto out; | |
336 | } | |
337 | ||
338 | if ((atomic_read(&bat_priv->aggregated_ogms)) && | |
339 | (packet_len < MAX_AGGREGATION_BYTES)) | |
340 | forw_packet_aggr->skb = dev_alloc_skb(MAX_AGGREGATION_BYTES + | |
341 | sizeof(struct ethhdr)); | |
342 | else | |
343 | forw_packet_aggr->skb = dev_alloc_skb(packet_len + | |
344 | sizeof(struct ethhdr)); | |
345 | ||
346 | if (!forw_packet_aggr->skb) { | |
347 | if (!own_packet) | |
348 | atomic_inc(&bat_priv->batman_queue_left); | |
349 | kfree(forw_packet_aggr); | |
350 | goto out; | |
351 | } | |
352 | skb_reserve(forw_packet_aggr->skb, sizeof(struct ethhdr)); | |
353 | ||
354 | INIT_HLIST_NODE(&forw_packet_aggr->list); | |
355 | ||
356 | skb_buff = skb_put(forw_packet_aggr->skb, packet_len); | |
357 | forw_packet_aggr->packet_len = packet_len; | |
358 | memcpy(skb_buff, packet_buff, packet_len); | |
359 | ||
360 | forw_packet_aggr->own = own_packet; | |
361 | forw_packet_aggr->if_incoming = if_incoming; | |
362 | forw_packet_aggr->num_packets = 0; | |
363 | forw_packet_aggr->direct_link_flags = NO_FLAGS; | |
364 | forw_packet_aggr->send_time = send_time; | |
365 | ||
366 | /* save packet direct link flag status */ | |
367 | if (direct_link) | |
368 | forw_packet_aggr->direct_link_flags |= 1; | |
369 | ||
370 | /* add new packet to packet list */ | |
371 | spin_lock_bh(&bat_priv->forw_bat_list_lock); | |
372 | hlist_add_head(&forw_packet_aggr->list, &bat_priv->forw_bat_list); | |
373 | spin_unlock_bh(&bat_priv->forw_bat_list_lock); | |
374 | ||
375 | /* start timer for this packet */ | |
376 | INIT_DELAYED_WORK(&forw_packet_aggr->delayed_work, | |
377 | send_outstanding_bat_ogm_packet); | |
378 | queue_delayed_work(bat_event_workqueue, | |
379 | &forw_packet_aggr->delayed_work, | |
380 | send_time - jiffies); | |
381 | ||
382 | return; | |
383 | out: | |
384 | hardif_free_ref(if_incoming); | |
385 | } | |
386 | ||
387 | /* aggregate a new packet into the existing ogm packet */ | |
388 | static void bat_ogm_aggregate(struct forw_packet *forw_packet_aggr, | |
389 | const unsigned char *packet_buff, | |
390 | int packet_len, bool direct_link) | |
391 | { | |
392 | unsigned char *skb_buff; | |
393 | ||
394 | skb_buff = skb_put(forw_packet_aggr->skb, packet_len); | |
395 | memcpy(skb_buff, packet_buff, packet_len); | |
396 | forw_packet_aggr->packet_len += packet_len; | |
397 | forw_packet_aggr->num_packets++; | |
398 | ||
399 | /* save packet direct link flag status */ | |
400 | if (direct_link) | |
401 | forw_packet_aggr->direct_link_flags |= | |
402 | (1 << forw_packet_aggr->num_packets); | |
403 | } | |
404 | ||
405 | static void bat_ogm_queue_add(struct bat_priv *bat_priv, | |
406 | unsigned char *packet_buff, | |
407 | int packet_len, struct hard_iface *if_incoming, | |
408 | int own_packet, unsigned long send_time) | |
409 | { | |
410 | /** | |
411 | * _aggr -> pointer to the packet we want to aggregate with | |
412 | * _pos -> pointer to the position in the queue | |
413 | */ | |
414 | struct forw_packet *forw_packet_aggr = NULL, *forw_packet_pos = NULL; | |
415 | struct hlist_node *tmp_node; | |
416 | struct batman_ogm_packet *batman_ogm_packet; | |
417 | bool direct_link; | |
418 | ||
419 | batman_ogm_packet = (struct batman_ogm_packet *)packet_buff; | |
420 | direct_link = batman_ogm_packet->flags & DIRECTLINK ? 1 : 0; | |
421 | ||
422 | /* find position for the packet in the forward queue */ | |
423 | spin_lock_bh(&bat_priv->forw_bat_list_lock); | |
424 | /* own packets are not to be aggregated */ | |
425 | if ((atomic_read(&bat_priv->aggregated_ogms)) && (!own_packet)) { | |
426 | hlist_for_each_entry(forw_packet_pos, tmp_node, | |
427 | &bat_priv->forw_bat_list, list) { | |
428 | if (bat_ogm_can_aggregate(batman_ogm_packet, | |
429 | bat_priv, packet_len, | |
430 | send_time, direct_link, | |
431 | if_incoming, | |
432 | forw_packet_pos)) { | |
433 | forw_packet_aggr = forw_packet_pos; | |
434 | break; | |
435 | } | |
436 | } | |
437 | } | |
438 | ||
439 | /* nothing to aggregate with - either aggregation disabled or no | |
440 | * suitable aggregation packet found */ | |
441 | if (!forw_packet_aggr) { | |
442 | /* the following section can run without the lock */ | |
443 | spin_unlock_bh(&bat_priv->forw_bat_list_lock); | |
444 | ||
445 | /** | |
446 | * if we could not aggregate this packet with one of the others | |
447 | * we hold it back for a while, so that it might be aggregated | |
448 | * later on | |
449 | */ | |
450 | if ((!own_packet) && | |
451 | (atomic_read(&bat_priv->aggregated_ogms))) | |
452 | send_time += msecs_to_jiffies(MAX_AGGREGATION_MS); | |
453 | ||
454 | bat_ogm_aggregate_new(packet_buff, packet_len, | |
455 | send_time, direct_link, | |
456 | if_incoming, own_packet); | |
457 | } else { | |
458 | bat_ogm_aggregate(forw_packet_aggr, packet_buff, packet_len, | |
459 | direct_link); | |
460 | spin_unlock_bh(&bat_priv->forw_bat_list_lock); | |
461 | } | |
462 | } | |
463 | ||
464 | static void bat_ogm_forward(struct orig_node *orig_node, | |
465 | const struct ethhdr *ethhdr, | |
466 | struct batman_ogm_packet *batman_ogm_packet, | |
467 | int directlink, struct hard_iface *if_incoming) | |
468 | { | |
469 | struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface); | |
470 | struct neigh_node *router; | |
471 | uint8_t in_tq, in_ttl, tq_avg = 0; | |
472 | uint8_t tt_num_changes; | |
473 | ||
474 | if (batman_ogm_packet->ttl <= 1) { | |
475 | bat_dbg(DBG_BATMAN, bat_priv, "ttl exceeded\n"); | |
476 | return; | |
477 | } | |
478 | ||
479 | router = orig_node_get_router(orig_node); | |
480 | ||
481 | in_tq = batman_ogm_packet->tq; | |
482 | in_ttl = batman_ogm_packet->ttl; | |
483 | tt_num_changes = batman_ogm_packet->tt_num_changes; | |
484 | ||
485 | batman_ogm_packet->ttl--; | |
486 | memcpy(batman_ogm_packet->prev_sender, ethhdr->h_source, ETH_ALEN); | |
487 | ||
488 | /* rebroadcast tq of our best ranking neighbor to ensure the rebroadcast | |
489 | * of our best tq value */ | |
490 | if (router && router->tq_avg != 0) { | |
491 | ||
492 | /* rebroadcast ogm of best ranking neighbor as is */ | |
493 | if (!compare_eth(router->addr, ethhdr->h_source)) { | |
494 | batman_ogm_packet->tq = router->tq_avg; | |
495 | ||
496 | if (router->last_ttl) | |
497 | batman_ogm_packet->ttl = router->last_ttl - 1; | |
498 | } | |
499 | ||
500 | tq_avg = router->tq_avg; | |
501 | } | |
502 | ||
503 | if (router) | |
504 | neigh_node_free_ref(router); | |
505 | ||
506 | /* apply hop penalty */ | |
507 | batman_ogm_packet->tq = hop_penalty(batman_ogm_packet->tq, bat_priv); | |
508 | ||
509 | bat_dbg(DBG_BATMAN, bat_priv, | |
510 | "Forwarding packet: tq_orig: %i, tq_avg: %i, " | |
511 | "tq_forw: %i, ttl_orig: %i, ttl_forw: %i\n", | |
512 | in_tq, tq_avg, batman_ogm_packet->tq, in_ttl - 1, | |
513 | batman_ogm_packet->ttl); | |
514 | ||
515 | batman_ogm_packet->seqno = htonl(batman_ogm_packet->seqno); | |
516 | batman_ogm_packet->tt_crc = htons(batman_ogm_packet->tt_crc); | |
517 | ||
518 | /* switch of primaries first hop flag when forwarding */ | |
519 | batman_ogm_packet->flags &= ~PRIMARIES_FIRST_HOP; | |
520 | if (directlink) | |
521 | batman_ogm_packet->flags |= DIRECTLINK; | |
522 | else | |
523 | batman_ogm_packet->flags &= ~DIRECTLINK; | |
524 | ||
525 | bat_ogm_queue_add(bat_priv, (unsigned char *)batman_ogm_packet, | |
526 | BATMAN_OGM_LEN + tt_len(tt_num_changes), | |
527 | if_incoming, 0, bat_ogm_fwd_send_time()); | |
528 | } | |
529 | ||
530 | void bat_ogm_schedule(struct hard_iface *hard_iface, int tt_num_changes) | |
531 | { | |
532 | struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface); | |
533 | struct batman_ogm_packet *batman_ogm_packet; | |
534 | struct hard_iface *primary_if; | |
535 | int vis_server; | |
536 | ||
537 | vis_server = atomic_read(&bat_priv->vis_mode); | |
538 | primary_if = primary_if_get_selected(bat_priv); | |
539 | ||
540 | batman_ogm_packet = (struct batman_ogm_packet *)hard_iface->packet_buff; | |
541 | ||
542 | /* change sequence number to network order */ | |
543 | batman_ogm_packet->seqno = | |
544 | htonl((uint32_t)atomic_read(&hard_iface->seqno)); | |
545 | ||
546 | batman_ogm_packet->ttvn = atomic_read(&bat_priv->ttvn); | |
547 | batman_ogm_packet->tt_crc = htons((uint16_t) | |
548 | atomic_read(&bat_priv->tt_crc)); | |
549 | if (tt_num_changes >= 0) | |
550 | batman_ogm_packet->tt_num_changes = tt_num_changes; | |
551 | ||
552 | if (vis_server == VIS_TYPE_SERVER_SYNC) | |
553 | batman_ogm_packet->flags |= VIS_SERVER; | |
554 | else | |
555 | batman_ogm_packet->flags &= ~VIS_SERVER; | |
556 | ||
557 | if ((hard_iface == primary_if) && | |
558 | (atomic_read(&bat_priv->gw_mode) == GW_MODE_SERVER)) | |
559 | batman_ogm_packet->gw_flags = | |
560 | (uint8_t)atomic_read(&bat_priv->gw_bandwidth); | |
561 | else | |
562 | batman_ogm_packet->gw_flags = NO_FLAGS; | |
563 | ||
564 | atomic_inc(&hard_iface->seqno); | |
565 | ||
566 | slide_own_bcast_window(hard_iface); | |
567 | bat_ogm_queue_add(bat_priv, hard_iface->packet_buff, | |
568 | hard_iface->packet_len, hard_iface, 1, | |
569 | bat_ogm_emit_send_time(bat_priv)); | |
570 | ||
571 | if (primary_if) | |
572 | hardif_free_ref(primary_if); | |
573 | } | |
574 | ||
fc957275 ML |
575 | static void bat_ogm_orig_update(struct bat_priv *bat_priv, |
576 | struct orig_node *orig_node, | |
577 | const struct ethhdr *ethhdr, | |
578 | const struct batman_ogm_packet | |
579 | *batman_ogm_packet, | |
580 | struct hard_iface *if_incoming, | |
581 | const unsigned char *tt_buff, int is_duplicate) | |
582 | { | |
583 | struct neigh_node *neigh_node = NULL, *tmp_neigh_node = NULL; | |
584 | struct neigh_node *router = NULL; | |
585 | struct orig_node *orig_node_tmp; | |
586 | struct hlist_node *node; | |
587 | uint8_t bcast_own_sum_orig, bcast_own_sum_neigh; | |
588 | ||
589 | bat_dbg(DBG_BATMAN, bat_priv, "update_originator(): " | |
590 | "Searching and updating originator entry of received packet\n"); | |
591 | ||
592 | rcu_read_lock(); | |
593 | hlist_for_each_entry_rcu(tmp_neigh_node, node, | |
594 | &orig_node->neigh_list, list) { | |
595 | if (compare_eth(tmp_neigh_node->addr, ethhdr->h_source) && | |
596 | (tmp_neigh_node->if_incoming == if_incoming) && | |
597 | atomic_inc_not_zero(&tmp_neigh_node->refcount)) { | |
598 | if (neigh_node) | |
599 | neigh_node_free_ref(neigh_node); | |
600 | neigh_node = tmp_neigh_node; | |
601 | continue; | |
602 | } | |
603 | ||
604 | if (is_duplicate) | |
605 | continue; | |
606 | ||
607 | spin_lock_bh(&tmp_neigh_node->tq_lock); | |
608 | ring_buffer_set(tmp_neigh_node->tq_recv, | |
609 | &tmp_neigh_node->tq_index, 0); | |
610 | tmp_neigh_node->tq_avg = | |
611 | ring_buffer_avg(tmp_neigh_node->tq_recv); | |
612 | spin_unlock_bh(&tmp_neigh_node->tq_lock); | |
613 | } | |
614 | ||
615 | if (!neigh_node) { | |
616 | struct orig_node *orig_tmp; | |
617 | ||
618 | orig_tmp = get_orig_node(bat_priv, ethhdr->h_source); | |
619 | if (!orig_tmp) | |
620 | goto unlock; | |
621 | ||
622 | neigh_node = create_neighbor(orig_node, orig_tmp, | |
623 | ethhdr->h_source, if_incoming); | |
624 | ||
625 | orig_node_free_ref(orig_tmp); | |
626 | if (!neigh_node) | |
627 | goto unlock; | |
628 | } else | |
629 | bat_dbg(DBG_BATMAN, bat_priv, | |
630 | "Updating existing last-hop neighbor of originator\n"); | |
631 | ||
632 | rcu_read_unlock(); | |
633 | ||
634 | orig_node->flags = batman_ogm_packet->flags; | |
635 | neigh_node->last_valid = jiffies; | |
636 | ||
637 | spin_lock_bh(&neigh_node->tq_lock); | |
638 | ring_buffer_set(neigh_node->tq_recv, | |
639 | &neigh_node->tq_index, | |
640 | batman_ogm_packet->tq); | |
641 | neigh_node->tq_avg = ring_buffer_avg(neigh_node->tq_recv); | |
642 | spin_unlock_bh(&neigh_node->tq_lock); | |
643 | ||
644 | if (!is_duplicate) { | |
645 | orig_node->last_ttl = batman_ogm_packet->ttl; | |
646 | neigh_node->last_ttl = batman_ogm_packet->ttl; | |
647 | } | |
648 | ||
649 | bonding_candidate_add(orig_node, neigh_node); | |
650 | ||
651 | /* if this neighbor already is our next hop there is nothing | |
652 | * to change */ | |
653 | router = orig_node_get_router(orig_node); | |
654 | if (router == neigh_node) | |
655 | goto update_tt; | |
656 | ||
657 | /* if this neighbor does not offer a better TQ we won't consider it */ | |
658 | if (router && (router->tq_avg > neigh_node->tq_avg)) | |
659 | goto update_tt; | |
660 | ||
661 | /* if the TQ is the same and the link not more symmetric we | |
662 | * won't consider it either */ | |
663 | if (router && (neigh_node->tq_avg == router->tq_avg)) { | |
664 | orig_node_tmp = router->orig_node; | |
665 | spin_lock_bh(&orig_node_tmp->ogm_cnt_lock); | |
666 | bcast_own_sum_orig = | |
667 | orig_node_tmp->bcast_own_sum[if_incoming->if_num]; | |
668 | spin_unlock_bh(&orig_node_tmp->ogm_cnt_lock); | |
669 | ||
670 | orig_node_tmp = neigh_node->orig_node; | |
671 | spin_lock_bh(&orig_node_tmp->ogm_cnt_lock); | |
672 | bcast_own_sum_neigh = | |
673 | orig_node_tmp->bcast_own_sum[if_incoming->if_num]; | |
674 | spin_unlock_bh(&orig_node_tmp->ogm_cnt_lock); | |
675 | ||
676 | if (bcast_own_sum_orig >= bcast_own_sum_neigh) | |
677 | goto update_tt; | |
678 | } | |
679 | ||
680 | update_route(bat_priv, orig_node, neigh_node); | |
681 | ||
682 | update_tt: | |
683 | /* I have to check for transtable changes only if the OGM has been | |
684 | * sent through a primary interface */ | |
685 | if (((batman_ogm_packet->orig != ethhdr->h_source) && | |
686 | (batman_ogm_packet->ttl > 2)) || | |
687 | (batman_ogm_packet->flags & PRIMARIES_FIRST_HOP)) | |
688 | tt_update_orig(bat_priv, orig_node, tt_buff, | |
689 | batman_ogm_packet->tt_num_changes, | |
690 | batman_ogm_packet->ttvn, | |
691 | batman_ogm_packet->tt_crc); | |
692 | ||
693 | if (orig_node->gw_flags != batman_ogm_packet->gw_flags) | |
694 | gw_node_update(bat_priv, orig_node, | |
695 | batman_ogm_packet->gw_flags); | |
696 | ||
697 | orig_node->gw_flags = batman_ogm_packet->gw_flags; | |
698 | ||
699 | /* restart gateway selection if fast or late switching was enabled */ | |
700 | if ((orig_node->gw_flags) && | |
701 | (atomic_read(&bat_priv->gw_mode) == GW_MODE_CLIENT) && | |
702 | (atomic_read(&bat_priv->gw_sel_class) > 2)) | |
703 | gw_check_election(bat_priv, orig_node); | |
704 | ||
705 | goto out; | |
706 | ||
707 | unlock: | |
708 | rcu_read_unlock(); | |
709 | out: | |
710 | if (neigh_node) | |
711 | neigh_node_free_ref(neigh_node); | |
712 | if (router) | |
713 | neigh_node_free_ref(router); | |
714 | } | |
715 | ||
716 | static int bat_ogm_calc_tq(struct orig_node *orig_node, | |
717 | struct orig_node *orig_neigh_node, | |
718 | struct batman_ogm_packet *batman_ogm_packet, | |
719 | struct hard_iface *if_incoming) | |
720 | { | |
721 | struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface); | |
722 | struct neigh_node *neigh_node = NULL, *tmp_neigh_node; | |
723 | struct hlist_node *node; | |
724 | uint8_t total_count; | |
725 | uint8_t orig_eq_count, neigh_rq_count, tq_own; | |
726 | int tq_asym_penalty, ret = 0; | |
727 | ||
728 | /* find corresponding one hop neighbor */ | |
729 | rcu_read_lock(); | |
730 | hlist_for_each_entry_rcu(tmp_neigh_node, node, | |
731 | &orig_neigh_node->neigh_list, list) { | |
732 | ||
733 | if (!compare_eth(tmp_neigh_node->addr, orig_neigh_node->orig)) | |
734 | continue; | |
735 | ||
736 | if (tmp_neigh_node->if_incoming != if_incoming) | |
737 | continue; | |
738 | ||
739 | if (!atomic_inc_not_zero(&tmp_neigh_node->refcount)) | |
740 | continue; | |
741 | ||
742 | neigh_node = tmp_neigh_node; | |
743 | break; | |
744 | } | |
745 | rcu_read_unlock(); | |
746 | ||
747 | if (!neigh_node) | |
748 | neigh_node = create_neighbor(orig_neigh_node, | |
749 | orig_neigh_node, | |
750 | orig_neigh_node->orig, | |
751 | if_incoming); | |
752 | ||
753 | if (!neigh_node) | |
754 | goto out; | |
755 | ||
756 | /* if orig_node is direct neighbor update neigh_node last_valid */ | |
757 | if (orig_node == orig_neigh_node) | |
758 | neigh_node->last_valid = jiffies; | |
759 | ||
760 | orig_node->last_valid = jiffies; | |
761 | ||
762 | /* find packet count of corresponding one hop neighbor */ | |
763 | spin_lock_bh(&orig_node->ogm_cnt_lock); | |
764 | orig_eq_count = orig_neigh_node->bcast_own_sum[if_incoming->if_num]; | |
765 | neigh_rq_count = neigh_node->real_packet_count; | |
766 | spin_unlock_bh(&orig_node->ogm_cnt_lock); | |
767 | ||
768 | /* pay attention to not get a value bigger than 100 % */ | |
769 | total_count = (orig_eq_count > neigh_rq_count ? | |
770 | neigh_rq_count : orig_eq_count); | |
771 | ||
772 | /* if we have too few packets (too less data) we set tq_own to zero */ | |
773 | /* if we receive too few packets it is not considered bidirectional */ | |
774 | if ((total_count < TQ_LOCAL_BIDRECT_SEND_MINIMUM) || | |
775 | (neigh_rq_count < TQ_LOCAL_BIDRECT_RECV_MINIMUM)) | |
776 | tq_own = 0; | |
777 | else | |
778 | /* neigh_node->real_packet_count is never zero as we | |
779 | * only purge old information when getting new | |
780 | * information */ | |
781 | tq_own = (TQ_MAX_VALUE * total_count) / neigh_rq_count; | |
782 | ||
783 | /* | |
784 | * 1 - ((1-x) ** 3), normalized to TQ_MAX_VALUE this does | |
785 | * affect the nearly-symmetric links only a little, but | |
786 | * punishes asymmetric links more. This will give a value | |
787 | * between 0 and TQ_MAX_VALUE | |
788 | */ | |
789 | tq_asym_penalty = TQ_MAX_VALUE - (TQ_MAX_VALUE * | |
790 | (TQ_LOCAL_WINDOW_SIZE - neigh_rq_count) * | |
791 | (TQ_LOCAL_WINDOW_SIZE - neigh_rq_count) * | |
792 | (TQ_LOCAL_WINDOW_SIZE - neigh_rq_count)) / | |
793 | (TQ_LOCAL_WINDOW_SIZE * | |
794 | TQ_LOCAL_WINDOW_SIZE * | |
795 | TQ_LOCAL_WINDOW_SIZE); | |
796 | ||
797 | batman_ogm_packet->tq = ((batman_ogm_packet->tq * tq_own | |
798 | * tq_asym_penalty) / | |
799 | (TQ_MAX_VALUE * TQ_MAX_VALUE)); | |
800 | ||
801 | bat_dbg(DBG_BATMAN, bat_priv, | |
802 | "bidirectional: " | |
803 | "orig = %-15pM neigh = %-15pM => own_bcast = %2i, " | |
804 | "real recv = %2i, local tq: %3i, asym_penalty: %3i, " | |
805 | "total tq: %3i\n", | |
806 | orig_node->orig, orig_neigh_node->orig, total_count, | |
807 | neigh_rq_count, tq_own, tq_asym_penalty, batman_ogm_packet->tq); | |
808 | ||
809 | /* if link has the minimum required transmission quality | |
810 | * consider it bidirectional */ | |
811 | if (batman_ogm_packet->tq >= TQ_TOTAL_BIDRECT_LIMIT) | |
812 | ret = 1; | |
813 | ||
814 | out: | |
815 | if (neigh_node) | |
816 | neigh_node_free_ref(neigh_node); | |
817 | return ret; | |
818 | } | |
819 | ||
820 | /* processes a batman packet for all interfaces, adjusts the sequence number and | |
821 | * finds out whether it is a duplicate. | |
822 | * returns: | |
823 | * 1 the packet is a duplicate | |
824 | * 0 the packet has not yet been received | |
825 | * -1 the packet is old and has been received while the seqno window | |
826 | * was protected. Caller should drop it. | |
827 | */ | |
828 | static int bat_ogm_update_seqnos(const struct ethhdr *ethhdr, | |
829 | const struct batman_ogm_packet | |
830 | *batman_ogm_packet, | |
831 | const struct hard_iface *if_incoming) | |
832 | { | |
833 | struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface); | |
834 | struct orig_node *orig_node; | |
835 | struct neigh_node *tmp_neigh_node; | |
836 | struct hlist_node *node; | |
837 | int is_duplicate = 0; | |
838 | int32_t seq_diff; | |
839 | int need_update = 0; | |
840 | int set_mark, ret = -1; | |
841 | ||
842 | orig_node = get_orig_node(bat_priv, batman_ogm_packet->orig); | |
843 | if (!orig_node) | |
844 | return 0; | |
845 | ||
846 | spin_lock_bh(&orig_node->ogm_cnt_lock); | |
847 | seq_diff = batman_ogm_packet->seqno - orig_node->last_real_seqno; | |
848 | ||
849 | /* signalize caller that the packet is to be dropped. */ | |
850 | if (window_protected(bat_priv, seq_diff, | |
851 | &orig_node->batman_seqno_reset)) | |
852 | goto out; | |
853 | ||
854 | rcu_read_lock(); | |
855 | hlist_for_each_entry_rcu(tmp_neigh_node, node, | |
856 | &orig_node->neigh_list, list) { | |
857 | ||
858 | is_duplicate |= get_bit_status(tmp_neigh_node->real_bits, | |
859 | orig_node->last_real_seqno, | |
860 | batman_ogm_packet->seqno); | |
861 | ||
862 | if (compare_eth(tmp_neigh_node->addr, ethhdr->h_source) && | |
863 | (tmp_neigh_node->if_incoming == if_incoming)) | |
864 | set_mark = 1; | |
865 | else | |
866 | set_mark = 0; | |
867 | ||
868 | /* if the window moved, set the update flag. */ | |
869 | need_update |= bit_get_packet(bat_priv, | |
870 | tmp_neigh_node->real_bits, | |
871 | seq_diff, set_mark); | |
872 | ||
873 | tmp_neigh_node->real_packet_count = | |
874 | bit_packet_count(tmp_neigh_node->real_bits); | |
875 | } | |
876 | rcu_read_unlock(); | |
877 | ||
878 | if (need_update) { | |
879 | bat_dbg(DBG_BATMAN, bat_priv, | |
880 | "updating last_seqno: old %d, new %d\n", | |
881 | orig_node->last_real_seqno, batman_ogm_packet->seqno); | |
882 | orig_node->last_real_seqno = batman_ogm_packet->seqno; | |
883 | } | |
884 | ||
885 | ret = is_duplicate; | |
886 | ||
887 | out: | |
888 | spin_unlock_bh(&orig_node->ogm_cnt_lock); | |
889 | orig_node_free_ref(orig_node); | |
890 | return ret; | |
891 | } | |
892 | ||
893 | static void bat_ogm_process(const struct ethhdr *ethhdr, | |
894 | struct batman_ogm_packet *batman_ogm_packet, | |
895 | const unsigned char *tt_buff, | |
896 | struct hard_iface *if_incoming) | |
897 | { | |
898 | struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface); | |
899 | struct hard_iface *hard_iface; | |
900 | struct orig_node *orig_neigh_node, *orig_node; | |
901 | struct neigh_node *router = NULL, *router_router = NULL; | |
902 | struct neigh_node *orig_neigh_router = NULL; | |
903 | int has_directlink_flag; | |
904 | int is_my_addr = 0, is_my_orig = 0, is_my_oldorig = 0; | |
905 | int is_broadcast = 0, is_bidirectional, is_single_hop_neigh; | |
906 | int is_duplicate; | |
907 | uint32_t if_incoming_seqno; | |
908 | ||
909 | /* Silently drop when the batman packet is actually not a | |
910 | * correct packet. | |
911 | * | |
912 | * This might happen if a packet is padded (e.g. Ethernet has a | |
913 | * minimum frame length of 64 byte) and the aggregation interprets | |
914 | * it as an additional length. | |
915 | * | |
916 | * TODO: A more sane solution would be to have a bit in the | |
917 | * batman_ogm_packet to detect whether the packet is the last | |
918 | * packet in an aggregation. Here we expect that the padding | |
919 | * is always zero (or not 0x01) | |
920 | */ | |
921 | if (batman_ogm_packet->packet_type != BAT_OGM) | |
922 | return; | |
923 | ||
924 | /* could be changed by schedule_own_packet() */ | |
925 | if_incoming_seqno = atomic_read(&if_incoming->seqno); | |
926 | ||
927 | has_directlink_flag = (batman_ogm_packet->flags & DIRECTLINK ? 1 : 0); | |
928 | ||
929 | is_single_hop_neigh = (compare_eth(ethhdr->h_source, | |
930 | batman_ogm_packet->orig) ? 1 : 0); | |
931 | ||
932 | bat_dbg(DBG_BATMAN, bat_priv, | |
933 | "Received BATMAN packet via NB: %pM, IF: %s [%pM] " | |
934 | "(from OG: %pM, via prev OG: %pM, seqno %d, ttvn %u, " | |
935 | "crc %u, changes %u, td %d, TTL %d, V %d, IDF %d)\n", | |
936 | ethhdr->h_source, if_incoming->net_dev->name, | |
937 | if_incoming->net_dev->dev_addr, batman_ogm_packet->orig, | |
938 | batman_ogm_packet->prev_sender, batman_ogm_packet->seqno, | |
939 | batman_ogm_packet->ttvn, batman_ogm_packet->tt_crc, | |
940 | batman_ogm_packet->tt_num_changes, batman_ogm_packet->tq, | |
941 | batman_ogm_packet->ttl, batman_ogm_packet->version, | |
942 | has_directlink_flag); | |
943 | ||
944 | rcu_read_lock(); | |
945 | list_for_each_entry_rcu(hard_iface, &hardif_list, list) { | |
946 | if (hard_iface->if_status != IF_ACTIVE) | |
947 | continue; | |
948 | ||
949 | if (hard_iface->soft_iface != if_incoming->soft_iface) | |
950 | continue; | |
951 | ||
952 | if (compare_eth(ethhdr->h_source, | |
953 | hard_iface->net_dev->dev_addr)) | |
954 | is_my_addr = 1; | |
955 | ||
956 | if (compare_eth(batman_ogm_packet->orig, | |
957 | hard_iface->net_dev->dev_addr)) | |
958 | is_my_orig = 1; | |
959 | ||
960 | if (compare_eth(batman_ogm_packet->prev_sender, | |
961 | hard_iface->net_dev->dev_addr)) | |
962 | is_my_oldorig = 1; | |
963 | ||
964 | if (is_broadcast_ether_addr(ethhdr->h_source)) | |
965 | is_broadcast = 1; | |
966 | } | |
967 | rcu_read_unlock(); | |
968 | ||
969 | if (batman_ogm_packet->version != COMPAT_VERSION) { | |
970 | bat_dbg(DBG_BATMAN, bat_priv, | |
971 | "Drop packet: incompatible batman version (%i)\n", | |
972 | batman_ogm_packet->version); | |
973 | return; | |
974 | } | |
975 | ||
976 | if (is_my_addr) { | |
977 | bat_dbg(DBG_BATMAN, bat_priv, | |
978 | "Drop packet: received my own broadcast (sender: %pM" | |
979 | ")\n", | |
980 | ethhdr->h_source); | |
981 | return; | |
982 | } | |
983 | ||
984 | if (is_broadcast) { | |
985 | bat_dbg(DBG_BATMAN, bat_priv, "Drop packet: " | |
986 | "ignoring all packets with broadcast source addr (sender: %pM" | |
987 | ")\n", ethhdr->h_source); | |
988 | return; | |
989 | } | |
990 | ||
991 | if (is_my_orig) { | |
992 | unsigned long *word; | |
993 | int offset; | |
994 | ||
995 | orig_neigh_node = get_orig_node(bat_priv, ethhdr->h_source); | |
996 | if (!orig_neigh_node) | |
997 | return; | |
998 | ||
999 | /* neighbor has to indicate direct link and it has to | |
1000 | * come via the corresponding interface */ | |
1001 | /* save packet seqno for bidirectional check */ | |
1002 | if (has_directlink_flag && | |
1003 | compare_eth(if_incoming->net_dev->dev_addr, | |
1004 | batman_ogm_packet->orig)) { | |
1005 | offset = if_incoming->if_num * NUM_WORDS; | |
1006 | ||
1007 | spin_lock_bh(&orig_neigh_node->ogm_cnt_lock); | |
1008 | word = &(orig_neigh_node->bcast_own[offset]); | |
1009 | bit_mark(word, | |
1010 | if_incoming_seqno - | |
1011 | batman_ogm_packet->seqno - 2); | |
1012 | orig_neigh_node->bcast_own_sum[if_incoming->if_num] = | |
1013 | bit_packet_count(word); | |
1014 | spin_unlock_bh(&orig_neigh_node->ogm_cnt_lock); | |
1015 | } | |
1016 | ||
1017 | bat_dbg(DBG_BATMAN, bat_priv, "Drop packet: " | |
1018 | "originator packet from myself (via neighbor)\n"); | |
1019 | orig_node_free_ref(orig_neigh_node); | |
1020 | return; | |
1021 | } | |
1022 | ||
1023 | if (is_my_oldorig) { | |
1024 | bat_dbg(DBG_BATMAN, bat_priv, | |
1025 | "Drop packet: ignoring all rebroadcast echos (sender: " | |
1026 | "%pM)\n", ethhdr->h_source); | |
1027 | return; | |
1028 | } | |
1029 | ||
1030 | orig_node = get_orig_node(bat_priv, batman_ogm_packet->orig); | |
1031 | if (!orig_node) | |
1032 | return; | |
1033 | ||
1034 | is_duplicate = bat_ogm_update_seqnos(ethhdr, batman_ogm_packet, | |
1035 | if_incoming); | |
1036 | ||
1037 | if (is_duplicate == -1) { | |
1038 | bat_dbg(DBG_BATMAN, bat_priv, | |
1039 | "Drop packet: packet within seqno protection time " | |
1040 | "(sender: %pM)\n", ethhdr->h_source); | |
1041 | goto out; | |
1042 | } | |
1043 | ||
1044 | if (batman_ogm_packet->tq == 0) { | |
1045 | bat_dbg(DBG_BATMAN, bat_priv, | |
1046 | "Drop packet: originator packet with tq equal 0\n"); | |
1047 | goto out; | |
1048 | } | |
1049 | ||
1050 | router = orig_node_get_router(orig_node); | |
1051 | if (router) | |
1052 | router_router = orig_node_get_router(router->orig_node); | |
1053 | ||
1054 | /* avoid temporary routing loops */ | |
1055 | if (router && router_router && | |
1056 | (compare_eth(router->addr, batman_ogm_packet->prev_sender)) && | |
1057 | !(compare_eth(batman_ogm_packet->orig, | |
1058 | batman_ogm_packet->prev_sender)) && | |
1059 | (compare_eth(router->addr, router_router->addr))) { | |
1060 | bat_dbg(DBG_BATMAN, bat_priv, | |
1061 | "Drop packet: ignoring all rebroadcast packets that " | |
1062 | "may make me loop (sender: %pM)\n", ethhdr->h_source); | |
1063 | goto out; | |
1064 | } | |
1065 | ||
1066 | /* if sender is a direct neighbor the sender mac equals | |
1067 | * originator mac */ | |
1068 | orig_neigh_node = (is_single_hop_neigh ? | |
1069 | orig_node : | |
1070 | get_orig_node(bat_priv, ethhdr->h_source)); | |
1071 | if (!orig_neigh_node) | |
1072 | goto out; | |
1073 | ||
1074 | orig_neigh_router = orig_node_get_router(orig_neigh_node); | |
1075 | ||
1076 | /* drop packet if sender is not a direct neighbor and if we | |
1077 | * don't route towards it */ | |
1078 | if (!is_single_hop_neigh && (!orig_neigh_router)) { | |
1079 | bat_dbg(DBG_BATMAN, bat_priv, | |
1080 | "Drop packet: OGM via unknown neighbor!\n"); | |
1081 | goto out_neigh; | |
1082 | } | |
1083 | ||
1084 | is_bidirectional = bat_ogm_calc_tq(orig_node, orig_neigh_node, | |
1085 | batman_ogm_packet, if_incoming); | |
1086 | ||
1087 | bonding_save_primary(orig_node, orig_neigh_node, batman_ogm_packet); | |
1088 | ||
1089 | /* update ranking if it is not a duplicate or has the same | |
1090 | * seqno and similar ttl as the non-duplicate */ | |
1091 | if (is_bidirectional && | |
1092 | (!is_duplicate || | |
1093 | ((orig_node->last_real_seqno == batman_ogm_packet->seqno) && | |
1094 | (orig_node->last_ttl - 3 <= batman_ogm_packet->ttl)))) | |
1095 | bat_ogm_orig_update(bat_priv, orig_node, ethhdr, | |
1096 | batman_ogm_packet, if_incoming, | |
1097 | tt_buff, is_duplicate); | |
1098 | ||
1099 | /* is single hop (direct) neighbor */ | |
1100 | if (is_single_hop_neigh) { | |
1101 | ||
1102 | /* mark direct link on incoming interface */ | |
b9dacc52 ML |
1103 | bat_ogm_forward(orig_node, ethhdr, batman_ogm_packet, |
1104 | 1, if_incoming); | |
fc957275 ML |
1105 | |
1106 | bat_dbg(DBG_BATMAN, bat_priv, "Forwarding packet: " | |
1107 | "rebroadcast neighbor packet with direct link flag\n"); | |
1108 | goto out_neigh; | |
1109 | } | |
1110 | ||
1111 | /* multihop originator */ | |
1112 | if (!is_bidirectional) { | |
1113 | bat_dbg(DBG_BATMAN, bat_priv, | |
1114 | "Drop packet: not received via bidirectional link\n"); | |
1115 | goto out_neigh; | |
1116 | } | |
1117 | ||
1118 | if (is_duplicate) { | |
1119 | bat_dbg(DBG_BATMAN, bat_priv, | |
1120 | "Drop packet: duplicate packet received\n"); | |
1121 | goto out_neigh; | |
1122 | } | |
1123 | ||
1124 | bat_dbg(DBG_BATMAN, bat_priv, | |
1125 | "Forwarding packet: rebroadcast originator packet\n"); | |
b9dacc52 | 1126 | bat_ogm_forward(orig_node, ethhdr, batman_ogm_packet, 0, if_incoming); |
fc957275 ML |
1127 | |
1128 | out_neigh: | |
1129 | if ((orig_neigh_node) && (!is_single_hop_neigh)) | |
1130 | orig_node_free_ref(orig_neigh_node); | |
1131 | out: | |
1132 | if (router) | |
1133 | neigh_node_free_ref(router); | |
1134 | if (router_router) | |
1135 | neigh_node_free_ref(router_router); | |
1136 | if (orig_neigh_router) | |
1137 | neigh_node_free_ref(orig_neigh_router); | |
1138 | ||
1139 | orig_node_free_ref(orig_node); | |
1140 | } | |
1141 | ||
1142 | void bat_ogm_receive(const struct ethhdr *ethhdr, unsigned char *packet_buff, | |
1143 | int packet_len, struct hard_iface *if_incoming) | |
1144 | { | |
1145 | struct batman_ogm_packet *batman_ogm_packet; | |
1146 | int buff_pos = 0; | |
1147 | unsigned char *tt_buff; | |
1148 | ||
1149 | batman_ogm_packet = (struct batman_ogm_packet *)packet_buff; | |
1150 | ||
1151 | /* unpack the aggregated packets and process them one by one */ | |
1152 | do { | |
1153 | /* network to host order for our 32bit seqno and the | |
1154 | orig_interval */ | |
1155 | batman_ogm_packet->seqno = ntohl(batman_ogm_packet->seqno); | |
1156 | batman_ogm_packet->tt_crc = ntohs(batman_ogm_packet->tt_crc); | |
1157 | ||
1158 | tt_buff = packet_buff + buff_pos + BATMAN_OGM_LEN; | |
1159 | ||
1160 | bat_ogm_process(ethhdr, batman_ogm_packet, | |
1161 | tt_buff, if_incoming); | |
1162 | ||
1163 | buff_pos += BATMAN_OGM_LEN + | |
1164 | tt_len(batman_ogm_packet->tt_num_changes); | |
1165 | ||
1166 | batman_ogm_packet = (struct batman_ogm_packet *) | |
1167 | (packet_buff + buff_pos); | |
1168 | } while (bat_ogm_aggr_packet(buff_pos, packet_len, | |
1169 | batman_ogm_packet->tt_num_changes)); | |
1170 | } |