batman-adv: agglomerate all batman iv ogm sending functions in the batman iv file

In the process the batman iv OGM aggregation code could be merged
into the batman iv code base which makes the separate aggregation
files superfluous.

Signed-off-by: Marek Lindner <lindner_marek@yahoo.de>

1 files changed, 19 insertions, 278 deletions

diff --git a/net/batman-adv/send.c b/net/batman-adv/send.c
index 40a5fcd67136..8a684eb738ad 100644
--- a/net/batman-adv/send.c
+++ b/net/batman-adv/send.c
@@ -26,33 +26,12 @@
 #include "soft-interface.h"
 #include "hard-interface.h"
 #include "vis.h"
-#include "aggregation.h"
 #include "gateway_common.h"
 #include "originator.h"
+#include "bat_ogm.h"
 
 static void send_outstanding_bcast_packet(struct work_struct *work);
 
-/* apply hop penalty for a normal link */
-static uint8_t hop_penalty(uint8_t tq, const struct bat_priv *bat_priv)
-{
-        int hop_penalty = atomic_read(&bat_priv->hop_penalty);
-        return (tq * (TQ_MAX_VALUE - hop_penalty)) / (TQ_MAX_VALUE);
-}
-
-/* when do we schedule our own packet to be sent */
-static unsigned long own_send_time(const struct bat_priv *bat_priv)
-{
-        return jiffies + msecs_to_jiffies(
-                   atomic_read(&bat_priv->orig_interval) -
-                   JITTER + (random32() % 2*JITTER));
-}
-
-/* when do we schedule a forwarded packet to be sent */
-static unsigned long forward_send_time(void)
-{
-        return jiffies + msecs_to_jiffies(random32() % (JITTER/2));
-}
-
 /* send out an already prepared packet to the given address via the
  * specified batman interface */
 int send_skb_packet(struct sk_buff *skb, struct hard_iface *hard_iface,
@@ -99,133 +78,6 @@ send_skb_err:
         return NET_XMIT_DROP;
 }
 
