← Back to branch summary

~ubuntu-branches/ubuntu/trusty/linux-armadaxp/trusty

« back to all changes in this revision

Viewing changes to net/batman-adv/routing.c

  • Committer: Package Import Robot
  • Author(s): Michael Casadevall, Bryan Wu, Dann Frazier, Michael Casadeall
  • Date: 2012-03-10 15:00:54 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120310150054-flugb39zon8vvgwe
Tags: 3.2.0-1600.1
[ Bryan Wu ]
* UBUNTU: import debian/debian.env and debian.armadaxp

[ Dann Frazier ]
* ARM: Armada XP: remove trailing '/' in dirnames in mvRules.mk

[ Michael Casadeall ]
* tools: add some tools for Marvell Armada XP processor
* kernel: timer tick hacking from Marvell
* kernel: Sheeva Errata: add delay on Sheeva when powering down
* net: add Marvell NFP netfilter
* net: socket and skb modifications made by Marvell
* miscdevice: add minor IDs for some Marvell Armada drivers
* fs: introduce memory pool for splice()
* video: EDID detection updates from Marvell Armada XP patchset
* video: backlight: add Marvell Dove LCD backlight driver
* video: display: add THS8200 display driver
* video: framebuffer: add Marvell Dove and Armada XP processor onchip LCD controller driver
* usbtest: add Interrupt transfer testing by Marvell Armada XP code
* usb: ehci: add support for Marvell EHCI controler
* tty/serial: 8250: add support for Marvell Armada XP processor and DeviceTree work
* rtc: add support for Marvell Armada XP onchip RTC controller
* net: pppoe: add Marvell ethernet NFP hook in PPPoE networking driver
* mtd: nand: add support for Marvell Armada XP Nand Flash Controller
* mtd: maps: add Marvell Armada XP specific map driver
* mmc: add support for Marvell Armada XP MMC/SD host controller
* i2c: add support for Marvell Armada XP onchip i2c bus controller
* hwmon: add Kconfig option for Armada XP onchip thermal sensor driver
* dmaengine: add Net DMA support for splice and update Marvell XOR DMA engine driver
* ata: add support for Marvell Armada XP SATA controller and update some quirks
* ARM: add Marvell Armada XP machine to mach-types
* ARM: oprofile: add support for Marvell PJ4B core
* ARM: mm: more ARMv6 switches for Marvell Armada XP
* ARM: remove static declaration to allow compilation
* ARM: alignment access fault trick
* ARM: mm: skip some fault fixing when run on NONE SMP ARMv6 mode during early abort event
* ARM: mm: add Marvell Sheeva CPU Architecture for PJ4B
* ARM: introduce optimized copy operation for Marvell Armada XP
* ARM: SAUCE: hardware breakpoint trick for Marvell Armada XP
* ARM: big endian and little endian tricks for Marvell Armada XP
* ARM: SAUCE: Add Marvell Armada XP build rules to arch/arm/kernel/Makefile
* ARM: vfp: add special handling for Marvell Armada XP
* ARM: add support for Marvell U-Boot
* ARM: add mv_controller_num for ARM PCI drivers
* ARM: add support for local PMUs, general SMP tweaks and cache flushing
* ARM: add Marvell device identifies in glue-proc.h
* ARM: add IPC driver support for Marvell platforms
* ARM: add DMA mapping for Marvell platforms
* ARM: add Sheeva errata and PJ4B code for booting
* ARM: update Kconfig and Makefile to include Marvell Armada XP platforms
* ARM: Armada XP: import LSP from Marvell for Armada XP 3.2 kernel enablement

Show diffs side-by-side

added added

removed removed

Lines of Context:
net/batman-adv/routing.c
22
22
#include "main.h"
23
23
#include "routing.h"
24
24
#include "send.h"
25
 
#include "hash.h"
26
25
#include "soft-interface.h"
27
26
#include "hard-interface.h"
28
27
#include "icmp_socket.h"
29
28
#include "translation-table.h"
30
29
#include "originator.h"
31
 
#include "ring_buffer.h"
32
30
#include "vis.h"
33
 
#include "aggregation.h"
34
 
#include "gateway_common.h"
35
 
#include "gateway_client.h"
36
31
#include "unicast.h"
 
32
#include "bat_ogm.h"
37
33
 
38
34
void slide_own_bcast_window(struct hard_iface *hard_iface)
39
35
{
64
60
        }
65
61
}
66
62
 
67
 
static void update_TT(struct bat_priv *bat_priv, struct orig_node *orig_node,
68
 
                       unsigned char *tt_buff, int tt_buff_len)
69
 
{
70
 
        if ((tt_buff_len != orig_node->tt_buff_len) ||
71
 
            ((tt_buff_len > 0) &&
72
 
             (orig_node->tt_buff_len > 0) &&
73
 
             (memcmp(orig_node->tt_buff, tt_buff, tt_buff_len) != 0))) {
74
 
 
75
 
                if (orig_node->tt_buff_len > 0)
76
 
                        tt_global_del_orig(bat_priv, orig_node,
77
 
                                            "originator changed tt");
78
 
 
79
 
                if ((tt_buff_len > 0) && (tt_buff))
80
 
                        tt_global_add_orig(bat_priv, orig_node,
81
 
                                            tt_buff, tt_buff_len);
82
 
        }
83
 
}
84
 
 
85
 
static void update_route(struct bat_priv *bat_priv,
86
 
                         struct orig_node *orig_node,
87
 
                         struct neigh_node *neigh_node,
88
 
                         unsigned char *tt_buff, int tt_buff_len)
 
63
static void _update_route(struct bat_priv *bat_priv,
 
64
                          struct orig_node *orig_node,
 
65
                          struct neigh_node *neigh_node)
