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