#include <linux/phy.h>

#include <net/arp.h>

#include <net/macsec.h>

#include "vlan.h"

#include "vlanproc.h"

goto out;

}

ether_addr_copy(vlan->real_dev_addr, real_dev->dev_addr);

if (vlan->flags & VLAN_FLAG_GVRP)

netif_carrier_on(dev);

return 0;

out:

netif_carrier_off(dev);

return err;

dev_mc_unsync(real_dev, dev);

dev_uc_unsync(real_dev, dev);

if (!ether_addr_equal(dev->dev_addr, real_dev->dev_addr))

dev_uc_del(real_dev, dev->dev_addr);

static int vlan_dev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)

{

struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;

struct ifreq ifrr;

int err = -EOPNOTSUPP;

case SIOCGMIIPHY:

case SIOCGMIIREG:

case SIOCSMIIREG:

break;

}

{

struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;

}

static void vlan_dev_set_rx_mode(struct net_device *vlan_dev)

return 0;

}

struct netlink_ext_ack *extack)

{

struct vlan_dev_priv *vlan = vlan_dev_priv(dev);

struct net_device *real_dev;

unsigned int max_mtu;

__be16 proto;

return -EINVAL;

}

if (!real_dev) {

NL_SET_ERR_MSG_MOD(extack, "link does not exist");

return -ENODEV;

holding_time = msg->content.eg_info.holding_time;

dprintk("(%s) entry = %p, holding_time = %u\n",

mpc->dev->name, entry, holding_time);

if (entry == NULL && holding_time) {

entry = mpc->eg_ops->add_entry(msg, mpc);

mpc->eg_ops->put(entry);

}

}

if (sock_flag(sk, SOCK_ZAPPED)) {

}

if (sk->sk_type == SOCK_SEQPACKET &&

return ax25_rt;

}

struct sk_buff *ax25_rt_build_path(struct sk_buff *skb, ax25_address *src,

ax25_address *dest, ax25_digi *digi)

batman-adv-y += hash.o

batman-adv-$(CONFIG_BATMAN_ADV_DEBUG) += log.o

batman-adv-y += main.o

batman-adv-$(CONFIG_BATMAN_ADV_MCAST) += multicast.o

batman-adv-$(CONFIG_BATMAN_ADV_MCAST) += multicast_forw.o

batman-adv-y += netlink.o

batman-adv-y += originator.o

batman-adv-y += routing.o

batman-adv-y += send.o

batman-adv-$(CONFIG_BATMAN_ADV_TRACING) += trace.o

batman-adv-y += tp_meter.o

batman-adv-y += translation-table.o

}

/**

* @name: name of the algorithm to select

*

* with the correct name was found. Any previous selected algorithm will not be

* deinitialized and the new selected algorithm will also not be initialized.

* It is therefore not allowed to call batadv_algo_select outside the creation

*

* Return: 0 on success or negative error number in case of failure

*/

#include <linux/kref.h>

#include <linux/list.h>

#include <linux/lockdep.h>

#include <linux/mutex.h>

#include <linux/netdevice.h>

#include <linux/netlink.h>

/**

* batadv_iv_ogm_orig_get() - retrieve or create (if does not exist) an

* originator

* @addr: mac address of the originator

*

* Return: the originator object corresponding to the passed mac address or NULL

static void batadv_iv_ogm_send_to_if(struct batadv_forw_packet *forw_packet,

struct batadv_hard_iface *hard_iface)

{

const char *fwd_str;

u8 packet_num;

s16 buff_pos;

/* we might have aggregated direct link packets with an

* ordinary base packet

*/

forw_packet->if_incoming == hard_iface)

batadv_ogm_packet->flags |= BATADV_DIRECTLINK;

else

/* send a batman ogm packet */

static void batadv_iv_ogm_emit(struct batadv_forw_packet *forw_packet)

{

if (!forw_packet->if_incoming) {

pr_err("Error - can't forward packet: incoming iface not specified\n");

return;

}

if (WARN_ON(!forw_packet->if_outgoing))

return;

return;

}

* batadv_iv_ogm_can_aggregate() - find out if an OGM can be aggregated on an

* existing forward packet

* @new_bat_ogm_packet: OGM packet to be aggregated

* @packet_len: (total) length of the OGM

* @send_time: timestamp (jiffies) when the packet is to be sent

* @directlink: true if this is a direct link packet

const struct batadv_forw_packet *forw_packet)

{

struct batadv_ogm_packet *batadv_ogm_packet;

struct batadv_hard_iface *primary_if = NULL;

bool res = false;

unsigned long aggregation_end_time;

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);

/* we can aggregate the current packet to this aggregated packet

* if:

*

* - the send time is within our MAX_AGGREGATION_MS time

* - the resulting packet won't be bigger than

* otherwise aggregation is not possible

*/

if (!time_before(send_time, forw_packet->send_time) ||

!time_after_eq(aggregation_end_time, forw_packet->send_time))

return false;

return false;

/* packet is not leaving on the same interface. */

struct batadv_hard_iface *if_outgoing,

int own_packet)

{

struct batadv_forw_packet *forw_packet_aggr;

struct sk_buff *skb;

unsigned char *skb_buff;

unsigned int skb_size;

atomic_t *queue_left = own_packet ? NULL : &bat_priv->batman_queue_left;

else

skb_size = packet_len;

memcpy(skb_buff, packet_buff, packet_len);

forw_packet_aggr->own = own_packet;

forw_packet_aggr->send_time = send_time;

/* save packet direct link flag status */

if (direct_link)

INIT_DELAYED_WORK(&forw_packet_aggr->delayed_work,

batadv_iv_send_outstanding_bat_ogm_packet);

const unsigned char *packet_buff,

int packet_len, bool direct_link)

{

skb_put_data(forw_packet_aggr->skb, packet_buff, packet_len);

forw_packet_aggr->packet_len += packet_len;

/* save packet direct link flag status */

}

/**

* batadv_iv_ogm_queue_add() - queue up an OGM for transmission

* @packet_buff: pointer to the OGM

* @packet_len: (total) length of the OGM

* @if_incoming: interface where the packet was received

struct batadv_hard_iface *if_incoming,

struct batadv_hard_iface *if_outgoing)

{

u16 tvlv_len;

if (batadv_ogm_packet->ttl <= 1) {

static void

batadv_iv_ogm_slide_own_bcast_window(struct batadv_hard_iface *hard_iface)

{

struct batadv_hashtable *hash = bat_priv->orig_hash;

struct hlist_head *head;

struct batadv_orig_node *orig_node;

*/

static void batadv_iv_ogm_schedule_buff(struct batadv_hard_iface *hard_iface)