89
66
{
90
67
        struct neigh_node *curr_router;
91
68
 
93
70
 
94
71
        /* route deleted */
95
72
        if ((curr_router) && (!neigh_node)) {
96
 
 
97
73
                bat_dbg(DBG_ROUTES, bat_priv, "Deleting route towards: %pM\n",
98
74
                        orig_node->orig);
99
75
                tt_global_del_orig(bat_priv, orig_node,
100
 
                                    "originator timed out");
 
76
                                    "Deleted route towards originator");
101
77
 
102
78
        /* route added */
103
79
        } else if ((!curr_router) && (neigh_node)) {
105
81
                bat_dbg(DBG_ROUTES, bat_priv,
106
82
                        "Adding route towards: %pM (via %pM)\n",
107
83
                        orig_node->orig, neigh_node->addr);
108
 
                tt_global_add_orig(bat_priv, orig_node,
109
 
                                    tt_buff, tt_buff_len);
110
 
 
111
84
        /* route changed */
112
 
        } else {
 
85
        } else if (neigh_node && curr_router) {
113
86
                bat_dbg(DBG_ROUTES, bat_priv,
114
87
                        "Changing route towards: %pM "
115
88
                        "(now via %pM - was via %pM)\n",
133
106
                neigh_node_free_ref(curr_router);
134
107
}
135
108
 
136
 
 
137
 
void update_routes(struct bat_priv *bat_priv, struct orig_node *orig_node,
138
 
                   struct neigh_node *neigh_node, unsigned char *tt_buff,
139
 
                   int tt_buff_len)
 
109
void update_route(struct bat_priv *bat_priv, struct orig_node *orig_node,
 
110
                  struct neigh_node *neigh_node)
140
111
{
141
112
        struct neigh_node *router = NULL;
142
113
 
146
117
        router = orig_node_get_router(orig_node);
147
118
 
148
119
        if (router != neigh_node)
149
 
                update_route(bat_priv, orig_node, neigh_node,
150
 
                             tt_buff, tt_buff_len);
151
 
        /* may be just TT changed */
152
 
        else
153
 
                update_TT(bat_priv, orig_node, tt_buff, tt_buff_len);
 
120
                _update_route(bat_priv, orig_node, neigh_node);
154
121
 
155
122
out:
156
123
        if (router)
157
124
                neigh_node_free_ref(router);
158
125
}
159
126
 
160
 
static int is_bidirectional_neigh(struct orig_node *orig_node,
161
 
                                struct orig_node *orig_neigh_node,
162
 
                                struct batman_packet *batman_packet,
163
 
                                struct hard_iface *if_incoming)
164
 
{
165
 
        struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
166
 
        struct neigh_node *neigh_node = NULL, *tmp_neigh_node;
167
 
        struct hlist_node *node;
168
 
        unsigned char total_count;
169
 
        uint8_t orig_eq_count, neigh_rq_count, tq_own;
170
 
        int tq_asym_penalty, ret = 0;
171
 
 
172
 
        /* find corresponding one hop neighbor */
173
 
        rcu_read_lock();
174
 
        hlist_for_each_entry_rcu(tmp_neigh_node, node,
175
 
                                 &orig_neigh_node->neigh_list, list) {
176
 
 
177
 
                if (!compare_eth(tmp_neigh_node->addr, orig_neigh_node->orig))
178
 
                        continue;
179
 
 
180
 
                if (tmp_neigh_node->if_incoming != if_incoming)
181
 
                        continue;
182
 
 
183
 
                if (!atomic_inc_not_zero(&tmp_neigh_node->refcount))
184
 
                        continue;
185
 
 
186
 
                neigh_node = tmp_neigh_node;
187
 
                break;
188
 
        }
189
 
        rcu_read_unlock();
190
 
 
191
 
        if (!neigh_node)
192
 
                neigh_node = create_neighbor(orig_neigh_node,
193
 
                                             orig_neigh_node,
194
 
                                             orig_neigh_node->orig,
195
 
                                             if_incoming);
196
 
 
197
 
        if (!neigh_node)
198
 
                goto out;
199
 
 
200
 
        /* if orig_node is direct neighbour update neigh_node last_valid */
201
 
        if (orig_node == orig_neigh_node)
202
 
                neigh_node->last_valid = jiffies;
203
 
 
204
 
        orig_node->last_valid = jiffies;
205
 
 
206
 
        /* find packet count of corresponding one hop neighbor */
207
 
        spin_lock_bh(&orig_node->ogm_cnt_lock);
208
 
        orig_eq_count = orig_neigh_node->bcast_own_sum[if_incoming->if_num];
209
 
        neigh_rq_count = neigh_node->real_packet_count;
210
 
        spin_unlock_bh(&orig_node->ogm_cnt_lock);
211
 
 
212
 
        /* pay attention to not get a value bigger than 100 % */
213
 
        total_count = (orig_eq_count > neigh_rq_count ?
214
 
                       neigh_rq_count : orig_eq_count);
215
 
 
216
 
        /* if we have too few packets (too less data) we set tq_own to zero */
217
 
        /* if we receive too few packets it is not considered bidirectional */
218
 
        if ((total_count < TQ_LOCAL_BIDRECT_SEND_MINIMUM) ||
219
 
            (neigh_rq_count < TQ_LOCAL_BIDRECT_RECV_MINIMUM))
220
 
                tq_own = 0;
221
 
        else
222
 
                /* neigh_node->real_packet_count is never zero as we
223
 
                 * only purge old information when getting new
224
 
                 * information */
225
 
                tq_own = (TQ_MAX_VALUE * total_count) / neigh_rq_count;
226
 
 
227
 
        /*
228
 
         * 1 - ((1-x) ** 3), normalized to TQ_MAX_VALUE this does
229
 
         * affect the nearly-symmetric links only a little, but
230
 
         * punishes asymmetric links more.  This will give a value
231
 
         * between 0 and TQ_MAX_VALUE
232
 
         */
233
 
        tq_asym_penalty = TQ_MAX_VALUE - (TQ_MAX_VALUE *
234
 
                                (TQ_LOCAL_WINDOW_SIZE - neigh_rq_count) *
235
 
                                (TQ_LOCAL_WINDOW_SIZE - neigh_rq_count) *
236
 
                                (TQ_LOCAL_WINDOW_SIZE - neigh_rq_count)) /
237
 
                                        (TQ_LOCAL_WINDOW_SIZE *
238
 
                                         TQ_LOCAL_WINDOW_SIZE *
239
 
                                         TQ_LOCAL_WINDOW_SIZE);
240
 
 
241
 
        batman_packet->tq = ((batman_packet->tq * tq_own * tq_asym_penalty) /
242
 
                                                (TQ_MAX_VALUE * TQ_MAX_VALUE));
243
 
 
244
 
        bat_dbg(DBG_BATMAN, bat_priv,
245
 
                "bidirectional: "
246
 
                "orig = %-15pM neigh = %-15pM => own_bcast = %2i, "
247
 
                "real recv = %2i, local tq: %3i, asym_penalty: %3i, "
248
 
                "total tq: %3i\n",
249
 
                orig_node->orig, orig_neigh_node->orig, total_count,
250
 
                neigh_rq_count, tq_own, tq_asym_penalty, batman_packet->tq);
251
 
 
252
 
        /* if link has the minimum required transmission quality
253
 
         * consider it bidirectional */
254
 
        if (batman_packet->tq >= TQ_TOTAL_BIDRECT_LIMIT)
255
 
                ret = 1;
256
 
 
257
 
out:
258
 
        if (neigh_node)
259
 
                neigh_node_free_ref(neigh_node);
260
 
        return ret;
261
 
}
262
 
 
263
127
/* caller must hold the neigh_list_lock */
264
128
void bonding_candidate_del(struct orig_node *orig_node,
265
129
                           struct neigh_node *neigh_node)
277
141
        return;
278
142
}
279
143
 
