/* adjust all flags and log packets */
        while (batadv_iv_ogm_aggr_packet(buff_pos, forw_packet->packet_len,
                                         batadv_ogm_packet->tt_num_changes)) {
-
                /* we might have aggregated direct link packets with an
                 * ordinary base packet
                 */
         */
        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",
        if (time_before(send_time, forw_packet->send_time) &&
            time_after_eq(aggregation_end_time, forw_packet->send_time) &&
            (aggregated_bytes <= BATADV_MAX_AGGREGATION_BYTES)) {
-
                /* check aggregation compatibility
                 * -> direct link packets are broadcasted on
                 *    their interface only
        rcu_read_lock();
        hlist_for_each_entry_rcu(tmp_neigh_node, node,
                                 &orig_neigh_node->neigh_list, list) {
-
                if (!batadv_compare_eth(tmp_neigh_node->addr,
                                        orig_neigh_node->orig))
                        continue;
        rcu_read_lock();
        hlist_for_each_entry_rcu(tmp_neigh_node, node,
                                 &orig_node->neigh_list, list) {
-
                is_duplicate |= batadv_test_bit(tmp_neigh_node->real_bits,
                                                orig_node->last_real_seqno,
                                                seqno);
 
        /* is single hop (direct) neighbor */
        if (is_single_hop_neigh) {
-
                /* mark direct link on incoming interface */
                batadv_iv_ogm_forward(orig_node, ethhdr, batadv_ogm_packet,
                                      is_single_hop_neigh,
 
                spin_lock_bh(list_lock);
                hlist_for_each_entry_safe(claim, node, node_tmp,
                                          head, hash_entry) {
-
                        if (claim->backbone_gw != backbone_gw)
                                continue;
 
                           "bla_send_claim(): REQUEST of %pM to %pMon vid %d\n",
                           ethhdr->h_source, ethhdr->h_dest, vid);
                break;
-
        }
 
        if (vid != -1)
 
        batadv_bla_send_claim(bat_priv, mac, backbone_gw->vid,
                              BATADV_CLAIM_TYPE_ANNOUNCE);
-
 }
 
 /**
 
                claim->backbone_gw->crc ^= crc16(0, claim->addr, ETH_ALEN);
                batadv_backbone_gw_free_ref(claim->backbone_gw);
-
        }
        /* set (new) backbone gw */
        atomic_inc(&backbone_gw->refcount);
 
 
                buf++;
                i++;
-
        }
 
        spin_unlock_bh(&debug_log->lock);
 
                spin_lock_bh(list_lock);
                hlist_for_each_entry_safe(orig_node, node, node_tmp,
                                          head, hash_entry) {
-
                        hlist_del_rcu(node);
                        batadv_orig_node_free_ref(orig_node);
                }
        /* for all neighbors towards this originator ... */
        hlist_for_each_entry_safe(neigh_node, node, node_tmp,
                                  &orig_node->neigh_list, list) {
-
                last_seen = neigh_node->last_seen;
                if_incoming = neigh_node->if_incoming;
 
                    (if_incoming->if_status == BATADV_IF_INACTIVE) ||
                    (if_incoming->if_status == BATADV_IF_NOT_IN_USE) ||
                    (if_incoming->if_status == BATADV_IF_TO_BE_REMOVED)) {
-
                        if ((if_incoming->if_status == BATADV_IF_INACTIVE) ||
                            (if_incoming->if_status == BATADV_IF_NOT_IN_USE) ||
                            (if_incoming->if_status == BATADV_IF_TO_BE_REMOVED))
 
 
        /* route added */
        } else if ((!curr_router) && (neigh_node)) {
-
                batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
                           "Adding route towards: %pM (via %pM)\n",
                           orig_node->orig, neigh_node->addr);
         */
        hlist_for_each_entry_rcu(tmp_neigh_node, node,
                                 &orig_node->neigh_list, list) {
-
                if (tmp_neigh_node == neigh_node)
                        continue;
 
        if (unicast_packet->header.packet_type == BATADV_UNICAST_FRAG &&
            batadv_frag_can_reassemble(skb,
                                       neigh_node->if_incoming->net_dev->mtu)) {
-
                ret = batadv_frag_reassemble_skb(skb, bat_priv, &new_skb);
 
                if (ret == NET_RX_DROP)
 
        /* packet for me */
        if (batadv_is_my_mac(unicast_packet->dest)) {
-
                ret = batadv_frag_reassemble_skb(skb, bat_priv, &new_skb);
 
                if (ret == NET_RX_DROP)
 
        spin_lock_bh(&bat_priv->forw_bcast_list_lock);
        hlist_for_each_entry_safe(forw_packet, tmp_node, safe_tmp_node,
                                  &bat_priv->forw_bcast_list, list) {
-
                /* if purge_outstanding_packets() was called with an argument
                 * we delete only packets belonging to the given interface
                 */
        spin_lock_bh(&bat_priv->forw_bat_list_lock);
        hlist_for_each_entry_safe(forw_packet, tmp_node, safe_tmp_node,
                                  &bat_priv->forw_bat_list, list) {
-
                /* if purge_outstanding_packets() was called with an argument
                 * we delete only packets belonging to the given interface
                 */
 
                                               struct batadv_tt_global_entry,
                                               common);
        return tt_global_entry;
-
 }
 
 static void
        batadv_hash_remove(bat_priv->tt.global_hash, batadv_compare_tt,
                           batadv_choose_orig, tt_global->common.addr);
        batadv_tt_global_entry_free_ref(tt_global);
-
 }
 
 void batadv_tt_local_add(struct net_device *soft_iface, const uint8_t *addr,
                batadv_tt_local_purge_list(bat_priv, head);
                spin_unlock_bh(list_lock);
        }
-
 }
 
 static void batadv_tt_local_table_free(struct batadv_priv *bat_priv)
                batadv_tt_orig_list_entry_free_ref(orig_entry);
        }
        spin_unlock_bh(&tt_global_entry->list_lock);
-
 }
 
 static void
        if (!ret)
                kfree_skb(skb);
        return ret;
-
 }
 
 static bool
                }
                spin_unlock_bh(list_lock);
        }
-
 }
 
 static int batadv_tt_commit_changes(struct batadv_priv *bat_priv,
        batadv_tt_local_entry_free_ref(tt_local_entry);
 out:
        return ret;
-
 }
 
 bool batadv_tt_add_temporary_global_entry(struct batadv_priv *bat_priv,
 
        is_head = !!(up->flags & BATADV_UNI_FRAG_HEAD);
 
        list_for_each_entry(tfp, head, list) {
-
                if (!tfp->skb)
                        continue;
 
        struct batadv_frag_packet_list_entry *pf, *tmp_pf;
 
        if (!list_empty(head)) {
-
                list_for_each_entry_safe(pf, tmp_pf, head, list) {
                        kfree_skb(pf->skb);
                        list_del(&pf->list);