{

unsigned char **ogm_buff = &hard_iface->bat_iv.ogm_buff;

struct batadv_ogm_packet *batadv_ogm_packet;

struct batadv_hard_iface *primary_if, *tmp_hard_iface;

*/

rcu_read_lock();

list_for_each_entry_rcu(tmp_hard_iface, &batadv_hardif_list, list) {

continue;

if (!kref_get_unless_zero(&tmp_hard_iface->refcount))

/**

* batadv_iv_ogm_orig_update() - use OGM to update corresponding data in an

* originator

* @orig_node: the orig node who originally emitted the ogm packet

* @orig_ifinfo: ifinfo for the outgoing interface of the orig_node

* @ethhdr: Ethernet header of the OGM

struct batadv_hard_iface *if_incoming,

struct batadv_hard_iface *if_outgoing)

{

struct batadv_neigh_node *neigh_node = NULL, *tmp_neigh_node;

struct batadv_neigh_ifinfo *neigh_ifinfo;

u8 total_count;

const struct batadv_hard_iface *if_incoming,

struct batadv_hard_iface *if_outgoing)

{

struct batadv_orig_node *orig_node;

struct batadv_orig_ifinfo *orig_ifinfo = NULL;

struct batadv_neigh_node *neigh_node;

struct batadv_hard_iface *if_incoming,

struct batadv_hard_iface *if_outgoing)

{

struct batadv_hardif_neigh_node *hardif_neigh = NULL;

struct batadv_neigh_node *router = NULL;

struct batadv_neigh_node *router_router = NULL;

static void batadv_iv_ogm_process(const struct sk_buff *skb, int ogm_offset,

struct batadv_hard_iface *if_incoming)

{

struct batadv_orig_node *orig_neigh_node, *orig_node;

struct batadv_hard_iface *hard_iface;

struct batadv_ogm_packet *ogm_packet;

if (hard_iface->if_status != BATADV_IF_ACTIVE)

continue;

continue;

if (batadv_compare_eth(ethhdr->h_source,

if (hard_iface->if_status != BATADV_IF_ACTIVE)

continue;

continue;

if (!kref_get_unless_zero(&hard_iface->refcount))

delayed_work = to_delayed_work(work);

forw_packet = container_of(delayed_work, struct batadv_forw_packet,

delayed_work);

if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_DEACTIVATING) {

dropped = true;

static int batadv_iv_ogm_receive(struct sk_buff *skb,

struct batadv_hard_iface *if_incoming)

{

struct batadv_ogm_packet *ogm_packet;

u8 *packet_pos;

int ogm_offset;

* @msg: Netlink message to dump into

* @portid: Port making netlink request

* @seq: Sequence number of netlink message

* @if_outgoing: Limit dump to entries with this outgoing interface

* @orig_node: Originator to dump

* @neigh_node: Single hops neighbour

* @msg: Netlink message to dump into

* @portid: Port making netlink request

* @seq: Sequence number of netlink message

* @if_outgoing: Limit dump to entries with this outgoing interface

* @orig_node: Originator to dump

* @sub_s: Number of sub entries to skip

* @msg: Netlink message to dump into

* @portid: Port making netlink request

* @seq: Sequence number of netlink message

* @if_outgoing: Limit dump to entries with this outgoing interface

* @head: Bucket to be dumped

* @idx_s: Number of entries to be skipped

* batadv_iv_ogm_orig_dump() - Dump the originators into a message

* @msg: Netlink message to dump into

* @cb: Control block containing additional options

* @if_outgoing: Limit dump to entries with this outgoing interface

*/

static void

* @msg: Netlink message to dump into

* @portid: Port making netlink request

* @seq: Sequence number of netlink message

* @hard_iface: Hard interface to dump the neighbours for

* @idx_s: Number of entries to skip

*

* batadv_iv_ogm_neigh_dump() - Dump the neighbours into a message

* @msg: Netlink message to dump into

* @cb: Control block containing additional options

* @single_hardif: Limit dump to this hard interface

*/

static void

} else {

list_for_each_entry_rcu(hard_iface, &batadv_hardif_list,

list) {

continue;

if (i_hardif++ < i_hardif_s)

/**

* batadv_iv_init_sel_class() - initialize GW selection class

*/

static void batadv_iv_init_sel_class(struct batadv_priv *bat_priv)

{

* @msg: Netlink message to dump into

* @portid: Port making netlink request

* @cb: Control block containing additional options

* @gw_node: Gateway to be dumped

*

* Return: Error code, or 0 on success

* batadv_iv_gw_dump() - Dump gateways into a message

* @msg: Netlink message to dump into

* @cb: Control block containing additional options

*/

static void batadv_iv_gw_dump(struct sk_buff *msg, struct netlink_callback *cb,

struct batadv_priv *bat_priv)

static void batadv_v_iface_activate(struct batadv_hard_iface *hard_iface)

{

struct batadv_hard_iface *primary_if;

primary_if = batadv_primary_if_get_selected(bat_priv);

*/

static void batadv_v_iface_update_mac(struct batadv_hard_iface *hard_iface)

{

struct batadv_hard_iface *primary_if;

primary_if = batadv_primary_if_get_selected(bat_priv);

* @msg: Netlink message to dump into

* @portid: Port making netlink request

* @seq: Sequence number of netlink message

* @hard_iface: The hard interface to be dumped

* @idx_s: Entries to be skipped

*

* message

* @msg: Netlink message to dump into

* @cb: Control block containing additional options

* @single_hardif: Limit dumping to this hard interface

*/

static void

}

} else {

list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {

continue;

if (i_hardif++ < i_hardif_s)

* @msg: Netlink message to dump into

* @portid: Port making netlink request

* @seq: Sequence number of netlink message

* @if_outgoing: Limit dump to entries with this outgoing interface

* @orig_node: Originator to dump

* @neigh_node: Single hops neighbour

* @msg: Netlink message to dump into

* @portid: Port making netlink request

* @seq: Sequence number of netlink message

* @if_outgoing: Limit dump to entries with this outgoing interface

* @orig_node: Originator to dump

* @sub_s: Number of sub entries to skip

* @msg: Netlink message to dump into

* @portid: Port making netlink request

* @seq: Sequence number of netlink message

* @if_outgoing: Limit dump to entries with this outgoing interface

* @head: Bucket to be dumped

* @idx_s: Number of entries to be skipped

* batadv_v_orig_dump() - Dump the originators into a message

* @msg: Netlink message to dump into

* @cb: Control block containing additional options

* @if_outgoing: Limit dump to entries with this outgoing interface

*/

static void

/**

* batadv_v_init_sel_class() - initialize GW selection class

*/

static void batadv_v_init_sel_class(struct batadv_priv *bat_priv)

{

/**

* batadv_v_gw_get_best_gw_node() - retrieve the best GW node

*

* Return: the GW node having the best GW-metric, NULL if no GW is known

*/

/**

* batadv_v_gw_is_eligible() - check if a originator would be selected as GW

* @curr_gw_orig: originator representing the currently selected GW

* @orig_node: the originator representing the new candidate

*

* @msg: Netlink message to dump into

* @portid: Port making netlink request

* @cb: Control block containing additional options

* @gw_node: Gateway to be dumped

*

* Return: Error code, or 0 on success

* batadv_v_gw_dump() - Dump gateways into a message

* @msg: Netlink message to dump into

* @cb: Control block containing additional options

*/

static void batadv_v_gw_dump(struct sk_buff *msg, struct netlink_callback *cb,

struct batadv_priv *bat_priv)

u32 *pthroughput)

{

struct batadv_hard_iface *hard_iface = neigh->if_incoming;

struct ethtool_link_ksettings link_settings;

struct net_device *real_netdev;

struct station_info sinfo;

/* don't query throughput when no longer associated with any

* batman-adv interface

*/

return false;

/* if the user specified a customised value for this interface, then

default_throughput:

if (!(hard_iface->bat_v.flags & BATADV_WARNING_DEFAULT)) {

"WiFi driver or ethtool info does not provide information about link speeds on interface %s, therefore defaulting to hardcoded throughput values of %u.%1u Mbps. Consider overriding the throughput manually or checking your driver.\n",

hard_iface->net_dev->name,

BATADV_THROUGHPUT_DEFAULT_VALUE / 10,

batadv_v_elp_wifi_neigh_probe(struct batadv_hardif_neigh_node *neigh)

{

struct batadv_hard_iface *hard_iface = neigh->if_incoming;

unsigned long last_tx_diff;

struct sk_buff *skb;

int probe_len, i;

bat_v = container_of(work, struct batadv_hard_iface_bat_v, elp_wq.work);

hard_iface = container_of(bat_v, struct batadv_hard_iface, bat_v);

if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_DEACTIVATING)

goto out;

/* update orig field of every elp iface belonging to this mesh */

rcu_read_lock();

list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {

continue;

batadv_v_elp_iface_activate(primary_iface, hard_iface);

/**

* batadv_v_elp_neigh_update() - update an ELP neighbour node

* @neigh_addr: the neighbour interface address

* @if_incoming: the interface the packet was received through

* @elp_packet: the received ELP packet

int batadv_v_elp_packet_recv(struct sk_buff *skb,

struct batadv_hard_iface *if_incoming)

{

struct batadv_elp_packet *elp_packet;

struct batadv_hard_iface *primary_if;

struct ethhdr *ethhdr;

/**

* batadv_v_ogm_orig_get() - retrieve and possibly create an originator node

* @addr: the address of the originator

*

* Return: the orig_node corresponding to the specified address. If such an

/**

* batadv_v_ogm_start_timer() - restart the OGM sending timer

*/

static void batadv_v_ogm_start_timer(struct batadv_priv *bat_priv)

{

static void batadv_v_ogm_send_to_if(struct sk_buff *skb,

struct batadv_hard_iface *hard_iface)

{

if (hard_iface->if_status != BATADV_IF_ACTIVE) {

kfree_skb(skb);

static void batadv_v_ogm_queue_on_if(struct sk_buff *skb,

struct batadv_hard_iface *hard_iface)

{

if (!atomic_read(&bat_priv->aggregated_ogms)) {

batadv_v_ogm_send_to_if(skb, hard_iface);

}

/**

*/

{

struct batadv_hard_iface *hard_iface;

struct batadv_ogm2_packet *ogm_packet;

/* broadcast on every interface */

rcu_read_lock();

list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {

continue;

if (!kref_get_unless_zero(&hard_iface->refcount))

bat_priv = container_of(bat_v, struct batadv_priv, bat_v);

mutex_lock(&bat_priv->bat_v.ogm_buff_mutex);

mutex_unlock(&bat_priv->bat_v.ogm_buff_mutex);

}

*/

int batadv_v_ogm_iface_enable(struct batadv_hard_iface *hard_iface)

{

batadv_v_ogm_start_queue_timer(hard_iface);

batadv_v_ogm_start_timer(bat_priv);

*/

void batadv_v_ogm_primary_iface_set(struct batadv_hard_iface *primary_iface)

{

struct batadv_ogm2_packet *ogm_packet;

mutex_lock(&bat_priv->bat_v.ogm_buff_mutex);

/**

* batadv_v_forward_penalty() - apply a penalty to the throughput metric

* forwarded with B.A.T.M.A.N. V OGMs

* @if_incoming: the interface where the OGM has been received

* @if_outgoing: the interface where the OGM has to be forwarded to

* @throughput: the current throughput

/**

* batadv_v_ogm_forward() - check conditions and forward an OGM to the given

* outgoing interface

* @ogm_received: previously received OGM to be forwarded

* @orig_node: the originator which has been updated

* @neigh_node: the neigh_node through with the OGM has been received

/**

* batadv_v_ogm_metric_update() - update route metric based on OGM

* @ogm2: OGM2 structure

* @orig_node: Originator structure for which the OGM has been received

* @neigh_node: the neigh_node through with the OGM has been received

/**

* batadv_v_ogm_route_update() - update routes based on OGM

* @ethhdr: the Ethernet header of the OGM2

* @ogm2: OGM2 structure

* @orig_node: Originator structure for which the OGM has been received

/**

* batadv_v_ogm_process_per_outif() - process a batman v OGM for an outgoing if

* @ethhdr: the Ethernet header of the OGM2

* @ogm2: OGM2 structure

* @orig_node: Originator structure for which the OGM has been received

static void batadv_v_ogm_process(const struct sk_buff *skb, int ogm_offset,

struct batadv_hard_iface *if_incoming)

{

struct ethhdr *ethhdr;

struct batadv_orig_node *orig_node = NULL;

struct batadv_hardif_neigh_node *hardif_neigh = NULL;

if (hard_iface->if_status != BATADV_IF_ACTIVE)

continue;

continue;

if (!kref_get_unless_zero(&hard_iface->refcount))

int batadv_v_ogm_packet_recv(struct sk_buff *skb,

struct batadv_hard_iface *if_incoming)

{

struct batadv_ogm2_packet *ogm_packet;

struct ethhdr *ethhdr;

int ogm_offset;

/**

* batadv_v_ogm_init() - initialise the OGM2 engine

*

* Return: 0 on success or a negative error code in case of failure

*/

/**

* batadv_v_ogm_free() - free OGM private resources

*/

void batadv_v_ogm_free(struct batadv_priv *bat_priv)

{

/**

* batadv_bit_get_packet() - receive and process one packet within the sequence

* number window

* @seq_bits: pointer to the sequence number receive packet

* @seq_num_diff: difference between the current/received sequence number and

* the last sequence number

/**

* batadv_claim_hash_find() - looks for a claim in the claim hash

* @data: search data (may be local/static data)

*

* Return: claim if found or NULL otherwise.

/**

* batadv_backbone_hash_find() - looks for a backbone gateway in the hash

* @addr: the address of the originator

* @vid: the VLAN ID

*

/**

* batadv_bla_send_claim() - sends a claim frame according to the provided info

* @mac: the mac address to be announced within the claim

* @vid: the VLAN ID

* @claimtype: the type of the claim (CLAIM, UNCLAIM, ANNOUNCE, ...)

struct sk_buff *skb;

struct ethhdr *ethhdr;

struct batadv_hard_iface *primary_if;

u8 *hw_src;

struct batadv_bla_claim_dst local_claim_dest;

__be32 zeroip = 0;

sizeof(local_claim_dest));

local_claim_dest.type = claimtype;

skb = arp_create(ARPOP_REPLY, ETH_P_ARP,

/* IP DST: 0.0.0.0 */

zeroip,

/* IP SRC: 0.0.0.0 */

zeroip,

/* Ethernet DST: Broadcast */

}

skb_reset_mac_header(skb);

batadv_inc_counter(bat_priv, BATADV_CNT_RX);

batadv_add_counter(bat_priv, BATADV_CNT_RX_BYTES,

skb->len + ETH_HLEN);

report_work);

bat_priv = backbone_gw->bat_priv;

"Possible loop on VLAN %d detected which can't be handled by BLA - please check your network setup!\n",

batadv_print_vid(backbone_gw->vid));

snprintf(vid_str, sizeof(vid_str), "%d",

/**

* batadv_bla_get_backbone_gw() - finds or creates a backbone gateway

* @orig: the mac address of the originator

* @vid: the VLAN ID

* @own_backbone: set if the requested backbone is local

/**

* batadv_bla_update_own_backbone_gw() - updates the own backbone gw for a VLAN

* @primary_if: the selected primary interface

* @vid: VLAN identifier

*

/**

* batadv_bla_answer_request() - answer a bla request by sending own claims

* @primary_if: interface where the request came on

* @vid: the vid where the request came on

*

/**

* batadv_bla_send_announce() - Send an announcement frame

* @backbone_gw: our backbone gateway which should be announced

*/

static void batadv_bla_send_announce(struct batadv_priv *bat_priv,

/**

* batadv_bla_add_claim() - Adds a claim in the claim hash

* @mac: the mac address of the claim

* @vid: the VLAN ID of the frame

* @backbone_gw: the backbone gateway which claims it

/**

* batadv_bla_del_claim() - delete a claim from the claim hash

* @mac: mac address of the claim to be removed

* @vid: VLAN id for the claim to be removed

*/

/**

* batadv_handle_announce() - check for ANNOUNCE frame

* @an_addr: announcement mac address (ARP Sender HW address)

* @backbone_addr: originator address of the sender (Ethernet source MAC)

* @vid: the VLAN ID of the frame

/**

* batadv_handle_request() - check for REQUEST frame

* @backbone_addr: backbone address to be requested (ARP sender HW MAC)

* @ethhdr: ethernet header of a packet

* @vid: the VLAN ID of the frame

/**

* batadv_handle_unclaim() - check for UNCLAIM frame

* @backbone_addr: originator address of the backbone (Ethernet source)

* @claim_addr: Client to be unclaimed (ARP sender HW MAC)

* @vid: the VLAN ID of the frame

/**

* batadv_handle_claim() - check for CLAIM frame

* @backbone_addr: originator address of the backbone (Ethernet Source)

* @claim_addr: client mac address to be claimed (ARP sender HW MAC)

* @vid: the VLAN ID of the frame

/**

* batadv_check_claim_group() - check for claim group membership

* @primary_if: the primary interface of this batman interface

* @hw_src: the Hardware source in the ARP Header

* @hw_dst: the Hardware destination in the ARP Header

/**

* batadv_bla_process_claim() - Check if this is a claim frame, and process it

* @skb: the frame to be checked

*

* Return: true if it was a claim frame, otherwise return false to

/**

* batadv_bla_purge_backbone_gw() - Remove backbone gateways after a timeout or

* immediately

* @now: whether the whole hash shall be wiped now

*

* Check when we last heard from other nodes, and remove them in case of

/**

* batadv_bla_purge_claims() - Remove claims after a timeout or immediately

* @primary_if: the selected primary interface, may be NULL if now is set

* @now: whether the whole hash shall be wiped now

*

/**

* batadv_bla_update_orig_address() - Update the backbone gateways when the own

* originator address changes

* @primary_if: the new selected primary_if

* @oldif: the old primary interface, may be NULL

*/

/**

* batadv_bla_send_loopdetect() - send a loopdetect frame

* @backbone_gw: the backbone gateway for which a loop should be detected

*

* To detect loops that the bridge loop avoidance can't handle, send a loop

/**

* batadv_bla_status_update() - purge bla interfaces if necessary

*/

void batadv_bla_status_update(struct net_device *net_dev)

{

/**

* batadv_bla_init() - initialize all bla structures

*

* Return: 0 on success, < 0 on error.

*/

/**

* batadv_bla_check_duplist() - Check if a frame is in the broadcast dup.

* @skb: contains the multicast packet to be checked

* @payload_ptr: pointer to position inside the head buffer of the skb

* marking the start of the data to be CRC'ed

/**

* batadv_bla_check_ucast_duplist() - Check if a frame is in the broadcast dup.

* @skb: contains the multicast packet to be checked, decapsulated from a

* unicast_packet

*

/**

* batadv_bla_check_bcast_duplist() - Check if a frame is in the broadcast dup.

* @skb: contains the bcast_packet to be checked

*

* Check if it is on our broadcast list. Another gateway might have sent the

/**

* batadv_bla_is_backbone_gw_orig() - Check if the originator is a gateway for

* the VLAN identified by vid.

* @orig: originator mac address

* @vid: VLAN identifier

*

* @orig_node: the orig_node of the frame

* @hdr_size: maximum length of the frame

*

* otherwise it returns false.

*/

bool batadv_bla_is_backbone_gw(struct sk_buff *skb,

/**

* batadv_bla_free() - free all bla structures

*

*/

void batadv_bla_free(struct batadv_priv *bat_priv)

{

/**

* batadv_bla_loopdetect_check() - check and handle a detected loop

* @skb: the packet to check

* @primary_if: interface where the request came on

* @vid: the VLAN ID of the frame

/**

* batadv_bla_rx() - check packets coming from the mesh.

* @skb: the frame to be checked

* @vid: the VLAN ID of the frame

* @packet_type: the batman packet type this frame came in

/**

* batadv_bla_tx() - check packets going into the mesh

* @skb: the frame to be checked

* @vid: the VLAN ID of the frame

*

{

struct batadv_hard_iface *primary_if = NULL;

int portid = NETLINK_CB(cb->skb).portid;

struct batadv_hashtable *hash;

struct batadv_priv *bat_priv;

int bucket = cb->args[0];

int idx = cb->args[1];

int ret = 0;

hash = bat_priv->bla.claim_hash;

primary_if = batadv_primary_if_get_selected(bat_priv);

out:

batadv_hardif_put(primary_if);

return ret;

}

{

struct batadv_hard_iface *primary_if = NULL;

int portid = NETLINK_CB(cb->skb).portid;

struct batadv_hashtable *hash;

struct batadv_priv *bat_priv;

int bucket = cb->args[0];

int idx = cb->args[1];

int ret = 0;

hash = bat_priv->bla.backbone_hash;

primary_if = batadv_primary_if_get_selected(bat_priv);

out:

batadv_hardif_put(primary_if);

return ret;

}

/**

* batadv_bla_check_claim() - check if address is claimed

*

* @addr: mac address of which the claim status is checked

* @vid: the VLAN ID

*

/**

* batadv_dat_start_timer() - initialise the DAT periodic worker

*/

static void batadv_dat_start_timer(struct batadv_priv *bat_priv)

{

/**

* __batadv_dat_purge() - delete entries from the DAT local storage

* @to_purge: function in charge to decide whether an entry has to be purged or

* not. This function takes the dat_entry as argument and has to

* returns a boolean value: true is the entry has to be deleted,

/**

* batadv_dat_entry_hash_find() - look for a given dat_entry in the local hash

* table

* @ip: search key

* @vid: VLAN identifier

*

/**

* batadv_dat_entry_add() - add a new dat entry or update it if already exists

* @ip: ipv4 to add/edit

* @mac_addr: mac address to assign to the given ipv4

* @vid: VLAN identifier

/**

* batadv_dbg_arp() - print a debug message containing all the ARP packet

* details

* @skb: ARP packet

* @hdr_size: size of the possible header before the ARP packet

* @msg: message to print together with the debugging information

/**

* batadv_choose_next_candidate() - select the next DHT candidate

* @cands: candidates array

* @select: number of candidates already present in the array

* @ip_key: key to look up in the DHT

/**

* batadv_dat_select_candidates() - select the nodes which the DHT message has

* to be sent to

* @ip_dst: ipv4 to look up in the DHT

* @vid: VLAN identifier

*

/**

* batadv_dat_forward_data() - copy and send payload to the selected candidates

* @skb: payload to send

* @ip: the DHT key

* @vid: VLAN identifier

/**

* batadv_dat_tvlv_container_update() - update the dat tvlv container after dat

* setting change

*/

static void batadv_dat_tvlv_container_update(struct batadv_priv *bat_priv)

{

/**

* batadv_dat_status_update() - update the dat tvlv container after dat

* setting change

*/

void batadv_dat_status_update(struct net_device *net_dev)

{

/**

* batadv_dat_tvlv_ogm_handler_v1() - process incoming dat tvlv container

* @orig: the orig_node of the ogm

* @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags)

* @tvlv_value: tvlv buffer containing the gateway data

/**

* batadv_dat_hash_free() - free the local DAT hash table

*/

static void batadv_dat_hash_free(struct batadv_priv *bat_priv)

{

/**

* batadv_dat_init() - initialise the DAT internals

*

* Return: 0 in case of success, a negative error code otherwise

*/

/**

* batadv_dat_free() - free the DAT internals

*/

void batadv_dat_free(struct batadv_priv *bat_priv)

{

{

struct batadv_hard_iface *primary_if = NULL;

int portid = NETLINK_CB(cb->skb).portid;

struct batadv_hashtable *hash;

struct batadv_priv *bat_priv;

int bucket = cb->args[0];

int idx = cb->args[1];

int ret = 0;

hash = bat_priv->dat.hash;

primary_if = batadv_primary_if_get_selected(bat_priv);

out:

batadv_hardif_put(primary_if);

return ret;

}

/**

* batadv_arp_get_type() - parse an ARP packet and gets the type

* @skb: packet to analyse

* @hdr_size: size of the possible header before the ARP packet in the skb

*

/**

* batadv_dat_arp_create_reply() - create an ARP Reply

* @ip_src: ARP sender IP

* @ip_dst: ARP target IP

* @hw_src: Ethernet source and ARP sender MAC

{

struct sk_buff *skb;

ip_src, hw_dst, hw_src, hw_dst);

if (!skb)

return NULL;

/**

* batadv_dat_snoop_outgoing_arp_request() - snoop the ARP request and try to

* answer using DAT

* @skb: packet to check

*

* Return: true if the message has been sent to the dht candidates, false

bool ret = false;

struct batadv_dat_entry *dat_entry = NULL;

struct sk_buff *skb_new;

int hdr_size = 0;

unsigned short vid;

* client will answer itself. DAT would only generate a

* duplicate packet.

*

* additional DAT answer may trigger kernel warnings about

* a packet coming from the wrong port.

*/

if (!skb_new)

goto out;

batadv_inc_counter(bat_priv, BATADV_CNT_RX);

batadv_add_counter(bat_priv, BATADV_CNT_RX_BYTES,

/**

* batadv_dat_snoop_incoming_arp_request() - snoop the ARP request and try to

* answer using the local DAT storage

* @skb: packet to check

* @hdr_size: size of the encapsulation header

*

/**

* batadv_dat_snoop_outgoing_arp_reply() - snoop the ARP reply and fill the DHT

* @skb: packet to check

*/

void batadv_dat_snoop_outgoing_arp_reply(struct batadv_priv *bat_priv,

/**

* batadv_dat_snoop_incoming_arp_reply() - snoop the ARP reply and fill the

* local DAT storage only

* @skb: packet to check

* @hdr_size: size of the encapsulation header

*

/**

* batadv_dat_put_dhcp() - puts addresses from a DHCP packet into the DHT and

* DAT cache

* @chaddr: the DHCP client MAC address

* @yiaddr: the DHCP client IP address

* @hw_dst: the DHCP server MAC address

/**

* batadv_dat_snoop_outgoing_dhcp_ack() - snoop DHCPACK and fill DAT with it

* @skb: the packet to snoop

* @proto: ethernet protocol hint (behind a potential vlan)

* @vid: VLAN identifier

/**

* batadv_dat_snoop_incoming_dhcp_ack() - snoop DHCPACK and fill DAT cache

* @skb: the packet to snoop

* @hdr_size: header size, up to the tail of the batman-adv header

*

/**

* batadv_dat_drop_broadcast_packet() - check if an ARP request has to be

* dropped (because the node has already obtained the reply via DAT) or not

* @forw_packet: the broadcast packet

*

* Return: true if the node can drop the packet, false otherwise.

/**

* batadv_dat_init_own_addr() - assign a DAT address to the node itself

* @primary_if: a pointer to the primary interface

*/

static inline void

/**

* batadv_dat_inc_counter() - increment the correct DAT packet counter

* @subtype: the 4addr subtype of the packet to be counted

*

* Updates the ethtool statistics for the received packet if it is a DAT subtype

struct batadv_hard_iface *recv_if,

struct batadv_orig_node *orig_node_src)

{

struct batadv_neigh_node *neigh_node = NULL;

struct batadv_frag_packet *packet;

u16 total_size;

/**

* batadv_gw_get_selected_gw_node() - Get currently selected gateway

*

* Return: selected gateway (with increased refcnt), NULL on errors

*/

/**

* batadv_gw_get_selected_orig() - Get originator of currently selected gateway

*

* Return: orig_node of selected gateway (with increased refcnt), NULL on errors

*/

/**

* batadv_gw_reselect() - force a gateway reselection

*

* Set a flag to remind the GW component to perform a new gateway reselection.

* However this function does not ensure that the current gateway is going to be

/**

* batadv_gw_check_client_stop() - check if client mode has been switched off

*

* This function assumes the caller has checked that the gw state *is actually

* changing*. This function is not supposed to be called when there is no state

/**

* batadv_gw_election() - Elect the best gateway

*/

void batadv_gw_election(struct batadv_priv *bat_priv)

{

/**

* batadv_gw_check_election() - Elect orig node as best gateway when eligible

* @orig_node: orig node which is to be checked

*/

void batadv_gw_check_election(struct batadv_priv *bat_priv,

/**

* batadv_gw_node_add() - add gateway node to list of available gateways

* @orig_node: originator announcing gateway capabilities

* @gateway: announced bandwidth information

*

/**

* batadv_gw_node_get() - retrieve gateway node from list of available gateways

* @orig_node: originator announcing gateway capabilities

*

* Return: gateway node if found or NULL otherwise.

/**

* batadv_gw_node_update() - update list of available gateways with changed

* bandwidth information

* @orig_node: originator announcing gateway capabilities

* @gateway: announced bandwidth information

*/

/**

* batadv_gw_node_delete() - Remove orig_node from gateway list

* @orig_node: orig node which is currently in process of being removed

*/

void batadv_gw_node_delete(struct batadv_priv *bat_priv,

}

/**

*/

void batadv_gw_node_free(struct batadv_priv *bat_priv)

{

int batadv_gw_dump(struct sk_buff *msg, struct netlink_callback *cb)

{

struct batadv_hard_iface *primary_if = NULL;

struct batadv_priv *bat_priv;

int ret;

primary_if = batadv_primary_if_get_selected(bat_priv);

if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {

out:

batadv_hardif_put(primary_if);

return ret;

}

/**

* batadv_gw_out_of_range() - check if the dhcp request destination is the best

* gateway

* @skb: the outgoing packet

*

* Check if the skb is a DHCP request and if it is sent to the current best GW

/**

* batadv_gw_tvlv_container_update() - update the gw tvlv container after

* gateway setting change

*/

void batadv_gw_tvlv_container_update(struct batadv_priv *bat_priv)

{

/**

* batadv_gw_tvlv_ogm_handler_v1() - process incoming gateway tvlv container

* @orig: the orig_node of the ogm

* @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags)

* @tvlv_value: tvlv buffer containing the gateway data

/**

* batadv_gw_init() - initialise the gateway handling internals

*/

void batadv_gw_init(struct batadv_priv *bat_priv)

{

/**

* batadv_gw_free() - free the gateway handling internals

*/

void batadv_gw_free(struct batadv_priv *bat_priv)

{

#include "distributed-arp-table.h"

#include "gateway_client.h"

#include "log.h"

#include "originator.h"

#include "send.h"

#include "translation-table.h"

/**

struct batadv_hard_iface *hard_iface;

hard_iface = container_of(ref, struct batadv_hard_iface, refcount);

kfree_rcu(hard_iface, rcu);

}

* is important to prevent this new interface from being used to create a new

* mesh network (this behaviour would lead to a batman-over-batman

* configuration). This function recursively checks all the fathers of the

*

* Return: true if the device is descendant of a batman-adv mesh interface (or

* if it is a batman-adv interface itself), false otherwise

bool ret;

/* check if this is a batman-adv mesh interface */

return true;

iflink = dev_get_iflink(net_dev);

}

hard_iface = batadv_hardif_get_by_netdev(netdev);

goto out;

real_net = batadv_getlink_net(netdev, net);

/* iflink to itself, most likely physical device */

}

static struct batadv_hard_iface *

{

struct batadv_hard_iface *hard_iface;

rcu_read_lock();

list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {

continue;

if (hard_iface->if_status == BATADV_IF_ACTIVE &&

/**

* batadv_hardif_recalc_extra_skbroom() - Recalculate skbuff extra head/tailroom

*/

{

const struct batadv_hard_iface *hard_iface;

unsigned short lower_header_len = ETH_HLEN;

if (hard_iface->if_status == BATADV_IF_NOT_IN_USE)

continue;

continue;

lower_header_len = max_t(unsigned short, lower_header_len,

/* fragmentation headers don't strip the unicast/... header */

needed_headroom += sizeof(struct batadv_frag_packet);

}

/**

*

* slave interfaces)

*/

{

const struct batadv_hard_iface *hard_iface;

int min_mtu = INT_MAX;

hard_iface->if_status != BATADV_IF_TO_BE_ACTIVATED)

continue;

continue;

min_mtu = min_t(int, hard_iface->net_dev->mtu, min_mtu);

*/

atomic_set(&bat_priv->packet_size_max, min_mtu);

* overhead from the maximum amount of bytes that was just computed.

*/

}

/**

* batadv_update_min_mtu() - Adjusts the MTU if a new interface with a smaller

* MTU appeared

*/

{

int limit_mtu;

int mtu;

if (bat_priv->mtu_set_by_user)

limit_mtu = bat_priv->mtu_set_by_user;

limit_mtu = ETH_DATA_LEN;

mtu = min(mtu, limit_mtu);

/* Check if the local translate table should be cleaned up to match a

* new (and smaller) MTU.

*/

}

static void

if (hard_iface->if_status != BATADV_IF_INACTIVE)

goto out;

bat_priv->algo_ops->iface.update_mac(hard_iface);

hard_iface->if_status = BATADV_IF_TO_BE_ACTIVATED;

if (!primary_if)

batadv_primary_if_select(bat_priv, hard_iface);

hard_iface->net_dev->name);

if (bat_priv->algo_ops->iface.activate)

bat_priv->algo_ops->iface.activate(hard_iface);

hard_iface->if_status = BATADV_IF_INACTIVE;

hard_iface->net_dev->name);

}

/**

*

* Return: 0 on success or negative error number in case of failure

*/

int batadv_hardif_enable_interface(struct batadv_hard_iface *hard_iface,

{

struct batadv_priv *bat_priv;

__be16 ethertype = htons(ETH_P_BATMAN);

int ret;

hardif_mtu = READ_ONCE(hard_iface->net_dev->mtu);

if (hardif_mtu < ETH_MIN_MTU + max_header_len)

return -EINVAL;

kref_get(&hard_iface->refcount);

ret = netdev_master_upper_dev_link(hard_iface->net_dev,

if (ret)

goto err_dev;

hard_iface->batman_adv_ptype.dev = hard_iface->net_dev;

dev_add_pack(&hard_iface->batman_adv_ptype);

hard_iface->net_dev->name);

if (atomic_read(&bat_priv->fragmentation) &&

hardif_mtu < required_mtu)

"The MTU of interface %s is too small (%i) to handle the transport of batman-adv packets. Packets going over this interface will be fragmented on layer2 which could impact the performance. Setting the MTU to %i would solve the problem.\n",

hard_iface->net_dev->name, hardif_mtu,

required_mtu);

if (!atomic_read(&bat_priv->fragmentation) &&

hardif_mtu < required_mtu)

"The MTU of interface %s is too small (%i) to handle the transport of batman-adv packets. If you experience problems getting traffic through try increasing the MTU to %i.\n",

hard_iface->net_dev->name, hardif_mtu,

required_mtu);

if (batadv_hardif_is_iface_up(hard_iface))

batadv_hardif_activate_interface(hard_iface);

else

"Not using interface %s (retrying later): interface not active\n",

hard_iface->net_dev->name);

if (bat_priv->algo_ops->iface.enabled)

bat_priv->algo_ops->iface.enabled(hard_iface);

return 0;

err_upper:

err_dev:

batadv_hardif_put(hard_iface);

return ret;

}

/**

*

* This function is only using RCU for locking - the result can therefore be

* off when another function is modifying the list at the same time. The

*

* Return: number of connected/enslaved hard interfaces

*/

{

struct batadv_hard_iface *hard_iface;

size_t count = 0;

rcu_read_lock();

list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {

continue;

count++;

}

/**

* @hard_iface: hard interface to be removed

*/

void batadv_hardif_disable_interface(struct batadv_hard_iface *hard_iface)

{

struct batadv_hard_iface *primary_if = NULL;

batadv_hardif_deactivate_interface(hard_iface);

if (hard_iface->if_status != BATADV_IF_INACTIVE)

goto out;

hard_iface->net_dev->name);

dev_remove_pack(&hard_iface->batman_adv_ptype);

batadv_hardif_put(hard_iface);

if (hard_iface == primary_if) {

struct batadv_hard_iface *new_if;

batadv_primary_if_select(bat_priv, new_if);

batadv_hardif_put(new_if);

/* delete all references to this hard_iface */

batadv_purge_orig_ref(bat_priv);

batadv_purge_outstanding_packets(bat_priv, hard_iface);

/* nobody uses this interface anymore */

batadv_gw_check_client_stop(bat_priv);

batadv_hardif_put(hard_iface);

out:

ASSERT_RTNL();

if (!batadv_is_valid_iface(net_dev))

hard_iface = kzalloc(sizeof(*hard_iface), GFP_ATOMIC);

if (!hard_iface)

hard_iface->net_dev = net_dev;

hard_iface->if_status = BATADV_IF_NOT_IN_USE;

INIT_LIST_HEAD(&hard_iface->list);

batadv_hardif_generation++;

return hard_iface;

}

static void batadv_hardif_remove_interface(struct batadv_hard_iface *hard_iface)

}

/**

* @event: NETDEV_* event to handle

* @net_dev: net_device which generated an event

*

* Return: NOTIFY_* result

*/

struct net_device *net_dev)

{

struct batadv_priv *bat_priv;

switch (event) {

case NETDEV_REGISTER:

bat_priv = netdev_priv(net_dev);

break;

}

struct batadv_hard_iface *primary_if = NULL;

struct batadv_priv *bat_priv;

hard_iface = batadv_hardif_get_by_netdev(net_dev);

if (!hard_iface && (event == NETDEV_REGISTER ||

batadv_hardif_remove_interface(hard_iface);

break;

case NETDEV_CHANGEMTU:

break;

case NETDEV_CHANGEADDR:

if (hard_iface->if_status == BATADV_IF_NOT_IN_USE)

batadv_check_known_mac_addr(hard_iface->net_dev);

bat_priv->algo_ops->iface.update_mac(hard_iface);

primary_if = batadv_primary_if_get_selected(bat_priv);

enum batadv_hard_if_state {

/**

* @BATADV_IF_NOT_IN_USE: interface is not used as slave interface of a

*/

BATADV_IF_NOT_IN_USE,

/**

* interface

*/

BATADV_IF_TO_BE_REMOVED,

struct batadv_hard_iface*

batadv_hardif_get_by_netdev(const struct net_device *net_dev);

int batadv_hardif_enable_interface(struct batadv_hard_iface *hard_iface,

void batadv_hardif_disable_interface(struct batadv_hard_iface *hard_iface);

void batadv_hardif_release(struct kref *ref);

int batadv_hardif_no_broadcast(struct batadv_hard_iface *if_outgoing,

u8 *orig_addr, u8 *orig_neigh);

/**

* batadv_primary_if_get_selected() - Get reference to primary interface

*

* Return: primary interface (with increased refcnt), otherwise NULL

*/

/**

* batadv_debug_log() - Add debug log entry

* @fmt: format string

*

* Return: 0 on success or negative error number in case of failure

/**

* _batadv_dbg() - Store debug output with(out) rate limiting

* @type: type of debug message

* @ratelimited: whether output should be rate limited

* @fmt: format string

* @arg: variable arguments

/**

* batadv_dbg() - Store debug output without rate limiting

* @type: type of debug message

* @arg: format string and variable arguments

*/

#define batadv_dbg(type, bat_priv, arg...) \

/**

* batadv_dbg_ratelimited() - Store debug output with rate limiting

* @type: type of debug message

* @arg: format string and variable arguments

*/

#define batadv_dbg_ratelimited(type, bat_priv, arg...) \

/**

* batadv_info() - Store message in debug buffer and print it to kmsg buffer

* @fmt: format string

* @arg: variable arguments

*/

/**

* batadv_err() - Store error in debug buffer and print it to kmsg buffer

* @fmt: format string

* @arg: variable arguments

*/

#include "gateway_common.h"

#include "hard-interface.h"

#include "log.h"

#include "multicast.h"

#include "netlink.h"

#include "network-coding.h"

#include "originator.h"

#include "routing.h"

#include "send.h"

#include "tp_meter.h"

#include "translation-table.h"

}

/**

*

* Return: 0 on success or negative error number in case of failure

*/

{

int ret;

spin_lock_init(&bat_priv->forw_bat_list_lock);

#endif

spin_lock_init(&bat_priv->tvlv.container_list_lock);

spin_lock_init(&bat_priv->tvlv.handler_list_lock);

spin_lock_init(&bat_priv->tp_list_lock);

INIT_HLIST_HEAD(&bat_priv->forw_bat_list);

#endif

INIT_HLIST_HEAD(&bat_priv->tvlv.container_list);

INIT_HLIST_HEAD(&bat_priv->tvlv.handler_list);

INIT_HLIST_HEAD(&bat_priv->tp_list);

bat_priv->gw.generation = 0;

}

/**

*/

{

atomic_set(&bat_priv->mesh_state, BATADV_MESH_DEACTIVATING);

/**

* batadv_is_my_mac() - check if the given mac address belongs to any of the

* real interfaces in the current mesh

* @addr: the address to check

*

* Return: 'true' if the mac address was found, false otherwise.

if (hard_iface->if_status != BATADV_IF_ACTIVE)

continue;

continue;

if (batadv_compare_eth(hard_iface->net_dev->dev_addr, addr)) {

if (unlikely(skb->mac_len != ETH_HLEN || !skb_mac_header(skb)))

goto err_free;

goto err_free;

if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)

goto err_free;

/**

* batadv_vlan_ap_isola_get() - return AP isolation status for the given vlan

* @vid: the VLAN identifier for which the AP isolation attributed as to be

* looked up

*

bool batadv_vlan_ap_isola_get(struct batadv_priv *bat_priv, unsigned short vid)

{

bool ap_isolation_enabled = false;

/* if the AP isolation is requested on a VLAN, then check for its

* setting in the proper VLAN private data structure

*/

if (vlan) {

ap_isolation_enabled = atomic_read(&vlan->ap_isolation);

}

return ap_isolation_enabled;

/**

* batadv_throw_uevent() - Send an uevent with batman-adv specific env data

* @type: subsystem type of event. Stored in uevent's BATTYPE

* @action: action type of event. Stored in uevent's BATACTION

* @data: string with additional information to the event (ignored for

struct kobject *bat_kobj;

char *uevent_env[4] = { NULL, NULL, NULL, NULL };

uevent_env[0] = kasprintf(GFP_ATOMIC,

"%s%s", BATADV_UEV_TYPE_VAR,

#define BATADV_DRIVER_DEVICE "batman-adv"

#ifndef BATADV_SOURCE_VERSION

#endif

/* B.A.T.M.A.N. parameters */

#define BATADV_THROUGHPUT_MAX_VALUE 0xFFFFFFFF

#define BATADV_JITTER 20

/* Time To Live of broadcast messages */

#define BATADV_TTL 50

*/

#define BATADV_TQ_SIMILARITY_THRESHOLD 50

#define BATADV_MAX_AGGREGATION_BYTES 512

#define BATADV_MAX_AGGREGATION_MS 100

#define BATADV_TP_MAX_NUM 5

/**

*/

enum batadv_mesh_state {

BATADV_MESH_INACTIVE,

/** @BATADV_MESH_ACTIVE: interface is up and running */

extern unsigned char batadv_broadcast_addr[];

extern struct workqueue_struct *batadv_event_workqueue;

bool batadv_is_my_mac(struct batadv_priv *bat_priv, const u8 *addr);

int batadv_max_header_len(void);

void batadv_skb_set_priority(struct sk_buff *skb, int offset);

#define batadv_seq_after(x, y) batadv_seq_before(y, x)

/**

* @idx: counter index which should be modified

* @count: value to increase counter by

*

}

/**

* @i: counter index which should be modified

*/

#define batadv_inc_counter(b, i) batadv_add_counter(b, i, 1)

* Marek Lindner, Simon Wunderlich

*/

#include "main.h"

#include <linux/atomic.h>

/**

* batadv_sum_counter() - Sum the cpu-local counters for index 'idx'

* @idx: index of counter to sum up

*

* Return: sum of all cpu-local counters

static int batadv_interface_set_mac_addr(struct net_device *dev, void *p)

{

struct batadv_priv *bat_priv = netdev_priv(dev);

struct sockaddr *addr = p;

u8 old_addr[ETH_ALEN];

return 0;

rcu_read_lock();

batadv_tt_local_remove(bat_priv, old_addr, vlan->vid,

"mac address changed", false);

batadv_tt_local_add(dev, addr->sa_data, vlan->vid,

* @dev: registered network device to modify

*

* We do not actually need to set any rx filters for the virtual batman

* multicast listeners for instance.

*/

static void batadv_interface_set_rx_mode(struct net_device *dev)

}

static netdev_tx_t batadv_interface_tx(struct sk_buff *skb,

{

struct ethhdr *ethhdr;

struct batadv_hard_iface *primary_if = NULL;

struct batadv_bcast_packet *bcast_packet;

static const u8 stp_addr[ETH_ALEN] = {0x01, 0x80, 0xC2, 0x00,

/* reset control block to avoid left overs from previous users */

memset(skb->cb, 0, sizeof(struct batadv_skb_cb));

vid = batadv_get_vid(skb, 0);

skb_reset_mac_header(skb);

/* Register the client MAC in the transtable */

if (!is_multicast_ether_addr(ethhdr->h_source) &&

!batadv_bla_is_loopdetect_mac(ethhdr->h_source)) {

vid, skb->skb_iif,

skb->mark);

if (!client_added)

/**

* batadv_interface_rx() - receive ethernet frame on local batman-adv interface

* @hdr_size: size of already parsed batman-adv header

* @orig_node: originator from which the batman-adv packet was sent

*

* skb->data has still point to the batman-adv header with the size @hdr_size.

* The caller has to have parsed this header already and made sure that at least

* @hdr_size bytes are still available for pull in @skb.

* unicast packets will be dropped directly when it was sent between two

* isolated clients.

*/

struct sk_buff *skb, int hdr_size,

struct batadv_orig_node *orig_node)

{

struct batadv_bcast_packet *batadv_bcast_packet;

struct vlan_ethhdr *vhdr;

struct ethhdr *ethhdr;

unsigned short vid;

}

/* skb->dev & skb->pkt_type are set here */

skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);

batadv_inc_counter(bat_priv, BATADV_CNT_RX);

}

/**

* after rcu grace period

* @ref: kref pointer of the vlan object

*/

{

hlist_del_rcu(&vlan->list);

kfree_rcu(vlan, rcu);

}

/**

* @vid: the identifier of the vlan object to retrieve

*

* Return: the private data of the vlan matching the vid passed as argument or

* NULL otherwise. The refcounter of the returned object is incremented by 1.

*/

unsigned short vid)

{

rcu_read_lock();

if (vlan_tmp->vid != vid)

continue;

}

/**

* @vid: the VLAN identifier

*

* Return: 0 on success, a negative error otherwise.

*/

{

if (vlan) {

return -EEXIST;

}

vlan = kzalloc(sizeof(*vlan), GFP_ATOMIC);

if (!vlan) {

return -ENOMEM;

}

atomic_set(&vlan->ap_isolation, 0);

kref_get(&vlan->refcount);

/* add a new TT local entry. This one will be marked with the NOPURGE

* flag

*/

BATADV_NULL_IFINDEX, BATADV_NO_MARK);

return 0;

}

/**

* @vlan: the object to remove

*/

{

/* explicitly remove the associated TT local entry because it is marked

* with the NOPURGE flag

*/

vlan->vid, "vlan interface destroyed", false);

}

/**

unsigned short vid)

{

struct batadv_priv *bat_priv = netdev_priv(dev);

/* only 802.1Q vlans are supported.

* batman-adv does not know how to handle other types

vid |= BATADV_VLAN_HAS_TAG;

/* if a new vlan is getting created and it already exists, it means that

* refcount in order to revive the object.

*

* if it does not exist then create it.

*/

if (!vlan)

/* add a new TT local entry. This one will be marked with the NOPURGE

* flag. This must be added again, even if the vlan object already

* exists, because the entry was deleted by kill_vid()

*/

BATADV_NULL_IFINDEX, BATADV_NO_MARK);

return 0;

unsigned short vid)

{

struct batadv_priv *bat_priv = netdev_priv(dev);

/* only 802.1Q vlans are supported. batman-adv does not know how to

* handle other types

return -EINVAL;

/* "priority tag" frames are handled like "untagged" frames

*/

if (vid == 0)

return 0;

if (!vlan)

return -ENOENT;

/* finally free the vlan object */

return 0;

}

}

/**

* @dev: registered network device to modify

*

* Return: error code on failures

*/

{

struct batadv_priv *bat_priv;

u32 random_seqno;

batadv_set_lockdep_class(dev);

bat_priv = netdev_priv(dev);

/* batadv_interface_stats() needs to be available as soon as

* register_netdevice() has been called

atomic_set(&bat_priv->log_level, 0);

#endif

atomic_set(&bat_priv->fragmentation, 1);

atomic_set(&bat_priv->bcast_queue_left, BATADV_BCAST_QUEUE_LEN);

atomic_set(&bat_priv->batman_queue_left, BATADV_BATMAN_QUEUE_LEN);

}

/**

* @slave_dev: net_device which should become the slave interface

* @extack: extended ACK report struct

*

* Return: 0 if successful or error otherwise.

*/

struct net_device *slave_dev,

struct netlink_ext_ack *extack)

{

int ret = -EINVAL;

hard_iface = batadv_hardif_get_by_netdev(slave_dev);

goto out;

ret = batadv_hardif_enable_interface(hard_iface, dev);

}

/**

* @slave_dev: net_device which should be removed from the master interface

*

* Return: 0 if successful or error otherwise.

*/

struct net_device *slave_dev)

{

struct batadv_hard_iface *hard_iface;

hard_iface = batadv_hardif_get_by_netdev(slave_dev);

goto out;

batadv_hardif_disable_interface(hard_iface);

}

static const struct net_device_ops batadv_netdev_ops = {

.ndo_open = batadv_interface_open,

.ndo_stop = batadv_interface_release,

.ndo_get_stats = batadv_interface_stats,

.ndo_set_rx_mode = batadv_interface_set_rx_mode,

.ndo_start_xmit = batadv_interface_tx,

.ndo_validate_addr = eth_validate_addr,

};

static void batadv_get_drvinfo(struct net_device *dev,

};

/**

* @dev: Device to cleanup and remove

*/

{

batadv_mesh_free(dev);

}

/**

* @dev: registered network device to modify

*/

{

ether_setup(dev);

dev->netdev_ops = &batadv_netdev_ops;

dev->needs_free_netdev = true;

dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;

dev->priv_flags |= IFF_NO_QUEUE;

dev->lltx = true;

/* can't call min_mtu, because the needed variables

* have not been initialized yet

*/

dev->mtu = ETH_DATA_LEN;

/* generate random address */

eth_hw_addr_random(dev);

}

/**

* @tb: IFLA_INFO_DATA netlink attributes

* @data: enum batadv_ifla_attrs attributes

* @extack: extended ACK report struct

*

* Return: 0 if successful or error otherwise.

*/

struct netlink_ext_ack *extack)

{

struct batadv_algo_ops *algo_ops;

}

/**

* @dev: network device to register

* @extack: extended ACK report struct

*

* Return: 0 if successful or error otherwise.

*/

struct netlink_ext_ack *extack)

{

struct batadv_priv *bat_priv = netdev_priv(dev);

const char *algo_name;

int err;

}

/**

* netlink

* @head: list pointer

*/

struct list_head *head)

{

struct batadv_hard_iface *hard_iface;

list_for_each_entry(hard_iface, &batadv_hardif_list, list) {

batadv_hardif_disable_interface(hard_iface);

}

/* destroy the "untagged" VLAN */

if (vlan) {

}

}

/**

* @net_dev: device which should be checked

*

* Return: true when net_dev is a batman-adv interface, false otherwise

*/

{

if (net_dev->netdev_ops->ndo_start_xmit == batadv_interface_tx)

return true;

struct rtnl_link_ops batadv_link_ops __read_mostly = {

.kind = "batadv",

.priv_size = sizeof(struct batadv_priv),

.maxtype = IFLA_BATADV_MAX,

.policy = batadv_ifla_policy,

};

* Marek Lindner

*/

#include "main.h"

#include <net/rtnetlink.h>

int batadv_skb_head_push(struct sk_buff *skb, unsigned int len);

struct sk_buff *skb, int hdr_size,

struct batadv_orig_node *orig_node);

extern struct rtnl_link_ops batadv_link_ops;

unsigned short vid);

/**

* possibly release it

* @vlan: the vlan object to release

*/

{

if (!vlan)

return;

}

/**

* batadv_mcast_start_timer() - schedule the multicast periodic worker

*/

static void batadv_mcast_start_timer(struct batadv_priv *bat_priv)

{

}

/**

*

* of the according net device is increased.

*

* Return: NULL if no such bridge exists. Otherwise the net device of the

* bridge.

*/

{

rcu_read_lock();

do {

}

/**

* node for IPv4

* @dev: the interface to check

*

*

* Return: BATADV_NO_FLAGS if present, BATADV_MCAST_WANT_NO_RTR4 otherwise.

*/

{

struct in_device *in_dev = __in_dev_get_rcu(dev);

}

/**

* node for IPv6

* @dev: the interface to check

*

* Return: BATADV_NO_FLAGS if present, BATADV_MCAST_WANT_NO_RTR6 otherwise.

*/

#if IS_ENABLED(CONFIG_IPV6_MROUTE)

{

struct inet6_dev *in6_dev = __in6_dev_get(dev);

}

#else

static inline u8

{

return BATADV_MCAST_WANT_NO_RTR6;

}

#endif

/**

* otherwise pass NULL

*

* Checks the presence of IPv4 and IPv6 multicast routers on this

* BATADV_MCAST_WANT_NO_RTR6: No IPv6 multicast router is present

* The former two OR'd: no multicast router is present

*/

struct net_device *bridge)

{

u8 flags = BATADV_NO_FLAGS;

rcu_read_lock();

rcu_read_unlock();

/**

* batadv_mcast_mla_rtr_flags_bridge_get() - get mcast router flags from bridge

* otherwise pass NULL

*

* Checks the presence of IPv4 and IPv6 multicast routers behind a bridge.

static u8 batadv_mcast_mla_rtr_flags_bridge_get(struct batadv_priv *bat_priv,

struct net_device *bridge)

{

u8 flags = BATADV_NO_FLAGS;

if (!bridge)

/**

* batadv_mcast_mla_rtr_flags_get() - get multicast router flags

* otherwise pass NULL

*

* Checks the presence of IPv4 and IPv6 multicast routers on this

{

u8 flags = BATADV_MCAST_WANT_NO_RTR4 | BATADV_MCAST_WANT_NO_RTR6;

flags &= batadv_mcast_mla_rtr_flags_bridge_get(bat_priv, bridge);

return flags;

/**

* batadv_mcast_mla_forw_flags_get() - get multicast forwarding flags

*

* Checks if all active hard interfaces have an MTU larger or equal to 1280

* bytes (IPv6 minimum MTU).

if (hard_iface->if_status != BATADV_IF_ACTIVE)

continue;

continue;

if (hard_iface->net_dev->mtu < IPV6_MIN_MTU) {

/**

* batadv_mcast_mla_flags_get() - get the new multicast flags

*

* Return: A set of flags for the current/next TVLV, querier and

* bridge state.

static struct batadv_mcast_mla_flags

batadv_mcast_mla_flags_get(struct batadv_priv *bat_priv)

{

struct batadv_mcast_querier_state *qr4, *qr6;

struct batadv_mcast_mla_flags mla_flags;

struct net_device *bridge;

}

/**

* @dev: the device to collect multicast addresses from

* @mcast_list: a list to put found addresses into

* @flags: flags indicating the new multicast state

*

* Collects multicast addresses of IPv4 multicast listeners residing

* the given mcast_list. In general, multicast listeners provided by

* your multicast receiving applications run directly on this node.

*

* items added to the mcast_list otherwise.

*/

static int

struct hlist_head *mcast_list,

struct batadv_mcast_mla_flags *flags)

{

}

/**

* @dev: the device to collect multicast addresses from

* @mcast_list: a list to put found addresses into

* @flags: flags indicating the new multicast state

*

* Collects multicast addresses of IPv6 multicast listeners residing

* the given mcast_list. In general, multicast listeners provided by

* your multicast receiving applications run directly on this node.

*

*/

#if IS_ENABLED(CONFIG_IPV6)

static int

struct hlist_head *mcast_list,

struct batadv_mcast_mla_flags *flags)

{

}

#else

static inline int

struct hlist_head *mcast_list,

struct batadv_mcast_mla_flags *flags)

{

#endif

/**

* @dev: the device to collect multicast addresses from

* @mcast_list: a list to put found addresses into

* @flags: flags indicating the new multicast state

*

* Collects multicast addresses of multicast listeners residing

* the given mcast_list. In general, multicast listeners provided by

* your multicast receiving applications run directly on this node.

*

* items added to the mcast_list otherwise.

*/

static int

struct hlist_head *mcast_list,

struct batadv_mcast_mla_flags *flags)

{

if (bridge)

dev = bridge;

if (ret4 < 0)

goto out;

if (ret6 < 0) {

ret4 = 0;

goto out;

*

* Collects multicast addresses of multicast listeners residing

* on foreign, non-mesh devices which we gave access to our mesh via

* mcast_list.

*

* Return: -ENOMEM on memory allocation error or the number of

/**

* batadv_mcast_mla_tt_retract() - clean up multicast listener announcements

* @mcast_list: a list of addresses which should _not_ be removed

*

* Retracts the announcement of any multicast listener from the

/**

* batadv_mcast_mla_tt_add() - add multicast listener announcements

* @mcast_list: a list of addresses which are going to get added

*

* Adds multicast listener announcements from the given mcast_list to the

&bat_priv->mcast.mla_list))

continue;

mcast_entry->addr, BATADV_NO_FLAGS,

BATADV_NULL_IFINDEX, BATADV_NO_MARK))

continue;

/**

* batadv_mcast_querier_log() - debug output regarding the querier status on

* link

* @str_proto: a string for the querier protocol (e.g. "IGMP" or "MLD")

* @old_state: the previous querier state on our link

* @new_state: the new querier state on our link

* potentially shadowing listeners from us then.

*

* This is only interesting for nodes with a bridge on top of their

*/

static void

batadv_mcast_querier_log(struct batadv_priv *bat_priv, char *str_proto,

struct batadv_mcast_querier_state *new_state)

{

if (!old_state->exists && new_state->exists)

str_proto);

else if (old_state->exists && !new_state->exists)

"%s Querier disappeared - multicast optimizations disabled\n",

str_proto);

else if (!bat_priv->mcast.mla_flags.bridged && !new_state->exists)

"No %s Querier present - multicast optimizations disabled\n",

str_proto);

/**

* batadv_mcast_bridge_log() - debug output for topology changes in bridged

* setups

* @new_flags: flags indicating the new multicast state

*

* If no bridges are ever used on this node, then this function does nothing.

* which might be relevant to our multicast optimizations.

*

* More precisely, it outputs information when a bridge interface is added or

* outputs information about the querier state which is relevant for the

* multicast flags this node is going to set.

*/

/**

* batadv_mcast_flags_log() - output debug information about mcast flag changes

* @flags: TVLV flags indicating the new multicast state

*

* Whenever the multicast TVLV flags this node announces change, this function

/**

* batadv_mcast_mla_flags_update() - update multicast flags

* @flags: flags indicating the new multicast state

*

* Updates the own multicast tvlv with our current multicast related settings,

/**

* __batadv_mcast_mla_update() - update the own MLAs

*

* Updates the own multicast listener announcements in the translation

* table as well as the own, announced multicast tvlv container.

*/

static void __batadv_mcast_mla_update(struct batadv_priv *bat_priv)

{

struct hlist_head mcast_list = HLIST_HEAD_INIT;

struct batadv_mcast_mla_flags flags;

int ret;

flags = batadv_mcast_mla_flags_get(bat_priv);

if (ret < 0)

goto out;

if (ret < 0)

goto out;

/**

* batadv_mcast_forw_mode_check_ipv4() - check for optimized forwarding

* potential

* @skb: the IPv4 packet to check

* @is_unsnoopable: stores whether the destination is snoopable

* @is_routable: stores whether the destination is routable

/**

* batadv_mcast_forw_mode_check_ipv6() - check for optimized forwarding

* potential

* @skb: the IPv6 packet to check

* @is_unsnoopable: stores whether the destination is snoopable

* @is_routable: stores whether the destination is routable

/**

* batadv_mcast_forw_mode_check() - check for optimized forwarding potential

* @skb: the multicast frame to check

* @is_unsnoopable: stores whether the destination is snoopable

* @is_routable: stores whether the destination is routable

/**

* batadv_mcast_forw_want_all_ip_count() - count nodes with unspecific mcast

* interest

* @ethhdr: ethernet header of a packet

*

* Return: the number of nodes which want all IPv4 multicast traffic if the

/**

* batadv_mcast_forw_rtr_count() - count nodes with a multicast router

* @protocol: the ethernet protocol type to count multicast routers for

*

* Return: the number of nodes which want all routable IPv4 multicast traffic

/**

* batadv_mcast_forw_mode_by_count() - get forwarding mode by count

* @skb: the multicast packet to check

* @vid: the vlan identifier

* @is_routable: stores whether the destination is routable

/**

* batadv_mcast_forw_mode() - check on how to forward a multicast packet

* @skb: the multicast packet to check

* @vid: the vlan identifier

* @is_routable: stores whether the destination is routable

/**

* batadv_mcast_forw_send_orig() - send a multicast packet to an originator

* @skb: the multicast packet to send

* @vid: the vlan identifier

* @orig_node: the originator to send the packet to

/**

* batadv_mcast_forw_tt() - forwards a packet to multicast listeners

* @skb: the multicast packet to transmit

* @vid: the vlan identifier

*

/**

* batadv_mcast_forw_want_all_ipv4() - forward to nodes with want-all-ipv4

* @skb: the multicast packet to transmit

* @vid: the vlan identifier

*

/**

* batadv_mcast_forw_want_all_ipv6() - forward to nodes with want-all-ipv6

* @skb: The multicast packet to transmit

* @vid: the vlan identifier

*

/**

* batadv_mcast_forw_want_all() - forward packet to nodes in a want-all list

* @skb: the multicast packet to transmit

* @vid: the vlan identifier

*

/**

* batadv_mcast_forw_want_all_rtr4() - forward to nodes with want-all-rtr4

* @skb: the multicast packet to transmit

* @vid: the vlan identifier

*

/**

* batadv_mcast_forw_want_all_rtr6() - forward to nodes with want-all-rtr6

* @skb: The multicast packet to transmit

* @vid: the vlan identifier

*

/**

* batadv_mcast_forw_want_rtr() - forward packet to nodes in a want-all-rtr list

* @skb: the multicast packet to transmit

* @vid: the vlan identifier

*

/**

* batadv_mcast_forw_send() - send packet to any detected multicast recipient

* @skb: the multicast packet to transmit

* @vid: the vlan identifier

* @is_routable: stores whether the destination is routable

/**

* batadv_mcast_want_unsnoop_update() - update unsnoop counter and list

* @orig: the orig_node which multicast state might have changed of

* @mcast_flags: flags indicating the new multicast state

*

/**

* batadv_mcast_want_ipv4_update() - update want-all-ipv4 counter and list

* @orig: the orig_node which multicast state might have changed of

* @mcast_flags: flags indicating the new multicast state

*

/**

* batadv_mcast_want_ipv6_update() - update want-all-ipv6 counter and list

* @orig: the orig_node which multicast state might have changed of

* @mcast_flags: flags indicating the new multicast state

*

/**

* batadv_mcast_want_rtr4_update() - update want-all-rtr4 counter and list

* @orig: the orig_node which multicast state might have changed of

* @mcast_flags: flags indicating the new multicast state

*

/**

* batadv_mcast_want_rtr6_update() - update want-all-rtr6 counter and list

* @orig: the orig_node which multicast state might have changed of

* @mcast_flags: flags indicating the new multicast state

*

/**

* batadv_mcast_have_mc_ptype_update() - update multicast packet type counter

* @orig: the orig_node which multicast state might have changed of

* @mcast_flags: flags indicating the new multicast state

*

/**

* batadv_mcast_tvlv_ogm_handler() - process incoming multicast tvlv container

* @orig: the orig_node of the ogm

* @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags)

* @tvlv_value: tvlv buffer containing the multicast data

/**

* batadv_mcast_init() - initialize the multicast optimizations structures

*/

void batadv_mcast_init(struct batadv_priv *bat_priv)

{

/**

* batadv_mcast_mesh_info_put() - put multicast info into a netlink message

* @msg: buffer for the message

*

* Return: 0 or error code.

*/

* @msg: buffer for the message

* @portid: netlink port

* @cb: Control block containing additional options

* @bucket: current bucket to dump

* @idx: index in current bucket to the next entry to dump

*

struct batadv_hard_iface **primary_if)

{

struct batadv_hard_iface *hard_iface = NULL;

struct batadv_priv *bat_priv;

int ret = 0;

hard_iface = batadv_primary_if_get_selected(bat_priv);

if (!hard_iface || hard_iface->if_status != BATADV_IF_ACTIVE) {

}

out:

if (!ret && primary_if)

*primary_if = hard_iface;

if (ret)

return ret;

ret = __batadv_mcast_flags_dump(msg, portid, cb, bat_priv, bucket, idx);

batadv_hardif_put(primary_if);

/**

* batadv_mcast_free() - free the multicast optimizations structures

*/

void batadv_mcast_free(struct batadv_priv *bat_priv)

{

/**

* batadv_mcast_forw_push_dest() - push an originator MAC address onto an skb

* @skb: the skb to push the destination address onto

* @vid: the vlan identifier

* @orig_node: the originator node to get the MAC address from

/**

* batadv_mcast_forw_push_dests_list() - push originators from list onto an skb

* @skb: the skb to push the destination addresses onto

* @vid: the vlan identifier

* @head: the list to gather originators from

/**

* batadv_mcast_forw_push_tt() - push originators with interest through TT

* @skb: the skb to push the destination addresses onto

* @vid: the vlan identifier

* @num_dests: a pointer to store the number of pushed addresses in

/**

* batadv_mcast_forw_push_want_all() - push originators with want-all flag

* @skb: the skb to push the destination addresses onto

* @vid: the vlan identifier

* @num_dests: a pointer to store the number of pushed addresses in

/**

* batadv_mcast_forw_push_want_rtr() - push originators with want-router flag

* @skb: the skb to push the destination addresses onto

* @vid: the vlan identifier

* @num_dests: a pointer to store the number of pushed addresses in

/**

* batadv_mcast_forw_push_dests() - push originator addresses onto an skb

* @skb: the skb to push the destination addresses onto

* @vid: the vlan identifier

* @is_routable: indicates whether the destination is routable

/**

* batadv_mcast_forw_push_tvlvs() - push a multicast tracker TVLV onto an skb

* @skb: the skb to push the tracker TVLV onto

* @vid: the vlan identifier

* @is_routable: indicates whether the destination is routable

/**

* batadv_mcast_forw_scrub_dests() - scrub destinations in a tracker TVLV

* @comp_neigh: next hop neighbor to scrub+collect destinations for

* @dest: start MAC entry in original skb's tracker TVLV

* @next_dest: start MAC entry in to be sent skb's tracker TVLV

/**

* batadv_mcast_forw_packet() - forward a batman-adv multicast packet

* @skb: the received or locally generated batman-adv multicast packet

* @local_xmit: indicates that the packet was locally generated and not received

*

*

* Return: NET_RX_SUCCESS or NET_RX_DROP on success or a negative error

* code on failure. NET_RX_SUCCESS if the received packet is supposed to be

*/

static int batadv_mcast_forw_packet(struct batadv_priv *bat_priv,

struct sk_buff *skb, bool local_xmit)

/**

* batadv_mcast_forw_tracker_tvlv_handler() - handle an mcast tracker tvlv

* @skb: the received batman-adv multicast packet

*

* Parses the tracker TVLV of an incoming batman-adv multicast packet and

*

* Return: NET_RX_SUCCESS or NET_RX_DROP on success or a negative error

* code on failure. NET_RX_SUCCESS if the received packet is supposed to be

*/

int batadv_mcast_forw_tracker_tvlv_handler(struct batadv_priv *bat_priv,

struct sk_buff *skb)

/**

* batadv_mcast_forw_expand_head() - expand headroom for an mcast packet

* @skb: the multicast packet to send

*

* Tries to expand an skb's headroom so that its head to tail is 1298

/**

* batadv_mcast_forw_push() - encapsulate skb in a batman-adv multicast packet

* @skb: the multicast packet to encapsulate and send

* @vid: the vlan identifier

* @is_routable: indicates whether the destination is routable

/**

* batadv_mcast_forw_mcsend() - send a self prepared batman-adv multicast packet

* @skb: the multicast packet to encapsulate and send

*

* Transmits a batman-adv multicast packet that was locally prepared and

#include "gateway_common.h"

#include "hard-interface.h"

#include "log.h"

#include "multicast.h"

#include "network-coding.h"

#include "originator.h"

#include "tp_meter.h"

#include "translation-table.h"

*/

enum batadv_genl_ops_flags {

/**

* attribute BATADV_ATTR_MESH_IFINDEX and expects a pointer to it to be

* saved in info->user_ptr[0]

*/

}

/**