280
 
static void bonding_candidate_add(struct orig_node *orig_node,
281
 
                                  struct neigh_node *neigh_node)
 
144
void bonding_candidate_add(struct orig_node *orig_node,
 
145
                           struct neigh_node *neigh_node)
282
146
{
283
147
        struct hlist_node *node;
284
148
        struct neigh_node *tmp_neigh_node, *router = NULL;
348
212
}
349
213
 
350
214
/* copy primary address for bonding */
351
 
static void bonding_save_primary(struct orig_node *orig_node,
352
 
                                 struct orig_node *orig_neigh_node,
353
 
                                 struct batman_packet *batman_packet)
 
215
void bonding_save_primary(const struct orig_node *orig_node,
 
216
                          struct orig_node *orig_neigh_node,
 
217
                          const struct batman_ogm_packet *batman_ogm_packet)
354
218
{
355
 
        if (!(batman_packet->flags & PRIMARIES_FIRST_HOP))
 
219
        if (!(batman_ogm_packet->flags & PRIMARIES_FIRST_HOP))
356
220
                return;
357
221
 
358
222
        memcpy(orig_neigh_node->primary_addr, orig_node->orig, ETH_ALEN);
359
223
}
360
224
 
361
 
static void update_orig(struct bat_priv *bat_priv,
362
 
                        struct orig_node *orig_node,
363
 
                        struct ethhdr *ethhdr,
364
 
                        struct batman_packet *batman_packet,
365
 
                        struct hard_iface *if_incoming,
366
 
                        unsigned char *tt_buff, int tt_buff_len,
367
 
                        char is_duplicate)
368
 
{
369
 
        struct neigh_node *neigh_node = NULL, *tmp_neigh_node = NULL;
370
 
        struct neigh_node *router = NULL;
371
 
        struct orig_node *orig_node_tmp;
372
 
        struct hlist_node *node;
373
 
        int tmp_tt_buff_len;
374
 
        uint8_t bcast_own_sum_orig, bcast_own_sum_neigh;
375
 
 
376
 
        bat_dbg(DBG_BATMAN, bat_priv, "update_originator(): "
377
 
                "Searching and updating originator entry of received packet\n");
378
 
 
379
 
        rcu_read_lock();
380
 
        hlist_for_each_entry_rcu(tmp_neigh_node, node,
381
 
                                 &orig_node->neigh_list, list) {
382
 
                if (compare_eth(tmp_neigh_node->addr, ethhdr->h_source) &&
383
 
                    (tmp_neigh_node->if_incoming == if_incoming) &&
384
 
                     atomic_inc_not_zero(&tmp_neigh_node->refcount)) {
385
 
                        if (neigh_node)
386
 
                                neigh_node_free_ref(neigh_node);
387
 
                        neigh_node = tmp_neigh_node;
388
 
                        continue;
389
 
                }
390
 
 
391
 
                if (is_duplicate)
392
 
                        continue;
393
 
 
394
 
                spin_lock_bh(&tmp_neigh_node->tq_lock);
395
 
                ring_buffer_set(tmp_neigh_node->tq_recv,
396
 
                                &tmp_neigh_node->tq_index, 0);
397
 
                tmp_neigh_node->tq_avg =
398
 
                        ring_buffer_avg(tmp_neigh_node->tq_recv);
399
 
                spin_unlock_bh(&tmp_neigh_node->tq_lock);
400
 
        }
401
 
 
402
 
        if (!neigh_node) {
403
 
                struct orig_node *orig_tmp;
404
 
 
405
 
                orig_tmp = get_orig_node(bat_priv, ethhdr->h_source);
406
 
                if (!orig_tmp)
407
 
                        goto unlock;
408
 
 
409
 
                neigh_node = create_neighbor(orig_node, orig_tmp,
410
 
                                             ethhdr->h_source, if_incoming);
411
 
 
412
 
                orig_node_free_ref(orig_tmp);
413
 
                if (!neigh_node)
414
 
                        goto unlock;
415
 
        } else
416
 
                bat_dbg(DBG_BATMAN, bat_priv,
417
 
                        "Updating existing last-hop neighbor of originator\n");
418
 
 
419
 
        rcu_read_unlock();
420
 
 
421
 
        orig_node->flags = batman_packet->flags;
422
 
        neigh_node->last_valid = jiffies;
423
 
 
424
 
        spin_lock_bh(&neigh_node->tq_lock);
425
 
        ring_buffer_set(neigh_node->tq_recv,
426
 
                        &neigh_node->tq_index,
427
 
                        batman_packet->tq);
428
 
        neigh_node->tq_avg = ring_buffer_avg(neigh_node->tq_recv);
429
 
        spin_unlock_bh(&neigh_node->tq_lock);
430
 
 
431
 
        if (!is_duplicate) {
432
 
                orig_node->last_ttl = batman_packet->ttl;
433
 
                neigh_node->last_ttl = batman_packet->ttl;
434
 
        }
435
 
 
436
 
        bonding_candidate_add(orig_node, neigh_node);
437
 
 
438
 
        tmp_tt_buff_len = (tt_buff_len > batman_packet->num_tt * ETH_ALEN ?
439
 
                            batman_packet->num_tt * ETH_ALEN : tt_buff_len);
440
 
 
441
 
        /* if this neighbor already is our next hop there is nothing
442
 
         * to change */
443
 
        router = orig_node_get_router(orig_node);
444
 
        if (router == neigh_node)
445
 
                goto update_tt;
446
 
 
447
 
        /* if this neighbor does not offer a better TQ we won't consider it */
448
 
        if (router && (router->tq_avg > neigh_node->tq_avg))
449
 
                goto update_tt;
450
 
 
451
 
        /* if the TQ is the same and the link not more symetric we
452
 
         * won't consider it either */
453
 
        if (router && (neigh_node->tq_avg == router->tq_avg)) {
454
 
                orig_node_tmp = router->orig_node;
455
 
                spin_lock_bh(&orig_node_tmp->ogm_cnt_lock);
456
 
                bcast_own_sum_orig =
457
 
                        orig_node_tmp->bcast_own_sum[if_incoming->if_num];
458
 
                spin_unlock_bh(&orig_node_tmp->ogm_cnt_lock);
459
 
 
460
 
                orig_node_tmp = neigh_node->orig_node;
461
 
                spin_lock_bh(&orig_node_tmp->ogm_cnt_lock);
462
 
                bcast_own_sum_neigh =
463
 
                        orig_node_tmp->bcast_own_sum[if_incoming->if_num];
464
 
                spin_unlock_bh(&orig_node_tmp->ogm_cnt_lock);
465
 
 
466
 
                if (bcast_own_sum_orig >= bcast_own_sum_neigh)
467
 
                        goto update_tt;
468
 
        }
469
 
 
470
 
        update_routes(bat_priv, orig_node, neigh_node,
471
 
                      tt_buff, tmp_tt_buff_len);
472
 
        goto update_gw;
473
 
 
474
 
update_tt:
475
 
        update_routes(bat_priv, orig_node, router,
476
 
                      tt_buff, tmp_tt_buff_len);
477
 
 
478
 
update_gw:
479
 
        if (orig_node->gw_flags != batman_packet->gw_flags)
480
 
                gw_node_update(bat_priv, orig_node, batman_packet->gw_flags);
481
 
 
482
 
        orig_node->gw_flags = batman_packet->gw_flags;
483
 
 
484
 
        /* restart gateway selection if fast or late switching was enabled */
485
 
        if ((orig_node->gw_flags) &&
486
 
            (atomic_read(&bat_priv->gw_mode) == GW_MODE_CLIENT) &&
487
 
            (atomic_read(&bat_priv->gw_sel_class) > 2))
488
 
                gw_check_election(bat_priv, orig_node);
489
 
 
490
 
        goto out;
491
 
 
492
 
unlock:
493
 
        rcu_read_unlock();
494
 
out:
495
 
        if (neigh_node)
496
 
                neigh_node_free_ref(neigh_node);
497
 
        if (router)
498
 
                neigh_node_free_ref(router);
499
 
}
500
 
 
501
225
/* checks whether the host restarted and is in the protection time.
502
226
 * returns:
503
227
 *  0 if the packet is to be accepted
504
228
 *  1 if the packet is to be ignored.
505
229
 */
