/*
 * Copyright (C) 2007-2011 B.A.T.M.A.N. contributors:
 *
 * Marek Lindner, Simon Wunderlich
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of version 2 of the GNU General Public
 * License as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA
 *
 */

#include "main.h"
#include "aggregation.h"
#include "send.h"
#include "routing.h"
#include "hard-interface.h"

/* calculate the size of the tt information for a given packet */
static int tt_len(struct batman_packet *batman_packet)
{
        return batman_packet->num_tt * ETH_ALEN;
}

/* return true if new_packet can be aggregated with forw_packet */
static bool can_aggregate_with(struct batman_packet *new_batman_packet,
                               int packet_len,
                               unsigned long send_time,
                               bool directlink,
                               struct hard_iface *if_incoming,
                               struct forw_packet *forw_packet)
{
        struct batman_packet *batman_packet =
                (struct batman_packet *)forw_packet->skb->data;
        int aggregated_bytes = forw_packet->packet_len + packet_len;

        /**
         * we can aggregate the current packet to this aggregated packet
         * if:
         *
         * - the send time is within our MAX_AGGREGATION_MS time
         * - the resulting packet wont be bigger than
         *   MAX_AGGREGATION_BYTES
         */

        if (time_before(send_time, forw_packet->send_time) &&
            time_after_eq(send_time + msecs_to_jiffies(MAX_AGGREGATION_MS),
                                        forw_packet->send_time) &&
            (aggregated_bytes <= MAX_AGGREGATION_BYTES)) {

                /**
                 * check aggregation compatibility
                 * -> direct link packets are broadcasted on
                 *    their interface only
                 * -> aggregate packet if the current packet is
                 *    a "global" packet as well as the base
                 *    packet
                 */

                /* packets without direct link flag and high TTL
                 * are flooded through the net  */
                if ((!directlink) &&
                    (!(batman_packet->flags & DIRECTLINK)) &&
                    (batman_packet->ttl != 1) &&

                    /* own packets originating non-primary
                     * interfaces leave only that interface */
                    ((!forw_packet->own) ||
                     (forw_packet->if_incoming->if_num == 0)))
                        return true;

                /* if the incoming packet is sent via this one
                 * interface only - we still can aggregate */
                if ((directlink) &&
                    (new_batman_packet->ttl == 1) &&
                    (forw_packet->if_incoming == if_incoming) &&

                    /* packets from direct neighbors or
                     * own secondary interface packets
                     * (= secondary interface packets in general) */
                    (batman_packet->flags & DIRECTLINK ||
                     (forw_packet->own &&
                      forw_packet->if_incoming->if_num != 0)))
                        return true;
        }

        return false;
}

/* create a new aggregated packet and add this packet to it */
static void new_aggregated_packet(unsigned char *packet_buff, int packet_len,
                                  unsigned long send_time, bool direct_link,
                                  struct hard_iface *if_incoming,
                                  int own_packet)
{
        struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
        struct forw_packet *forw_packet_aggr;
        unsigned char *skb_buff;

        if (!atomic_inc_not_zero(&if_incoming->refcount))
                return;

        /* own packet should always be scheduled */
        if (!own_packet) {
                if (!atomic_dec_not_zero(&bat_priv->batman_queue_left)) {
                        bat_dbg(DBG_BATMAN, bat_priv,
                                "batman packet queue full\n");
                        goto out;
                }
        }

        forw_packet_aggr = kmalloc(sizeof(struct forw_packet), GFP_ATOMIC);
        if (!forw_packet_aggr) {
                if (!own_packet)
                        atomic_inc(&bat_priv->batman_queue_left);
                goto out;
        }

        if ((atomic_read(&bat_priv->aggregated_ogms)) &&
            (packet_len < MAX_AGGREGATION_BYTES))
                forw_packet_aggr->skb = dev_alloc_skb(MAX_AGGREGATION_BYTES +
                                                      sizeof(struct ethhdr));
        else
                forw_packet_aggr->skb = dev_alloc_skb(packet_len +
                                                      sizeof(struct ethhdr));

        if (!forw_packet_aggr->skb) {
                if (!own_packet)
                        atomic_inc(&bat_priv->batman_queue_left);
                kfree(forw_packet_aggr);
                goto out;
        }
        skb_reserve(forw_packet_aggr->skb, sizeof(struct ethhdr));

        INIT_HLIST_NODE(&forw_packet_aggr->list);

        skb_buff = skb_put(forw_packet_aggr->skb, packet_len);
        forw_packet_aggr->packet_len = packet_len;
        memcpy(skb_buff, packet_buff, packet_len);

        forw_packet_aggr->own = own_packet;
        forw_packet_aggr->if_incoming = if_incoming;
        forw_packet_aggr->num_packets = 0;
        forw_packet_aggr->direct_link_flags = 0;
        forw_packet_aggr->send_time = send_time;

        /* save packet direct link flag status */
        if (direct_link)
                forw_packet_aggr->direct_link_flags |= 1;

        /* add new packet to packet list */
        spin_lock_bh(&bat_priv->forw_bat_list_lock);
        hlist_add_head(&forw_packet_aggr->list, &bat_priv->forw_bat_list);
        spin_unlock_bh(&bat_priv->forw_bat_list_lock);

        /* start timer for this packet */
        INIT_DELAYED_WORK(&forw_packet_aggr->delayed_work,
                          send_outstanding_bat_packet);
        queue_delayed_work(bat_event_workqueue,
                           &forw_packet_aggr->delayed_work,
                           send_time - jiffies);

        return;
out:
        hardif_free_ref(if_incoming);
}

