net/batman-adv/send.c

   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 "distributed-arp-table.h"
  22 #include "send.h"
  23 #include "routing.h"
  24 #include "translation-table.h"
  25 #include "soft-interface.h"
  26 #include "hard-interface.h"
  27 #include "gateway_common.h"
  28 #include "gateway_client.h"
  29 #include "originator.h"
  30 #include "network-coding.h"
  31 #include "fragmentation.h"
  32
  33 static void batadv_send_outstanding_bcast_packet(struct work_struct *work);
  34
  35 /* send out an already prepared packet to the given address via the
  36  * specified batman interface
  37  */
  38 int batadv_send_skb_packet(struct sk_buff *skb,
  39                            struct batadv_hard_iface *hard_iface,
  40                            const uint8_t *dst_addr)
  41 {
  42         struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
  43         struct ethhdr *ethhdr;
  44
  45         if (hard_iface->if_status != BATADV_IF_ACTIVE)
  46                 goto send_skb_err;
  47
  48         if (unlikely(!hard_iface->net_dev))
  49                 goto send_skb_err;
  50
  51         if (!(hard_iface->net_dev->flags & IFF_UP)) {
  52                 pr_warn("Interface %s is not up - can't send packet via that interface!\n",
  53                         hard_iface->net_dev->name);
  54                 goto send_skb_err;
  55         }
  56
  57         /* push to the ethernet header. */
  58         if (batadv_skb_head_push(skb, ETH_HLEN) < 0)
  59                 goto send_skb_err;
  60
  61         skb_reset_mac_header(skb);
  62
  63         ethhdr = eth_hdr(skb);
  64         memcpy(ethhdr->h_source, hard_iface->net_dev->dev_addr, ETH_ALEN);
  65         memcpy(ethhdr->h_dest, dst_addr, ETH_ALEN);
  66         ethhdr->h_proto = htons(ETH_P_BATMAN);
  67
  68         skb_set_network_header(skb, ETH_HLEN);
  69         skb->protocol = htons(ETH_P_BATMAN);
  70
  71         skb->dev = hard_iface->net_dev;
  72
  73         /* Save a clone of the skb to use when decoding coded packets */
  74         batadv_nc_skb_store_for_decoding(bat_priv, skb);
  75
  76         /* dev_queue_xmit() returns a negative result on error.  However on
  77          * congestion and traffic shaping, it drops and returns NET_XMIT_DROP
  78          * (which is > 0). This will not be treated as an error.
  79          */
  80         return dev_queue_xmit(skb);
  81 send_skb_err:
  82         kfree_skb(skb);
  83         return NET_XMIT_DROP;
  84 }
  85
  86 /**
  87  * batadv_send_skb_to_orig - Lookup next-hop and transmit skb.
  88  * @skb: Packet to be transmitted.
  89  * @orig_node: Final destination of the packet.
  90  * @recv_if: Interface used when receiving the packet (can be NULL).
  91  *
  92  * Looks up the best next-hop towards the passed originator and passes the
  93  * skb on for preparation of MAC header. If the packet originated from this
  94  * host, NULL can be passed as recv_if and no interface alternating is
  95  * attempted.
  96  *
  97  * Returns NET_XMIT_SUCCESS on success, NET_XMIT_DROP on failure, or
  98  * NET_XMIT_POLICED if the skb is buffered for later transmit.
  99  */
 100 int batadv_send_skb_to_orig(struct sk_buff *skb,
 101                             struct batadv_orig_node *orig_node,
 102                             struct batadv_hard_iface *recv_if)
 103 {
 104         struct batadv_priv *bat_priv = orig_node->bat_priv;
 105         struct batadv_neigh_node *neigh_node;
 106         int ret = NET_XMIT_DROP;
 107
 108         /* batadv_find_router() increases neigh_nodes refcount if found. */
 109         neigh_node = batadv_find_router(bat_priv, orig_node, recv_if);
 110         if (!neigh_node)
 111                 goto out;
 112
 113         /* Check if the skb is too large to send in one piece and fragment
 114          * it if needed.
 115          */
 116         if (atomic_read(&bat_priv->fragmentation) &&
 117             skb->len > neigh_node->if_incoming->net_dev->mtu) {
 118                 /* Fragment and send packet. */
 119                 if (batadv_frag_send_packet(skb, orig_node, neigh_node))
 120                         ret = NET_XMIT_SUCCESS;
 121
 122                 goto out;
 123         }
 124
 125         /* try to network code the packet, if it is received on an interface
 126          * (i.e. being forwarded). If the packet originates from this node or if
 127          * network coding fails, then send the packet as usual.
 128          */
 129         if (recv_if && batadv_nc_skb_forward(skb, neigh_node)) {
 130                 ret = NET_XMIT_POLICED;
 131         } else {
 132                 batadv_send_skb_packet(skb, neigh_node->if_incoming,
 133                                        neigh_node->addr);
 134                 ret = NET_XMIT_SUCCESS;
 135         }
 136
 137 out:
 138         if (neigh_node)
 139                 batadv_neigh_node_free_ref(neigh_node);
 140
 141         return ret;
 142 }
 143
 144 /**
 145  * batadv_send_skb_push_fill_unicast - extend the buffer and initialize the
 146  *  common fields for unicast packets
 147  * @skb: the skb carrying the unicast header to initialize
 148  * @hdr_size: amount of bytes to push at the beginning of the skb
 149  * @orig_node: the destination node
 150  *
 151  * Returns false if the buffer extension was not possible or true otherwise.
 152  */
 153 static bool
 154 batadv_send_skb_push_fill_unicast(struct sk_buff *skb, int hdr_size,
 155                                   struct batadv_orig_node *orig_node)
 156 {
 157         struct batadv_unicast_packet *unicast_packet;
 158         uint8_t ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);
 159
 160         if (batadv_skb_head_push(skb, hdr_size) < 0)
 161                 return false;
 162
 163         unicast_packet = (struct batadv_unicast_packet *)skb->data;
 164         unicast_packet->header.version = BATADV_COMPAT_VERSION;
 165         /* batman packet type: unicast */
 166         unicast_packet->header.packet_type = BATADV_UNICAST;
 167         /* set unicast ttl */
 168         unicast_packet->header.ttl = BATADV_TTL;
 169         /* copy the destination for faster routing */
 170         memcpy(unicast_packet->dest, orig_node->orig, ETH_ALEN);
 171         /* set the destination tt version number */
 172         unicast_packet->ttvn = ttvn;
 173
 174         return true;
 175 }
 176
 177 /**
 178  * batadv_send_skb_prepare_unicast - encapsulate an skb with a unicast header
 179  * @skb: the skb containing the payload to encapsulate
 180  * @orig_node: the destination node
 181  *
 182  * Returns false if the payload could not be encapsulated or true otherwise.
 183  */
 184 static bool batadv_send_skb_prepare_unicast(struct sk_buff *skb,
 185                                             struct batadv_orig_node *orig_node)
 186 {
 187         size_t uni_size = sizeof(struct batadv_unicast_packet);
 188
 189         return batadv_send_skb_push_fill_unicast(skb, uni_size, orig_node);
 190 }
 191
 192 /**
 193  * batadv_send_skb_prepare_unicast_4addr - encapsulate an skb with a
 194  *  unicast 4addr header
 195  * @bat_priv: the bat priv with all the soft interface information
 196  * @skb: the skb containing the payload to encapsulate
 197  * @orig_node: the destination node
 198  * @packet_subtype: the unicast 4addr packet subtype to use
 199  *
 200  * Returns false if the payload could not be encapsulated or true otherwise.
 201  */
 202 bool batadv_send_skb_prepare_unicast_4addr(struct batadv_priv *bat_priv,
 203                                            struct sk_buff *skb,
 204                                            struct batadv_orig_node *orig,
 205                                            int packet_subtype)
 206 {
 207         struct batadv_hard_iface *primary_if;
 208         struct batadv_unicast_4addr_packet *uc_4addr_packet;
 209         bool ret = false;
 210
 211         primary_if = batadv_primary_if_get_selected(bat_priv);
 212         if (!primary_if)
 213                 goto out;
 214
 215         /* Pull the header space and fill the unicast_packet substructure.
 216          * We can do that because the first member of the uc_4addr_packet
 217          * is of type struct unicast_packet
 218          */
 219         if (!batadv_send_skb_push_fill_unicast(skb, sizeof(*uc_4addr_packet),
 220                                                orig))
 221                 goto out;
 222
 223         uc_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data;
 224         uc_4addr_packet->u.header.packet_type = BATADV_UNICAST_4ADDR;
 225         memcpy(uc_4addr_packet->src, primary_if->net_dev->dev_addr, ETH_ALEN);
 226         uc_4addr_packet->subtype = packet_subtype;
 227         uc_4addr_packet->reserved = 0;
 228
 229         ret = true;
 230 out:
 231         if (primary_if)
 232                 batadv_hardif_free_ref(primary_if);
 233         return ret;
 234 }
 235
 236 /**
 237  * batadv_send_generic_unicast_skb - send an skb as unicast
 238  * @bat_priv: the bat priv with all the soft interface information
 239  * @skb: payload to send
 240  * @packet_type: the batman unicast packet type to use
 241  * @packet_subtype: the unicast 4addr packet subtype (only relevant for unicast
 242  *  4addr packets)
 243  *
 244  * Returns 1 in case of error or 0 otherwise.
 245  */
 246 int batadv_send_skb_generic_unicast(struct batadv_priv *bat_priv,
 247                                     struct sk_buff *skb, int packet_type,
 248                                     int packet_subtype)
 249 {
 250         struct ethhdr *ethhdr = (struct ethhdr *)skb->data;
 251         struct batadv_unicast_packet *unicast_packet;
 252         struct batadv_orig_node *orig_node;
 253         int ret = NET_RX_DROP;
 254
 255         /* get routing information */
 256         if (is_multicast_ether_addr(ethhdr->h_dest))
 257                 orig_node = batadv_gw_get_selected_orig(bat_priv);
 258         else
 259                 /* check for tt host - increases orig_node refcount.
 260                  * returns NULL in case of AP isolation
 261                  */
 262                 orig_node = batadv_transtable_search(bat_priv, ethhdr->h_source,
 263                                                      ethhdr->h_dest);
 264
 265         if (!orig_node)
 266                 goto out;
 267
 268         switch (packet_type) {
 269         case BATADV_UNICAST:
 270                 if (!batadv_send_skb_prepare_unicast(skb, orig_node))
 271                         goto out;
 272                 break;
 273         case BATADV_UNICAST_4ADDR:
 274                 if (!batadv_send_skb_prepare_unicast_4addr(bat_priv, skb,
 275                                                            orig_node,
 276                                                            packet_subtype))
 277                         goto out;
 278                 break;
 279         default:
 280                 /* this function supports UNICAST and UNICAST_4ADDR only. It
 281                  * should never be invoked with any other packet type
 282                  */
 283                 goto out;
 284         }
 285
 286         unicast_packet = (struct batadv_unicast_packet *)skb->data;
 287
 288         /* inform the destination node that we are still missing a correct route
 289          * for this client. The destination will receive this packet and will
 290          * try to reroute it because the ttvn contained in the header is less
 291          * than the current one
 292          */
 293         if (batadv_tt_global_client_is_roaming(bat_priv, ethhdr->h_dest))
 294                 unicast_packet->ttvn = unicast_packet->ttvn - 1;
 295
 296         if (batadv_send_skb_to_orig(skb, orig_node, NULL) != NET_XMIT_DROP)
 297                 ret = 0;
 298
 299 out:
 300         if (orig_node)
 301                 batadv_orig_node_free_ref(orig_node);
 302         if (ret == NET_RX_DROP)
 303                 kfree_skb(skb);
 304         return ret;
 305 }
 306
 307 void batadv_schedule_bat_ogm(struct batadv_hard_iface *hard_iface)
 308 {
 309         struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
 310
 311         if ((hard_iface->if_status == BATADV_IF_NOT_IN_USE) ||
 312             (hard_iface->if_status == BATADV_IF_TO_BE_REMOVED))
 313                 return;
 314
 315         /* the interface gets activated here to avoid race conditions between
 316          * the moment of activating the interface in
 317          * hardif_activate_interface() where the originator mac is set and
 318          * outdated packets (especially uninitialized mac addresses) in the
 319          * packet queue
 320          */
 321         if (hard_iface->if_status == BATADV_IF_TO_BE_ACTIVATED)
 322                 hard_iface->if_status = BATADV_IF_ACTIVE;
 323
 324         bat_priv->bat_algo_ops->bat_ogm_schedule(hard_iface);
 325 }
 326
 327 static void batadv_forw_packet_free(struct batadv_forw_packet *forw_packet)
 328 {
 329         if (forw_packet->skb)
 330                 kfree_skb(forw_packet->skb);
 331         if (forw_packet->if_incoming)
 332                 batadv_hardif_free_ref(forw_packet->if_incoming);
 333         kfree(forw_packet);
 334 }
 335
 336 static void
 337 _batadv_add_bcast_packet_to_list(struct batadv_priv *bat_priv,
 338                                  struct batadv_forw_packet *forw_packet,
 339                                  unsigned long send_time)
 340 {
 341         /* add new packet to packet list */
 342         spin_lock_bh(&bat_priv->forw_bcast_list_lock);
 343         hlist_add_head(&forw_packet->list, &bat_priv->forw_bcast_list);
 344         spin_unlock_bh(&bat_priv->forw_bcast_list_lock);
 345
 346         /* start timer for this packet */
 347         queue_delayed_work(batadv_event_workqueue, &forw_packet->delayed_work,
 348                            send_time);
 349 }
 350
 351 /* add a broadcast packet to the queue and setup timers. broadcast packets
 352  * are sent multiple times to increase probability for being received.
 353  *
 354  * This function returns NETDEV_TX_OK on success and NETDEV_TX_BUSY on
 355  * errors.
 356  *
 357  * The skb is not consumed, so the caller should make sure that the
 358  * skb is freed.
 359  */
 360 int batadv_add_bcast_packet_to_list(struct batadv_priv *bat_priv,
 361                                     const struct sk_buff *skb,
 362                                     unsigned long delay)
 363 {
 364         struct batadv_hard_iface *primary_if = NULL;
 365         struct batadv_forw_packet *forw_packet;
 366         struct batadv_bcast_packet *bcast_packet;
 367         struct sk_buff *newskb;
 368
 369         if (!batadv_atomic_dec_not_zero(&bat_priv->bcast_queue_left)) {
 370                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 371                            "bcast packet queue full\n");
 372                 goto out;
 373         }
 374
 375         primary_if = batadv_primary_if_get_selected(bat_priv);
 376         if (!primary_if)
 377                 goto out_and_inc;
 378
 379         forw_packet = kmalloc(sizeof(*forw_packet), GFP_ATOMIC);
 380
 381         if (!forw_packet)
 382                 goto out_and_inc;
 383
 384         newskb = skb_copy(skb, GFP_ATOMIC);
 385         if (!newskb)
 386                 goto packet_free;
 387
 388         /* as we have a copy now, it is safe to decrease the TTL */
 389         bcast_packet = (struct batadv_bcast_packet *)newskb->data;
 390         bcast_packet->header.ttl--;
 391
 392         skb_reset_mac_header(newskb);
 393
 394         forw_packet->skb = newskb;
 395         forw_packet->if_incoming = primary_if;
 396
 397         /* how often did we send the bcast packet ? */
 398         forw_packet->num_packets = 0;
 399
 400         INIT_DELAYED_WORK(&forw_packet->delayed_work,
 401                           batadv_send_outstanding_bcast_packet);
 402
 403         _batadv_add_bcast_packet_to_list(bat_priv, forw_packet, delay);
 404         return NETDEV_TX_OK;
 405
 406 packet_free:
 407         kfree(forw_packet);
 408 out_and_inc:
 409         atomic_inc(&bat_priv->bcast_queue_left);
 410 out:
 411         if (primary_if)
 412                 batadv_hardif_free_ref(primary_if);
 413         return NETDEV_TX_BUSY;
 414 }
 415
 416 static void batadv_send_outstanding_bcast_packet(struct work_struct *work)
 417 {
 418         struct batadv_hard_iface *hard_iface;
 419         struct delayed_work *delayed_work;
 420         struct batadv_forw_packet *forw_packet;
 421         struct sk_buff *skb1;
 422         struct net_device *soft_iface;
 423         struct batadv_priv *bat_priv;
 424
 425         delayed_work = container_of(work, struct delayed_work, work);
 426         forw_packet = container_of(delayed_work, struct batadv_forw_packet,
 427                                    delayed_work);
 428         soft_iface = forw_packet->if_incoming->soft_iface;
 429         bat_priv = netdev_priv(soft_iface);
 430
 431         spin_lock_bh(&bat_priv->forw_bcast_list_lock);
 432         hlist_del(&forw_packet->list);
 433         spin_unlock_bh(&bat_priv->forw_bcast_list_lock);
 434
 435         if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_DEACTIVATING)
 436                 goto out;
 437
 438         if (batadv_dat_drop_broadcast_packet(bat_priv, forw_packet))
 439                 goto out;
 440
 441         /* rebroadcast packet */
 442         rcu_read_lock();
 443         list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
 444                 if (hard_iface->soft_iface != soft_iface)
 445                         continue;
 446
 447                 if (forw_packet->num_packets >= hard_iface->num_bcasts)
 448                         continue;
 449
 450                 /* send a copy of the saved skb */
 451                 skb1 = skb_clone(forw_packet->skb, GFP_ATOMIC);
 452                 if (skb1)
 453                         batadv_send_skb_packet(skb1, hard_iface,
 454                                                batadv_broadcast_addr);
 455         }
 456         rcu_read_unlock();
 457
 458         forw_packet->num_packets++;
 459
 460         /* if we still have some more bcasts to send */
 461         if (forw_packet->num_packets < BATADV_NUM_BCASTS_MAX) {
 462                 _batadv_add_bcast_packet_to_list(bat_priv, forw_packet,
 463                                                  msecs_to_jiffies(5));
 464                 return;
 465         }
 466
 467 out:
 468         batadv_forw_packet_free(forw_packet);
 469         atomic_inc(&bat_priv->bcast_queue_left);
 470 }
 471
 472 void batadv_send_outstanding_bat_ogm_packet(struct work_struct *work)
 473 {
 474         struct delayed_work *delayed_work;
 475         struct batadv_forw_packet *forw_packet;
 476         struct batadv_priv *bat_priv;
 477
 478         delayed_work = container_of(work, struct delayed_work, work);
 479         forw_packet = container_of(delayed_work, struct batadv_forw_packet,
 480                                    delayed_work);
 481         bat_priv = netdev_priv(forw_packet->if_incoming->soft_iface);
 482         spin_lock_bh(&bat_priv->forw_bat_list_lock);
 483         hlist_del(&forw_packet->list);
 484         spin_unlock_bh(&bat_priv->forw_bat_list_lock);
 485
 486         if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_DEACTIVATING)
 487                 goto out;
 488
 489         bat_priv->bat_algo_ops->bat_ogm_emit(forw_packet);
 490
 491         /* we have to have at least one packet in the queue
 492          * to determine the queues wake up time unless we are
 493          * shutting down
 494          */
 495         if (forw_packet->own)
 496                 batadv_schedule_bat_ogm(forw_packet->if_incoming);
 497
 498 out:
 499         /* don't count own packet */
 500         if (!forw_packet->own)
 501                 atomic_inc(&bat_priv->batman_queue_left);
 502
 503         batadv_forw_packet_free(forw_packet);
 504 }
 505
 506 void
 507 batadv_purge_outstanding_packets(struct batadv_priv *bat_priv,
 508                                  const struct batadv_hard_iface *hard_iface)
 509 {
 510         struct batadv_forw_packet *forw_packet;
 511         struct hlist_node *safe_tmp_node;
 512         bool pending;
 513
 514         if (hard_iface)
 515                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 516                            "purge_outstanding_packets(): %s\n",
 517                            hard_iface->net_dev->name);
 518         else
 519                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 520                            "purge_outstanding_packets()\n");
 521
 522         /* free bcast list */
 523         spin_lock_bh(&bat_priv->forw_bcast_list_lock);
 524         hlist_for_each_entry_safe(forw_packet, safe_tmp_node,
 525                                   &bat_priv->forw_bcast_list, list) {
 526                 /* if purge_outstanding_packets() was called with an argument
 527                  * we delete only packets belonging to the given interface
 528                  */
 529                 if ((hard_iface) &&
 530                     (forw_packet->if_incoming != hard_iface))
 531                         continue;
 532
 533                 spin_unlock_bh(&bat_priv->forw_bcast_list_lock);
 534
 535                 /* batadv_send_outstanding_bcast_packet() will lock the list to
 536                  * delete the item from the list
 537                  */
 538                 pending = cancel_delayed_work_sync(&forw_packet->delayed_work);
 539                 spin_lock_bh(&bat_priv->forw_bcast_list_lock);
 540
 541                 if (pending) {
 542                         hlist_del(&forw_packet->list);
 543                         batadv_forw_packet_free(forw_packet);
 544                 }
 545         }
 546         spin_unlock_bh(&bat_priv->forw_bcast_list_lock);
 547
 548         /* free batman packet list */
 549         spin_lock_bh(&bat_priv->forw_bat_list_lock);
 550         hlist_for_each_entry_safe(forw_packet, safe_tmp_node,
 551                                   &bat_priv->forw_bat_list, list) {
 552                 /* if purge_outstanding_packets() was called with an argument
 553                  * we delete only packets belonging to the given interface
 554                  */
 555                 if ((hard_iface) &&
 556                     (forw_packet->if_incoming != hard_iface))
 557                         continue;
 558
 559                 spin_unlock_bh(&bat_priv->forw_bat_list_lock);
 560
 561                 /* send_outstanding_bat_packet() will lock the list to
 562                  * delete the item from the list
 563                  */
 564                 pending = cancel_delayed_work_sync(&forw_packet->delayed_work);
 565                 spin_lock_bh(&bat_priv->forw_bat_list_lock);
 566
 567                 if (pending) {
 568                         hlist_del(&forw_packet->list);
 569                         batadv_forw_packet_free(forw_packet);
 570                 }
 571         }
 572         spin_unlock_bh(&bat_priv->forw_bat_list_lock);
 573 }