506
 
static int window_protected(struct bat_priv *bat_priv,
507
 
                            int32_t seq_num_diff,
508
 
                            unsigned long *last_reset)
 
230
int window_protected(struct bat_priv *bat_priv, int32_t seq_num_diff,
 
231
                     unsigned long *last_reset)
509
232
{
510
233
        if ((seq_num_diff <= -TQ_LOCAL_WINDOW_SIZE)
511
234
                || (seq_num_diff >= EXPECTED_SEQNO_RANGE)) {
523
246
        return 0;
524
247
}
525
248
 
526
 
/* processes a batman packet for all interfaces, adjusts the sequence number and
527
 
 * finds out whether it is a duplicate.
528
 
 * returns:
529
 
 *   1 the packet is a duplicate
530
 
 *   0 the packet has not yet been received
531
 
 *  -1 the packet is old and has been received while the seqno window
532
 
 *     was protected. Caller should drop it.
533
 
 */
534
 
static char count_real_packets(struct ethhdr *ethhdr,
535
 
                               struct batman_packet *batman_packet,
536
 
                               struct hard_iface *if_incoming)
537
 
{
538
 
        struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
539
 
        struct orig_node *orig_node;
540
 
        struct neigh_node *tmp_neigh_node;
541
 
        struct hlist_node *node;
542
 
        char is_duplicate = 0;
543
 
        int32_t seq_diff;
544
 
        int need_update = 0;
545
 
        int set_mark, ret = -1;
546
 
 
547
 
        orig_node = get_orig_node(bat_priv, batman_packet->orig);
548
 
        if (!orig_node)
549
 
                return 0;
550
 
 
551
 
        spin_lock_bh(&orig_node->ogm_cnt_lock);
552
 
        seq_diff = batman_packet->seqno - orig_node->last_real_seqno;
553
 
 
554
 
        /* signalize caller that the packet is to be dropped. */
555
 
        if (window_protected(bat_priv, seq_diff,
556
 
                             &orig_node->batman_seqno_reset))
557
 
                goto out;
558
 
 
559
 
        rcu_read_lock();
560
 
        hlist_for_each_entry_rcu(tmp_neigh_node, node,
561
 
                                 &orig_node->neigh_list, list) {
562
 
 
563
 
                is_duplicate |= get_bit_status(tmp_neigh_node->real_bits,
564
 
                                               orig_node->last_real_seqno,
565
 
                                               batman_packet->seqno);
566
 
 
567
 
                if (compare_eth(tmp_neigh_node->addr, ethhdr->h_source) &&
568
 
                    (tmp_neigh_node->if_incoming == if_incoming))
569
 
                        set_mark = 1;
570
 
                else
571
 
                        set_mark = 0;
572
 
 
573
 
                /* if the window moved, set the update flag. */
574
 
                need_update |= bit_get_packet(bat_priv,
575
 
                                              tmp_neigh_node->real_bits,
576
 
                                              seq_diff, set_mark);
577
 
 
578
 
                tmp_neigh_node->real_packet_count =
579
 
                        bit_packet_count(tmp_neigh_node->real_bits);
580
 
        }
581
 
        rcu_read_unlock();
582
 
 
583
 
        if (need_update) {
584
 
                bat_dbg(DBG_BATMAN, bat_priv,
585
 
                        "updating last_seqno: old %d, new %d\n",
586
 
                        orig_node->last_real_seqno, batman_packet->seqno);
587
 
                orig_node->last_real_seqno = batman_packet->seqno;
588
 
        }
589
 
 
590
 
        ret = is_duplicate;
591
 
 
592
 
out:
593
 
        spin_unlock_bh(&orig_node->ogm_cnt_lock);
594
 
        orig_node_free_ref(orig_node);
595
 
        return ret;
596
 
}
597
 
 
598
 
void receive_bat_packet(struct ethhdr *ethhdr,
599
 
                        struct batman_packet *batman_packet,
600
 
                        unsigned char *tt_buff, int tt_buff_len,
601
 
                        struct hard_iface *if_incoming)
602
 
{
603
 
        struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
604
 
        struct hard_iface *hard_iface;
605
 
        struct orig_node *orig_neigh_node, *orig_node;
606
 
        struct neigh_node *router = NULL, *router_router = NULL;
607
 
        struct neigh_node *orig_neigh_router = NULL;
608
 
        char has_directlink_flag;
609
 
        char is_my_addr = 0, is_my_orig = 0, is_my_oldorig = 0;
610
 
        char is_broadcast = 0, is_bidirectional, is_single_hop_neigh;
611
 
        char is_duplicate;
612
 
        uint32_t if_incoming_seqno;
613
 
 
614
 
        /* Silently drop when the batman packet is actually not a
615
 
         * correct packet.
616
 
         *
617
 
         * This might happen if a packet is padded (e.g. Ethernet has a
618
 
         * minimum frame length of 64 byte) and the aggregation interprets
619
 
         * it as an additional length.
620
 
         *
621
 
         * TODO: A more sane solution would be to have a bit in the
622
 
         * batman_packet to detect whether the packet is the last
623
 
         * packet in an aggregation.  Here we expect that the padding
624
 
         * is always zero (or not 0x01)
625
 
         */
626
 
        if (batman_packet->packet_type != BAT_PACKET)
627
 
                return;
628
 
 
629
 
        /* could be changed by schedule_own_packet() */
630
 
        if_incoming_seqno = atomic_read(&if_incoming->seqno);
631
 
 
632
 
        has_directlink_flag = (batman_packet->flags & DIRECTLINK ? 1 : 0);
633
 
 
634
 
        is_single_hop_neigh = (compare_eth(ethhdr->h_source,
635
 
                                           batman_packet->orig) ? 1 : 0);
636
 
 
637
 
        bat_dbg(DBG_BATMAN, bat_priv,
638
 
                "Received BATMAN packet via NB: %pM, IF: %s [%pM] "
639
 
                "(from OG: %pM, via prev OG: %pM, seqno %d, tq %d, "
640
 
                "TTL %d, V %d, IDF %d)\n",
641
 
                ethhdr->h_source, if_incoming->net_dev->name,
642
 
                if_incoming->net_dev->dev_addr, batman_packet->orig,
643
 
                batman_packet->prev_sender, batman_packet->seqno,
644
 
                batman_packet->tq, batman_packet->ttl, batman_packet->version,
645
 
                has_directlink_flag);
646
 
 
647
 
        rcu_read_lock();
648
 
        list_for_each_entry_rcu(hard_iface, &hardif_list, list) {
649
 
                if (hard_iface->if_status != IF_ACTIVE)
650
 
                        continue;
651
 
 
652
 
                if (hard_iface->soft_iface != if_incoming->soft_iface)
653
 
                        continue;
654
 
 
655
 
                if (compare_eth(ethhdr->h_source,
656
 
                                hard_iface->net_dev->dev_addr))
657
 
                        is_my_addr = 1;
658
 
 
659
 
                if (compare_eth(batman_packet->orig,
660
 
                                hard_iface->net_dev->dev_addr))
661
 
                        is_my_orig = 1;
662
 
 
663
 
                if (compare_eth(batman_packet->prev_sender,
664
 
                                hard_iface->net_dev->dev_addr))
665
 
                        is_my_oldorig = 1;
666
 
 
667
 
                if (compare_eth(ethhdr->h_source, broadcast_addr))
668
 
                        is_broadcast = 1;
669
 
        }
670
 
        rcu_read_unlock();
671
 
 
672
 
        if (batman_packet->version != COMPAT_VERSION) {
673
 
                bat_dbg(DBG_BATMAN, bat_priv,
674
 
                        "Drop packet: incompatible batman version (%i)\n",
675
 
                        batman_packet->version);
676
 
                return;
677
 
        }
678
 
 
679
 
        if (is_my_addr) {
680
 
                bat_dbg(DBG_BATMAN, bat_priv,
681
 
                        "Drop packet: received my own broadcast (sender: %pM"
682
 
                        ")\n",
683
 
                        ethhdr->h_source);
684
 
                return;
685
 
        }
686
 
 
687
 
        if (is_broadcast) {
688
 
                bat_dbg(DBG_BATMAN, bat_priv, "Drop packet: "
689
 
                "ignoring all packets with broadcast source addr (sender: %pM"
690
 
                ")\n", ethhdr->h_source);
691
 
                return;
692
 
        }
693
 
 
694
 
        if (is_my_orig) {
695
 
                unsigned long *word;
696
 
                int offset;
697
 
 
698
 
                orig_neigh_node = get_orig_node(bat_priv, ethhdr->h_source);
699
 
                if (!orig_neigh_node)
700
 
                        return;
701
 
 
702
 
                /* neighbor has to indicate direct link and it has to
703
 
                 * come via the corresponding interface */
704
 
                /* if received seqno equals last send seqno save new
705
 
                 * seqno for bidirectional check */
706
 
                if (has_directlink_flag &&
707
 
                    compare_eth(if_incoming->net_dev->dev_addr,
708
 
                                batman_packet->orig) &&
709
 
                    (batman_packet->seqno - if_incoming_seqno + 2 == 0)) {
710
 
                        offset = if_incoming->if_num * NUM_WORDS;
711
 
 
712
 
                        spin_lock_bh(&orig_neigh_node->ogm_cnt_lock);
713
 
                        word = &(orig_neigh_node->bcast_own[offset]);
714
 
                        bit_mark(word, 0);
715
 
                        orig_neigh_node->bcast_own_sum[if_incoming->if_num] =
716
 
                                bit_packet_count(word);
717
 
                        spin_unlock_bh(&orig_neigh_node->ogm_cnt_lock);
718
 
                }
719
 
 
720
 
                bat_dbg(DBG_BATMAN, bat_priv, "Drop packet: "
721
 
                        "originator packet from myself (via neighbor)\n");
722
 
                orig_node_free_ref(orig_neigh_node);
723
 
                return;
724
 
        }
725
 
 
726
 
        if (is_my_oldorig) {
727
 
                bat_dbg(DBG_BATMAN, bat_priv,
728
 
                        "Drop packet: ignoring all rebroadcast echos (sender: "
729
 
                        "%pM)\n", ethhdr->h_source);
730
 
                return;
731
 
        }
732
 
 
733
 
        orig_node = get_orig_node(bat_priv, batman_packet->orig);
734
 
        if (!orig_node)
735
 
                return;
736
 
 
737
 
        is_duplicate = count_real_packets(ethhdr, batman_packet, if_incoming);
738
 
 
739
 
        if (is_duplicate == -1) {
740
 
                bat_dbg(DBG_BATMAN, bat_priv,
741
 
                        "Drop packet: packet within seqno protection time "
742
 
                        "(sender: %pM)\n", ethhdr->h_source);
743
 
                goto out;
744
 
        }
745
 
 
746
 
        if (batman_packet->tq == 0) {
747
 
                bat_dbg(DBG_BATMAN, bat_priv,
748
 
                        "Drop packet: originator packet with tq equal 0\n");
749
 
                goto out;
750
 
        }
751
 
 
752
 
        router = orig_node_get_router(orig_node);
753
 
        if (router)
754
 
                router_router = orig_node_get_router(router->orig_node);
755
 
 
756
 
        /* avoid temporary routing loops */
757
 
        if (router && router_router &&
758
 
            (compare_eth(router->addr, batman_packet->prev_sender)) &&
759
 
            !(compare_eth(batman_packet->orig, batman_packet->prev_sender)) &&
760
 
            (compare_eth(router->addr, router_router->addr))) {
761
 
                bat_dbg(DBG_BATMAN, bat_priv,
762
 
                        "Drop packet: ignoring all rebroadcast packets that "
763
 
                        "may make me loop (sender: %pM)\n", ethhdr->h_source);
764
 
                goto out;
765
 
        }
766
 
 
767
 
        /* if sender is a direct neighbor the sender mac equals
768
 
         * originator mac */
769
 
        orig_neigh_node = (is_single_hop_neigh ?
770
 
                           orig_node :
771
 
                           get_orig_node(bat_priv, ethhdr->h_source));
772
 
        if (!orig_neigh_node)
773
 
                goto out;
774
 
 
775
 
        orig_neigh_router = orig_node_get_router(orig_neigh_node);
776
 
 
777
 
        /* drop packet if sender is not a direct neighbor and if we
778
 
         * don't route towards it */
779
 
        if (!is_single_hop_neigh && (!orig_neigh_router)) {
780
 
                bat_dbg(DBG_BATMAN, bat_priv,
781
 
                        "Drop packet: OGM via unknown neighbor!\n");
782
 
                goto out_neigh;
783
 
        }
784
 
 
785
 
        is_bidirectional = is_bidirectional_neigh(orig_node, orig_neigh_node,
786
 
                                                batman_packet, if_incoming);
787
 
 
788
 
        bonding_save_primary(orig_node, orig_neigh_node, batman_packet);
789
 
 
790
 
        /* update ranking if it is not a duplicate or has the same
791
 
         * seqno and similar ttl as the non-duplicate */
792
 
        if (is_bidirectional &&
793
 
            (!is_duplicate ||
794
 
             ((orig_node->last_real_seqno == batman_packet->seqno) &&
795
 
              (orig_node->last_ttl - 3 <= batman_packet->ttl))))
796
 
                update_orig(bat_priv, orig_node, ethhdr, batman_packet,
797
 
                            if_incoming, tt_buff, tt_buff_len, is_duplicate);
798
 
 
799
 
        /* is single hop (direct) neighbor */
800
 
        if (is_single_hop_neigh) {
801
 
 
802
 
                /* mark direct link on incoming interface */
803
 
                schedule_forward_packet(orig_node, ethhdr, batman_packet,
804
 
                                        1, tt_buff_len, if_incoming);
805
 
 
806
 
                bat_dbg(DBG_BATMAN, bat_priv, "Forwarding packet: "
807
 
                        "rebroadcast neighbor packet with direct link flag\n");
808
 
                goto out_neigh;
809
 
        }
810
 
 
811
 
        /* multihop originator */
812
 
        if (!is_bidirectional) {
813
 
                bat_dbg(DBG_BATMAN, bat_priv,
814
 
                        "Drop packet: not received via bidirectional link\n");
815
 
                goto out_neigh;
816
 
        }
817
 
 
818
 
        if (is_duplicate) {
819
 
                bat_dbg(DBG_BATMAN, bat_priv,
820
 
                        "Drop packet: duplicate packet received\n");
821
 
                goto out_neigh;
822
 
        }
823
 
 
824
 
        bat_dbg(DBG_BATMAN, bat_priv,
825
 
                "Forwarding packet: rebroadcast originator packet\n");
826
 
        schedule_forward_packet(orig_node, ethhdr, batman_packet,
827
 
                                0, tt_buff_len, if_incoming);
828
 
 
829
 
out_neigh:
830
 
        if ((orig_neigh_node) && (!is_single_hop_neigh))
831
 
                orig_node_free_ref(orig_neigh_node);
832
 
out:
833
 
        if (router)
834
 
                neigh_node_free_ref(router);
835
 
        if (router_router)
836
 
                neigh_node_free_ref(router_router);
837
 
        if (orig_neigh_router)
838
 
                neigh_node_free_ref(orig_neigh_router);
839
 
 
840
 
        orig_node_free_ref(orig_node);
841
 
}
842
 
 
843
 
int recv_bat_packet(struct sk_buff *skb, struct hard_iface *hard_iface)
 
249
int recv_bat_ogm_packet(struct sk_buff *skb, struct hard_iface *hard_iface)
844
250
{
845
251
        struct ethhdr *ethhdr;
846
252
 
847
253
        /* drop packet if it has not necessary minimum size */
848
 
        if (unlikely(!pskb_may_pull(skb, sizeof(struct batman_packet))))
 
254
        if (unlikely(!pskb_may_pull(skb, BATMAN_OGM_LEN)))
849
255
                return NET_RX_DROP;
850
256
 
851
257
        ethhdr = (struct ethhdr *)skb_mac_header(skb);
868
274
 
869
275
        ethhdr = (struct ethhdr *)skb_mac_header(skb);
870
276
 
871
 
        receive_aggr_bat_packet(ethhdr,
872
 
                                skb->data,
873
 
                                skb_headlen(skb),
874
 
                                hard_iface);
 
277
        bat_ogm_receive(ethhdr, skb->data, skb_headlen(skb), hard_iface);
875
278
 
876
279
        kfree_skb(skb);
877
280
        return NET_RX_SUCCESS;
1077
480
 * This method rotates the bonding list and increases the
1078
481
 * returned router's refcount. */
1079
482
static struct neigh_node *find_bond_router(struct orig_node *primary_orig,
1080
 
                                           struct hard_iface *recv_if)
 
483
                                           const struct hard_iface *recv_if)
1081
484
{
1082
485
        struct neigh_node *tmp_neigh_node;
1083
486
        struct neigh_node *router = NULL, *first_candidate = NULL;
1128
531
 *
1129
532
 * Increases the returned router's refcount */
1130
533
static struct neigh_node *find_ifalter_router(struct orig_node *primary_orig,
1131
 
                                              struct hard_iface *recv_if)
 
534
                                              const struct hard_iface *recv_if)
1132
535
{
1133
536
        struct neigh_node *tmp_neigh_node;
1134
537
        struct neigh_node *router = NULL, *first_candidate = NULL;
1171
574
        return router;
1172
575
}
1173
576
 
 
577
int recv_tt_query(struct sk_buff *skb, struct hard_iface *recv_if)
 
578
{
 
579
        struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
 
580
        struct tt_query_packet *tt_query;
 
581
        struct ethhdr *ethhdr;
 
582
 
 
583
        /* drop packet if it has not necessary minimum size */
 
584
        if (unlikely(!pskb_may_pull(skb, sizeof(struct tt_query_packet))))
 
585
                goto out;
 
586
 
 
587
        /* I could need to modify it */
 
588
        if (skb_cow(skb, sizeof(struct tt_query_packet)) < 0)
 
589
                goto out;
 
590
 
 
591
        ethhdr = (struct ethhdr *)skb_mac_header(skb);
 
592
 
 
593
        /* packet with unicast indication but broadcast recipient */
 
594
        if (is_broadcast_ether_addr(ethhdr->h_dest))
 
595
                goto out;
 
596
 
 
597
        /* packet with broadcast sender address */
 
598
        if (is_broadcast_ether_addr(ethhdr->h_source))
 
599
                goto out;
 
600
 
 
601
        tt_query = (struct tt_query_packet *)skb->data;
 
602
 
 
603
        tt_query->tt_data = ntohs(tt_query->tt_data);
 
604
 
 
605
        switch (tt_query->flags & TT_QUERY_TYPE_MASK) {
 
606
        case TT_REQUEST:
 
607
                /* If we cannot provide an answer the tt_request is
 
608
                 * forwarded */
 
609
                if (!send_tt_response(bat_priv, tt_query)) {
 
610
                        bat_dbg(DBG_TT, bat_priv,
 
611
                                "Routing TT_REQUEST to %pM [%c]\n",
 
612
                                tt_query->dst,
 
613
                                (tt_query->flags & TT_FULL_TABLE ? 'F' : '.'));
 
614
                        tt_query->tt_data = htons(tt_query->tt_data);
 
615
                        return route_unicast_packet(skb, recv_if);
 
616
                }
 
617
                break;
 
618
        case TT_RESPONSE:
 
619
                /* packet needs to be linearized to access the TT changes */
 
620
                if (skb_linearize(skb) < 0)
 
621
                        goto out;
 
622
 
 
623
                if (is_my_mac(tt_query->dst))
 
624
                        handle_tt_response(bat_priv, tt_query);
 
625
                else {
 
626
                        bat_dbg(DBG_TT, bat_priv,
 
627
                                "Routing TT_RESPONSE to %pM [%c]\n",
 
628
                                tt_query->dst,
 
629
                                (tt_query->flags & TT_FULL_TABLE ? 'F' : '.'));
 
630
                        tt_query->tt_data = htons(tt_query->tt_data);
 
631
                        return route_unicast_packet(skb, recv_if);
 
632
                }
 
633
                break;
 
634
        }
 
635
 
 
636
out:
 
637
        /* returning NET_RX_DROP will make the caller function kfree the skb */
 
638
        return NET_RX_DROP;
 
639
}
 
640
 
 
641
int recv_roam_adv(struct sk_buff *skb, struct hard_iface *recv_if)
 
642
{
 
643
        struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
 
644
        struct roam_adv_packet *roam_adv_packet;
 
645
        struct orig_node *orig_node;
 
646
        struct ethhdr *ethhdr;
 
647
 
 
648
        /* drop packet if it has not necessary minimum size */
 
649
        if (unlikely(!pskb_may_pull(skb, sizeof(struct roam_adv_packet))))
 
650
                goto out;
 
651
 
 
652
        ethhdr = (struct ethhdr *)skb_mac_header(skb);
 
653
 
 
654
        /* packet with unicast indication but broadcast recipient */
 
655
        if (is_broadcast_ether_addr(ethhdr->h_dest))
 
656
                goto out;
 
657
 
 
658
        /* packet with broadcast sender address */
 
659
        if (is_broadcast_ether_addr(ethhdr->h_source))
 
660
                goto out;
 
661
 
 
662
        roam_adv_packet = (struct roam_adv_packet *)skb->data;
 
663
 
 
664
        if (!is_my_mac(roam_adv_packet->dst))
 
665
                return route_unicast_packet(skb, recv_if);
 
666
 
 
667
        orig_node = orig_hash_find(bat_priv, roam_adv_packet->src);
 
668
        if (!orig_node)
 
669
                goto out;
 
670
 
 
671
        bat_dbg(DBG_TT, bat_priv, "Received ROAMING_ADV from %pM "
 
672
                "(client %pM)\n", roam_adv_packet->src,
 
673
                roam_adv_packet->client);
 
674
 
 
675
        tt_global_add(bat_priv, orig_node, roam_adv_packet->client,
 
676
                      atomic_read(&orig_node->last_ttvn) + 1, true, false);
 
677
 
 
678
        /* Roaming phase starts: I have new information but the ttvn has not
 
679
         * been incremented yet. This flag will make me check all the incoming
 
680
         * packets for the correct destination. */
 
681
        bat_priv->tt_poss_change = true;
 
682
 
 
683
        orig_node_free_ref(orig_node);
 
684
out:
 
685
        /* returning NET_RX_DROP will make the caller function kfree the skb */
 
686
        return NET_RX_DROP;
 
687
}
 
688
 
1174
689
/* find a suitable router for this originator, and use
1175
690
 * bonding if possible. increases the found neighbors
1176
691
 * refcount.*/
1177
692
struct neigh_node *find_router(struct bat_priv *bat_priv,
1178
693
                               struct orig_node *orig_node,
1179
 
                               struct hard_iface *recv_if)
 
694
                               const struct hard_iface *recv_if)