/* aggregate a new packet into the existing aggregation */
static void aggregate(struct forw_packet *forw_packet_aggr,
                      unsigned char *packet_buff,
                      int packet_len,
                      bool direct_link)
{
        unsigned char *skb_buff;

        skb_buff = skb_put(forw_packet_aggr->skb, packet_len);
        memcpy(skb_buff, packet_buff, packet_len);
        forw_packet_aggr->packet_len += packet_len;
        forw_packet_aggr->num_packets++;

        /* save packet direct link flag status */
        if (direct_link)
                forw_packet_aggr->direct_link_flags |=
                        (1 << forw_packet_aggr->num_packets);
}

void add_bat_packet_to_list(struct bat_priv *bat_priv,
                            unsigned char *packet_buff, int packet_len,
                            struct hard_iface *if_incoming, char own_packet,
                            unsigned long send_time)
{
        /**
         * _aggr -> pointer to the packet we want to aggregate with
         * _pos -> pointer to the position in the queue
         */
        struct forw_packet *forw_packet_aggr = NULL, *forw_packet_pos = NULL;
        struct hlist_node *tmp_node;
        struct batman_packet *batman_packet =
                (struct batman_packet *)packet_buff;
        bool direct_link = batman_packet->flags & DIRECTLINK ? 1 : 0;

        /* find position for the packet in the forward queue */
        spin_lock_bh(&bat_priv->forw_bat_list_lock);
        /* own packets are not to be aggregated */
        if ((atomic_read(&bat_priv->aggregated_ogms)) && (!own_packet)) {
                hlist_for_each_entry(forw_packet_pos, tmp_node,
                                     &bat_priv->forw_bat_list, list) {
                        if (can_aggregate_with(batman_packet,
                                               packet_len,
                                               send_time,
                                               direct_link,
                                               if_incoming,
                                               forw_packet_pos)) {
                                forw_packet_aggr = forw_packet_pos;
                                break;
                        }
                }
        }

        /* nothing to aggregate with - either aggregation disabled or no
         * suitable aggregation packet found */
        if (!forw_packet_aggr) {
                /* the following section can run without the lock */
                spin_unlock_bh(&bat_priv->forw_bat_list_lock);

                /**
                 * if we could not aggregate this packet with one of the others
                 * we hold it back for a while, so that it might be aggregated
                 * later on
                 */
                if ((!own_packet) &&
                    (atomic_read(&bat_priv->aggregated_ogms)))
                        send_time += msecs_to_jiffies(MAX_AGGREGATION_MS);

                new_aggregated_packet(packet_buff, packet_len,
                                      send_time, direct_link,
                                      if_incoming, own_packet);
        } else {
                aggregate(forw_packet_aggr,
                          packet_buff, packet_len,
                          direct_link);
                spin_unlock_bh(&bat_priv->forw_bat_list_lock);
        }
}

/* unpack the aggregated packets and process them one by one */
void receive_aggr_bat_packet(struct ethhdr *ethhdr, unsigned char *packet_buff,
                             int packet_len, struct hard_iface *if_incoming)
{
        struct batman_packet *batman_packet;
        int buff_pos = 0;
        unsigned char *tt_buff;

        batman_packet = (struct batman_packet *)packet_buff;

        do {
                /* network to host order for our 32bit seqno, and the
                   orig_interval. */
                batman_packet->seqno = ntohl(batman_packet->seqno);

                tt_buff = packet_buff + buff_pos + BAT_PACKET_LEN;
                receive_bat_packet(ethhdr, batman_packet,
                                   tt_buff, tt_len(batman_packet),
                                   if_incoming);

                buff_pos += BAT_PACKET_LEN + tt_len(batman_packet);
                batman_packet = (struct batman_packet *)
                        (packet_buff + buff_pos);
        } while (aggregated_packet(buff_pos, packet_len,
                                   batman_packet->num_tt));
}