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