1180
695
{
1181
696
        struct orig_node *primary_orig_node;
1182
697
        struct orig_node *router_orig;
1240
755
                router = find_ifalter_router(primary_orig_node, recv_if);
1241
756
 
1242
757
return_router:
 
758
        if (router && router->if_incoming->if_status != IF_ACTIVE)
 
759
                goto err_unlock;
 
760
 
1243
761
        rcu_read_unlock();
1244
762
        return router;
1245
763
err_unlock:
1354
872
        return ret;
1355
873
}
1356
874
 
 
875
static int check_unicast_ttvn(struct bat_priv *bat_priv,
 
876
                               struct sk_buff *skb) {
 
877
        uint8_t curr_ttvn;
 
878
        struct orig_node *orig_node;
 
879
        struct ethhdr *ethhdr;
 
880
        struct hard_iface *primary_if;
 
881
        struct unicast_packet *unicast_packet;
 
882
        bool tt_poss_change;
 
883
 
 
884
        /* I could need to modify it */
 
885
        if (skb_cow(skb, sizeof(struct unicast_packet)) < 0)
 
886
                return 0;
 
887
 
 
888
        unicast_packet = (struct unicast_packet *)skb->data;
 
889
 
 
890
        if (is_my_mac(unicast_packet->dest)) {
 
891
                tt_poss_change = bat_priv->tt_poss_change;
 
892
                curr_ttvn = (uint8_t)atomic_read(&bat_priv->ttvn);
 
893
        } else {
 
894
                orig_node = orig_hash_find(bat_priv, unicast_packet->dest);
 
895
 
 
896
                if (!orig_node)
 
897
                        return 0;
 
898
 
 
899
                curr_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);
 
900
                tt_poss_change = orig_node->tt_poss_change;
 
901
                orig_node_free_ref(orig_node);
 
902
        }
 
