batman-adv: Prefix packet structs with batadv_
authorSven Eckelmann <sven@narfation.org>
Tue, 5 Jun 2012 20:31:30 +0000 (22:31 +0200)
committerAntonio Quartulli <ordex@autistici.org>
Sun, 1 Jul 2012 20:47:21 +0000 (22:47 +0200)
Reported-by: Martin Hundebøll <martin@hundeboll.net>
Signed-off-by: Sven Eckelmann <sven@narfation.org>
19 files changed:
net/batman-adv/bat_iv_ogm.c
net/batman-adv/bridge_loop_avoidance.c
net/batman-adv/bridge_loop_avoidance.h
net/batman-adv/hard-interface.c
net/batman-adv/icmp_socket.c
net/batman-adv/icmp_socket.h
net/batman-adv/main.c
net/batman-adv/packet.h
net/batman-adv/routing.c
net/batman-adv/routing.h
net/batman-adv/send.c
net/batman-adv/soft-interface.c
net/batman-adv/translation-table.c
net/batman-adv/translation-table.h
net/batman-adv/types.h
net/batman-adv/unicast.c
net/batman-adv/unicast.h
net/batman-adv/vis.c
net/batman-adv/vis.h

index f9981e608c13fd9567ef44d13942423d0d790c5f..a2bafd9e4fb7b19466466ab9e1718af9c897bbff 100644 (file)
@@ -56,7 +56,7 @@ out:
 
 static int batadv_iv_ogm_iface_enable(struct hard_iface *hard_iface)
 {
-       struct batman_ogm_packet *batman_ogm_packet;
+       struct batadv_ogm_packet *batadv_ogm_packet;
        uint32_t random_seqno;
        int res = -ENOMEM;
 
@@ -70,14 +70,14 @@ static int batadv_iv_ogm_iface_enable(struct hard_iface *hard_iface)
        if (!hard_iface->packet_buff)
                goto out;
 
-       batman_ogm_packet = (struct batman_ogm_packet *)hard_iface->packet_buff;
-       batman_ogm_packet->header.packet_type = BATADV_IV_OGM;
-       batman_ogm_packet->header.version = BATADV_COMPAT_VERSION;
-       batman_ogm_packet->header.ttl = 2;
-       batman_ogm_packet->flags = BATADV_NO_FLAGS;
-       batman_ogm_packet->tq = BATADV_TQ_MAX_VALUE;
-       batman_ogm_packet->tt_num_changes = 0;
-       batman_ogm_packet->ttvn = 0;
+       batadv_ogm_packet = (struct batadv_ogm_packet *)hard_iface->packet_buff;
+       batadv_ogm_packet->header.packet_type = BATADV_IV_OGM;
+       batadv_ogm_packet->header.version = BATADV_COMPAT_VERSION;
+       batadv_ogm_packet->header.ttl = 2;
+       batadv_ogm_packet->flags = BATADV_NO_FLAGS;
+       batadv_ogm_packet->tq = BATADV_TQ_MAX_VALUE;
+       batadv_ogm_packet->tt_num_changes = 0;
+       batadv_ogm_packet->ttvn = 0;
 
        res = 0;
 
@@ -93,22 +93,22 @@ static void batadv_iv_ogm_iface_disable(struct hard_iface *hard_iface)
 
 static void batadv_iv_ogm_iface_update_mac(struct hard_iface *hard_iface)
 {
-       struct batman_ogm_packet *batman_ogm_packet;
+       struct batadv_ogm_packet *batadv_ogm_packet;
 
-       batman_ogm_packet = (struct batman_ogm_packet *)hard_iface->packet_buff;
-       memcpy(batman_ogm_packet->orig,
+       batadv_ogm_packet = (struct batadv_ogm_packet *)hard_iface->packet_buff;
+       memcpy(batadv_ogm_packet->orig,
               hard_iface->net_dev->dev_addr, ETH_ALEN);
-       memcpy(batman_ogm_packet->prev_sender,
+       memcpy(batadv_ogm_packet->prev_sender,
               hard_iface->net_dev->dev_addr, ETH_ALEN);
 }
 
 static void batadv_iv_ogm_primary_iface_set(struct hard_iface *hard_iface)
 {
-       struct batman_ogm_packet *batman_ogm_packet;
+       struct batadv_ogm_packet *batadv_ogm_packet;
 
-       batman_ogm_packet = (struct batman_ogm_packet *)hard_iface->packet_buff;
-       batman_ogm_packet->flags = BATADV_PRIMARIES_FIRST_HOP;
-       batman_ogm_packet->header.ttl = BATADV_TTL;
+       batadv_ogm_packet = (struct batadv_ogm_packet *)hard_iface->packet_buff;
+       batadv_ogm_packet->flags = BATADV_PRIMARIES_FIRST_HOP;
+       batadv_ogm_packet->header.ttl = BATADV_TTL;
 }
 
 /* when do we schedule our own ogm to be sent */
@@ -162,7 +162,7 @@ static void batadv_iv_ogm_send_to_if(struct forw_packet *forw_packet,
        char *fwd_str;
        uint8_t packet_num;
        int16_t buff_pos;
-       struct batman_ogm_packet *batman_ogm_packet;
+       struct batadv_ogm_packet *batadv_ogm_packet;
        struct sk_buff *skb;
 
        if (hard_iface->if_status != BATADV_IF_ACTIVE)
@@ -170,20 +170,20 @@ static void batadv_iv_ogm_send_to_if(struct forw_packet *forw_packet,
 
        packet_num = 0;
        buff_pos = 0;
-       batman_ogm_packet = (struct batman_ogm_packet *)forw_packet->skb->data;
+       batadv_ogm_packet = (struct batadv_ogm_packet *)forw_packet->skb->data;
 
        /* adjust all flags and log packets */
        while (batadv_iv_ogm_aggr_packet(buff_pos, forw_packet->packet_len,
-                                        batman_ogm_packet->tt_num_changes)) {
+                                        batadv_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 |= BATADV_DIRECTLINK;
+                       batadv_ogm_packet->flags |= BATADV_DIRECTLINK;
                else
-                       batman_ogm_packet->flags &= ~BATADV_DIRECTLINK;
+                       batadv_ogm_packet->flags &= ~BATADV_DIRECTLINK;
 
                fwd_str = (packet_num > 0 ? "Forwarding" : (forw_packet->own ?
                                                            "Sending own" :
@@ -191,18 +191,18 @@ static void batadv_iv_ogm_send_to_if(struct forw_packet *forw_packet,
                batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
                           "%s %spacket (originator %pM, seqno %u, 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->header.ttl,
-                          (batman_ogm_packet->flags & BATADV_DIRECTLINK ?
+                          batadv_ogm_packet->orig,
+                          ntohl(batadv_ogm_packet->seqno),
+                          batadv_ogm_packet->tq, batadv_ogm_packet->header.ttl,
+                          (batadv_ogm_packet->flags & BATADV_DIRECTLINK ?
                            "on" : "off"),
-                          batman_ogm_packet->ttvn, hard_iface->net_dev->name,
+                          batadv_ogm_packet->ttvn, hard_iface->net_dev->name,
                           hard_iface->net_dev->dev_addr);
 
                buff_pos += BATADV_OGM_HLEN;
-               buff_pos += batadv_tt_len(batman_ogm_packet->tt_num_changes);
+               buff_pos += batadv_tt_len(batadv_ogm_packet->tt_num_changes);
                packet_num++;
-               batman_ogm_packet = (struct batman_ogm_packet *)
+               batadv_ogm_packet = (struct batadv_ogm_packet *)
                                        (forw_packet->skb->data + buff_pos);
        }
 
@@ -223,12 +223,12 @@ static void batadv_iv_ogm_emit(struct forw_packet *forw_packet)
        struct net_device *soft_iface;
        struct bat_priv *bat_priv;
        struct hard_iface *primary_if = NULL;
-       struct batman_ogm_packet *batman_ogm_packet;
+       struct batadv_ogm_packet *batadv_ogm_packet;
        unsigned char directlink;
 
-       batman_ogm_packet = (struct batman_ogm_packet *)
+       batadv_ogm_packet = (struct batadv_ogm_packet *)
                                                (forw_packet->skb->data);
-       directlink = (batman_ogm_packet->flags & BATADV_DIRECTLINK ? 1 : 0);
+       directlink = (batadv_ogm_packet->flags & BATADV_DIRECTLINK ? 1 : 0);
 
        if (!forw_packet->if_incoming) {
                pr_err("Error - can't forward packet: incoming iface not specified\n");
@@ -248,16 +248,16 @@ static void batadv_iv_ogm_emit(struct forw_packet *forw_packet)
        /* multihomed peer assumed
         * non-primary OGMs are only broadcasted on their interface
         */
-       if ((directlink && (batman_ogm_packet->header.ttl == 1)) ||
+       if ((directlink && (batadv_ogm_packet->header.ttl == 1)) ||
            (forw_packet->own && (forw_packet->if_incoming != primary_if))) {
 
                /* FIXME: what about aggregated packets ? */
                batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
                           "%s packet (originator %pM, seqno %u, 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->header.ttl,
+                          batadv_ogm_packet->orig,
+                          ntohl(batadv_ogm_packet->seqno),
+                          batadv_ogm_packet->header.ttl,
                           forw_packet->if_incoming->net_dev->name,
                           forw_packet->if_incoming->net_dev->dev_addr);
 
@@ -287,20 +287,20 @@ out:
 
 /* return true if new_packet can be aggregated with forw_packet */
 static bool
-batadv_iv_ogm_can_aggregate(const struct batman_ogm_packet *new_bat_ogm_packet,
+batadv_iv_ogm_can_aggregate(const struct batadv_ogm_packet *new_bat_ogm_packet,
                            struct bat_priv *bat_priv,
                            int packet_len, unsigned long send_time,
                            bool directlink,
                            const struct hard_iface *if_incoming,
                            const struct forw_packet *forw_packet)
 {
-       struct batman_ogm_packet *batman_ogm_packet;
+       struct batadv_ogm_packet *batadv_ogm_packet;
        int aggregated_bytes = forw_packet->packet_len + packet_len;
        struct hard_iface *primary_if = NULL;
        bool res = false;
        unsigned long aggregation_end_time;
 
-       batman_ogm_packet = (struct batman_ogm_packet *)forw_packet->skb->data;
+       batadv_ogm_packet = (struct batadv_ogm_packet *)forw_packet->skb->data;
        aggregation_end_time = send_time;
        aggregation_end_time += msecs_to_jiffies(BATADV_MAX_AGGREGATION_MS);
 
@@ -330,8 +330,8 @@ batadv_iv_ogm_can_aggregate(const struct batman_ogm_packet *new_bat_ogm_packet,
                 * are flooded through the net
                 */
                if ((!directlink) &&
-                   (!(batman_ogm_packet->flags & BATADV_DIRECTLINK)) &&
-                   (batman_ogm_packet->header.ttl != 1) &&
+                   (!(batadv_ogm_packet->flags & BATADV_DIRECTLINK)) &&
+                   (batadv_ogm_packet->header.ttl != 1) &&
 
                    /* own packets originating non-primary
                     * interfaces leave only that interface
@@ -353,7 +353,7 @@ batadv_iv_ogm_can_aggregate(const struct batman_ogm_packet *new_bat_ogm_packet,
                     * own secondary interface packets
                     * (= secondary interface packets in general)
                     */
-                   (batman_ogm_packet->flags & BATADV_DIRECTLINK ||
+                   (batadv_ogm_packet->flags & BATADV_DIRECTLINK ||
                     (forw_packet->own &&
                      forw_packet->if_incoming != primary_if))) {
                        res = true;
@@ -475,12 +475,12 @@ static void batadv_iv_ogm_queue_add(struct bat_priv *bat_priv,
         */
        struct forw_packet *forw_packet_aggr = NULL, *forw_packet_pos = NULL;
        struct hlist_node *tmp_node;
-       struct batman_ogm_packet *batman_ogm_packet;
+       struct batadv_ogm_packet *batadv_ogm_packet;
        bool direct_link;
        unsigned long max_aggregation_jiffies;
 
-       batman_ogm_packet = (struct batman_ogm_packet *)packet_buff;
-       direct_link = batman_ogm_packet->flags & BATADV_DIRECTLINK ? 1 : 0;
+       batadv_ogm_packet = (struct batadv_ogm_packet *)packet_buff;
+       direct_link = batadv_ogm_packet->flags & BATADV_DIRECTLINK ? 1 : 0;
        max_aggregation_jiffies = msecs_to_jiffies(BATADV_MAX_AGGREGATION_MS);
 
        /* find position for the packet in the forward queue */
@@ -489,7 +489,7 @@ static void batadv_iv_ogm_queue_add(struct bat_priv *bat_priv,
        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 (batadv_iv_ogm_can_aggregate(batman_ogm_packet,
+                       if (batadv_iv_ogm_can_aggregate(batadv_ogm_packet,
                                                        bat_priv, packet_len,
                                                        send_time, direct_link,
                                                        if_incoming,
@@ -526,7 +526,7 @@ static void batadv_iv_ogm_queue_add(struct bat_priv *bat_priv,
 
 static void batadv_iv_ogm_forward(struct orig_node *orig_node,
                                  const struct ethhdr *ethhdr,
-                                 struct batman_ogm_packet *batman_ogm_packet,
+                                 struct batadv_ogm_packet *batadv_ogm_packet,
                                  bool is_single_hop_neigh,
                                  bool is_from_best_next_hop,
                                  struct hard_iface *if_incoming)
@@ -534,7 +534,7 @@ static void batadv_iv_ogm_forward(struct orig_node *orig_node,
        struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
        uint8_t tt_num_changes;
 
-       if (batman_ogm_packet->header.ttl <= 1) {
+       if (batadv_ogm_packet->header.ttl <= 1) {
                batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "ttl exceeded\n");
                return;
        }
@@ -547,32 +547,32 @@ static void batadv_iv_ogm_forward(struct orig_node *orig_node,
                 * simply drop the ogm.
                 */
                if (is_single_hop_neigh)
-                       batman_ogm_packet->flags |= BATADV_NOT_BEST_NEXT_HOP;
+                       batadv_ogm_packet->flags |= BATADV_NOT_BEST_NEXT_HOP;
                else
                        return;
        }
 
-       tt_num_changes = batman_ogm_packet->tt_num_changes;
+       tt_num_changes = batadv_ogm_packet->tt_num_changes;
 
-       batman_ogm_packet->header.ttl--;
-       memcpy(batman_ogm_packet->prev_sender, ethhdr->h_source, ETH_ALEN);
+       batadv_ogm_packet->header.ttl--;
+       memcpy(batadv_ogm_packet->prev_sender, ethhdr->h_source, ETH_ALEN);
 
        /* apply hop penalty */
-       batman_ogm_packet->tq = batadv_hop_penalty(batman_ogm_packet->tq,
+       batadv_ogm_packet->tq = batadv_hop_penalty(batadv_ogm_packet->tq,
                                                   bat_priv);
 
        batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
                   "Forwarding packet: tq: %i, ttl: %i\n",
-                  batman_ogm_packet->tq, batman_ogm_packet->header.ttl);
+                  batadv_ogm_packet->tq, batadv_ogm_packet->header.ttl);
 
        /* switch of primaries first hop flag when forwarding */
-       batman_ogm_packet->flags &= ~BATADV_PRIMARIES_FIRST_HOP;
+       batadv_ogm_packet->flags &= ~BATADV_PRIMARIES_FIRST_HOP;
        if (is_single_hop_neigh)
-               batman_ogm_packet->flags |= BATADV_DIRECTLINK;
+               batadv_ogm_packet->flags |= BATADV_DIRECTLINK;
        else
-               batman_ogm_packet->flags &= ~BATADV_DIRECTLINK;
+               batadv_ogm_packet->flags &= ~BATADV_DIRECTLINK;
 
-       batadv_iv_ogm_queue_add(bat_priv, (unsigned char *)batman_ogm_packet,
+       batadv_iv_ogm_queue_add(bat_priv, (unsigned char *)batadv_ogm_packet,
                                BATADV_OGM_HLEN + batadv_tt_len(tt_num_changes),
                                if_incoming, 0, batadv_iv_ogm_fwd_send_time());
 }
@@ -580,7 +580,7 @@ static void batadv_iv_ogm_forward(struct orig_node *orig_node,
 static void batadv_iv_ogm_schedule(struct hard_iface *hard_iface)
 {
        struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
-       struct batman_ogm_packet *batman_ogm_packet;
+       struct batadv_ogm_packet *batadv_ogm_packet;
        struct hard_iface *primary_if;
        int vis_server, tt_num_changes = 0;
 
@@ -593,29 +593,29 @@ static void batadv_iv_ogm_schedule(struct hard_iface *hard_iface)
                                                       &hard_iface->packet_len,
                                                       BATADV_OGM_HLEN);
 
-       batman_ogm_packet = (struct batman_ogm_packet *)hard_iface->packet_buff;
+       batadv_ogm_packet = (struct batadv_ogm_packet *)hard_iface->packet_buff;
 
        /* change sequence number to network order */
-       batman_ogm_packet->seqno =
+       batadv_ogm_packet->seqno =
                        htonl((uint32_t)atomic_read(&hard_iface->seqno));
        atomic_inc(&hard_iface->seqno);
 
-       batman_ogm_packet->ttvn = atomic_read(&bat_priv->ttvn);
-       batman_ogm_packet->tt_crc = htons(bat_priv->tt_crc);
+       batadv_ogm_packet->ttvn = atomic_read(&bat_priv->ttvn);
+       batadv_ogm_packet->tt_crc = htons(bat_priv->tt_crc);
        if (tt_num_changes >= 0)
-               batman_ogm_packet->tt_num_changes = tt_num_changes;
+               batadv_ogm_packet->tt_num_changes = tt_num_changes;
 
        if (vis_server == BATADV_VIS_TYPE_SERVER_SYNC)
-               batman_ogm_packet->flags |= BATADV_VIS_SERVER;
+               batadv_ogm_packet->flags |= BATADV_VIS_SERVER;
        else
-               batman_ogm_packet->flags &= ~BATADV_VIS_SERVER;
+               batadv_ogm_packet->flags &= ~BATADV_VIS_SERVER;
 
        if ((hard_iface == primary_if) &&
            (atomic_read(&bat_priv->gw_mode) == BATADV_GW_MODE_SERVER))
-               batman_ogm_packet->gw_flags =
+               batadv_ogm_packet->gw_flags =
                                (uint8_t)atomic_read(&bat_priv->gw_bandwidth);
        else
-               batman_ogm_packet->gw_flags = BATADV_NO_FLAGS;
+               batadv_ogm_packet->gw_flags = BATADV_NO_FLAGS;
 
        batadv_slide_own_bcast_window(hard_iface);
        batadv_iv_ogm_queue_add(bat_priv, hard_iface->packet_buff,
@@ -630,7 +630,7 @@ static void
 batadv_iv_ogm_orig_update(struct bat_priv *bat_priv,
                          struct orig_node *orig_node,
                          const struct ethhdr *ethhdr,
-                         const struct batman_ogm_packet *batman_ogm_packet,
+                         const struct batadv_ogm_packet *batadv_ogm_packet,
                          struct hard_iface *if_incoming,
                          const unsigned char *tt_buff,
                          int is_duplicate)
@@ -679,7 +679,7 @@ batadv_iv_ogm_orig_update(struct bat_priv *bat_priv,
                neigh_node = batadv_iv_ogm_neigh_new(if_incoming,
                                                     ethhdr->h_source,
                                                     orig_node, orig_tmp,
-                                                    batman_ogm_packet->seqno);
+                                                    batadv_ogm_packet->seqno);
 
                batadv_orig_node_free_ref(orig_tmp);
                if (!neigh_node)
@@ -690,19 +690,19 @@ batadv_iv_ogm_orig_update(struct bat_priv *bat_priv,
 
        rcu_read_unlock();
 
-       orig_node->flags = batman_ogm_packet->flags;
+       orig_node->flags = batadv_ogm_packet->flags;
        neigh_node->last_seen = jiffies;
 
        spin_lock_bh(&neigh_node->lq_update_lock);
        batadv_ring_buffer_set(neigh_node->tq_recv,
                               &neigh_node->tq_index,
-                              batman_ogm_packet->tq);
+                              batadv_ogm_packet->tq);
        neigh_node->tq_avg = batadv_ring_buffer_avg(neigh_node->tq_recv);
        spin_unlock_bh(&neigh_node->lq_update_lock);
 
        if (!is_duplicate) {
-               orig_node->last_ttl = batman_ogm_packet->header.ttl;
-               neigh_node->last_ttl = batman_ogm_packet->header.ttl;
+               orig_node->last_ttl = batadv_ogm_packet->header.ttl;
+               neigh_node->last_ttl = batadv_ogm_packet->header.ttl;
        }
 
        batadv_bonding_candidate_add(orig_node, neigh_node);
@@ -744,19 +744,19 @@ update_tt:
        /* I have to check for transtable changes only if the OGM has been
         * sent through a primary interface
         */
-       if (((batman_ogm_packet->orig != ethhdr->h_source) &&
-            (batman_ogm_packet->header.ttl > 2)) ||
-           (batman_ogm_packet->flags & BATADV_PRIMARIES_FIRST_HOP))
+       if (((batadv_ogm_packet->orig != ethhdr->h_source) &&
+            (batadv_ogm_packet->header.ttl > 2)) ||
+           (batadv_ogm_packet->flags & BATADV_PRIMARIES_FIRST_HOP))
                batadv_tt_update_orig(bat_priv, orig_node, tt_buff,
-                                     batman_ogm_packet->tt_num_changes,
-                                     batman_ogm_packet->ttvn,
-                                     ntohs(batman_ogm_packet->tt_crc));
+                                     batadv_ogm_packet->tt_num_changes,
+                                     batadv_ogm_packet->ttvn,
+                                     ntohs(batadv_ogm_packet->tt_crc));
 
-       if (orig_node->gw_flags != batman_ogm_packet->gw_flags)
+       if (orig_node->gw_flags != batadv_ogm_packet->gw_flags)
                batadv_gw_node_update(bat_priv, orig_node,
-                                     batman_ogm_packet->gw_flags);
+                                     batadv_ogm_packet->gw_flags);
 
-       orig_node->gw_flags = batman_ogm_packet->gw_flags;
+       orig_node->gw_flags = batadv_ogm_packet->gw_flags;
 
        /* restart gateway selection if fast or late switching was enabled */
        if ((orig_node->gw_flags) &&
@@ -777,7 +777,7 @@ out:
 
 static int batadv_iv_ogm_calc_tq(struct orig_node *orig_node,
                                 struct orig_node *orig_neigh_node,
-                                struct batman_ogm_packet *batman_ogm_packet,
+                                struct batadv_ogm_packet *batadv_ogm_packet,
                                 struct hard_iface *if_incoming)
 {
        struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
@@ -814,7 +814,7 @@ static int batadv_iv_ogm_calc_tq(struct orig_node *orig_node,
                                                     orig_neigh_node->orig,
                                                     orig_neigh_node,
                                                     orig_neigh_node,
-                                                    batman_ogm_packet->seqno);
+                                                    batadv_ogm_packet->seqno);
 
        if (!neigh_node)
                goto out;
@@ -862,20 +862,20 @@ static int batadv_iv_ogm_calc_tq(struct orig_node *orig_node,
        inv_asym_penalty /= neigh_rq_max_cube;
        tq_asym_penalty = BATADV_TQ_MAX_VALUE - inv_asym_penalty;
 
-       combined_tq = batman_ogm_packet->tq * tq_own * tq_asym_penalty;
+       combined_tq = batadv_ogm_packet->tq * tq_own * tq_asym_penalty;
        combined_tq /= BATADV_TQ_MAX_VALUE * BATADV_TQ_MAX_VALUE;
-       batman_ogm_packet->tq = combined_tq;
+       batadv_ogm_packet->tq = combined_tq;
 
        batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
                   "bidirectional: orig = %-15pM neigh = %-15pM => own_bcast = %2i, real recv = %2i, local tq: %3i, asym_penalty: %3i, total tq: %3i\n",
                   orig_node->orig, orig_neigh_node->orig, total_count,
                   neigh_rq_count, tq_own,
-                  tq_asym_penalty, batman_ogm_packet->tq);
+                  tq_asym_penalty, batadv_ogm_packet->tq);
 
        /* if link has the minimum required transmission quality
         * consider it bidirectional
         */
-       if (batman_ogm_packet->tq >= BATADV_TQ_TOTAL_BIDRECT_LIMIT)
+       if (batadv_ogm_packet->tq >= BATADV_TQ_TOTAL_BIDRECT_LIMIT)
                ret = 1;
 
 out:
@@ -894,7 +894,7 @@ out:
  */
 static int
 batadv_iv_ogm_update_seqnos(const struct ethhdr *ethhdr,
-                           const struct batman_ogm_packet *batman_ogm_packet,
+                           const struct batadv_ogm_packet *batadv_ogm_packet,
                            const struct hard_iface *if_incoming)
 {
        struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
@@ -905,10 +905,10 @@ batadv_iv_ogm_update_seqnos(const struct ethhdr *ethhdr,
        int32_t seq_diff;
        int need_update = 0;
        int set_mark, ret = -1;
-       uint32_t seqno = ntohl(batman_ogm_packet->seqno);
+       uint32_t seqno = ntohl(batadv_ogm_packet->seqno);
        uint8_t *neigh_addr;
 
-       orig_node = batadv_get_orig_node(bat_priv, batman_ogm_packet->orig);
+       orig_node = batadv_get_orig_node(bat_priv, batadv_ogm_packet->orig);
        if (!orig_node)
                return 0;
 
@@ -963,7 +963,7 @@ out:
 }
 
 static void batadv_iv_ogm_process(const struct ethhdr *ethhdr,
-                                 struct batman_ogm_packet *batman_ogm_packet,
+                                 struct batadv_ogm_packet *batadv_ogm_packet,
                                  const unsigned char *tt_buff,
                                  struct hard_iface *if_incoming)
 {
@@ -989,34 +989,34 @@ static void batadv_iv_ogm_process(const struct ethhdr *ethhdr,
         * it as an additional length.
         *
         * TODO: A more sane solution would be to have a bit in the
-        * batman_ogm_packet to detect whether the packet is the last
+        * batadv_ogm_packet to detect whether the packet is the last
         * packet in an aggregation.  Here we expect that the padding
         * is always zero (or not 0x01)
         */
-       if (batman_ogm_packet->header.packet_type != BATADV_IV_OGM)
+       if (batadv_ogm_packet->header.packet_type != BATADV_IV_OGM)
                return;
 
        /* could be changed by schedule_own_packet() */
        if_incoming_seqno = atomic_read(&if_incoming->seqno);
 
-       if (batman_ogm_packet->flags & BATADV_DIRECTLINK)
+       if (batadv_ogm_packet->flags & BATADV_DIRECTLINK)
                has_directlink_flag = 1;
        else
                has_directlink_flag = 0;
 
-       if (batadv_compare_eth(ethhdr->h_source, batman_ogm_packet->orig))
+       if (batadv_compare_eth(ethhdr->h_source, batadv_ogm_packet->orig))
                is_single_hop_neigh = true;
 
        batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
                   "Received BATMAN packet via NB: %pM, IF: %s [%pM] (from OG: %pM, via prev OG: %pM, seqno %u, ttvn %u, crc %u, changes %u, td %d, TTL %d, V %d, IDF %d)\n",
                   ethhdr->h_source, if_incoming->net_dev->name,
-                  if_incoming->net_dev->dev_addr, batman_ogm_packet->orig,
-                  batman_ogm_packet->prev_sender,
-                  ntohl(batman_ogm_packet->seqno), batman_ogm_packet->ttvn,
-                  ntohs(batman_ogm_packet->tt_crc),
-                  batman_ogm_packet->tt_num_changes, batman_ogm_packet->tq,
-                  batman_ogm_packet->header.ttl,
-                  batman_ogm_packet->header.version, has_directlink_flag);
+                  if_incoming->net_dev->dev_addr, batadv_ogm_packet->orig,
+                  batadv_ogm_packet->prev_sender,
+                  ntohl(batadv_ogm_packet->seqno), batadv_ogm_packet->ttvn,
+                  ntohs(batadv_ogm_packet->tt_crc),
+                  batadv_ogm_packet->tt_num_changes, batadv_ogm_packet->tq,
+                  batadv_ogm_packet->header.ttl,
+                  batadv_ogm_packet->header.version, has_directlink_flag);
 
        rcu_read_lock();
        list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
@@ -1030,11 +1030,11 @@ static void batadv_iv_ogm_process(const struct ethhdr *ethhdr,
                                       hard_iface->net_dev->dev_addr))
                        is_my_addr = 1;
 
-               if (batadv_compare_eth(batman_ogm_packet->orig,
+               if (batadv_compare_eth(batadv_ogm_packet->orig,
                                       hard_iface->net_dev->dev_addr))
                        is_my_orig = 1;
 
-               if (batadv_compare_eth(batman_ogm_packet->prev_sender,
+               if (batadv_compare_eth(batadv_ogm_packet->prev_sender,
                                       hard_iface->net_dev->dev_addr))
                        is_my_oldorig = 1;
 
@@ -1043,10 +1043,10 @@ static void batadv_iv_ogm_process(const struct ethhdr *ethhdr,
        }
        rcu_read_unlock();
 
-       if (batman_ogm_packet->header.version != BATADV_COMPAT_VERSION) {
+       if (batadv_ogm_packet->header.version != BATADV_COMPAT_VERSION) {
                batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
                           "Drop packet: incompatible batman version (%i)\n",
-                          batman_ogm_packet->header.version);
+                          batadv_ogm_packet->header.version);
                return;
        }
 
@@ -1082,14 +1082,14 @@ static void batadv_iv_ogm_process(const struct ethhdr *ethhdr,
                 */
                if (has_directlink_flag &&
                    batadv_compare_eth(if_incoming->net_dev->dev_addr,
-                                      batman_ogm_packet->orig)) {
+                                      batadv_ogm_packet->orig)) {
                        if_num = if_incoming->if_num;
                        offset = if_num * BATADV_NUM_WORDS;
 
                        spin_lock_bh(&orig_neigh_node->ogm_cnt_lock);
                        word = &(orig_neigh_node->bcast_own[offset]);
                        bit_pos = if_incoming_seqno - 2;
-                       bit_pos -= ntohl(batman_ogm_packet->seqno);
+                       bit_pos -= ntohl(batadv_ogm_packet->seqno);
                        batadv_set_bit(word, bit_pos);
                        weight = &orig_neigh_node->bcast_own_sum[if_num];
                        *weight = bitmap_weight(word,
@@ -1110,18 +1110,18 @@ static void batadv_iv_ogm_process(const struct ethhdr *ethhdr,
                return;
        }
 
-       if (batman_ogm_packet->flags & BATADV_NOT_BEST_NEXT_HOP) {
+       if (batadv_ogm_packet->flags & BATADV_NOT_BEST_NEXT_HOP) {
                batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
                           "Drop packet: ignoring all packets not forwarded from the best next hop (sender: %pM)\n",
                           ethhdr->h_source);
                return;
        }
 
-       orig_node = batadv_get_orig_node(bat_priv, batman_ogm_packet->orig);
+       orig_node = batadv_get_orig_node(bat_priv, batadv_ogm_packet->orig);
        if (!orig_node)
                return;
 
-       is_duplicate = batadv_iv_ogm_update_seqnos(ethhdr, batman_ogm_packet,
+       is_duplicate = batadv_iv_ogm_update_seqnos(ethhdr, batadv_ogm_packet,
                                                   if_incoming);
 
        if (is_duplicate == -1) {
@@ -1131,7 +1131,7 @@ static void batadv_iv_ogm_process(const struct ethhdr *ethhdr,
                goto out;
        }
 
-       if (batman_ogm_packet->tq == 0) {
+       if (batadv_ogm_packet->tq == 0) {
                batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
                           "Drop packet: originator packet with tq equal 0\n");
                goto out;
@@ -1145,11 +1145,11 @@ static void batadv_iv_ogm_process(const struct ethhdr *ethhdr,
            (batadv_compare_eth(router->addr, ethhdr->h_source)))
                is_from_best_next_hop = true;
 
-       prev_sender = batman_ogm_packet->prev_sender;
+       prev_sender = batadv_ogm_packet->prev_sender;
        /* avoid temporary routing loops */
        if (router && router_router &&
            (batadv_compare_eth(router->addr, prev_sender)) &&
-           !(batadv_compare_eth(batman_ogm_packet->orig, prev_sender)) &&
+           !(batadv_compare_eth(batadv_ogm_packet->orig, prev_sender)) &&
            (batadv_compare_eth(router->addr, router_router->addr))) {
                batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
                           "Drop packet: ignoring all rebroadcast packets that may make me loop (sender: %pM)\n",
@@ -1178,26 +1178,26 @@ static void batadv_iv_ogm_process(const struct ethhdr *ethhdr,
        }
 
        is_bidirect = batadv_iv_ogm_calc_tq(orig_node, orig_neigh_node,
-                                           batman_ogm_packet, if_incoming);
+                                           batadv_ogm_packet, if_incoming);
 
        batadv_bonding_save_primary(orig_node, orig_neigh_node,
-                                   batman_ogm_packet);
+                                   batadv_ogm_packet);
 
        /* update ranking if it is not a duplicate or has the same
         * seqno and similar ttl as the non-duplicate
         */
-       sameseq = orig_node->last_real_seqno == ntohl(batman_ogm_packet->seqno);
-       simlar_ttl = orig_node->last_ttl - 3 <= batman_ogm_packet->header.ttl;
+       sameseq = orig_node->last_real_seqno == ntohl(batadv_ogm_packet->seqno);
+       simlar_ttl = orig_node->last_ttl - 3 <= batadv_ogm_packet->header.ttl;
        if (is_bidirect && (!is_duplicate || (sameseq && simlar_ttl)))
                batadv_iv_ogm_orig_update(bat_priv, orig_node, ethhdr,
-                                         batman_ogm_packet, if_incoming,
+                                         batadv_ogm_packet, if_incoming,
                                          tt_buff, is_duplicate);
 
        /* is single hop (direct) neighbor */
        if (is_single_hop_neigh) {
 
                /* mark direct link on incoming interface */
-               batadv_iv_ogm_forward(orig_node, ethhdr, batman_ogm_packet,
+               batadv_iv_ogm_forward(orig_node, ethhdr, batadv_ogm_packet,
                                      is_single_hop_neigh,
                                      is_from_best_next_hop, if_incoming);
 
@@ -1221,7 +1221,7 @@ static void batadv_iv_ogm_process(const struct ethhdr *ethhdr,
 
        batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
                   "Forwarding packet: rebroadcast originator packet\n");
-       batadv_iv_ogm_forward(orig_node, ethhdr, batman_ogm_packet,
+       batadv_iv_ogm_forward(orig_node, ethhdr, batadv_ogm_packet,
                              is_single_hop_neigh, is_from_best_next_hop,
                              if_incoming);
 
@@ -1243,7 +1243,7 @@ static int batadv_iv_ogm_receive(struct sk_buff *skb,
                                 struct hard_iface *if_incoming)
 {
        struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
-       struct batman_ogm_packet *batman_ogm_packet;
+       struct batadv_ogm_packet *batadv_ogm_packet;
        struct ethhdr *ethhdr;
        int buff_pos = 0, packet_len;
        unsigned char *tt_buff, *packet_buff;
@@ -1266,22 +1266,22 @@ static int batadv_iv_ogm_receive(struct sk_buff *skb,
        packet_len = skb_headlen(skb);
        ethhdr = (struct ethhdr *)skb_mac_header(skb);
        packet_buff = skb->data;
-       batman_ogm_packet = (struct batman_ogm_packet *)packet_buff;
+       batadv_ogm_packet = (struct batadv_ogm_packet *)packet_buff;
 
        /* unpack the aggregated packets and process them one by one */
        do {
                tt_buff = packet_buff + buff_pos + BATADV_OGM_HLEN;
 
-               batadv_iv_ogm_process(ethhdr, batman_ogm_packet, tt_buff,
+               batadv_iv_ogm_process(ethhdr, batadv_ogm_packet, tt_buff,
                                      if_incoming);
 
                buff_pos += BATADV_OGM_HLEN;
-               buff_pos += batadv_tt_len(batman_ogm_packet->tt_num_changes);
+               buff_pos += batadv_tt_len(batadv_ogm_packet->tt_num_changes);
 
-               batman_ogm_packet = (struct batman_ogm_packet *)
+               batadv_ogm_packet = (struct batadv_ogm_packet *)
                                                (packet_buff + buff_pos);
        } while (batadv_iv_ogm_aggr_packet(buff_pos, packet_len,
-                                          batman_ogm_packet->tt_num_changes));
+                                          batadv_ogm_packet->tt_num_changes));
 
        kfree_skb(skb);
        return NET_RX_SUCCESS;
index 8bd70501b1e012710aa717bf0fc2a8a019651a12..fdda2c8d48fecca3ed2a457a90fe5c3ba993f9b2 100644 (file)
@@ -255,7 +255,7 @@ static void batadv_bla_send_claim(struct bat_priv *bat_priv, uint8_t *mac,
        struct hard_iface *primary_if;
        struct net_device *soft_iface;
        uint8_t *hw_src;
-       struct bla_claim_dst local_claim_dest;
+       struct batadv_bla_claim_dst local_claim_dest;
        __be32 zeroip = 0;
 
        primary_if = batadv_primary_if_get_selected(bat_priv);
@@ -759,9 +759,9 @@ static int batadv_check_claim_group(struct bat_priv *bat_priv,
 {
        uint8_t *backbone_addr;
        struct orig_node *orig_node;
-       struct bla_claim_dst *bla_dst, *bla_dst_own;
+       struct batadv_bla_claim_dst *bla_dst, *bla_dst_own;
 
-       bla_dst = (struct bla_claim_dst *)hw_dst;
+       bla_dst = (struct batadv_bla_claim_dst *)hw_dst;
        bla_dst_own = &bat_priv->claim_dest;
 
        /* check if it is a claim packet in general */
@@ -832,7 +832,7 @@ static int batadv_bla_process_claim(struct bat_priv *bat_priv,
        struct vlan_ethhdr *vhdr;
        struct arphdr *arphdr;
        uint8_t *hw_src, *hw_dst;
-       struct bla_claim_dst *bla_dst;
+       struct batadv_bla_claim_dst *bla_dst;
        uint16_t proto;
        int headlen;
        short vid = -1;
@@ -876,7 +876,7 @@ static int batadv_bla_process_claim(struct bat_priv *bat_priv,
 
        hw_src = (uint8_t *)arphdr + sizeof(struct arphdr);
        hw_dst = hw_src + ETH_ALEN + 4;
-       bla_dst = (struct bla_claim_dst *)hw_dst;
+       bla_dst = (struct batadv_bla_claim_dst *)hw_dst;
 
        /* check if it is a claim frame. */
        ret = batadv_check_claim_group(bat_priv, primary_if, hw_src, hw_dst,
@@ -1201,7 +1201,7 @@ int batadv_bla_init(struct bat_priv *bat_priv)
  * the same host however as this might be intended.
  */
 int batadv_bla_check_bcast_duplist(struct bat_priv *bat_priv,
-                                  struct bcast_packet *bcast_packet,
+                                  struct batadv_bcast_packet *bcast_packet,
                                   int hdr_size)
 {
        int i, length, curr;
index 58563f0cf61d8150a691d178f74039ebf378a434..d69f453d2b128e3ab82e8039a5f6acd035acf2d0 100644 (file)
@@ -28,7 +28,7 @@ int batadv_bla_is_backbone_gw(struct sk_buff *skb,
 int batadv_bla_claim_table_seq_print_text(struct seq_file *seq, void *offset);
 int batadv_bla_is_backbone_gw_orig(struct bat_priv *bat_priv, uint8_t *orig);
 int batadv_bla_check_bcast_duplist(struct bat_priv *bat_priv,
-                                  struct bcast_packet *bcast_packet,
+                                  struct batadv_bcast_packet *bcast_packet,
                                   int hdr_size);
 void batadv_bla_update_orig_address(struct bat_priv *bat_priv,
                                    struct hard_iface *primary_if,
@@ -72,7 +72,7 @@ static inline int batadv_bla_is_backbone_gw_orig(struct bat_priv *bat_priv,
 
 static inline int
 batadv_bla_check_bcast_duplist(struct bat_priv *bat_priv,
-                              struct bcast_packet *bcast_packet,
+                              struct batadv_bcast_packet *bcast_packet,
                               int hdr_size)
 {
        return 0;
index e109d65c6803bf8f1b362b0cf03671dd01f3a61e..0a14fdf9e8773a2ed0c202e0e9909c1d9b5c04ed 100644 (file)
@@ -100,14 +100,14 @@ out:
 static void batadv_primary_if_update_addr(struct bat_priv *bat_priv,
                                          struct hard_iface *oldif)
 {
-       struct vis_packet *vis_packet;
+       struct batadv_vis_packet *vis_packet;
        struct hard_iface *primary_if;
 
        primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if)
                goto out;
 
-       vis_packet = (struct vis_packet *)
+       vis_packet = (struct batadv_vis_packet *)
                                bat_priv->my_vis_info->skb_packet->data;
        memcpy(vis_packet->vis_orig, primary_if->net_dev->dev_addr, ETH_ALEN);
        memcpy(vis_packet->sender_orig,
index 61b52b37956497400122be5a3ad4b15b711a2537..ca07580c1b44520316c0ededa7d132c0c3e59bf8 100644 (file)
@@ -29,7 +29,7 @@
 static struct socket_client *batadv_socket_client_hash[256];
 
 static void batadv_socket_add_packet(struct socket_client *socket_client,
-                                    struct icmp_packet_rr *icmp_packet,
+                                    struct batadv_icmp_packet_rr *icmp_packet,
                                     size_t icmp_len);
 
 void batadv_socket_init(void)
@@ -112,7 +112,7 @@ static ssize_t batadv_socket_read(struct file *file, char __user *buf,
        if ((file->f_flags & O_NONBLOCK) && (socket_client->queue_len == 0))
                return -EAGAIN;
 
-       if ((!buf) || (count < sizeof(struct icmp_packet)))
+       if ((!buf) || (count < sizeof(struct batadv_icmp_packet)))
                return -EINVAL;
 
        if (!access_ok(VERIFY_WRITE, buf, count))
@@ -151,13 +151,13 @@ static ssize_t batadv_socket_write(struct file *file, const char __user *buff,
        struct bat_priv *bat_priv = socket_client->bat_priv;
        struct hard_iface *primary_if = NULL;
        struct sk_buff *skb;
-       struct icmp_packet_rr *icmp_packet;
+       struct batadv_icmp_packet_rr *icmp_packet;
 
        struct orig_node *orig_node = NULL;
        struct neigh_node *neigh_node = NULL;
-       size_t packet_len = sizeof(struct icmp_packet);
+       size_t packet_len = sizeof(struct batadv_icmp_packet);
 
-       if (len < sizeof(struct icmp_packet)) {
+       if (len < sizeof(struct batadv_icmp_packet)) {
                batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
                           "Error - can't send packet from char device: invalid packet size\n");
                return -EINVAL;
@@ -170,8 +170,8 @@ static ssize_t batadv_socket_write(struct file *file, const char __user *buff,
                goto out;
        }
 
-       if (len >= sizeof(struct icmp_packet_rr))
-               packet_len = sizeof(struct icmp_packet_rr);
+       if (len >= sizeof(struct batadv_icmp_packet_rr))
+               packet_len = sizeof(struct batadv_icmp_packet_rr);
 
        skb = dev_alloc_skb(packet_len + ETH_HLEN);
        if (!skb) {
@@ -180,7 +180,7 @@ static ssize_t batadv_socket_write(struct file *file, const char __user *buff,
        }
 
        skb_reserve(skb, ETH_HLEN);
-       icmp_packet = (struct icmp_packet_rr *)skb_put(skb, packet_len);
+       icmp_packet = (struct batadv_icmp_packet_rr *)skb_put(skb, packet_len);
 
        if (copy_from_user(icmp_packet, buff, packet_len)) {
                len = -EFAULT;
@@ -231,7 +231,7 @@ static ssize_t batadv_socket_write(struct file *file, const char __user *buff,
        memcpy(icmp_packet->orig,
               primary_if->net_dev->dev_addr, ETH_ALEN);
 
-       if (packet_len == sizeof(struct icmp_packet_rr))
+       if (packet_len == sizeof(struct batadv_icmp_packet_rr))
                memcpy(icmp_packet->rr,
                       neigh_node->if_incoming->net_dev->dev_addr, ETH_ALEN);
 
@@ -294,7 +294,7 @@ err:
 }
 
 static void batadv_socket_add_packet(struct socket_client *socket_client,
-                                    struct icmp_packet_rr *icmp_packet,
+                                    struct batadv_icmp_packet_rr *icmp_packet,
                                     size_t icmp_len)
 {
        struct socket_packet *socket_packet;
@@ -336,7 +336,7 @@ static void batadv_socket_add_packet(struct socket_client *socket_client,
        wake_up(&socket_client->queue_wait);
 }
 
-void batadv_socket_receive_packet(struct icmp_packet_rr *icmp_packet,
+void batadv_socket_receive_packet(struct batadv_icmp_packet_rr *icmp_packet,
                                  size_t icmp_len)
 {
        struct socket_client *hash;
index f88f9f0fe7a731ec99b28be5e4575ea3665eeddc..7b8ad529b09cf3d256a4ce1323bedda92c292e81 100644 (file)
@@ -24,7 +24,7 @@
 
 void batadv_socket_init(void);
 int batadv_socket_setup(struct bat_priv *bat_priv);
-void batadv_socket_receive_packet(struct icmp_packet_rr *icmp_packet,
+void batadv_socket_receive_packet(struct batadv_icmp_packet_rr *icmp_packet,
                                  size_t icmp_len);
 
 #endif /* _NET_BATMAN_ADV_ICMP_SOCKET_H_ */
index 24d651da6fd7e7f860bfc55dfd1f068954866c61..97144a98c66feebe7bcebe3b250e2e236d28afbc 100644 (file)
@@ -205,7 +205,7 @@ int batadv_batman_skb_recv(struct sk_buff *skb, struct net_device *dev,
                           struct net_device *orig_dev)
 {
        struct bat_priv *bat_priv;
-       struct batman_ogm_packet *batman_ogm_packet;
+       struct batadv_ogm_packet *batadv_ogm_packet;
        struct hard_iface *hard_iface;
        uint8_t idx;
        int ret;
@@ -237,19 +237,19 @@ int batadv_batman_skb_recv(struct sk_buff *skb, struct net_device *dev,
        if (hard_iface->if_status != BATADV_IF_ACTIVE)
                goto err_free;
 
-       batman_ogm_packet = (struct batman_ogm_packet *)skb->data;
+       batadv_ogm_packet = (struct batadv_ogm_packet *)skb->data;
 
-       if (batman_ogm_packet->header.version != BATADV_COMPAT_VERSION) {
+       if (batadv_ogm_packet->header.version != BATADV_COMPAT_VERSION) {
                batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
                           "Drop packet: incompatible batman version (%i)\n",
-                          batman_ogm_packet->header.version);
+                          batadv_ogm_packet->header.version);
                goto err_free;
        }
 
        /* all receive handlers return whether they received or reused
         * the supplied skb. if not, we have to free the skb.
         */
-       idx = batman_ogm_packet->header.packet_type;
+       idx = batadv_ogm_packet->header.packet_type;
        ret = (*batadv_rx_handler[idx])(skb, hard_iface);
 
        if (ret == NET_RX_DROP)
index 59e328a22fb95049431b5c297c8f97a888cb6484..8d3e55a96adc8cc1a71d9994e90af4ddd81c50fc 100644 (file)
@@ -101,20 +101,20 @@ enum batadv_bla_claimframe {
 /* the destination hardware field in the ARP frame is used to
  * transport the claim type and the group id
  */
-struct bla_claim_dst {
+struct batadv_bla_claim_dst {
        uint8_t magic[3];       /* FF:43:05 */
        uint8_t type;           /* bla_claimframe */
        __be16 group;           /* group id */
 } __packed;
 
-struct batman_header {
+struct batadv_header {
        uint8_t  packet_type;
        uint8_t  version;  /* batman version field */
        uint8_t  ttl;
 } __packed;
 
-struct batman_ogm_packet {
-       struct batman_header header;
+struct batadv_ogm_packet {
+       struct batadv_header header;
        uint8_t  flags;    /* 0x40: DIRECTLINK flag, 0x20 VIS_SERVER flag... */
        __be32   seqno;
        uint8_t  orig[ETH_ALEN];
@@ -126,10 +126,10 @@ struct batman_ogm_packet {
        __be16   tt_crc;
 } __packed;
 
-#define BATADV_OGM_HLEN sizeof(struct batman_ogm_packet)
+#define BATADV_OGM_HLEN sizeof(struct batadv_ogm_packet)
 
-struct icmp_packet {
-       struct batman_header header;
+struct batadv_icmp_packet {
+       struct batadv_header header;
        uint8_t  msg_type; /* see ICMP message types above */
        uint8_t  dst[ETH_ALEN];
        uint8_t  orig[ETH_ALEN];
@@ -143,8 +143,8 @@ struct icmp_packet {
 /* icmp_packet_rr must start with all fields from imcp_packet
  * as this is assumed by code that handles ICMP packets
  */
-struct icmp_packet_rr {
-       struct batman_header header;
+struct batadv_icmp_packet_rr {
+       struct batadv_header header;
        uint8_t  msg_type; /* see ICMP message types above */
        uint8_t  dst[ETH_ALEN];
        uint8_t  orig[ETH_ALEN];
@@ -154,14 +154,14 @@ struct icmp_packet_rr {
        uint8_t  rr[BATADV_RR_LEN][ETH_ALEN];
 } __packed;
 
-struct unicast_packet {
-       struct batman_header header;
+struct batadv_unicast_packet {
+       struct batadv_header header;
        uint8_t  ttvn; /* destination translation table version number */
        uint8_t  dest[ETH_ALEN];
 } __packed;
 
-struct unicast_frag_packet {
-       struct batman_header header;
+struct batadv_unicast_frag_packet {
+       struct batadv_header header;
        uint8_t  ttvn; /* destination translation table version number */
        uint8_t  dest[ETH_ALEN];
        uint8_t  flags;
@@ -170,15 +170,15 @@ struct unicast_frag_packet {
        __be16   seqno;
 } __packed;
 
-struct bcast_packet {
-       struct batman_header header;
+struct batadv_bcast_packet {
+       struct batadv_header header;
        uint8_t  reserved;
        __be32   seqno;
        uint8_t  orig[ETH_ALEN];
 } __packed;
 
-struct vis_packet {
-       struct batman_header header;
+struct batadv_vis_packet {
+       struct batadv_header header;
        uint8_t  vis_type;       /* which type of vis-participant sent this? */
        __be32   seqno;          /* sequence number */
        uint8_t  entries;        /* number of entries behind this struct */
@@ -188,8 +188,8 @@ struct vis_packet {
        uint8_t  sender_orig[ETH_ALEN]; /* who sent or forwarded this packet */
 } __packed;
 
-struct tt_query_packet {
-       struct batman_header header;
+struct batadv_tt_query_packet {
+       struct batadv_header header;
        /* the flag field is a combination of:
         * - TT_REQUEST or TT_RESPONSE
         * - TT_FULL_TABLE
@@ -212,15 +212,15 @@ struct tt_query_packet {
        __be16 tt_data;
 } __packed;
 
-struct roam_adv_packet {
-       struct batman_header header;
+struct batadv_roam_adv_packet {
+       struct batadv_header header;
        uint8_t  reserved;
        uint8_t  dst[ETH_ALEN];
        uint8_t  src[ETH_ALEN];
        uint8_t  client[ETH_ALEN];
 } __packed;
 
-struct tt_change {
+struct batadv_tt_change {
        uint8_t flags;
        uint8_t addr[ETH_ALEN];
 } __packed;
index 86d444a87bde506c1032566f7775c9771147c1bd..e1579076110578f1edbc1c6ed95a2a36c712974a 100644 (file)
@@ -217,7 +217,7 @@ out:
 void
 batadv_bonding_save_primary(const struct orig_node *orig_node,
                            struct orig_node *orig_neigh_node,
-                           const struct batman_ogm_packet *batman_ogm_packet)
+                           const struct batadv_ogm_packet *batman_ogm_packet)
 {
        if (!(batman_ogm_packet->flags & BATADV_PRIMARIES_FIRST_HOP))
                return;
@@ -284,10 +284,10 @@ static int batadv_recv_my_icmp_packet(struct bat_priv *bat_priv,
        struct hard_iface *primary_if = NULL;
        struct orig_node *orig_node = NULL;
        struct neigh_node *router = NULL;
-       struct icmp_packet_rr *icmp_packet;
+       struct batadv_icmp_packet_rr *icmp_packet;
        int ret = NET_RX_DROP;
 
-       icmp_packet = (struct icmp_packet_rr *)skb->data;
+       icmp_packet = (struct batadv_icmp_packet_rr *)skb->data;
 
        /* add data to device queue */
        if (icmp_packet->msg_type != BATADV_ECHO_REQUEST) {
@@ -313,7 +313,7 @@ static int batadv_recv_my_icmp_packet(struct bat_priv *bat_priv,
        if (skb_cow(skb, ETH_HLEN) < 0)
                goto out;
 
-       icmp_packet = (struct icmp_packet_rr *)skb->data;
+       icmp_packet = (struct batadv_icmp_packet_rr *)skb->data;
 
        memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN);
        memcpy(icmp_packet->orig, primary_if->net_dev->dev_addr, ETH_ALEN);
@@ -339,10 +339,10 @@ static int batadv_recv_icmp_ttl_exceeded(struct bat_priv *bat_priv,
        struct hard_iface *primary_if = NULL;
        struct orig_node *orig_node = NULL;
        struct neigh_node *router = NULL;
-       struct icmp_packet *icmp_packet;
+       struct batadv_icmp_packet *icmp_packet;
        int ret = NET_RX_DROP;
 
-       icmp_packet = (struct icmp_packet *)skb->data;
+       icmp_packet = (struct batadv_icmp_packet *)skb->data;
 
        /* send TTL exceeded if packet is an echo request (traceroute) */
        if (icmp_packet->msg_type != BATADV_ECHO_REQUEST) {
@@ -368,7 +368,7 @@ static int batadv_recv_icmp_ttl_exceeded(struct bat_priv *bat_priv,
        if (skb_cow(skb, ETH_HLEN) < 0)
                goto out;
 
-       icmp_packet = (struct icmp_packet *)skb->data;
+       icmp_packet = (struct batadv_icmp_packet *)skb->data;
 
        memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN);
        memcpy(icmp_packet->orig, primary_if->net_dev->dev_addr, ETH_ALEN);
@@ -392,16 +392,16 @@ out:
 int batadv_recv_icmp_packet(struct sk_buff *skb, struct hard_iface *recv_if)
 {
        struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
-       struct icmp_packet_rr *icmp_packet;
+       struct batadv_icmp_packet_rr *icmp_packet;
        struct ethhdr *ethhdr;
        struct orig_node *orig_node = NULL;
        struct neigh_node *router = NULL;
-       int hdr_size = sizeof(struct icmp_packet);
+       int hdr_size = sizeof(struct batadv_icmp_packet);
        int ret = NET_RX_DROP;
 
        /* we truncate all incoming icmp packets if they don't match our size */
-       if (skb->len >= sizeof(struct icmp_packet_rr))
-               hdr_size = sizeof(struct icmp_packet_rr);
+       if (skb->len >= sizeof(struct batadv_icmp_packet_rr))
+               hdr_size = sizeof(struct batadv_icmp_packet_rr);
 
        /* drop packet if it has not necessary minimum size */
        if (unlikely(!pskb_may_pull(skb, hdr_size)))
@@ -421,10 +421,10 @@ int batadv_recv_icmp_packet(struct sk_buff *skb, struct hard_iface *recv_if)
        if (!batadv_is_my_mac(ethhdr->h_dest))
                goto out;
 
-       icmp_packet = (struct icmp_packet_rr *)skb->data;
+       icmp_packet = (struct batadv_icmp_packet_rr *)skb->data;
 
        /* add record route information if not full */
-       if ((hdr_size == sizeof(struct icmp_packet_rr)) &&
+       if ((hdr_size == sizeof(struct batadv_icmp_packet_rr)) &&
            (icmp_packet->rr_cur < BATADV_RR_LEN)) {
                memcpy(&(icmp_packet->rr[icmp_packet->rr_cur]),
                       ethhdr->h_dest, ETH_ALEN);
@@ -452,7 +452,7 @@ int batadv_recv_icmp_packet(struct sk_buff *skb, struct hard_iface *recv_if)
        if (skb_cow(skb, ETH_HLEN) < 0)
                goto out;
 
-       icmp_packet = (struct icmp_packet_rr *)skb->data;
+       icmp_packet = (struct batadv_icmp_packet_rr *)skb->data;
 
        /* decrement ttl */
        icmp_packet->header.ttl--;
@@ -580,17 +580,19 @@ batadv_find_ifalter_router(struct orig_node *primary_orig,
 int batadv_recv_tt_query(struct sk_buff *skb, struct hard_iface *recv_if)
 {
        struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
-       struct tt_query_packet *tt_query;
+       struct batadv_tt_query_packet *tt_query;
        uint16_t tt_size;
        struct ethhdr *ethhdr;
        char tt_flag;
+       size_t packet_size;
 
        /* drop packet if it has not necessary minimum size */
-       if (unlikely(!pskb_may_pull(skb, sizeof(struct tt_query_packet))))
+       if (unlikely(!pskb_may_pull(skb,
+                                   sizeof(struct batadv_tt_query_packet))))
                goto out;
 
        /* I could need to modify it */
-       if (skb_cow(skb, sizeof(struct tt_query_packet)) < 0)
+       if (skb_cow(skb, sizeof(struct batadv_tt_query_packet)) < 0)
                goto out;
 
        ethhdr = (struct ethhdr *)skb_mac_header(skb);
@@ -603,7 +605,7 @@ int batadv_recv_tt_query(struct sk_buff *skb, struct hard_iface *recv_if)
        if (is_broadcast_ether_addr(ethhdr->h_source))
                goto out;
 
-       tt_query = (struct tt_query_packet *)skb->data;
+       tt_query = (struct batadv_tt_query_packet *)skb->data;
 
        switch (tt_query->flags & BATADV_TT_QUERY_TYPE_MASK) {
        case BATADV_TT_REQUEST:
@@ -635,13 +637,14 @@ int batadv_recv_tt_query(struct sk_buff *skb, struct hard_iface *recv_if)
                        if (skb_linearize(skb) < 0)
                                goto out;
                        /* skb_linearize() possibly changed skb->data */
-                       tt_query = (struct tt_query_packet *)skb->data;
+                       tt_query = (struct batadv_tt_query_packet *)skb->data;
 
                        tt_size = batadv_tt_len(ntohs(tt_query->tt_data));
 
                        /* Ensure we have all the claimed data */
-                       if (unlikely(skb_headlen(skb) <
-                                    sizeof(struct tt_query_packet) + tt_size))
+                       packet_size = sizeof(struct batadv_tt_query_packet);
+                       packet_size += tt_size;
+                       if (unlikely(skb_headlen(skb) < packet_size))
                                goto out;
 
                        batadv_handle_tt_response(bat_priv, tt_query);
@@ -667,12 +670,13 @@ out:
 int batadv_recv_roam_adv(struct sk_buff *skb, struct hard_iface *recv_if)
 {
        struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
-       struct roam_adv_packet *roam_adv_packet;
+       struct batadv_roam_adv_packet *roam_adv_packet;
        struct orig_node *orig_node;
        struct ethhdr *ethhdr;
 
        /* drop packet if it has not necessary minimum size */
-       if (unlikely(!pskb_may_pull(skb, sizeof(struct roam_adv_packet))))
+       if (unlikely(!pskb_may_pull(skb,
+                                   sizeof(struct batadv_roam_adv_packet))))
                goto out;
 
        ethhdr = (struct ethhdr *)skb_mac_header(skb);
@@ -687,7 +691,7 @@ int batadv_recv_roam_adv(struct sk_buff *skb, struct hard_iface *recv_if)
 
        batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_RX);
 
-       roam_adv_packet = (struct roam_adv_packet *)skb->data;
+       roam_adv_packet = (struct batadv_roam_adv_packet *)skb->data;
 
        if (!batadv_is_my_mac(roam_adv_packet->dst))
                return batadv_route_unicast_packet(skb, recv_if);
@@ -843,12 +847,12 @@ static int batadv_route_unicast_packet(struct sk_buff *skb,
        struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
        struct orig_node *orig_node = NULL;
        struct neigh_node *neigh_node = NULL;
-       struct unicast_packet *unicast_packet;
+       struct batadv_unicast_packet *unicast_packet;
        struct ethhdr *ethhdr = (struct ethhdr *)skb_mac_header(skb);
        int ret = NET_RX_DROP;
        struct sk_buff *new_skb;
 
-       unicast_packet = (struct unicast_packet *)skb->data;
+       unicast_packet = (struct batadv_unicast_packet *)skb->data;
 
        /* TTL exceeded */
        if (unicast_packet->header.ttl < 2) {
@@ -873,7 +877,7 @@ static int batadv_route_unicast_packet(struct sk_buff *skb,
        if (skb_cow(skb, ETH_HLEN) < 0)
                goto out;
 
-       unicast_packet = (struct unicast_packet *)skb->data;
+       unicast_packet = (struct batadv_unicast_packet *)skb->data;
 
        if (unicast_packet->header.packet_type == BATADV_UNICAST &&
            atomic_read(&bat_priv->fragmentation) &&
@@ -900,7 +904,7 @@ static int batadv_route_unicast_packet(struct sk_buff *skb,
                }
 
                skb = new_skb;
-               unicast_packet = (struct unicast_packet *)skb->data;
+               unicast_packet = (struct batadv_unicast_packet *)skb->data;
        }
 
        /* decrement ttl */
@@ -929,15 +933,15 @@ static int batadv_check_unicast_ttvn(struct bat_priv *bat_priv,
        struct orig_node *orig_node;
        struct ethhdr *ethhdr;
        struct hard_iface *primary_if;
-       struct unicast_packet *unicast_packet;
+       struct batadv_unicast_packet *unicast_packet;
        bool tt_poss_change;
        int is_old_ttvn;
 
        /* I could need to modify it */
-       if (skb_cow(skb, sizeof(struct unicast_packet)) < 0)
+       if (skb_cow(skb, sizeof(struct batadv_unicast_packet)) < 0)
                return 0;
 
-       unicast_packet = (struct unicast_packet *)skb->data;
+       unicast_packet = (struct batadv_unicast_packet *)skb->data;
 
        if (batadv_is_my_mac(unicast_packet->dest)) {
                tt_poss_change = bat_priv->tt_poss_change;
@@ -958,12 +962,12 @@ static int batadv_check_unicast_ttvn(struct bat_priv *bat_priv,
        is_old_ttvn = batadv_seq_before(unicast_packet->ttvn, curr_ttvn);
        if (is_old_ttvn || tt_poss_change) {
                /* check if there is enough data before accessing it */
-               if (pskb_may_pull(skb, sizeof(struct unicast_packet) +
+               if (pskb_may_pull(skb, sizeof(struct batadv_unicast_packet) +
                                  ETH_HLEN) < 0)
                        return 0;
 
                ethhdr = (struct ethhdr *)(skb->data +
-                       sizeof(struct unicast_packet));
+                       sizeof(struct batadv_unicast_packet));
 
                /* we don't have an updated route for this client, so we should
                 * not try to reroute the packet!!
@@ -1005,7 +1009,7 @@ static int batadv_check_unicast_ttvn(struct bat_priv *bat_priv,
 int batadv_recv_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if)
 {
        struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
-       struct unicast_packet *unicast_packet;
+       struct batadv_unicast_packet *unicast_packet;
        int hdr_size = sizeof(*unicast_packet);
 
        if (batadv_check_unicast_packet(skb, hdr_size) < 0)
@@ -1014,7 +1018,7 @@ int batadv_recv_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if)
        if (!batadv_check_unicast_ttvn(bat_priv, skb))
                return NET_RX_DROP;
 
-       unicast_packet = (struct unicast_packet *)skb->data;
+       unicast_packet = (struct batadv_unicast_packet *)skb->data;
 
        /* packet for me */
        if (batadv_is_my_mac(unicast_packet->dest)) {
@@ -1030,7 +1034,7 @@ int batadv_recv_ucast_frag_packet(struct sk_buff *skb,
                                  struct hard_iface *recv_if)
 {
        struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
-       struct unicast_frag_packet *unicast_packet;
+       struct batadv_unicast_frag_packet *unicast_packet;
        int hdr_size = sizeof(*unicast_packet);
        struct sk_buff *new_skb = NULL;
        int ret;
@@ -1041,7 +1045,7 @@ int batadv_recv_ucast_frag_packet(struct sk_buff *skb,
        if (!batadv_check_unicast_ttvn(bat_priv, skb))
                return NET_RX_DROP;
 
-       unicast_packet = (struct unicast_frag_packet *)skb->data;
+       unicast_packet = (struct batadv_unicast_frag_packet *)skb->data;
 
        /* packet for me */
        if (batadv_is_my_mac(unicast_packet->dest)) {
@@ -1056,7 +1060,7 @@ int batadv_recv_ucast_frag_packet(struct sk_buff *skb,
                        return NET_RX_SUCCESS;
 
                batadv_interface_rx(recv_if->soft_iface, new_skb, recv_if,
-                                   sizeof(struct unicast_packet));
+                                   sizeof(struct batadv_unicast_packet));
                return NET_RX_SUCCESS;
        }
 
@@ -1068,7 +1072,7 @@ int batadv_recv_bcast_packet(struct sk_buff *skb, struct hard_iface *recv_if)
 {
        struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
        struct orig_node *orig_node = NULL;
-       struct bcast_packet *bcast_packet;
+       struct batadv_bcast_packet *bcast_packet;
        struct ethhdr *ethhdr;
        int hdr_size = sizeof(*bcast_packet);
        int ret = NET_RX_DROP;
@@ -1092,7 +1096,7 @@ int batadv_recv_bcast_packet(struct sk_buff *skb, struct hard_iface *recv_if)
        if (batadv_is_my_mac(ethhdr->h_source))
                goto out;
 
-       bcast_packet = (struct bcast_packet *)skb->data;
+       bcast_packet = (struct batadv_bcast_packet *)skb->data;
 
        /* ignore broadcasts originated by myself */
        if (batadv_is_my_mac(bcast_packet->orig))
@@ -1156,7 +1160,7 @@ out:
 
 int batadv_recv_vis_packet(struct sk_buff *skb, struct hard_iface *recv_if)
 {
-       struct vis_packet *vis_packet;
+       struct batadv_vis_packet *vis_packet;
        struct ethhdr *ethhdr;
        struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
        int hdr_size = sizeof(*vis_packet);
@@ -1168,7 +1172,7 @@ int batadv_recv_vis_packet(struct sk_buff *skb, struct hard_iface *recv_if)
        if (unlikely(!pskb_may_pull(skb, hdr_size)))
                return NET_RX_DROP;
 
-       vis_packet = (struct vis_packet *)skb->data;
+       vis_packet = (struct batadv_vis_packet *)skb->data;
        ethhdr = (struct ethhdr *)skb_mac_header(skb);
 
        /* not for me */
index c3fd219e8e532fc6e711237a2d321b448ddf2728..ead4ae05577659190b293db36c8a35bbf8e42a84 100644 (file)
@@ -43,7 +43,7 @@ void batadv_bonding_candidate_add(struct orig_node *orig_node,
                                  struct neigh_node *neigh_node);
 void batadv_bonding_save_primary(const struct orig_node *orig_node,
                                 struct orig_node *orig_neigh_node,
-                                const struct batman_ogm_packet
+                                const struct batadv_ogm_packet
                                 *batman_ogm_packet);
 int batadv_window_protected(struct bat_priv *bat_priv, int32_t seq_num_diff,
                            unsigned long *last_reset);
index aad981859688dfcd73f7e1a47532330ec3be6902..67c1c6c22f3b3068aed02b1084c2a2c4197e124d 100644 (file)
@@ -138,7 +138,7 @@ int batadv_add_bcast_packet_to_list(struct bat_priv *bat_priv,
 {
        struct hard_iface *primary_if = NULL;
        struct forw_packet *forw_packet;
-       struct bcast_packet *bcast_packet;
+       struct batadv_bcast_packet *bcast_packet;
        struct sk_buff *newskb;
 
        if (!batadv_atomic_dec_not_zero(&bat_priv->bcast_queue_left)) {
@@ -161,7 +161,7 @@ int batadv_add_bcast_packet_to_list(struct bat_priv *bat_priv,
                goto packet_free;
 
        /* as we have a copy now, it is safe to decrease the TTL */
-       bcast_packet = (struct bcast_packet *)newskb->data;
+       bcast_packet = (struct batadv_bcast_packet *)newskb->data;
        bcast_packet->header.ttl--;
 
        skb_reset_mac_header(newskb);
index 0a00324e67e32b2bb0889ec83a778493930994b2..0a5d73a549f62f85f33cd1857c494874bcd52155 100644 (file)
@@ -133,7 +133,7 @@ static int batadv_interface_tx(struct sk_buff *skb,
        struct ethhdr *ethhdr = (struct ethhdr *)skb->data;
        struct bat_priv *bat_priv = netdev_priv(soft_iface);
        struct hard_iface *primary_if = NULL;
-       struct bcast_packet *bcast_packet;
+       struct batadv_bcast_packet *bcast_packet;
        struct vlan_ethhdr *vhdr;
        __be16 ethertype = __constant_htons(BATADV_ETH_P_BATMAN);
        static const uint8_t stp_addr[ETH_ALEN] = {0x01, 0x80, 0xC2, 0x00, 0x00,
@@ -208,7 +208,7 @@ static int batadv_interface_tx(struct sk_buff *skb,
                if (batadv_skb_head_push(skb, sizeof(*bcast_packet)) < 0)
                        goto dropped;
 
-               bcast_packet = (struct bcast_packet *)skb->data;
+               bcast_packet = (struct batadv_bcast_packet *)skb->data;
                bcast_packet->header.version = BATADV_COMPAT_VERSION;
                bcast_packet->header.ttl = BATADV_TTL;
 
index 9b35d1f59a110bcc849a004259b2a318eb86cf5f..48217cc6729d0ad9fbaa4bfc9c689354d3c1911f 100644 (file)
@@ -212,7 +212,7 @@ unlock:
 
 int batadv_tt_len(int changes_num)
 {
-       return changes_num * sizeof(struct tt_change);
+       return changes_num * sizeof(struct batadv_tt_change);
 }
 
 static int batadv_tt_local_init(struct bat_priv *bat_priv)
@@ -384,7 +384,7 @@ static int batadv_tt_changes_fill_buff(struct bat_priv *bat_priv,
                                 list) {
                if (count < tot_changes) {
                        memcpy(tt_buff + batadv_tt_len(count),
-                              &entry->change, sizeof(struct tt_change));
+                              &entry->change, sizeof(struct batadv_tt_change));
                        count++;
                }
                list_del(&entry->list);
@@ -1366,31 +1366,32 @@ batadv_tt_response_fill_table(uint16_t tt_len, uint8_t ttvn,
                              void *cb_data)
 {
        struct tt_common_entry *tt_common_entry;
-       struct tt_query_packet *tt_response;
-       struct tt_change *tt_change;
+       struct batadv_tt_query_packet *tt_response;
+       struct batadv_tt_change *tt_change;
        struct hlist_node *node;
        struct hlist_head *head;
        struct sk_buff *skb = NULL;
        uint16_t tt_tot, tt_count;
-       ssize_t tt_query_size = sizeof(struct tt_query_packet);
+       ssize_t tt_query_size = sizeof(struct batadv_tt_query_packet);
        uint32_t i;
+       size_t len;
 
        if (tt_query_size + tt_len > primary_if->soft_iface->mtu) {
                tt_len = primary_if->soft_iface->mtu - tt_query_size;
-               tt_len -= tt_len % sizeof(struct tt_change);
+               tt_len -= tt_len % sizeof(struct batadv_tt_change);
        }
-       tt_tot = tt_len / sizeof(struct tt_change);
+       tt_tot = tt_len / sizeof(struct batadv_tt_change);
 
-       skb = dev_alloc_skb(tt_query_size + tt_len + ETH_HLEN);
+       len = tt_query_size + tt_len;
+       skb = dev_alloc_skb(len + ETH_HLEN);
        if (!skb)
                goto out;
 
        skb_reserve(skb, ETH_HLEN);
-       tt_response = (struct tt_query_packet *)skb_put(skb,
-                                                    tt_query_size + tt_len);
+       tt_response = (struct batadv_tt_query_packet *)skb_put(skb, len);
        tt_response->ttvn = ttvn;
 
-       tt_change = (struct tt_change *)(skb->data + tt_query_size);
+       tt_change = (struct batadv_tt_change *)(skb->data + tt_query_size);
        tt_count = 0;
 
        rcu_read_lock();
@@ -1430,11 +1431,12 @@ static int batadv_send_tt_request(struct bat_priv *bat_priv,
                                  bool full_table)
 {
        struct sk_buff *skb = NULL;
-       struct tt_query_packet *tt_request;
+       struct batadv_tt_query_packet *tt_request;
        struct neigh_node *neigh_node = NULL;
        struct hard_iface *primary_if;
        struct tt_req_node *tt_req_node = NULL;
        int ret = 1;
+       size_t tt_req_len;
 
        primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if)
@@ -1447,14 +1449,14 @@ static int batadv_send_tt_request(struct bat_priv *bat_priv,
        if (!tt_req_node)
                goto out;
 
-       skb = dev_alloc_skb(sizeof(struct tt_query_packet) + ETH_HLEN);
+       skb = dev_alloc_skb(sizeof(*tt_request) + ETH_HLEN);
        if (!skb)
                goto out;
 
        skb_reserve(skb, ETH_HLEN);
 
-       tt_request = (struct tt_query_packet *)skb_put(skb,
-                               sizeof(struct tt_query_packet));
+       tt_req_len = sizeof(*tt_request);
+       tt_request = (struct batadv_tt_query_packet *)skb_put(skb, tt_req_len);
 
        tt_request->header.packet_type = BATADV_TT_QUERY;
        tt_request->header.version = BATADV_COMPAT_VERSION;
@@ -1498,8 +1500,9 @@ out:
        return ret;
 }
 
-static bool batadv_send_other_tt_response(struct bat_priv *bat_priv,
-                                         struct tt_query_packet *tt_request)
+static bool
+batadv_send_other_tt_response(struct bat_priv *bat_priv,
+                             struct batadv_tt_query_packet *tt_request)
 {
        struct orig_node *req_dst_orig_node = NULL, *res_dst_orig_node = NULL;
        struct neigh_node *neigh_node = NULL;
@@ -1510,7 +1513,8 @@ static bool batadv_send_other_tt_response(struct bat_priv *bat_priv,
        bool full_table;
        uint16_t tt_len, tt_tot;
        struct sk_buff *skb = NULL;
-       struct tt_query_packet *tt_response;
+       struct batadv_tt_query_packet *tt_response;
+       size_t len;
 
        batadv_dbg(BATADV_DBG_TT, bat_priv,
                   "Received TT_REQUEST from %pM for ttvn: %u (%pM) [%c]\n",
@@ -1555,28 +1559,28 @@ static bool batadv_send_other_tt_response(struct bat_priv *bat_priv,
        if (!full_table) {
                spin_lock_bh(&req_dst_orig_node->tt_buff_lock);
                tt_len = req_dst_orig_node->tt_buff_len;
-               tt_tot = tt_len / sizeof(struct tt_change);
+               tt_tot = tt_len / sizeof(struct batadv_tt_change);
 
-               skb = dev_alloc_skb(sizeof(struct tt_query_packet) +
-                                   tt_len + ETH_HLEN);
+               len = sizeof(*tt_response) + tt_len;
+               skb = dev_alloc_skb(len + ETH_HLEN);
                if (!skb)
                        goto unlock;
 
                skb_reserve(skb, ETH_HLEN);
-               tt_response = (struct tt_query_packet *)skb_put(skb,
-                               sizeof(struct tt_query_packet) + tt_len);
+               tt_response = (struct batadv_tt_query_packet *)skb_put(skb,
+                                                                      len);
                tt_response->ttvn = req_ttvn;
                tt_response->tt_data = htons(tt_tot);
 
-               tt_buff = skb->data + sizeof(struct tt_query_packet);
+               tt_buff = skb->data + sizeof(*tt_response);
                /* Copy the last orig_node's OGM buffer */
                memcpy(tt_buff, req_dst_orig_node->tt_buff,
                       req_dst_orig_node->tt_buff_len);
 
                spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
        } else {
-               tt_len = (uint16_t)atomic_read(&req_dst_orig_node->tt_size) *
-                                               sizeof(struct tt_change);
+               tt_len = (uint16_t)atomic_read(&req_dst_orig_node->tt_size);
+               tt_len *= sizeof(struct batadv_tt_change);
                ttvn = (uint8_t)atomic_read(&req_dst_orig_node->last_ttvn);
 
                skb = batadv_tt_response_fill_table(tt_len, ttvn,
@@ -1587,7 +1591,7 @@ static bool batadv_send_other_tt_response(struct bat_priv *bat_priv,
                if (!skb)
                        goto out;
 
-               tt_response = (struct tt_query_packet *)skb->data;
+               tt_response = (struct batadv_tt_query_packet *)skb->data;
        }
 
        tt_response->header.packet_type = BATADV_TT_QUERY;
@@ -1628,8 +1632,10 @@ out:
        return ret;
 
 }
-static bool batadv_send_my_tt_response(struct bat_priv *bat_priv,
-                                      struct tt_query_packet *tt_request)
+
+static bool
+batadv_send_my_tt_response(struct bat_priv *bat_priv,
+                          struct batadv_tt_query_packet *tt_request)
 {
        struct orig_node *orig_node = NULL;
        struct neigh_node *neigh_node = NULL;
@@ -1640,7 +1646,8 @@ static bool batadv_send_my_tt_response(struct bat_priv *bat_priv,
        bool full_table;
        uint16_t tt_len, tt_tot;
        struct sk_buff *skb = NULL;
-       struct tt_query_packet *tt_response;
+       struct batadv_tt_query_packet *tt_response;
+       size_t len;
 
        batadv_dbg(BATADV_DBG_TT, bat_priv,
                   "Received TT_REQUEST from %pM for ttvn: %u (me) [%c]\n",
@@ -1678,26 +1685,26 @@ static bool batadv_send_my_tt_response(struct bat_priv *bat_priv,
        if (!full_table) {
                spin_lock_bh(&bat_priv->tt_buff_lock);
                tt_len = bat_priv->tt_buff_len;
-               tt_tot = tt_len / sizeof(struct tt_change);
+               tt_tot = tt_len / sizeof(struct batadv_tt_change);
 
-               skb = dev_alloc_skb(sizeof(struct tt_query_packet) +
-                                   tt_len + ETH_HLEN);
+               len = sizeof(*tt_response) + tt_len;
+               skb = dev_alloc_skb(len + ETH_HLEN);
                if (!skb)
                        goto unlock;
 
                skb_reserve(skb, ETH_HLEN);
-               tt_response = (struct tt_query_packet *)skb_put(skb,
-                               sizeof(struct tt_query_packet) + tt_len);
+               tt_response = (struct batadv_tt_query_packet *)skb_put(skb,
+                                                                      len);
                tt_response->ttvn = req_ttvn;
                tt_response->tt_data = htons(tt_tot);
 
-               tt_buff = skb->data + sizeof(struct tt_query_packet);
+               tt_buff = skb->data + sizeof(*tt_response);
                memcpy(tt_buff, bat_priv->tt_buff,
                       bat_priv->tt_buff_len);
                spin_unlock_bh(&bat_priv->tt_buff_lock);
        } else {
-               tt_len = (uint16_t)atomic_read(&bat_priv->num_local_tt) *
-                                               sizeof(struct tt_change);
+               tt_len = (uint16_t)atomic_read(&bat_priv->num_local_tt);
+               tt_len *= sizeof(struct batadv_tt_change);
                ttvn = (uint8_t)atomic_read(&bat_priv->ttvn);
 
                skb = batadv_tt_response_fill_table(tt_len, ttvn,
@@ -1708,7 +1715,7 @@ static bool batadv_send_my_tt_response(struct bat_priv *bat_priv,
                if (!skb)
                        goto out;
 
-               tt_response = (struct tt_query_packet *)skb->data;
+               tt_response = (struct batadv_tt_query_packet *)skb->data;
        }
 
        tt_response->header.packet_type = BATADV_TT_QUERY;
@@ -1748,7 +1755,7 @@ out:
 }
 
 bool batadv_send_tt_response(struct bat_priv *bat_priv,
-                            struct tt_query_packet *tt_request)
+                            struct batadv_tt_query_packet *tt_request)
 {
        if (batadv_is_my_mac(tt_request->dst)) {
                /* don't answer backbone gws! */
@@ -1763,7 +1770,7 @@ bool batadv_send_tt_response(struct bat_priv *bat_priv,
 
 static void _batadv_tt_update_changes(struct bat_priv *bat_priv,
                                      struct orig_node *orig_node,
-                                     struct tt_change *tt_change,
+                                     struct batadv_tt_change *tt_change,
                                      uint16_t tt_num_changes, uint8_t ttvn)
 {
        int i;
@@ -1793,7 +1800,7 @@ static void _batadv_tt_update_changes(struct bat_priv *bat_priv,
 }
 
 static void batadv_tt_fill_gtable(struct bat_priv *bat_priv,
-                                 struct tt_query_packet *tt_response)
+                                 struct batadv_tt_query_packet *tt_response)
 {
        struct orig_node *orig_node = NULL;
 
@@ -1805,7 +1812,7 @@ static void batadv_tt_fill_gtable(struct bat_priv *bat_priv,
        batadv_tt_global_del_orig(bat_priv, orig_node, "Received full table");
 
        _batadv_tt_update_changes(bat_priv, orig_node,
-                                 (struct tt_change *)(tt_response + 1),
+                                 (struct batadv_tt_change *)(tt_response + 1),
                                  ntohs(tt_response->tt_data),
                                  tt_response->ttvn);
 
@@ -1825,7 +1832,7 @@ out:
 static void batadv_tt_update_changes(struct bat_priv *bat_priv,
                                     struct orig_node *orig_node,
                                     uint16_t tt_num_changes, uint8_t ttvn,
-                                    struct tt_change *tt_change)
+                                    struct batadv_tt_change *tt_change)
 {
        _batadv_tt_update_changes(bat_priv, orig_node, tt_change,
                                  tt_num_changes, ttvn);
@@ -1856,10 +1863,11 @@ out:
 }
 
 void batadv_handle_tt_response(struct bat_priv *bat_priv,
-                              struct tt_query_packet *tt_response)
+                              struct batadv_tt_query_packet *tt_response)
 {
        struct tt_req_node *node, *safe;
        struct orig_node *orig_node = NULL;
+       struct batadv_tt_change *tt_change;
 
        batadv_dbg(BATADV_DBG_TT, bat_priv,
                   "Received TT_RESPONSE from %pM for ttvn %d t_size: %d [%c]\n",
@@ -1875,13 +1883,14 @@ void batadv_handle_tt_response(struct bat_priv *bat_priv,
        if (!orig_node)
                goto out;
 
-       if (tt_response->flags & BATADV_TT_FULL_TABLE)
+       if (tt_response->flags & BATADV_TT_FULL_TABLE) {
                batadv_tt_fill_gtable(bat_priv, tt_response);
-       else
+       } else {
+               tt_change = (struct batadv_tt_change *)(tt_response + 1);
                batadv_tt_update_changes(bat_priv, orig_node,
                                         ntohs(tt_response->tt_data),
-                                        tt_response->ttvn,
-                                        (struct tt_change *)(tt_response + 1));
+                                        tt_response->ttvn, tt_change);
+       }
 
        /* Delete the tt_req_node from pending tt_requests list */
        spin_lock_bh(&bat_priv->tt_req_list_lock);
@@ -2006,9 +2015,10 @@ static void batadv_send_roam_adv(struct bat_priv *bat_priv, uint8_t *client,
 {
        struct neigh_node *neigh_node = NULL;
        struct sk_buff *skb = NULL;
-       struct roam_adv_packet *roam_adv_packet;
+       struct batadv_roam_adv_packet *roam_adv_packet;
        int ret = 1;
        struct hard_iface *primary_if;
+       size_t len = sizeof(*roam_adv_packet);
 
        /* before going on we have to check whether the client has
         * already roamed to us too many times
@@ -2016,14 +2026,13 @@ static void batadv_send_roam_adv(struct bat_priv *bat_priv, uint8_t *client,
        if (!batadv_tt_check_roam_count(bat_priv, client))
                goto out;
 
-       skb = dev_alloc_skb(sizeof(struct roam_adv_packet) + ETH_HLEN);
+       skb = dev_alloc_skb(sizeof(*roam_adv_packet) + ETH_HLEN);
        if (!skb)
                goto out;
 
        skb_reserve(skb, ETH_HLEN);
 
-       roam_adv_packet = (struct roam_adv_packet *)skb_put(skb,
-                                       sizeof(struct roam_adv_packet));
+       roam_adv_packet = (struct batadv_roam_adv_packet *)skb_put(skb, len);
 
        roam_adv_packet->header.packet_type = BATADV_ROAM_ADV;
        roam_adv_packet->header.version = BATADV_COMPAT_VERSION;
@@ -2255,6 +2264,7 @@ void batadv_tt_update_orig(struct bat_priv *bat_priv,
 {
        uint8_t orig_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);
        bool full_table = true;
+       struct batadv_tt_change *tt_change;
 
        /* don't care about a backbone gateways updates. */
        if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig))
@@ -2275,8 +2285,9 @@ void batadv_tt_update_orig(struct bat_priv *bat_priv,
                        goto request_table;
                }
 
+               tt_change = (struct batadv_tt_change *)tt_buff;
                batadv_tt_update_changes(bat_priv, orig_node, tt_num_changes,
-                                        ttvn, (struct tt_change *)tt_buff);
+                                        ttvn, tt_change);
 
                /* Even if we received the precomputed crc with the OGM, we
                 * prefer to recompute it to spot any possible inconsistency
index 46b60bd822fe9af5e607a071be6a83f351cfe7ed..4e83b293992b6c50e7429a90ca772d9fa05f3bf8 100644 (file)
@@ -43,10 +43,10 @@ struct orig_node *batadv_transtable_search(struct bat_priv *bat_priv,
                                           const uint8_t *addr);
 void batadv_tt_free(struct bat_priv *bat_priv);
 bool batadv_send_tt_response(struct bat_priv *bat_priv,
-                            struct tt_query_packet *tt_request);
+                            struct batadv_tt_query_packet *tt_request);
 bool batadv_is_my_client(struct bat_priv *bat_priv, const uint8_t *addr);
 void batadv_handle_tt_response(struct bat_priv *bat_priv,
-                              struct tt_query_packet *tt_response);
+                              struct batadv_tt_query_packet *tt_response);
 bool batadv_is_ap_isolated(struct bat_priv *bat_priv, uint8_t *src,
                           uint8_t *dst);
 void batadv_tt_update_orig(struct bat_priv *bat_priv,
index 9dddaf1c1ca0695140963138987e988c576ec15e..fb61d9cd912fce4a21dcc64d5d75394da722d5c9 100644 (file)
@@ -25,8 +25,8 @@
 #include <linux/kernel.h>
 
 #define BATADV_HEADER_LEN \
-       (ETH_HLEN + max(sizeof(struct unicast_packet), \
-                       sizeof(struct bcast_packet)))
+       (ETH_HLEN + max(sizeof(struct batadv_unicast_packet), \
+                       sizeof(struct batadv_bcast_packet)))
 
 struct hard_iface {
        struct list_head list;
@@ -211,7 +211,7 @@ struct bat_priv {
 #ifdef CONFIG_BATMAN_ADV_BLA
        struct bcast_duplist_entry bcast_duplist[BATADV_DUPLIST_SIZE];
        int bcast_duplist_curr;
-       struct bla_claim_dst claim_dest;
+       struct batadv_bla_claim_dst claim_dest;
 #endif
        spinlock_t forw_bat_list_lock; /* protects forw_bat_list */
        spinlock_t forw_bcast_list_lock; /* protects  */
@@ -250,7 +250,7 @@ struct socket_client {
 struct socket_packet {
        struct list_head list;
        size_t icmp_len;
-       struct icmp_packet_rr icmp_packet;
+       struct batadv_icmp_packet_rr icmp_packet;
 };
 
 struct tt_common_entry {
@@ -306,7 +306,7 @@ struct claim {
 
 struct tt_change_node {
        struct list_head list;
-       struct tt_change change;
+       struct batadv_tt_change change;
 };
 
 struct tt_req_node {
index c4603552f9d86ac10700a60fc9250985f524694e..8a2a3df17fff1f39739b624f61be34b4c24a3b10 100644 (file)
@@ -34,13 +34,13 @@ batadv_frag_merge_packet(struct list_head *head,
                         struct frag_packet_list_entry *tfp,
                         struct sk_buff *skb)
 {
-       struct unicast_frag_packet *up =
-               (struct unicast_frag_packet *)skb->data;
+       struct batadv_unicast_frag_packet *up;
        struct sk_buff *tmp_skb;
-       struct unicast_packet *unicast_packet;
+       struct batadv_unicast_packet *unicast_packet;
        int hdr_len = sizeof(*unicast_packet);
        int uni_diff = sizeof(*up) - hdr_len;
 
+       up = (struct batadv_unicast_frag_packet *)skb->data;
        /* set skb to the first part and tmp_skb to the second part */
        if (up->flags & BATADV_UNI_FRAG_HEAD) {
                tmp_skb = tfp->skb;
@@ -65,7 +65,8 @@ batadv_frag_merge_packet(struct list_head *head,
        kfree_skb(tmp_skb);
 
        memmove(skb->data + uni_diff, skb->data, hdr_len);
-       unicast_packet = (struct unicast_packet *)skb_pull(skb, uni_diff);
+       unicast_packet = (struct batadv_unicast_packet *)skb_pull(skb,
+                                                                 uni_diff);
        unicast_packet->header.packet_type = BATADV_UNICAST;
 
        return skb;
@@ -80,8 +81,9 @@ static void batadv_frag_create_entry(struct list_head *head,
                                     struct sk_buff *skb)
 {
        struct frag_packet_list_entry *tfp;
-       struct unicast_frag_packet *up =
-               (struct unicast_frag_packet *)skb->data;
+       struct batadv_unicast_frag_packet *up;
+
+       up = (struct batadv_unicast_frag_packet *)skb->data;
 
        /* free and oldest packets stand at the end */
        tfp = list_entry((head)->prev, typeof(*tfp), list);
@@ -115,10 +117,10 @@ static int batadv_frag_create_buffer(struct list_head *head)
 
 static struct frag_packet_list_entry *
 batadv_frag_search_packet(struct list_head *head,
-                         const struct unicast_frag_packet *up)
+                         const struct batadv_unicast_frag_packet *up)
 {
        struct frag_packet_list_entry *tfp;
-       struct unicast_frag_packet *tmp_up = NULL;
+       struct batadv_unicast_frag_packet *tmp_up = NULL;
        uint16_t search_seqno;
 
        if (up->flags & BATADV_UNI_FRAG_HEAD)
@@ -134,7 +136,7 @@ batadv_frag_search_packet(struct list_head *head,
                if (tfp->seqno == ntohs(up->seqno))
                        goto mov_tail;
 
-               tmp_up = (struct unicast_frag_packet *)tfp->skb->data;
+               tmp_up = (struct batadv_unicast_frag_packet *)tfp->skb->data;
 
                if (tfp->seqno == search_seqno) {
 
@@ -179,9 +181,9 @@ int batadv_frag_reassemble_skb(struct sk_buff *skb, struct bat_priv *bat_priv,
        struct orig_node *orig_node;
        struct frag_packet_list_entry *tmp_frag_entry;
        int ret = NET_RX_DROP;
-       struct unicast_frag_packet *unicast_packet =
-               (struct unicast_frag_packet *)skb->data;
+       struct batadv_unicast_frag_packet *unicast_packet;
 
+       unicast_packet = (struct batadv_unicast_frag_packet *)skb->data;
        *new_skb = NULL;
 
        orig_node = batadv_orig_hash_find(bat_priv, unicast_packet->orig);
@@ -220,10 +222,10 @@ out:
 int batadv_frag_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv,
                         struct hard_iface *hard_iface, const uint8_t dstaddr[])
 {
-       struct unicast_packet tmp_uc, *unicast_packet;
+       struct batadv_unicast_packet tmp_uc, *unicast_packet;
        struct hard_iface *primary_if;
        struct sk_buff *frag_skb;
-       struct unicast_frag_packet *frag1, *frag2;
+       struct batadv_unicast_frag_packet *frag1, *frag2;
        int uc_hdr_len = sizeof(*unicast_packet);
        int ucf_hdr_len = sizeof(*frag1);
        int data_len = skb->len - uc_hdr_len;
@@ -239,7 +241,7 @@ int batadv_frag_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv,
                goto dropped;
        skb_reserve(frag_skb, ucf_hdr_len);
 
-       unicast_packet = (struct unicast_packet *)skb->data;
+       unicast_packet = (struct batadv_unicast_packet *)skb->data;
        memcpy(&tmp_uc, unicast_packet, uc_hdr_len);
        skb_split(skb, frag_skb, data_len / 2 + uc_hdr_len);
 
@@ -247,8 +249,8 @@ int batadv_frag_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv,
            batadv_skb_head_push(frag_skb, ucf_hdr_len) < 0)
                goto drop_frag;
 
-       frag1 = (struct unicast_frag_packet *)skb->data;
-       frag2 = (struct unicast_frag_packet *)frag_skb->data;
+       frag1 = (struct batadv_unicast_frag_packet *)skb->data;
+       frag2 = (struct batadv_unicast_frag_packet *)frag_skb->data;
 
        memcpy(frag1, &tmp_uc, sizeof(tmp_uc));
 
@@ -287,7 +289,7 @@ out:
 int batadv_unicast_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv)
 {
        struct ethhdr *ethhdr = (struct ethhdr *)skb->data;
-       struct unicast_packet *unicast_packet;
+       struct batadv_unicast_packet *unicast_packet;
        struct orig_node *orig_node;
        struct neigh_node *neigh_node;
        int data_len = skb->len;
@@ -317,7 +319,7 @@ find_router:
        if (batadv_skb_head_push(skb, sizeof(*unicast_packet)) < 0)
                goto out;
 
-       unicast_packet = (struct unicast_packet *)skb->data;
+       unicast_packet = (struct batadv_unicast_packet *)skb->data;
 
        unicast_packet->header.version = BATADV_COMPAT_VERSION;
        /* batman packet type: unicast */
index 510e23f4179d83f352bc0d6dcbfe39a6054e2c4b..e0b6e335797ed46fe563c579b7995fbf4e8021d6 100644 (file)
@@ -35,11 +35,11 @@ int batadv_frag_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv,
 
 static inline int batadv_frag_can_reassemble(const struct sk_buff *skb, int mtu)
 {
-       const struct unicast_frag_packet *unicast_packet;
+       const struct batadv_unicast_frag_packet *unicast_packet;
        int uneven_correction = 0;
        unsigned int merged_size;
 
-       unicast_packet = (struct unicast_frag_packet *)skb->data;
+       unicast_packet = (struct batadv_unicast_frag_packet *)skb->data;
 
        if (unicast_packet->flags & BATADV_UNI_FRAG_LARGETAIL) {
                if (unicast_packet->flags & BATADV_UNI_FRAG_HEAD)
@@ -49,7 +49,7 @@ static inline int batadv_frag_can_reassemble(const struct sk_buff *skb, int mtu)
        }
 
        merged_size = (skb->len - sizeof(*unicast_packet)) * 2;
-       merged_size += sizeof(struct unicast_packet) + uneven_correction;
+       merged_size += sizeof(struct batadv_unicast_packet) + uneven_correction;
 
        return merged_size <= mtu;
 }
index c1fafa3b172f53f39c4fdc79b3722f46f0f65b84..309493d9128a7ff3c17d55e1cc6eae3e7940344e 100644 (file)
@@ -53,12 +53,12 @@ static void batadv_free_info(struct kref *ref)
 static int batadv_vis_info_cmp(const struct hlist_node *node, const void *data2)
 {
        const struct vis_info *d1, *d2;
-       const struct vis_packet *p1, *p2;
+       const struct batadv_vis_packet *p1, *p2;
 
        d1 = container_of(node, struct vis_info, hash_entry);
        d2 = data2;
-       p1 = (struct vis_packet *)d1->skb_packet->data;
-       p2 = (struct vis_packet *)d2->skb_packet->data;
+       p1 = (struct batadv_vis_packet *)d1->skb_packet->data;
+       p2 = (struct batadv_vis_packet *)d2->skb_packet->data;
        return batadv_compare_eth(p1->vis_orig, p2->vis_orig);
 }
 
@@ -68,12 +68,12 @@ static int batadv_vis_info_cmp(const struct hlist_node *node, const void *data2)
 static uint32_t batadv_vis_info_choose(const void *data, uint32_t size)
 {
        const struct vis_info *vis_info = data;
-       const struct vis_packet *packet;
+       const struct batadv_vis_packet *packet;
        const unsigned char *key;
        uint32_t hash = 0;
        size_t i;
 
-       packet = (struct vis_packet *)vis_info->skb_packet->data;
+       packet = (struct batadv_vis_packet *)vis_info->skb_packet->data;
        key = packet->vis_orig;
        for (i = 0; i < ETH_ALEN; i++) {
                hash += key[i];
@@ -169,7 +169,7 @@ static ssize_t batadv_vis_data_read_entry(struct seq_file *seq,
 }
 
 static void batadv_vis_data_insert_interfaces(struct hlist_head *list,
-                                             struct vis_packet *packet,
+                                             struct batadv_vis_packet *packet,
                                              struct vis_info_entry *entries)
 {
        int i;
@@ -187,7 +187,7 @@ static void batadv_vis_data_insert_interfaces(struct hlist_head *list,
 
 static void batadv_vis_data_read_entries(struct seq_file *seq,
                                         struct hlist_head *list,
-                                        struct vis_packet *packet,
+                                        struct batadv_vis_packet *packet,
                                         struct vis_info_entry *entries)
 {
        int i;
@@ -214,7 +214,7 @@ static void batadv_vis_seq_print_text_bucket(struct seq_file *seq,
 {
        struct hlist_node *node;
        struct vis_info *info;
-       struct vis_packet *packet;
+       struct batadv_vis_packet *packet;
        uint8_t *entries_pos;
        struct vis_info_entry *entries;
        struct if_list_entry *entry;
@@ -223,7 +223,7 @@ static void batadv_vis_seq_print_text_bucket(struct seq_file *seq,
        HLIST_HEAD(vis_if_list);
 
        hlist_for_each_entry_rcu(info, node, head, hash_entry) {
-               packet = (struct vis_packet *)info->skb_packet->data;
+               packet = (struct batadv_vis_packet *)info->skb_packet->data;
                entries_pos = (uint8_t *)packet + sizeof(*packet);
                entries = (struct vis_info_entry *)entries_pos;
 
@@ -334,15 +334,17 @@ static int batadv_recv_list_is_in(struct bat_priv *bat_priv,
  * is newer than old entries in the hash.
  */
 static struct vis_info *batadv_add_packet(struct bat_priv *bat_priv,
-                                         struct vis_packet *vis_packet,
+                                         struct batadv_vis_packet *vis_packet,
                                          int vis_info_len, int *is_new,
                                          int make_broadcast)
 {
        struct vis_info *info, *old_info;
-       struct vis_packet *search_packet, *old_packet;
+       struct batadv_vis_packet *search_packet, *old_packet;
        struct vis_info search_elem;
-       struct vis_packet *packet;
+       struct batadv_vis_packet *packet;
+       struct sk_buff *tmp_skb;
        int hash_added;
+       size_t len;
 
        *is_new = 0;
        /* sanity check */
@@ -353,15 +355,17 @@ static struct vis_info *batadv_add_packet(struct bat_priv *bat_priv,
        search_elem.skb_packet = dev_alloc_skb(sizeof(*search_packet));
        if (!search_elem.skb_packet)
                return NULL;
-       search_packet = (struct vis_packet *)skb_put(search_elem.skb_packet,
-                                                    sizeof(*search_packet));
+       len = sizeof(*search_packet);
+       tmp_skb = search_elem.skb_packet;
+       search_packet = (struct batadv_vis_packet *)skb_put(tmp_skb, len);
 
        memcpy(search_packet->vis_orig, vis_packet->vis_orig, ETH_ALEN);
        old_info = batadv_vis_hash_find(bat_priv, &search_elem);
        kfree_skb(search_elem.skb_packet);
 
        if (old_info) {
-               old_packet = (struct vis_packet *)old_info->skb_packet->data;
+               tmp_skb = old_info->skb_packet;
+               old_packet = (struct batadv_vis_packet *)tmp_skb->data;
                if (!batadv_seq_after(ntohl(vis_packet->seqno),
                                      ntohl(old_packet->seqno))) {
                        if (old_packet->seqno == vis_packet->seqno) {
@@ -385,22 +389,21 @@ static struct vis_info *batadv_add_packet(struct bat_priv *bat_priv,
        if (!info)
                return NULL;
 
-       info->skb_packet = dev_alloc_skb(sizeof(*packet) + vis_info_len +
-                                        ETH_HLEN);
+       len = sizeof(*packet) + vis_info_len;
+       info->skb_packet = dev_alloc_skb(len + ETH_HLEN);
        if (!info->skb_packet) {
                kfree(info);
                return NULL;
        }
        skb_reserve(info->skb_packet, ETH_HLEN);
-       packet = (struct vis_packet *)skb_put(info->skb_packet, sizeof(*packet)
-                                             + vis_info_len);
+       packet = (struct batadv_vis_packet *)skb_put(info->skb_packet, len);
 
        kref_init(&info->refcount);
        INIT_LIST_HEAD(&info->send_list);
        INIT_LIST_HEAD(&info->recv_list);
        info->first_seen = jiffies;
        info->bat_priv = bat_priv;
-       memcpy(packet, vis_packet, sizeof(*packet) + vis_info_len);
+       memcpy(packet, vis_packet, len);
 
        /* initialize and add new packet. */
        *is_new = 1;
@@ -430,7 +433,7 @@ static struct vis_info *batadv_add_packet(struct bat_priv *bat_priv,
 
 /* handle the server sync packet, forward if needed. */
 void batadv_receive_server_sync_packet(struct bat_priv *bat_priv,
-                                      struct vis_packet *vis_packet,
+                                      struct batadv_vis_packet *vis_packet,
                                       int vis_info_len)
 {
        struct vis_info *info;
@@ -456,11 +459,11 @@ end:
 
 /* handle an incoming client update packet and schedule forward if needed. */
 void batadv_receive_client_update_packet(struct bat_priv *bat_priv,
-                                        struct vis_packet *vis_packet,
+                                        struct batadv_vis_packet *vis_packet,
                                         int vis_info_len)
 {
        struct vis_info *info;
-       struct vis_packet *packet;
+       struct batadv_vis_packet *packet;
        int is_new;
        int vis_server = atomic_read(&bat_priv->vis_mode);
        int are_target = 0;
@@ -482,7 +485,7 @@ void batadv_receive_client_update_packet(struct bat_priv *bat_priv,
                goto end;
        /* note that outdated packets will be dropped at this point. */
 
-       packet = (struct vis_packet *)info->skb_packet->data;
+       packet = (struct batadv_vis_packet *)info->skb_packet->data;
 
        /* send only if we're the target server or ... */
        if (are_target && is_new) {
@@ -511,11 +514,11 @@ static int batadv_find_best_vis_server(struct bat_priv *bat_priv,
        struct hlist_node *node;
        struct hlist_head *head;
        struct orig_node *orig_node;
-       struct vis_packet *packet;
+       struct batadv_vis_packet *packet;
        int best_tq = -1;
        uint32_t i;
 
-       packet = (struct vis_packet *)info->skb_packet->data;
+       packet = (struct batadv_vis_packet *)info->skb_packet->data;
 
        for (i = 0; i < hash->size; i++) {
                head = &hash->table[i];
@@ -543,10 +546,10 @@ static int batadv_find_best_vis_server(struct bat_priv *bat_priv,
 /* Return true if the vis packet is full. */
 static bool batadv_vis_packet_full(const struct vis_info *info)
 {
-       const struct vis_packet *packet;
+       const struct batadv_vis_packet *packet;
        size_t num_items;
 
-       packet = (struct vis_packet *)info->skb_packet->data;
+       packet = (struct batadv_vis_packet *)info->skb_packet->data;
        num_items = BATADV_MAX_VIS_PACKET_SIZE / sizeof(struct vis_info_entry);
 
        if (num_items < packet->entries + 1)
@@ -565,13 +568,14 @@ static int batadv_generate_vis_packet(struct bat_priv *bat_priv)
        struct orig_node *orig_node;
        struct neigh_node *router;
        struct vis_info *info = bat_priv->my_vis_info;
-       struct vis_packet *packet = (struct vis_packet *)info->skb_packet->data;
+       struct batadv_vis_packet *packet;
        struct vis_info_entry *entry;
        struct tt_common_entry *tt_common_entry;
        int best_tq = -1;
        uint32_t i;
 
        info->first_seen = jiffies;
+       packet = (struct batadv_vis_packet *)info->skb_packet->data;
        packet->vis_type = atomic_read(&bat_priv->vis_mode);
 
        memcpy(packet->target_orig, batadv_broadcast_addr, ETH_ALEN);
@@ -691,14 +695,14 @@ static void batadv_broadcast_vis_packet(struct bat_priv *bat_priv,
        struct hlist_node *node;
        struct hlist_head *head;
        struct orig_node *orig_node;
-       struct vis_packet *packet;
+       struct batadv_vis_packet *packet;
        struct sk_buff *skb;
        struct hard_iface *hard_iface;
        uint8_t dstaddr[ETH_ALEN];
        uint32_t i;
 
 
-       packet = (struct vis_packet *)info->skb_packet->data;
+       packet = (struct batadv_vis_packet *)info->skb_packet->data;
 
        /* send to all routers in range. */
        for (i = 0; i < hash->size; i++) {
@@ -745,9 +749,9 @@ static void batadv_unicast_vis_packet(struct bat_priv *bat_priv,
        struct orig_node *orig_node;
        struct neigh_node *router = NULL;
        struct sk_buff *skb;
-       struct vis_packet *packet;
+       struct batadv_vis_packet *packet;
 
-       packet = (struct vis_packet *)info->skb_packet->data;
+       packet = (struct batadv_vis_packet *)info->skb_packet->data;
 
        orig_node = batadv_orig_hash_find(bat_priv, packet->target_orig);
        if (!orig_node)
@@ -773,13 +777,13 @@ static void batadv_send_vis_packet(struct bat_priv *bat_priv,
                                   struct vis_info *info)
 {
        struct hard_iface *primary_if;
-       struct vis_packet *packet;
+       struct batadv_vis_packet *packet;
 
        primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if)
                goto out;
 
-       packet = (struct vis_packet *)info->skb_packet->data;
+       packet = (struct batadv_vis_packet *)info->skb_packet->data;
        if (packet->header.ttl < 2) {
                pr_debug("Error - can't send vis packet: ttl exceeded\n");
                goto out;
@@ -838,10 +842,11 @@ static void batadv_send_vis_packets(struct work_struct *work)
  */
 int batadv_vis_init(struct bat_priv *bat_priv)
 {
-       struct vis_packet *packet;
+       struct batadv_vis_packet *packet;
        int hash_added;
        unsigned int len;
        unsigned long first_seen;
+       struct sk_buff *tmp_skb;
 
        if (bat_priv->vis_hash)
                return 0;
@@ -864,8 +869,8 @@ int batadv_vis_init(struct bat_priv *bat_priv)
                goto free_info;
 
        skb_reserve(bat_priv->my_vis_info->skb_packet, ETH_HLEN);
-       packet = (struct vis_packet *)skb_put(bat_priv->my_vis_info->skb_packet,
-                                             sizeof(*packet));
+       tmp_skb = bat_priv->my_vis_info->skb_packet;
+       packet = (struct batadv_vis_packet *)skb_put(tmp_skb, sizeof(*packet));
 
        /* prefill the vis info */
        first_seen = jiffies - msecs_to_jiffies(BATADV_VIS_INTERVAL);
index 16a1a6b7e2c3f073e81996b96477e63e76073883..d6bfcc7b6ac7a6726585602dbb735e0b4a499d97 100644 (file)
 
 int batadv_vis_seq_print_text(struct seq_file *seq, void *offset);
 void batadv_receive_server_sync_packet(struct bat_priv *bat_priv,
-                                      struct vis_packet *vis_packet,
+                                      struct batadv_vis_packet *vis_packet,
                                       int vis_info_len);
 void batadv_receive_client_update_packet(struct bat_priv *bat_priv,
-                                        struct vis_packet *vis_packet,
+                                        struct batadv_vis_packet *vis_packet,
                                         int vis_info_len);
 int batadv_vis_init(struct bat_priv *bat_priv);
 void batadv_vis_quit(struct bat_priv *bat_priv);