1// SPDX-License-Identifier: GPL-2.0 2/* Copyright (C) 2007-2020 B.A.T.M.A.N. contributors: 3 * 4 * Marek Lindner, Simon Wunderlich 5 */ 6 7#include "send.h" 8#include "main.h" 9 10#include <linux/atomic.h> 11#include <linux/bug.h> 12#include <linux/byteorder/generic.h> 13#include <linux/errno.h> 14#include <linux/etherdevice.h> 15#include <linux/gfp.h> 16#include <linux/if.h> 17#include <linux/if_ether.h> 18#include <linux/jiffies.h> 19#include <linux/kernel.h> 20#include <linux/kref.h> 21#include <linux/list.h> 22#include <linux/netdevice.h> 23#include <linux/printk.h> 24#include <linux/rculist.h> 25#include <linux/rcupdate.h> 26#include <linux/skbuff.h> 27#include <linux/slab.h> 28#include <linux/spinlock.h> 29#include <linux/stddef.h> 30#include <linux/workqueue.h> 31 32#include "distributed-arp-table.h" 33#include "fragmentation.h" 34#include "gateway_client.h" 35#include "hard-interface.h" 36#include "log.h" 37#include "network-coding.h" 38#include "originator.h" 39#include "routing.h" 40#include "soft-interface.h" 41#include "translation-table.h" 42 43static void batadv_send_outstanding_bcast_packet(struct work_struct *work); 44 45/** 46 * batadv_send_skb_packet() - send an already prepared packet 47 * @skb: the packet to send 48 * @hard_iface: the interface to use to send the broadcast packet 49 * @dst_addr: the payload destination 50 * 51 * Send out an already prepared packet to the given neighbor or broadcast it 52 * using the specified interface. Either hard_iface or neigh_node must be not 53 * NULL. 54 * If neigh_node is NULL, then the packet is broadcasted using hard_iface, 55 * otherwise it is sent as unicast to the given neighbor. 56 * 57 * Regardless of the return value, the skb is consumed. 58 * 59 * Return: A negative errno code is returned on a failure. A success does not 60 * guarantee the frame will be transmitted as it may be dropped due 61 * to congestion or traffic shaping. 62 */ 63int batadv_send_skb_packet(struct sk_buff *skb, 64 struct batadv_hard_iface *hard_iface, 65 const u8 *dst_addr) 66{ 67 struct batadv_priv *bat_priv; 68 struct ethhdr *ethhdr; 69 int ret; 70 71 bat_priv = netdev_priv(hard_iface->soft_iface); 72 73 if (hard_iface->if_status != BATADV_IF_ACTIVE) 74 goto send_skb_err; 75 76 if (unlikely(!hard_iface->net_dev)) 77 goto send_skb_err; 78 79 if (!(hard_iface->net_dev->flags & IFF_UP)) { 80 pr_warn("Interface %s is not up - can't send packet via that interface!\n", 81 hard_iface->net_dev->name); 82 goto send_skb_err; 83 } 84 85 /* push to the ethernet header. */ 86 if (batadv_skb_head_push(skb, ETH_HLEN) < 0) 87 goto send_skb_err; 88 89 skb_reset_mac_header(skb); 90 91 ethhdr = eth_hdr(skb); 92 ether_addr_copy(ethhdr->h_source, hard_iface->net_dev->dev_addr); 93 ether_addr_copy(ethhdr->h_dest, dst_addr); 94 ethhdr->h_proto = htons(ETH_P_BATMAN); 95 96 skb_set_network_header(skb, ETH_HLEN); 97 skb->protocol = htons(ETH_P_BATMAN); 98 99 skb->dev = hard_iface->net_dev; 100 101 /* Save a clone of the skb to use when decoding coded packets */ 102 batadv_nc_skb_store_for_decoding(bat_priv, skb); 103 104 /* dev_queue_xmit() returns a negative result on error. However on 105 * congestion and traffic shaping, it drops and returns NET_XMIT_DROP 106 * (which is > 0). This will not be treated as an error. 107 */ 108 ret = dev_queue_xmit(skb); 109 return net_xmit_eval(ret); 110send_skb_err: 111 kfree_skb(skb); 112 return NET_XMIT_DROP; 113} 114 115/** 116 * batadv_send_broadcast_skb() - Send broadcast packet via hard interface 117 * @skb: packet to be transmitted (with batadv header and no outer eth header) 118 * @hard_iface: outgoing interface 119 * 120 * Return: A negative errno code is returned on a failure. A success does not 121 * guarantee the frame will be transmitted as it may be dropped due 122 * to congestion or traffic shaping. 123 */ 124int batadv_send_broadcast_skb(struct sk_buff *skb, 125 struct batadv_hard_iface *hard_iface) 126{ 127 return batadv_send_skb_packet(skb, hard_iface, batadv_broadcast_addr); 128} 129 130/** 131 * batadv_send_unicast_skb() - Send unicast packet to neighbor 132 * @skb: packet to be transmitted (with batadv header and no outer eth header) 133 * @neigh: neighbor which is used as next hop to destination 134 * 135 * Return: A negative errno code is returned on a failure. A success does not 136 * guarantee the frame will be transmitted as it may be dropped due 137 * to congestion or traffic shaping. 138 */ 139int batadv_send_unicast_skb(struct sk_buff *skb, 140 struct batadv_neigh_node *neigh) 141{ 142#ifdef CONFIG_BATMAN_ADV_BATMAN_V 143 struct batadv_hardif_neigh_node *hardif_neigh; 144#endif 145 int ret; 146 147 ret = batadv_send_skb_packet(skb, neigh->if_incoming, neigh->addr); 148 149#ifdef CONFIG_BATMAN_ADV_BATMAN_V 150 hardif_neigh = batadv_hardif_neigh_get(neigh->if_incoming, neigh->addr); 151 152 if (hardif_neigh && ret != NET_XMIT_DROP) 153 hardif_neigh->bat_v.last_unicast_tx = jiffies; 154 155 if (hardif_neigh) 156 batadv_hardif_neigh_put(hardif_neigh); 157#endif 158 159 return ret; 160} 161 162/** 163 * batadv_send_skb_to_orig() - Lookup next-hop and transmit skb. 164 * @skb: Packet to be transmitted. 165 * @orig_node: Final destination of the packet. 166 * @recv_if: Interface used when receiving the packet (can be NULL). 167 * 168 * Looks up the best next-hop towards the passed originator and passes the 169 * skb on for preparation of MAC header. If the packet originated from this 170 * host, NULL can be passed as recv_if and no interface alternating is 171 * attempted. 172 * 173 * Return: negative errno code on a failure, -EINPROGRESS if the skb is 174 * buffered for later transmit or the NET_XMIT status returned by the 175 * lower routine if the packet has been passed down. 176 */ 177int batadv_send_skb_to_orig(struct sk_buff *skb, 178 struct batadv_orig_node *orig_node, 179 struct batadv_hard_iface *recv_if) 180{ 181 struct batadv_priv *bat_priv = orig_node->bat_priv; 182 struct batadv_neigh_node *neigh_node; 183 int ret; 184 185 /* batadv_find_router() increases neigh_nodes refcount if found. */ 186 neigh_node = batadv_find_router(bat_priv, orig_node, recv_if); 187 if (!neigh_node) { 188 ret = -EINVAL; 189 goto free_skb; 190 } 191 192 /* Check if the skb is too large to send in one piece and fragment 193 * it if needed. 194 */ 195 if (atomic_read(&bat_priv->fragmentation) && 196 skb->len > neigh_node->if_incoming->net_dev->mtu) { 197 /* Fragment and send packet. */ 198 ret = batadv_frag_send_packet(skb, orig_node, neigh_node); 199 /* skb was consumed */ 200 skb = NULL; 201 202 goto put_neigh_node; 203 } 204 205 /* try to network code the packet, if it is received on an interface 206 * (i.e. being forwarded). If the packet originates from this node or if 207 * network coding fails, then send the packet as usual. 208 */ 209 if (recv_if && batadv_nc_skb_forward(skb, neigh_node)) 210 ret = -EINPROGRESS; 211 else 212 ret = batadv_send_unicast_skb(skb, neigh_node); 213 214 /* skb was consumed */ 215 skb = NULL; 216 217put_neigh_node: 218 batadv_neigh_node_put(neigh_node); 219free_skb: 220 kfree_skb(skb); 221 222 return ret; 223} 224 225/** 226 * batadv_send_skb_push_fill_unicast() - extend the buffer and initialize the 227 * common fields for unicast packets 228 * @skb: the skb carrying the unicast header to initialize 229 * @hdr_size: amount of bytes to push at the beginning of the skb 230 * @orig_node: the destination node 231 * 232 * Return: false if the buffer extension was not possible or true otherwise. 233 */ 234static bool 235batadv_send_skb_push_fill_unicast(struct sk_buff *skb, int hdr_size, 236 struct batadv_orig_node *orig_node) 237{ 238 struct batadv_unicast_packet *unicast_packet; 239 u8 ttvn = (u8)atomic_read(&orig_node->last_ttvn); 240 241 if (batadv_skb_head_push(skb, hdr_size) < 0) 242 return false; 243 244 unicast_packet = (struct batadv_unicast_packet *)skb->data; 245 unicast_packet->version = BATADV_COMPAT_VERSION; 246 /* batman packet type: unicast */ 247 unicast_packet->packet_type = BATADV_UNICAST; 248 /* set unicast ttl */ 249 unicast_packet->ttl = BATADV_TTL; 250 /* copy the destination for faster routing */ 251 ether_addr_copy(unicast_packet->dest, orig_node->orig); 252 /* set the destination tt version number */ 253 unicast_packet->ttvn = ttvn; 254 255 return true; 256} 257 258/** 259 * batadv_send_skb_prepare_unicast() - encapsulate an skb with a unicast header 260 * @skb: the skb containing the payload to encapsulate 261 * @orig_node: the destination node 262 * 263 * Return: false if the payload could not be encapsulated or true otherwise. 264 */ 265static bool batadv_send_skb_prepare_unicast(struct sk_buff *skb, 266 struct batadv_orig_node *orig_node) 267{ 268 size_t uni_size = sizeof(struct batadv_unicast_packet); 269 270 return batadv_send_skb_push_fill_unicast(skb, uni_size, orig_node); 271} 272 273/** 274 * batadv_send_skb_prepare_unicast_4addr() - encapsulate an skb with a 275 * unicast 4addr header 276 * @bat_priv: the bat priv with all the soft interface information 277 * @skb: the skb containing the payload to encapsulate 278 * @orig: the destination node 279 * @packet_subtype: the unicast 4addr packet subtype to use 280 * 281 * Return: false if the payload could not be encapsulated or true otherwise. 282 */ 283bool batadv_send_skb_prepare_unicast_4addr(struct batadv_priv *bat_priv, 284 struct sk_buff *skb, 285 struct batadv_orig_node *orig, 286 int packet_subtype) 287{ 288 struct batadv_hard_iface *primary_if; 289 struct batadv_unicast_4addr_packet *uc_4addr_packet; 290 bool ret = false; 291 292 primary_if = batadv_primary_if_get_selected(bat_priv); 293 if (!primary_if) 294 goto out; 295 296 /* Pull the header space and fill the unicast_packet substructure. 297 * We can do that because the first member of the uc_4addr_packet 298 * is of type struct unicast_packet 299 */ 300 if (!batadv_send_skb_push_fill_unicast(skb, sizeof(*uc_4addr_packet), 301 orig)) 302 goto out; 303 304 uc_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data; 305 uc_4addr_packet->u.packet_type = BATADV_UNICAST_4ADDR; 306 ether_addr_copy(uc_4addr_packet->src, primary_if->net_dev->dev_addr); 307 uc_4addr_packet->subtype = packet_subtype; 308 uc_4addr_packet->reserved = 0; 309 310 ret = true; 311out: 312 if (primary_if) 313 batadv_hardif_put(primary_if); 314 return ret; 315} 316 317/** 318 * batadv_send_skb_unicast() - encapsulate and send an skb via unicast 319 * @bat_priv: the bat priv with all the soft interface information 320 * @skb: payload to send 321 * @packet_type: the batman unicast packet type to use 322 * @packet_subtype: the unicast 4addr packet subtype (only relevant for unicast 323 * 4addr packets) 324 * @orig_node: the originator to send the packet to 325 * @vid: the vid to be used to search the translation table 326 * 327 * Wrap the given skb into a batman-adv unicast or unicast-4addr header 328 * depending on whether BATADV_UNICAST or BATADV_UNICAST_4ADDR was supplied 329 * as packet_type. Then send this frame to the given orig_node. 330 * 331 * Return: NET_XMIT_DROP in case of error or NET_XMIT_SUCCESS otherwise. 332 */ 333int batadv_send_skb_unicast(struct batadv_priv *bat_priv, 334 struct sk_buff *skb, int packet_type, 335 int packet_subtype, 336 struct batadv_orig_node *orig_node, 337 unsigned short vid) 338{ 339 struct batadv_unicast_packet *unicast_packet; 340 struct ethhdr *ethhdr; 341 int ret = NET_XMIT_DROP; 342 343 if (!orig_node) 344 goto out; 345 346 switch (packet_type) { 347 case BATADV_UNICAST: 348 if (!batadv_send_skb_prepare_unicast(skb, orig_node)) 349 goto out; 350 break; 351 case BATADV_UNICAST_4ADDR: 352 if (!batadv_send_skb_prepare_unicast_4addr(bat_priv, skb, 353 orig_node, 354 packet_subtype)) 355 goto out; 356 break; 357 default: 358 /* this function supports UNICAST and UNICAST_4ADDR only. It 359 * should never be invoked with any other packet type 360 */ 361 goto out; 362 } 363 364 /* skb->data might have been reallocated by 365 * batadv_send_skb_prepare_unicast{,_4addr}() 366 */ 367 ethhdr = eth_hdr(skb); 368 unicast_packet = (struct batadv_unicast_packet *)skb->data; 369 370 /* inform the destination node that we are still missing a correct route 371 * for this client. The destination will receive this packet and will 372 * try to reroute it because the ttvn contained in the header is less 373 * than the current one 374 */ 375 if (batadv_tt_global_client_is_roaming(bat_priv, ethhdr->h_dest, vid)) 376 unicast_packet->ttvn = unicast_packet->ttvn - 1; 377 378 ret = batadv_send_skb_to_orig(skb, orig_node, NULL); 379 /* skb was consumed */ 380 skb = NULL; 381 382out: 383 kfree_skb(skb); 384 return ret; 385} 386 387/** 388 * batadv_send_skb_via_tt_generic() - send an skb via TT lookup 389 * @bat_priv: the bat priv with all the soft interface information 390 * @skb: payload to send 391 * @packet_type: the batman unicast packet type to use 392 * @packet_subtype: the unicast 4addr packet subtype (only relevant for unicast 393 * 4addr packets) 394 * @dst_hint: can be used to override the destination contained in the skb 395 * @vid: the vid to be used to search the translation table 396 * 397 * Look up the recipient node for the destination address in the ethernet 398 * header via the translation table. Wrap the given skb into a batman-adv 399 * unicast or unicast-4addr header depending on whether BATADV_UNICAST or 400 * BATADV_UNICAST_4ADDR was supplied as packet_type. Then send this frame 401 * to the according destination node. 402 * 403 * Return: NET_XMIT_DROP in case of error or NET_XMIT_SUCCESS otherwise. 404 */ 405int batadv_send_skb_via_tt_generic(struct batadv_priv *bat_priv, 406 struct sk_buff *skb, int packet_type, 407 int packet_subtype, u8 *dst_hint, 408 unsigned short vid) 409{ 410 struct ethhdr *ethhdr = (struct ethhdr *)skb->data; 411 struct batadv_orig_node *orig_node; 412 u8 *src, *dst; 413 int ret; 414 415 src = ethhdr->h_source; 416 dst = ethhdr->h_dest; 417 418 /* if we got an hint! let's send the packet to this client (if any) */ 419 if (dst_hint) { 420 src = NULL; 421 dst = dst_hint; 422 } 423 orig_node = batadv_transtable_search(bat_priv, src, dst, vid); 424 425 ret = batadv_send_skb_unicast(bat_priv, skb, packet_type, 426 packet_subtype, orig_node, vid); 427 428 if (orig_node) 429 batadv_orig_node_put(orig_node); 430 431 return ret; 432} 433 434/** 435 * batadv_send_skb_via_gw() - send an skb via gateway lookup 436 * @bat_priv: the bat priv with all the soft interface information 437 * @skb: payload to send 438 * @vid: the vid to be used to search the translation table 439 * 440 * Look up the currently selected gateway. Wrap the given skb into a batman-adv 441 * unicast header and send this frame to this gateway node. 442 * 443 * Return: NET_XMIT_DROP in case of error or NET_XMIT_SUCCESS otherwise. 444 */ 445int batadv_send_skb_via_gw(struct batadv_priv *bat_priv, struct sk_buff *skb, 446 unsigned short vid) 447{ 448 struct batadv_orig_node *orig_node; 449 int ret; 450 451 orig_node = batadv_gw_get_selected_orig(bat_priv); 452 ret = batadv_send_skb_unicast(bat_priv, skb, BATADV_UNICAST_4ADDR, 453 BATADV_P_DATA, orig_node, vid); 454 455 if (orig_node) 456 batadv_orig_node_put(orig_node); 457 458 return ret; 459} 460 461/** 462 * batadv_forw_packet_free() - free a forwarding packet 463 * @forw_packet: The packet to free 464 * @dropped: whether the packet is freed because is dropped 465 * 466 * This frees a forwarding packet and releases any resources it might 467 * have claimed. 468 */ 469void batadv_forw_packet_free(struct batadv_forw_packet *forw_packet, 470 bool dropped) 471{ 472 if (dropped) 473 kfree_skb(forw_packet->skb); 474 else 475 consume_skb(forw_packet->skb); 476 477 if (forw_packet->if_incoming) 478 batadv_hardif_put(forw_packet->if_incoming); 479 if (forw_packet->if_outgoing) 480 batadv_hardif_put(forw_packet->if_outgoing); 481 if (forw_packet->queue_left) 482 atomic_inc(forw_packet->queue_left); 483 kfree(forw_packet); 484} 485 486/** 487 * batadv_forw_packet_alloc() - allocate a forwarding packet 488 * @if_incoming: The (optional) if_incoming to be grabbed 489 * @if_outgoing: The (optional) if_outgoing to be grabbed 490 * @queue_left: The (optional) queue counter to decrease 491 * @bat_priv: The bat_priv for the mesh of this forw_packet 492 * @skb: The raw packet this forwarding packet shall contain 493 * 494 * Allocates a forwarding packet and tries to get a reference to the 495 * (optional) if_incoming, if_outgoing and queue_left. If queue_left 496 * is NULL then bat_priv is optional, too. 497 * 498 * Return: An allocated forwarding packet on success, NULL otherwise. 499 */ 500struct batadv_forw_packet * 501batadv_forw_packet_alloc(struct batadv_hard_iface *if_incoming, 502 struct batadv_hard_iface *if_outgoing, 503 atomic_t *queue_left, 504 struct batadv_priv *bat_priv, 505 struct sk_buff *skb) 506{ 507 struct batadv_forw_packet *forw_packet; 508 const char *qname; 509 510 if (queue_left && !batadv_atomic_dec_not_zero(queue_left)) { 511 qname = "unknown"; 512 513 if (queue_left == &bat_priv->bcast_queue_left) 514 qname = "bcast"; 515 516 if (queue_left == &bat_priv->batman_queue_left) 517 qname = "batman"; 518 519 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 520 "%s queue is full\n", qname); 521 522 return NULL; 523 } 524 525 forw_packet = kmalloc(sizeof(*forw_packet), GFP_ATOMIC); 526 if (!forw_packet) 527 goto err; 528 529 if (if_incoming) 530 kref_get(&if_incoming->refcount); 531 532 if (if_outgoing) 533 kref_get(&if_outgoing->refcount); 534 535 INIT_HLIST_NODE(&forw_packet->list); 536 INIT_HLIST_NODE(&forw_packet->cleanup_list); 537 forw_packet->skb = skb; 538 forw_packet->queue_left = queue_left; 539 forw_packet->if_incoming = if_incoming; 540 forw_packet->if_outgoing = if_outgoing; 541 forw_packet->num_packets = 0; 542 543 return forw_packet; 544 545err: 546 if (queue_left) 547 atomic_inc(queue_left); 548 549 return NULL; 550} 551 552/** 553 * batadv_forw_packet_was_stolen() - check whether someone stole this packet 554 * @forw_packet: the forwarding packet to check 555 * 556 * This function checks whether the given forwarding packet was claimed by 557 * someone else for free(). 558 * 559 * Return: True if someone stole it, false otherwise. 560 */ 561static bool 562batadv_forw_packet_was_stolen(struct batadv_forw_packet *forw_packet) 563{ 564 return !hlist_unhashed(&forw_packet->cleanup_list); 565} 566 567/** 568 * batadv_forw_packet_steal() - claim a forw_packet for free() 569 * @forw_packet: the forwarding packet to steal 570 * @lock: a key to the store to steal from (e.g. forw_{bat,bcast}_list_lock) 571 * 572 * This function tries to steal a specific forw_packet from global 573 * visibility for the purpose of getting it for free(). That means 574 * the caller is *not* allowed to requeue it afterwards. 575 * 576 * Return: True if stealing was successful. False if someone else stole it 577 * before us. 578 */ 579bool batadv_forw_packet_steal(struct batadv_forw_packet *forw_packet, 580 spinlock_t *lock) 581{ 582 /* did purging routine steal it earlier? */ 583 spin_lock_bh(lock); 584 if (batadv_forw_packet_was_stolen(forw_packet)) { 585 spin_unlock_bh(lock); 586 return false; 587 } 588 589 hlist_del_init(&forw_packet->list); 590 591 /* Just to spot misuse of this function */ 592 hlist_add_fake(&forw_packet->cleanup_list); 593 594 spin_unlock_bh(lock); 595 return true; 596} 597 598/** 599 * batadv_forw_packet_list_steal() - claim a list of forward packets for free() 600 * @forw_list: the to be stolen forward packets 601 * @cleanup_list: a backup pointer, to be able to dispose the packet later 602 * @hard_iface: the interface to steal forward packets from 603 * 604 * This function claims responsibility to free any forw_packet queued on the 605 * given hard_iface. If hard_iface is NULL forwarding packets on all hard 606 * interfaces will be claimed. 607 * 608 * The packets are being moved from the forw_list to the cleanup_list. This 609 * makes it possible for already running threads to notice the claim. 610 */ 611static void 612batadv_forw_packet_list_steal(struct hlist_head *forw_list, 613 struct hlist_head *cleanup_list, 614 const struct batadv_hard_iface *hard_iface) 615{ 616 struct batadv_forw_packet *forw_packet; 617 struct hlist_node *safe_tmp_node; 618 619 hlist_for_each_entry_safe(forw_packet, safe_tmp_node, 620 forw_list, list) { 621 /* if purge_outstanding_packets() was called with an argument 622 * we delete only packets belonging to the given interface 623 */ 624 if (hard_iface && 625 forw_packet->if_incoming != hard_iface && 626 forw_packet->if_outgoing != hard_iface) 627 continue; 628 629 hlist_del(&forw_packet->list); 630 hlist_add_head(&forw_packet->cleanup_list, cleanup_list); 631 } 632} 633 634/** 635 * batadv_forw_packet_list_free() - free a list of forward packets 636 * @head: a list of to be freed forw_packets 637 * 638 * This function cancels the scheduling of any packet in the provided list, 639 * waits for any possibly running packet forwarding thread to finish and 640 * finally, safely frees this forward packet. 641 * 642 * This function might sleep. 643 */ 644static void batadv_forw_packet_list_free(struct hlist_head *head) 645{ 646 struct batadv_forw_packet *forw_packet; 647 struct hlist_node *safe_tmp_node; 648 649 hlist_for_each_entry_safe(forw_packet, safe_tmp_node, head, 650 cleanup_list) { 651 cancel_delayed_work_sync(&forw_packet->delayed_work); 652 653 hlist_del(&forw_packet->cleanup_list); 654 batadv_forw_packet_free(forw_packet, true); 655 } 656} 657 658/** 659 * batadv_forw_packet_queue() - try to queue a forwarding packet 660 * @forw_packet: the forwarding packet to queue 661 * @lock: a key to the store (e.g. forw_{bat,bcast}_list_lock) 662 * @head: the shelve to queue it on (e.g. forw_{bat,bcast}_list) 663 * @send_time: timestamp (jiffies) when the packet is to be sent 664 * 665 * This function tries to (re)queue a forwarding packet. Requeuing 666 * is prevented if the according interface is shutting down 667 * (e.g. if batadv_forw_packet_list_steal() was called for this 668 * packet earlier). 669 * 670 * Calling batadv_forw_packet_queue() after a call to 671 * batadv_forw_packet_steal() is forbidden! 672 * 673 * Caller needs to ensure that forw_packet->delayed_work was initialized. 674 */ 675static void batadv_forw_packet_queue(struct batadv_forw_packet *forw_packet, 676 spinlock_t *lock, struct hlist_head *head, 677 unsigned long send_time) 678{ 679 spin_lock_bh(lock); 680 681 /* did purging routine steal it from us? */ 682 if (batadv_forw_packet_was_stolen(forw_packet)) { 683 /* If you got it for free() without trouble, then 684 * don't get back into the queue after stealing... 685 */ 686 WARN_ONCE(hlist_fake(&forw_packet->cleanup_list), 687 "Requeuing after batadv_forw_packet_steal() not allowed!\n"); 688 689 spin_unlock_bh(lock); 690 return; 691 } 692 693 hlist_del_init(&forw_packet->list); 694 hlist_add_head(&forw_packet->list, head); 695 696 queue_delayed_work(batadv_event_workqueue, 697 &forw_packet->delayed_work, 698 send_time - jiffies); 699 spin_unlock_bh(lock); 700} 701 702/** 703 * batadv_forw_packet_bcast_queue() - try to queue a broadcast packet 704 * @bat_priv: the bat priv with all the soft interface information 705 * @forw_packet: the forwarding packet to queue 706 * @send_time: timestamp (jiffies) when the packet is to be sent 707 * 708 * This function tries to (re)queue a broadcast packet. 709 * 710 * Caller needs to ensure that forw_packet->delayed_work was initialized. 711 */ 712static void 713batadv_forw_packet_bcast_queue(struct batadv_priv *bat_priv, 714 struct batadv_forw_packet *forw_packet, 715 unsigned long send_time) 716{ 717 batadv_forw_packet_queue(forw_packet, &bat_priv->forw_bcast_list_lock, 718 &bat_priv->forw_bcast_list, send_time); 719} 720 721/** 722 * batadv_forw_packet_ogmv1_queue() - try to queue an OGMv1 packet 723 * @bat_priv: the bat priv with all the soft interface information 724 * @forw_packet: the forwarding packet to queue 725 * @send_time: timestamp (jiffies) when the packet is to be sent 726 * 727 * This function tries to (re)queue an OGMv1 packet. 728 * 729 * Caller needs to ensure that forw_packet->delayed_work was initialized. 730 */ 731void batadv_forw_packet_ogmv1_queue(struct batadv_priv *bat_priv, 732 struct batadv_forw_packet *forw_packet, 733 unsigned long send_time) 734{ 735 batadv_forw_packet_queue(forw_packet, &bat_priv->forw_bat_list_lock, 736 &bat_priv->forw_bat_list, send_time); 737} 738 739/** 740 * batadv_add_bcast_packet_to_list() - queue broadcast packet for multiple sends 741 * @bat_priv: the bat priv with all the soft interface information 742 * @skb: broadcast packet to add 743 * @delay: number of jiffies to wait before sending 744 * @own_packet: true if it is a self-generated broadcast packet 745 * 746 * add a broadcast packet to the queue and setup timers. broadcast packets 747 * are sent multiple times to increase probability for being received. 748 * 749 * The skb is not consumed, so the caller should make sure that the 750 * skb is freed. 751 * 752 * Return: NETDEV_TX_OK on success and NETDEV_TX_BUSY on errors. 753 */ 754int batadv_add_bcast_packet_to_list(struct batadv_priv *bat_priv, 755 const struct sk_buff *skb, 756 unsigned long delay, 757 bool own_packet) 758{ 759 struct batadv_hard_iface *primary_if; 760 struct batadv_forw_packet *forw_packet; 761 struct batadv_bcast_packet *bcast_packet; 762 struct sk_buff *newskb; 763 764 primary_if = batadv_primary_if_get_selected(bat_priv); 765 if (!primary_if) 766 goto err; 767 768 newskb = skb_copy(skb, GFP_ATOMIC); 769 if (!newskb) { 770 batadv_hardif_put(primary_if); 771 goto err; 772 } 773 774 forw_packet = batadv_forw_packet_alloc(primary_if, NULL, 775 &bat_priv->bcast_queue_left, 776 bat_priv, newskb); 777 batadv_hardif_put(primary_if); 778 if (!forw_packet) 779 goto err_packet_free; 780 781 /* as we have a copy now, it is safe to decrease the TTL */ 782 bcast_packet = (struct batadv_bcast_packet *)newskb->data; 783 bcast_packet->ttl--; 784 785 forw_packet->own = own_packet; 786 787 INIT_DELAYED_WORK(&forw_packet->delayed_work, 788 batadv_send_outstanding_bcast_packet); 789 790 batadv_forw_packet_bcast_queue(bat_priv, forw_packet, jiffies + delay); 791 return NETDEV_TX_OK; 792 793err_packet_free: 794 kfree_skb(newskb); 795err: 796 return NETDEV_TX_BUSY; 797} 798 799/** 800 * batadv_forw_packet_bcasts_left() - check if a retransmission is necessary 801 * @forw_packet: the forwarding packet to check 802 * @hard_iface: the interface to check on 803 * 804 * Checks whether a given packet has any (re)transmissions left on the provided 805 * interface. 806 * 807 * hard_iface may be NULL: In that case the number of transmissions this skb had 808 * so far is compared with the maximum amount of retransmissions independent of 809 * any interface instead. 810 * 811 * Return: True if (re)transmissions are left, false otherwise. 812 */ 813static bool 814batadv_forw_packet_bcasts_left(struct batadv_forw_packet *forw_packet, 815 struct batadv_hard_iface *hard_iface) 816{ 817 unsigned int max; 818 819 if (hard_iface) 820 max = hard_iface->num_bcasts; 821 else 822 max = BATADV_NUM_BCASTS_MAX; 823 824 return BATADV_SKB_CB(forw_packet->skb)->num_bcasts < max; 825} 826 827/** 828 * batadv_forw_packet_bcasts_inc() - increment retransmission counter of a 829 * packet 830 * @forw_packet: the packet to increase the counter for 831 */ 832static void 833batadv_forw_packet_bcasts_inc(struct batadv_forw_packet *forw_packet) 834{ 835 BATADV_SKB_CB(forw_packet->skb)->num_bcasts++; 836} 837 838/** 839 * batadv_forw_packet_is_rebroadcast() - check packet for previous transmissions 840 * @forw_packet: the packet to check 841 * 842 * Return: True if this packet was transmitted before, false otherwise. 843 */ 844bool batadv_forw_packet_is_rebroadcast(struct batadv_forw_packet *forw_packet) 845{ 846 return BATADV_SKB_CB(forw_packet->skb)->num_bcasts > 0; 847} 848 849static void batadv_send_outstanding_bcast_packet(struct work_struct *work) 850{ 851 struct batadv_hard_iface *hard_iface; 852 struct batadv_hardif_neigh_node *neigh_node; 853 struct delayed_work *delayed_work; 854 struct batadv_forw_packet *forw_packet; 855 struct batadv_bcast_packet *bcast_packet; 856 struct sk_buff *skb1; 857 struct net_device *soft_iface; 858 struct batadv_priv *bat_priv; 859 unsigned long send_time = jiffies + msecs_to_jiffies(5); 860 bool dropped = false; 861 u8 *neigh_addr; 862 u8 *orig_neigh; 863 int ret = 0; 864 865 delayed_work = to_delayed_work(work); 866 forw_packet = container_of(delayed_work, struct batadv_forw_packet, 867 delayed_work); 868 soft_iface = forw_packet->if_incoming->soft_iface; 869 bat_priv = netdev_priv(soft_iface); 870 871 if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_DEACTIVATING) { 872 dropped = true; 873 goto out; 874 } 875 876 if (batadv_dat_drop_broadcast_packet(bat_priv, forw_packet)) { 877 dropped = true; 878 goto out; 879 } 880 881 bcast_packet = (struct batadv_bcast_packet *)forw_packet->skb->data; 882 883 /* rebroadcast packet */ 884 rcu_read_lock(); 885 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { 886 if (hard_iface->soft_iface != soft_iface) 887 continue; 888 889 if (!batadv_forw_packet_bcasts_left(forw_packet, hard_iface)) 890 continue; 891 892 if (forw_packet->own) { 893 neigh_node = NULL; 894 } else { 895 neigh_addr = eth_hdr(forw_packet->skb)->h_source; 896 neigh_node = batadv_hardif_neigh_get(hard_iface, 897 neigh_addr); 898 } 899 900 orig_neigh = neigh_node ? neigh_node->orig : NULL; 901 902 ret = batadv_hardif_no_broadcast(hard_iface, bcast_packet->orig, 903 orig_neigh); 904 905 if (ret) { 906 char *type; 907 908 switch (ret) { 909 case BATADV_HARDIF_BCAST_NORECIPIENT: 910 type = "no neighbor"; 911 break; 912 case BATADV_HARDIF_BCAST_DUPFWD: 913 type = "single neighbor is source"; 914 break; 915 case BATADV_HARDIF_BCAST_DUPORIG: 916 type = "single neighbor is originator"; 917 break; 918 default: 919 type = "unknown"; 920 } 921 922 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "BCAST packet from orig %pM on %s suppressed: %s\n", 923 bcast_packet->orig, 924 hard_iface->net_dev->name, type); 925 926 if (neigh_node) 927 batadv_hardif_neigh_put(neigh_node); 928 929 continue; 930 } 931 932 if (neigh_node) 933 batadv_hardif_neigh_put(neigh_node); 934 935 if (!kref_get_unless_zero(&hard_iface->refcount)) 936 continue; 937 938 /* send a copy of the saved skb */ 939 skb1 = skb_clone(forw_packet->skb, GFP_ATOMIC); 940 if (skb1) 941 batadv_send_broadcast_skb(skb1, hard_iface); 942 943 batadv_hardif_put(hard_iface); 944 } 945 rcu_read_unlock(); 946 947 batadv_forw_packet_bcasts_inc(forw_packet); 948 949 /* if we still have some more bcasts to send */ 950 if (batadv_forw_packet_bcasts_left(forw_packet, NULL)) { 951 batadv_forw_packet_bcast_queue(bat_priv, forw_packet, 952 send_time); 953 return; 954 } 955 956out: 957 /* do we get something for free()? */ 958 if (batadv_forw_packet_steal(forw_packet, 959 &bat_priv->forw_bcast_list_lock)) 960 batadv_forw_packet_free(forw_packet, dropped); 961} 962 963/** 964 * batadv_purge_outstanding_packets() - stop/purge scheduled bcast/OGMv1 packets 965 * @bat_priv: the bat priv with all the soft interface information 966 * @hard_iface: the hard interface to cancel and purge bcast/ogm packets on 967 * 968 * This method cancels and purges any broadcast and OGMv1 packet on the given 969 * hard_iface. If hard_iface is NULL, broadcast and OGMv1 packets on all hard 970 * interfaces will be canceled and purged. 971 * 972 * This function might sleep. 973 */ 974void 975batadv_purge_outstanding_packets(struct batadv_priv *bat_priv, 976 const struct batadv_hard_iface *hard_iface) 977{ 978 struct hlist_head head = HLIST_HEAD_INIT; 979 980 if (hard_iface) 981 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 982 "%s(): %s\n", 983 __func__, hard_iface->net_dev->name); 984 else 985 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 986 "%s()\n", __func__); 987 988 /* claim bcast list for free() */ 989 spin_lock_bh(&bat_priv->forw_bcast_list_lock); 990 batadv_forw_packet_list_steal(&bat_priv->forw_bcast_list, &head, 991 hard_iface); 992 spin_unlock_bh(&bat_priv->forw_bcast_list_lock); 993 994 /* claim batman packet list for free() */ 995 spin_lock_bh(&bat_priv->forw_bat_list_lock); 996 batadv_forw_packet_list_steal(&bat_priv->forw_bat_list, &head, 997 hard_iface); 998 spin_unlock_bh(&bat_priv->forw_bat_list_lock); 999 1000 /* then cancel or wait for packet workers to finish and free */ 1001 batadv_forw_packet_list_free(&head); 1002} 1003