903
 
 
904
        /* Check whether I have to reroute the packet */
 
905
        if (seq_before(unicast_packet->ttvn, curr_ttvn) || tt_poss_change) {
 
906
                /* Linearize the skb before accessing it */
 
907
                if (skb_linearize(skb) < 0)
 
908
                        return 0;
 
909
 
 
910
                ethhdr = (struct ethhdr *)(skb->data +
 
911
                        sizeof(struct unicast_packet));
 
912
                orig_node = transtable_search(bat_priv, NULL, ethhdr->h_dest);
 
913
 
 
914
                if (!orig_node) {
 
915
                        if (!is_my_client(bat_priv, ethhdr->h_dest))
 
916
                                return 0;
 
917
                        primary_if = primary_if_get_selected(bat_priv);
 
918
                        if (!primary_if)
 
919
                                return 0;
 
920
                        memcpy(unicast_packet->dest,
 
921
                               primary_if->net_dev->dev_addr, ETH_ALEN);
 
922
                        hardif_free_ref(primary_if);
 
923
                } else {
 
924
                        memcpy(unicast_packet->dest, orig_node->orig,
 
925
                               ETH_ALEN);
 
926
                        curr_ttvn = (uint8_t)
 
927
                                atomic_read(&orig_node->last_ttvn);
 
928
                        orig_node_free_ref(orig_node);
 
929
                }
 
930
 
 
931
                bat_dbg(DBG_ROUTES, bat_priv, "TTVN mismatch (old_ttvn %u "
 
932
                        "new_ttvn %u)! Rerouting unicast packet (for %pM) to "
 
933
                        "%pM\n", unicast_packet->ttvn, curr_ttvn,
 
934
                        ethhdr->h_dest, unicast_packet->dest);
 
935
 
 
936
                unicast_packet->ttvn = curr_ttvn;
 
937
        }
 