-/* Send a packet to a given interface */
-static void send_packet_to_if(struct forw_packet *forw_packet,
-                              struct hard_iface *hard_iface)
-{
-        struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
-        char *fwd_str;
-        uint8_t packet_num;
-        int16_t buff_pos;
-        struct batman_ogm_packet *batman_ogm_packet;
-        struct sk_buff *skb;
-
-        if (hard_iface->if_status != IF_ACTIVE)
-                return;
-
-        packet_num = 0;
-        buff_pos = 0;
-        batman_ogm_packet = (struct batman_ogm_packet *)forw_packet->skb->data;
-
-        /* adjust all flags and log packets */
-        while (aggregated_packet(buff_pos,
-                                 forw_packet->packet_len,
-                                 batman_ogm_packet->tt_num_changes)) {
-
-                /* we might have aggregated direct link packets with an
-                 * ordinary base packet */
-                if ((forw_packet->direct_link_flags & (1 << packet_num)) &&
-                    (forw_packet->if_incoming == hard_iface))
-                        batman_ogm_packet->flags |= DIRECTLINK;
-                else
-                        batman_ogm_packet->flags &= ~DIRECTLINK;
-
-                fwd_str = (packet_num > 0 ? "Forwarding" : (forw_packet->own ?
-                                                            "Sending own" :
-                                                            "Forwarding"));
-                bat_dbg(DBG_BATMAN, bat_priv,
-                        "%s %spacket (originator %pM, seqno %d, TQ %d, TTL %d,"
-                        " IDF %s, ttvn %d) on interface %s [%pM]\n",
-                        fwd_str, (packet_num > 0 ? "aggregated " : ""),
-                        batman_ogm_packet->orig,
-                        ntohl(batman_ogm_packet->seqno),
-                        batman_ogm_packet->tq, batman_ogm_packet->ttl,
-                        (batman_ogm_packet->flags & DIRECTLINK ?
-                         "on" : "off"),
-                        batman_ogm_packet->ttvn, hard_iface->net_dev->name,
-                        hard_iface->net_dev->dev_addr);
-
-                buff_pos += BATMAN_OGM_LEN +
-                                tt_len(batman_ogm_packet->tt_num_changes);
-                packet_num++;
-                batman_ogm_packet = (struct batman_ogm_packet *)
-                                        (forw_packet->skb->data + buff_pos);
-        }
-
-        /* create clone because function is called more than once */
-        skb = skb_clone(forw_packet->skb, GFP_ATOMIC);
-        if (skb)
-                send_skb_packet(skb, hard_iface, broadcast_addr);
-}
-
-/* send a batman packet */
-static void send_packet(struct forw_packet *forw_packet)
-{
-        struct hard_iface *hard_iface;
-        struct net_device *soft_iface;
-        struct bat_priv *bat_priv;
-        struct hard_iface *primary_if = NULL;
-        struct batman_ogm_packet *batman_ogm_packet =
-                        (struct batman_ogm_packet *)(forw_packet->skb->data);
-        unsigned char directlink;
-
-        directlink = (batman_ogm_packet->flags & DIRECTLINK ? 1 : 0);
-
-        if (!forw_packet->if_incoming) {
-                pr_err("Error - can't forward packet: incoming iface not "
-                       "specified\n");
-                goto out;
-        }
-
-        soft_iface = forw_packet->if_incoming->soft_iface;
-        bat_priv = netdev_priv(soft_iface);
-
-        if (forw_packet->if_incoming->if_status != IF_ACTIVE)
-                goto out;
-
-        primary_if = primary_if_get_selected(bat_priv);
-        if (!primary_if)
-                goto out;
-
-        /* multihomed peer assumed */
-        /* non-primary OGMs are only broadcasted on their interface */
-        if ((directlink && (batman_ogm_packet->ttl == 1)) ||
-            (forw_packet->own && (forw_packet->if_incoming != primary_if))) {
-
-                /* FIXME: what about aggregated packets ? */
-                bat_dbg(DBG_BATMAN, bat_priv,
-                        "%s packet (originator %pM, seqno %d, TTL %d) "
-                        "on interface %s [%pM]\n",
-                        (forw_packet->own ? "Sending own" : "Forwarding"),
-                        batman_ogm_packet->orig,
-                        ntohl(batman_ogm_packet->seqno),
-                        batman_ogm_packet->ttl,
-                        forw_packet->if_incoming->net_dev->name,
-                        forw_packet->if_incoming->net_dev->dev_addr);
-
-                /* skb is only used once and than forw_packet is free'd */
-                send_skb_packet(forw_packet->skb, forw_packet->if_incoming,
-                                broadcast_addr);
-                forw_packet->skb = NULL;
-
-                goto out;
-        }
-
-        /* broadcast on every interface */
-        rcu_read_lock();
-        list_for_each_entry_rcu(hard_iface, &hardif_list, list) {
-                if (hard_iface->soft_iface != soft_iface)
-                        continue;
-
-                send_packet_to_if(forw_packet, hard_iface);
-        }
-        rcu_read_unlock();
-
-out:
-        if (primary_if)
-                hardif_free_ref(primary_if);
-}
-
 static void realloc_packet_buffer(struct hard_iface *hard_iface,
                                   int new_len)
 {
@@ -245,11 +97,10 @@ static void realloc_packet_buffer(struct hard_iface *hard_iface,
 }
 
 /* when calling this function (hard_iface == primary_if) has to be true */
-static void prepare_packet_buffer(struct bat_priv *bat_priv,
+static int prepare_packet_buffer(struct bat_priv *bat_priv,
                                   struct hard_iface *hard_iface)
 {
         int new_len;
-        struct batman_ogm_packet *batman_ogm_packet;
 
         new_len = BATMAN_OGM_LEN +
                   tt_len((uint8_t)atomic_read(&bat_priv->tt_local_changes));
@@ -260,45 +111,34 @@ static void prepare_packet_buffer(struct bat_priv *bat_priv,
                 new_len = BATMAN_OGM_LEN;
 
         realloc_packet_buffer(hard_iface, new_len);
-        batman_ogm_packet = (struct batman_ogm_packet *)hard_iface->packet_buff;
 
         atomic_set(&bat_priv->tt_crc, tt_local_crc(bat_priv));
 
         /* reset the sending counter */
         atomic_set(&bat_priv->tt_ogm_append_cnt, TT_OGM_APPEND_MAX);
 
-        batman_ogm_packet->tt_num_changes = tt_changes_fill_buffer(bat_priv,
-                                hard_iface->packet_buff + BATMAN_OGM_LEN,
-                                hard_iface->packet_len - BATMAN_OGM_LEN);
-
+        return tt_changes_fill_buffer(bat_priv,
+                                      hard_iface->packet_buff + BATMAN_OGM_LEN,
+                                      hard_iface->packet_len - BATMAN_OGM_LEN);
 }
 
-static void reset_packet_buffer(struct bat_priv *bat_priv,
+static int reset_packet_buffer(struct bat_priv *bat_priv,
                                 struct hard_iface *hard_iface)
 {
-        struct batman_ogm_packet *batman_ogm_packet;
-
         realloc_packet_buffer(hard_iface, BATMAN_OGM_LEN);
-
-        batman_ogm_packet = (struct batman_ogm_packet *)hard_iface->packet_buff;
-        batman_ogm_packet->tt_num_changes = 0;
+        return 0;
 }
 
-void schedule_own_packet(struct hard_iface *hard_iface)
+void schedule_bat_ogm(struct hard_iface *hard_iface)
 {
         struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
         struct hard_iface *primary_if;
-        unsigned long send_time;
-        struct batman_ogm_packet *batman_ogm_packet;
-        int vis_server;
+        int tt_num_changes = -1;
 
         if ((hard_iface->if_status == IF_NOT_IN_USE) ||
             (hard_iface->if_status == IF_TO_BE_REMOVED))
                 return;
 
-        vis_server = atomic_read(&bat_priv->vis_mode);
-        primary_if = primary_if_get_selected(bat_priv);
-
         /**
          * the interface gets activated here to avoid race conditions between
          * the moment of activating the interface in
@@ -309,125 +149,26 @@ void schedule_own_packet(struct hard_iface *hard_iface)
         if (hard_iface->if_status == IF_TO_BE_ACTIVATED)
                 hard_iface->if_status = IF_ACTIVE;
 
+        primary_if = primary_if_get_selected(bat_priv);
+
         if (hard_iface == primary_if) {
                 /* if at least one change happened */
                 if (atomic_read(&bat_priv->tt_local_changes) > 0) {
                         tt_commit_changes(bat_priv);
-                        prepare_packet_buffer(bat_priv, hard_iface);
+                        tt_num_changes = prepare_packet_buffer(bat_priv,
+                                                               hard_iface);
                 }
 
                 /* if the changes have been sent often enough */
                 if (!atomic_dec_not_zero(&bat_priv->tt_ogm_append_cnt))
-                        reset_packet_buffer(bat_priv, hard_iface);
+                        tt_num_changes = reset_packet_buffer(bat_priv,
+                                                             hard_iface);
         }
 
-        /**
-         * NOTE: packet_buff might just have been re-allocated in
-         * prepare_packet_buffer() or in reset_packet_buffer()
-         */
-        batman_ogm_packet = (struct batman_ogm_packet *)hard_iface->packet_buff;
-
-        /* change sequence number to network order */
-        batman_ogm_packet->seqno =
-                        htonl((uint32_t)atomic_read(&hard_iface->seqno));
-
-        batman_ogm_packet->ttvn = atomic_read(&bat_priv->ttvn);
-        batman_ogm_packet->tt_crc = htons((uint16_t)
-                                                atomic_read(&bat_priv->tt_crc));
-
-        if (vis_server == VIS_TYPE_SERVER_SYNC)
-                batman_ogm_packet->flags |= VIS_SERVER;
-        else
-                batman_ogm_packet->flags &= ~VIS_SERVER;
-
-        if ((hard_iface == primary_if) &&
-            (atomic_read(&bat_priv->gw_mode) == GW_MODE_SERVER))
-                batman_ogm_packet->gw_flags =
-                                (uint8_t)atomic_read(&bat_priv->gw_bandwidth);
-        else
-                batman_ogm_packet->gw_flags = NO_FLAGS;
-
-        atomic_inc(&hard_iface->seqno);
-
-        slide_own_bcast_window(hard_iface);
-        send_time = own_send_time(bat_priv);
-        add_bat_packet_to_list(bat_priv,
-                               hard_iface->packet_buff,
-                               hard_iface->packet_len,
-                               hard_iface, 1, send_time);
-
         if (primary_if)
                 hardif_free_ref(primary_if);
-}
-
-void schedule_forward_packet(struct orig_node *orig_node,
-                             const struct ethhdr *ethhdr,
-                             struct batman_ogm_packet *batman_ogm_packet,
-                             int directlink,
-                             struct hard_iface *if_incoming)
-{
-        struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
-        struct neigh_node *router;
-        uint8_t in_tq, in_ttl, tq_avg = 0;
-        unsigned long send_time;
-        uint8_t tt_num_changes;
-
-        if (batman_ogm_packet->ttl <= 1) {
-                bat_dbg(DBG_BATMAN, bat_priv, "ttl exceeded\n");
-                return;
-        }
-
-        router = orig_node_get_router(orig_node);
-
-        in_tq = batman_ogm_packet->tq;
-        in_ttl = batman_ogm_packet->ttl;
-        tt_num_changes = batman_ogm_packet->tt_num_changes;
-
-        batman_ogm_packet->ttl--;
-        memcpy(batman_ogm_packet->prev_sender, ethhdr->h_source, ETH_ALEN);
-
-        /* rebroadcast tq of our best ranking neighbor to ensure the rebroadcast
-         * of our best tq value */
-        if (router && router->tq_avg != 0) {
-
-                /* rebroadcast ogm of best ranking neighbor as is */
-                if (!compare_eth(router->addr, ethhdr->h_source)) {
-                        batman_ogm_packet->tq = router->tq_avg;
-
-                        if (router->last_ttl)
-                                batman_ogm_packet->ttl = router->last_ttl - 1;
-                }
-
-                tq_avg = router->tq_avg;
-        }
-
-        if (router)
-                neigh_node_free_ref(router);
-
-        /* apply hop penalty */
-        batman_ogm_packet->tq = hop_penalty(batman_ogm_packet->tq, bat_priv);
-
-        bat_dbg(DBG_BATMAN, bat_priv,
-                "Forwarding packet: tq_orig: %i, tq_avg: %i, "
-                "tq_forw: %i, ttl_orig: %i, ttl_forw: %i\n",
-                in_tq, tq_avg, batman_ogm_packet->tq, in_ttl - 1,
-                batman_ogm_packet->ttl);
-
-        batman_ogm_packet->seqno = htonl(batman_ogm_packet->seqno);
-        batman_ogm_packet->tt_crc = htons(batman_ogm_packet->tt_crc);
-
-        /* switch of primaries first hop flag when forwarding */
-        batman_ogm_packet->flags &= ~PRIMARIES_FIRST_HOP;
-        if (directlink)
-                batman_ogm_packet->flags |= DIRECTLINK;
-        else
-                batman_ogm_packet->flags &= ~DIRECTLINK;
 
-        send_time = forward_send_time();
-        add_bat_packet_to_list(bat_priv,
-                               (unsigned char *)batman_ogm_packet,
-                               BATMAN_OGM_LEN + tt_len(tt_num_changes),
-                               if_incoming, 0, send_time);
+        bat_ogm_schedule(hard_iface, tt_num_changes);
 }
 
 static void forw_packet_free(struct forw_packet *forw_packet)
@@ -561,7 +302,7 @@ out:
         atomic_inc(&bat_priv->bcast_queue_left);
 }
 
-void send_outstanding_bat_packet(struct work_struct *work)
+void send_outstanding_bat_ogm_packet(struct work_struct *work)
 {
         struct delayed_work *delayed_work =
                 container_of(work, struct delayed_work, work);
@@ -577,7 +318,7 @@ void send_outstanding_bat_packet(struct work_struct *work)
         if (atomic_read(&bat_priv->mesh_state) == MESH_DEACTIVATING)
                 goto out;
 
-        send_packet(forw_packet);
+        bat_ogm_emit(forw_packet);
 
         /**
          * we have to have at least one packet in the queue
@@ -585,7 +326,7 @@ void send_outstanding_bat_packet(struct work_struct *work)
          * shutting down
          */
         if (forw_packet->own)
-                schedule_own_packet(forw_packet->if_incoming);
+                schedule_bat_ogm(forw_packet->if_incoming);
 
 out:
         /* don't count own packet */