938
        return 1;
 
939
}
 
940
 
1357
941
int recv_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if)
1358
942
{
 
943
        struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1359
944
        struct unicast_packet *unicast_packet;
1360
 
        int hdr_size = sizeof(struct unicast_packet);
 
945
        int hdr_size = sizeof(*unicast_packet);
1361
946
 
1362
947
        if (check_unicast_packet(skb, hdr_size) < 0)
1363
948
                return NET_RX_DROP;
1364
949
 
 
950
        if (!check_unicast_ttvn(bat_priv, skb))
 
951
                return NET_RX_DROP;
 
952
 
1365
953
        unicast_packet = (struct unicast_packet *)skb->data;
1366
954
 
1367
955
        /* packet for me */
1377
965
{
1378
966
        struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1379
967
        struct unicast_frag_packet *unicast_packet;
1380
 
        int hdr_size = sizeof(struct unicast_frag_packet);
 
968
        int hdr_size = sizeof(*unicast_packet);
1381
969
        struct sk_buff *new_skb = NULL;
1382
970
        int ret;
1383
971
 
1384
972
        if (check_unicast_packet(skb, hdr_size) < 0)
1385
973
                return NET_RX_DROP;
1386
974
 
 
975
        if (!check_unicast_ttvn(bat_priv, skb))
 
976
                return NET_RX_DROP;
 
977
 
1387
978
        unicast_packet = (struct unicast_frag_packet *)skb->data;
1388
979
 
1389
980
        /* packet for me */
1413
1004
        struct orig_node *orig_node = NULL;
1414
1005
        struct bcast_packet *bcast_packet;
1415
1006
        struct ethhdr *ethhdr;
1416
 
        int hdr_size = sizeof(struct bcast_packet);
 
1007
        int hdr_size = sizeof(*bcast_packet);
1417
1008
        int ret = NET_RX_DROP;
1418
1009
        int32_t seq_diff;
1419
1010
 
1471
1062
        spin_unlock_bh(&orig_node->bcast_seqno_lock);
1472
1063
 
1473
1064
        /* rebroadcast packet */
1474
 
        add_bcast_packet_to_list(bat_priv, skb);
 
1065
        add_bcast_packet_to_list(bat_priv, skb, 1);
1475
1066
 
1476
1067
        /* broadcast for me */
1477
1068
        interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size);
1491
1082
        struct vis_packet *vis_packet;
1492
1083
        struct ethhdr *ethhdr;
1493
1084
        struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1494
 
        int hdr_size = sizeof(struct vis_packet);
 
1085
        int hdr_size = sizeof(*vis_packet);
1495
1086
 
1496
1087
        /* keep skb linear */
1497
1088
        if (skb_linearize(skb) < 0)