batman-adv: tvlv - basic infrastructure (ef261577) · Commits · 戴 / test

net/batman-adv/bat_iv_ogm.c

+21 −17

Original line number	Diff line number	Diff line
		@@ -207,12 +207,12 @@ static uint8_t batadv_hop_penalty(uint8_t tq,

		/* is there another aggregated packet here? */
		static int batadv_iv_ogm_aggr_packet(int buff_pos, int packet_len,
		int tt_num_changes)
		__be16 tvlv_len)
		{
		int next_buff_pos = 0;

		next_buff_pos += buff_pos + BATADV_OGM_HLEN;
		next_buff_pos += batadv_tt_len(tt_num_changes);
		next_buff_pos += ntohs(tvlv_len);

		return (next_buff_pos <= packet_len) &&
		(next_buff_pos <= BATADV_MAX_AGGREGATION_BYTES);
		@@ -240,7 +240,7 @@ static void batadv_iv_ogm_send_to_if(struct batadv_forw_packet *forw_packet,

		/* adjust all flags and log packets */
		while (batadv_iv_ogm_aggr_packet(buff_pos, forw_packet->packet_len,
		batadv_ogm_packet->tt_num_changes)) {
		batadv_ogm_packet->tvlv_len)) {
		/* we might have aggregated direct link packets with an
		* ordinary base packet
		*/
		@@ -267,7 +267,7 @@ static void batadv_iv_ogm_send_to_if(struct batadv_forw_packet *forw_packet,
		hard_iface->net_dev->dev_addr);

		buff_pos += BATADV_OGM_HLEN;
		buff_pos += batadv_tt_len(batadv_ogm_packet->tt_num_changes);
		buff_pos += ntohs(batadv_ogm_packet->tvlv_len);
		packet_num++;
		packet_pos = forw_packet->skb->data + buff_pos;
		batadv_ogm_packet = (struct batadv_ogm_packet *)packet_pos;
		@@ -601,7 +601,7 @@ static void batadv_iv_ogm_forward(struct batadv_orig_node *orig_node,
		struct batadv_hard_iface *if_incoming)
		{
		struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
		uint8_t tt_num_changes;
		uint16_t tvlv_len;

		if (batadv_ogm_packet->header.ttl <= 1) {
		batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "ttl exceeded\n");
		@@ -621,7 +621,7 @@ static void batadv_iv_ogm_forward(struct batadv_orig_node *orig_node,
		return;
		}

		tt_num_changes = batadv_ogm_packet->tt_num_changes;
		tvlv_len = ntohs(batadv_ogm_packet->tvlv_len);

		batadv_ogm_packet->header.ttl--;
		memcpy(batadv_ogm_packet->prev_sender, ethhdr->h_source, ETH_ALEN);
		@@ -642,7 +642,7 @@ static void batadv_iv_ogm_forward(struct batadv_orig_node *orig_node,
		batadv_ogm_packet->flags &= ~BATADV_DIRECTLINK;

		batadv_iv_ogm_queue_add(bat_priv, (unsigned char *)batadv_ogm_packet,
		BATADV_OGM_HLEN + batadv_tt_len(tt_num_changes),
		BATADV_OGM_HLEN + tvlv_len,
		if_incoming, 0, batadv_iv_ogm_fwd_send_time());
		}

		@@ -691,16 +691,18 @@ static void batadv_iv_ogm_schedule(struct batadv_hard_iface *hard_iface)
		int vis_server, tt_num_changes = 0;
		uint32_t seqno;
		uint8_t bandwidth;
		uint16_t tvlv_len = 0;

		vis_server = atomic_read(&bat_priv->vis_mode);
		primary_if = batadv_primary_if_get_selected(bat_priv);

		if (hard_iface == primary_if)
		tt_num_changes = batadv_tt_append_diff(bat_priv, ogm_buff,
		tvlv_len = batadv_tvlv_container_ogm_append(bat_priv, ogm_buff,
		ogm_buff_len,
		BATADV_OGM_HLEN);

		batadv_ogm_packet = (struct batadv_ogm_packet )(ogm_buff);
		batadv_ogm_packet->tvlv_len = htons(tvlv_len);

		/* change sequence number to network order */
		seqno = (uint32_t)atomic_read(&hard_iface->bat_iv.ogm_seqno);
		@@ -1254,6 +1256,8 @@ static void batadv_iv_ogm_process(const struct ethhdr *ethhdr,
		goto out;
		}

		batadv_tvlv_ogm_receive(bat_priv, batadv_ogm_packet, orig_node);

		/* if sender is a direct neighbor the sender mac equals
		* originator mac
		*/
		@@ -1350,9 +1354,9 @@ static int batadv_iv_ogm_receive(struct sk_buff *skb,
		struct batadv_ogm_packet *batadv_ogm_packet;
		struct ethhdr *ethhdr;
		int buff_pos = 0, packet_len;
		unsigned char tt_buff, packet_buff;
		bool ret;
		unsigned char tvlv_buff, packet_buff;
		uint8_t *packet_pos;
		bool ret;

		ret = batadv_check_management_packet(skb, if_incoming, BATADV_OGM_HLEN);
		if (!ret)
		@@ -1375,14 +1379,14 @@ static int batadv_iv_ogm_receive(struct sk_buff *skb,

		/* unpack the aggregated packets and process them one by one */
		while (batadv_iv_ogm_aggr_packet(buff_pos, packet_len,
		batadv_ogm_packet->tt_num_changes)) {
		tt_buff = packet_buff + buff_pos + BATADV_OGM_HLEN;
		batadv_ogm_packet->tvlv_len)) {
		tvlv_buff = packet_buff + buff_pos + BATADV_OGM_HLEN;

		batadv_iv_ogm_process(ethhdr, batadv_ogm_packet, tt_buff,
		if_incoming);
		batadv_iv_ogm_process(ethhdr, batadv_ogm_packet,
		tvlv_buff, if_incoming);

		buff_pos += BATADV_OGM_HLEN;
		buff_pos += batadv_tt_len(batadv_ogm_packet->tt_num_changes);
		buff_pos += ntohs(batadv_ogm_packet->tvlv_len);

		packet_pos = packet_buff + buff_pos;
		batadv_ogm_packet = (struct batadv_ogm_packet *)packet_pos;

net/batman-adv/main.c

+575 −0

Original line number	Diff line number	Diff line
		@@ -36,6 +36,7 @@
		#include "gateway_client.h"
		#include "bridge_loop_avoidance.h"
		#include "distributed-arp-table.h"
		#include "unicast.h"
		#include "vis.h"
		#include "hash.h"
		#include "bat_algo.h"
		@@ -112,6 +113,8 @@ int batadv_mesh_init(struct net_device *soft_iface)
		spin_lock_init(&bat_priv->gw.list_lock);
		spin_lock_init(&bat_priv->vis.hash_lock);
		spin_lock_init(&bat_priv->vis.list_lock);
		spin_lock_init(&bat_priv->tvlv.container_list_lock);
		spin_lock_init(&bat_priv->tvlv.handler_list_lock);

		INIT_HLIST_HEAD(&bat_priv->forw_bat_list);
		INIT_HLIST_HEAD(&bat_priv->forw_bcast_list);
		@@ -119,6 +122,8 @@ int batadv_mesh_init(struct net_device *soft_iface)
		INIT_LIST_HEAD(&bat_priv->tt.changes_list);
		INIT_LIST_HEAD(&bat_priv->tt.req_list);
		INIT_LIST_HEAD(&bat_priv->tt.roam_list);
		INIT_HLIST_HEAD(&bat_priv->tvlv.container_list);
		INIT_HLIST_HEAD(&bat_priv->tvlv.handler_list);

		ret = batadv_originator_init(bat_priv);
		if (ret < 0)
		@@ -408,6 +413,8 @@ static void batadv_recv_handler_init(void)
		batadv_rx_handler[BATADV_TT_QUERY] = batadv_recv_tt_query;
		/* Roaming advertisement */
		batadv_rx_handler[BATADV_ROAM_ADV] = batadv_recv_roam_adv;
		/* unicast tvlv packet */
		batadv_rx_handler[BATADV_UNICAST_TVLV] = batadv_recv_unicast_tvlv;
		}

		int
		@@ -536,6 +543,574 @@ __be32 batadv_skb_crc32(struct sk_buff skb, u8 payload_ptr)
		return htonl(crc);
		}

		/**
		* batadv_tvlv_handler_free_ref - decrement the tvlv handler refcounter and
		* possibly free it
		* @tvlv_handler: the tvlv handler to free
		*/
		static void
		batadv_tvlv_handler_free_ref(struct batadv_tvlv_handler *tvlv_handler)
		{
		if (atomic_dec_and_test(&tvlv_handler->refcount))
		kfree_rcu(tvlv_handler, rcu);
		}

		/**
		* batadv_tvlv_handler_get - retrieve tvlv handler from the tvlv handler list
		* based on the provided type and version (both need to match)
		* @bat_priv: the bat priv with all the soft interface information
		* @type: tvlv handler type to look for
		* @version: tvlv handler version to look for
		*
		* Returns tvlv handler if found or NULL otherwise.
		*/
		static struct batadv_tvlv_handler
		batadv_tvlv_handler_get(struct batadv_priv bat_priv,
		uint8_t type, uint8_t version)
		{
		struct batadv_tvlv_handler tvlv_handler_tmp, tvlv_handler = NULL;

		rcu_read_lock();
		hlist_for_each_entry_rcu(tvlv_handler_tmp,
		&bat_priv->tvlv.handler_list, list) {
		if (tvlv_handler_tmp->type != type)
		continue;

		if (tvlv_handler_tmp->version != version)
		continue;

		if (!atomic_inc_not_zero(&tvlv_handler_tmp->refcount))
		continue;

		tvlv_handler = tvlv_handler_tmp;
		break;
		}
		rcu_read_unlock();

		return tvlv_handler;
		}

		/**
		* batadv_tvlv_container_free_ref - decrement the tvlv container refcounter and
		* possibly free it
		* @tvlv_handler: the tvlv container to free
		*/
		static void batadv_tvlv_container_free_ref(struct batadv_tvlv_container *tvlv)
		{
		if (atomic_dec_and_test(&tvlv->refcount))
		kfree(tvlv);
		}

		/**
		* batadv_tvlv_container_get - retrieve tvlv container from the tvlv container
		* list based on the provided type and version (both need to match)
		* @bat_priv: the bat priv with all the soft interface information
		* @type: tvlv container type to look for
		* @version: tvlv container version to look for
		*
		* Has to be called with the appropriate locks being acquired
		* (tvlv.container_list_lock).
		*
		* Returns tvlv container if found or NULL otherwise.
		*/
		static struct batadv_tvlv_container
		batadv_tvlv_container_get(struct batadv_priv bat_priv,
		uint8_t type, uint8_t version)
		{
		struct batadv_tvlv_container tvlv_tmp, tvlv = NULL;

		hlist_for_each_entry(tvlv_tmp, &bat_priv->tvlv.container_list, list) {
		if (tvlv_tmp->tvlv_hdr.type != type)
		continue;

		if (tvlv_tmp->tvlv_hdr.version != version)
		continue;

		if (!atomic_inc_not_zero(&tvlv_tmp->refcount))
		continue;

		tvlv = tvlv_tmp;
		break;
		}

		return tvlv;
		}

		/**
		* batadv_tvlv_container_list_size - calculate the size of the tvlv container
		* list entries
		* @bat_priv: the bat priv with all the soft interface information
		*
		* Has to be called with the appropriate locks being acquired
		* (tvlv.container_list_lock).
		*
		* Returns size of all currently registered tvlv containers in bytes.
		*/
		static uint16_t batadv_tvlv_container_list_size(struct batadv_priv *bat_priv)
		{
		struct batadv_tvlv_container *tvlv;
		uint16_t tvlv_len = 0;

		hlist_for_each_entry(tvlv, &bat_priv->tvlv.container_list, list) {
		tvlv_len += sizeof(struct batadv_tvlv_hdr);
		tvlv_len += ntohs(tvlv->tvlv_hdr.len);
		}

		return tvlv_len;
		}

		/**
		* batadv_tvlv_container_remove - remove tvlv container from the tvlv container
		* list
		* @tvlv: the to be removed tvlv container
		*
		* Has to be called with the appropriate locks being acquired
		* (tvlv.container_list_lock).
		*/
		static void batadv_tvlv_container_remove(struct batadv_tvlv_container *tvlv)
		{
		if (!tvlv)
		return;

		hlist_del(&tvlv->list);

		/* first call to decrement the counter, second call to free */
		batadv_tvlv_container_free_ref(tvlv);
		batadv_tvlv_container_free_ref(tvlv);
		}

		/**
		* batadv_tvlv_container_unregister - unregister tvlv container based on the
		* provided type and version (both need to match)
		* @bat_priv: the bat priv with all the soft interface information
		* @type: tvlv container type to unregister
		* @version: tvlv container type to unregister
		*/
		void batadv_tvlv_container_unregister(struct batadv_priv *bat_priv,
		uint8_t type, uint8_t version)
		{
		struct batadv_tvlv_container *tvlv;

		spin_lock_bh(&bat_priv->tvlv.container_list_lock);
		tvlv = batadv_tvlv_container_get(bat_priv, type, version);
		batadv_tvlv_container_remove(tvlv);
		spin_unlock_bh(&bat_priv->tvlv.container_list_lock);
		}

		/**
		* batadv_tvlv_container_register - register tvlv type, version and content
		* to be propagated with each (primary interface) OGM
		* @bat_priv: the bat priv with all the soft interface information
		* @type: tvlv container type
		* @version: tvlv container version
		* @tvlv_value: tvlv container content
		* @tvlv_value_len: tvlv container content length
		*
		* If a container of the same type and version was already registered the new
		* content is going to replace the old one.
		*/
		void batadv_tvlv_container_register(struct batadv_priv *bat_priv,
		uint8_t type, uint8_t version,
		void *tvlv_value, uint16_t tvlv_value_len)
		{
		struct batadv_tvlv_container tvlv_old, tvlv_new;

		if (!tvlv_value)
		tvlv_value_len = 0;

		tvlv_new = kzalloc(sizeof(*tvlv_new) + tvlv_value_len, GFP_ATOMIC);
		if (!tvlv_new)
		return;

		tvlv_new->tvlv_hdr.version = version;
		tvlv_new->tvlv_hdr.type = type;
		tvlv_new->tvlv_hdr.len = htons(tvlv_value_len);

		memcpy(tvlv_new + 1, tvlv_value, ntohs(tvlv_new->tvlv_hdr.len));
		INIT_HLIST_NODE(&tvlv_new->list);
		atomic_set(&tvlv_new->refcount, 1);

		spin_lock_bh(&bat_priv->tvlv.container_list_lock);
		tvlv_old = batadv_tvlv_container_get(bat_priv, type, version);
		batadv_tvlv_container_remove(tvlv_old);
		hlist_add_head(&tvlv_new->list, &bat_priv->tvlv.container_list);
		spin_unlock_bh(&bat_priv->tvlv.container_list_lock);
		}

		/**
		* batadv_tvlv_realloc_packet_buff - reallocate packet buffer to accomodate
		* requested packet size
		* @packet_buff: packet buffer
		* @packet_buff_len: packet buffer size
		* @packet_min_len: requested packet minimum size
		* @additional_packet_len: requested additional packet size on top of minimum
		* size
		*
		* Returns true of the packet buffer could be changed to the requested size,
		* false otherwise.
		*/
		static bool batadv_tvlv_realloc_packet_buff(unsigned char **packet_buff,
		int *packet_buff_len,
		int min_packet_len,
		int additional_packet_len)
		{
		unsigned char *new_buff;

		new_buff = kmalloc(min_packet_len + additional_packet_len, GFP_ATOMIC);

		/* keep old buffer if kmalloc should fail */
		if (new_buff) {
		memcpy(new_buff, *packet_buff, min_packet_len);
		kfree(*packet_buff);
		*packet_buff = new_buff;
		*packet_buff_len = min_packet_len + additional_packet_len;
		return true;
		}

		return false;
		}

		/**
		* batadv_tvlv_container_ogm_append - append tvlv container content to given
		* OGM packet buffer
		* @bat_priv: the bat priv with all the soft interface information
		* @packet_buff: ogm packet buffer
		* @packet_buff_len: ogm packet buffer size including ogm header and tvlv
		* content
		* @packet_min_len: ogm header size to be preserved for the OGM itself
		*
		* The ogm packet might be enlarged or shrunk depending on the current size
		* and the size of the to-be-appended tvlv containers.
		*
		* Returns size of all appended tvlv containers in bytes.
		*/
		uint16_t batadv_tvlv_container_ogm_append(struct batadv_priv *bat_priv,
		unsigned char **packet_buff,
		int *packet_buff_len,
		int packet_min_len)
		{
		struct batadv_tvlv_container *tvlv;
		struct batadv_tvlv_hdr *tvlv_hdr;
		uint16_t tvlv_value_len;
		void *tvlv_value;
		bool ret;

		spin_lock_bh(&bat_priv->tvlv.container_list_lock);
		tvlv_value_len = batadv_tvlv_container_list_size(bat_priv);

		ret = batadv_tvlv_realloc_packet_buff(packet_buff, packet_buff_len,
		packet_min_len, tvlv_value_len);

		if (!ret)
		goto end;

		if (!tvlv_value_len)
		goto end;

		tvlv_value = (*packet_buff) + packet_min_len;

		hlist_for_each_entry(tvlv, &bat_priv->tvlv.container_list, list) {
		tvlv_hdr = tvlv_value;
		tvlv_hdr->type = tvlv->tvlv_hdr.type;
		tvlv_hdr->version = tvlv->tvlv_hdr.version;
		tvlv_hdr->len = tvlv->tvlv_hdr.len;
		tvlv_value = tvlv_hdr + 1;
		memcpy(tvlv_value, tvlv + 1, ntohs(tvlv->tvlv_hdr.len));
		tvlv_value = (uint8_t *)tvlv_value + ntohs(tvlv->tvlv_hdr.len);
		}

		end:
		spin_unlock_bh(&bat_priv->tvlv.container_list_lock);
		return tvlv_value_len;
		}

		/**
		* batadv_tvlv_call_handler - parse the given tvlv buffer to call the
		* appropriate handlers
		* @bat_priv: the bat priv with all the soft interface information
		* @tvlv_handler: tvlv callback function handling the tvlv content
		* @ogm_source: flag indicating wether the tvlv is an ogm or a unicast packet
		* @orig_node: orig node emitting the ogm packet
		* @src: source mac address of the unicast packet
		* @dst: destination mac address of the unicast packet
		* @tvlv_value: tvlv content
		* @tvlv_value_len: tvlv content length
		*
		* Returns success if handler was not found or the return value of the handler
		* callback.
		*/
		static int batadv_tvlv_call_handler(struct batadv_priv *bat_priv,
		struct batadv_tvlv_handler *tvlv_handler,
		bool ogm_source,
		struct batadv_orig_node *orig_node,
		uint8_t src, uint8_t dst,
		void *tvlv_value, uint16_t tvlv_value_len)
		{
		if (!tvlv_handler)
		return NET_RX_SUCCESS;

		if (ogm_source) {
		if (!tvlv_handler->ogm_handler)
		return NET_RX_SUCCESS;

		if (!orig_node)
		return NET_RX_SUCCESS;

		tvlv_handler->ogm_handler(bat_priv, orig_node,
		BATADV_NO_FLAGS,
		tvlv_value, tvlv_value_len);
		tvlv_handler->flags \|= BATADV_TVLV_HANDLER_OGM_CALLED;
		} else {
		if (!src)
		return NET_RX_SUCCESS;

		if (!dst)
		return NET_RX_SUCCESS;

		if (!tvlv_handler->unicast_handler)
		return NET_RX_SUCCESS;

		return tvlv_handler->unicast_handler(bat_priv, src,
		dst, tvlv_value,
		tvlv_value_len);
		}

		return NET_RX_SUCCESS;
		}

		/**
		* batadv_tvlv_containers_process - parse the given tvlv buffer to call the
		* appropriate handlers
		* @bat_priv: the bat priv with all the soft interface information
		* @ogm_source: flag indicating wether the tvlv is an ogm or a unicast packet
		* @orig_node: orig node emitting the ogm packet
		* @src: source mac address of the unicast packet
		* @dst: destination mac address of the unicast packet
		* @tvlv_value: tvlv content
		* @tvlv_value_len: tvlv content length
		*
		* Returns success when processing an OGM or the return value of all called
		* handler callbacks.
		*/
		int batadv_tvlv_containers_process(struct batadv_priv *bat_priv,
		bool ogm_source,
		struct batadv_orig_node *orig_node,
		uint8_t src, uint8_t dst,
		void *tvlv_value, uint16_t tvlv_value_len)
		{
		struct batadv_tvlv_handler *tvlv_handler;
		struct batadv_tvlv_hdr *tvlv_hdr;
		uint16_t tvlv_value_cont_len;
		uint8_t cifnotfound = BATADV_TVLV_HANDLER_OGM_CIFNOTFND;
		int ret = NET_RX_SUCCESS;

		while (tvlv_value_len >= sizeof(*tvlv_hdr)) {
		tvlv_hdr = tvlv_value;
		tvlv_value_cont_len = ntohs(tvlv_hdr->len);
		tvlv_value = tvlv_hdr + 1;
		tvlv_value_len -= sizeof(*tvlv_hdr);

		if (tvlv_value_cont_len > tvlv_value_len)
		break;

		tvlv_handler = batadv_tvlv_handler_get(bat_priv,
		tvlv_hdr->type,
		tvlv_hdr->version);

		ret \|= batadv_tvlv_call_handler(bat_priv, tvlv_handler,
		ogm_source, orig_node,
		src, dst, tvlv_value,
		tvlv_value_cont_len);
		if (tvlv_handler)
		batadv_tvlv_handler_free_ref(tvlv_handler);
		tvlv_value = (uint8_t *)tvlv_value + tvlv_value_cont_len;
		tvlv_value_len -= tvlv_value_cont_len;
		}

		if (!ogm_source)
		return ret;

		rcu_read_lock();
		hlist_for_each_entry_rcu(tvlv_handler,
		&bat_priv->tvlv.handler_list, list) {
		if ((tvlv_handler->flags & BATADV_TVLV_HANDLER_OGM_CIFNOTFND) &&
		!(tvlv_handler->flags & BATADV_TVLV_HANDLER_OGM_CALLED))
		tvlv_handler->ogm_handler(bat_priv, orig_node,
		cifnotfound, NULL, 0);

		tvlv_handler->flags &= ~BATADV_TVLV_HANDLER_OGM_CALLED;
		}
		rcu_read_unlock();

		return NET_RX_SUCCESS;
		}

		/**
		* batadv_tvlv_ogm_receive - process an incoming ogm and call the appropriate
		* handlers
		* @bat_priv: the bat priv with all the soft interface information
		* @batadv_ogm_packet: ogm packet containing the tvlv containers
		* @orig_node: orig node emitting the ogm packet
		*/
		void batadv_tvlv_ogm_receive(struct batadv_priv *bat_priv,
		struct batadv_ogm_packet *batadv_ogm_packet,
		struct batadv_orig_node *orig_node)
		{
		void *tvlv_value;
		uint16_t tvlv_value_len;

		if (!batadv_ogm_packet)
		return;

		tvlv_value_len = ntohs(batadv_ogm_packet->tvlv_len);
		if (!tvlv_value_len)
		return;

		tvlv_value = batadv_ogm_packet + 1;

		batadv_tvlv_containers_process(bat_priv, true, orig_node, NULL, NULL,
		tvlv_value, tvlv_value_len);
		}

		/**
		* batadv_tvlv_handler_register - register tvlv handler based on the provided
		* type and version (both need to match) for ogm tvlv payload and/or unicast
		* payload
		* @bat_priv: the bat priv with all the soft interface information
		* @optr: ogm tvlv handler callback function. This function receives the orig
		* node, flags and the tvlv content as argument to process.
		* @uptr: unicast tvlv handler callback function. This function receives the
		* source & destination of the unicast packet as well as the tvlv content
		* to process.
		* @type: tvlv handler type to be registered
		* @version: tvlv handler version to be registered
		* @flags: flags to enable or disable TVLV API behavior
		*/
		void batadv_tvlv_handler_register(struct batadv_priv *bat_priv,
		void (optr)(struct batadv_priv bat_priv,
		struct batadv_orig_node *orig,
		uint8_t flags,
		void *tvlv_value,
		uint16_t tvlv_value_len),
		int (uptr)(struct batadv_priv bat_priv,
		uint8_t src, uint8_t dst,
		void *tvlv_value,
		uint16_t tvlv_value_len),
		uint8_t type, uint8_t version, uint8_t flags)
		{
		struct batadv_tvlv_handler *tvlv_handler;

		tvlv_handler = batadv_tvlv_handler_get(bat_priv, type, version);
		if (tvlv_handler) {
		batadv_tvlv_handler_free_ref(tvlv_handler);
		return;
		}

		tvlv_handler = kzalloc(sizeof(*tvlv_handler), GFP_ATOMIC);
		if (!tvlv_handler)
		return;

		tvlv_handler->ogm_handler = optr;
		tvlv_handler->unicast_handler = uptr;
		tvlv_handler->type = type;
		tvlv_handler->version = version;
		tvlv_handler->flags = flags;
		atomic_set(&tvlv_handler->refcount, 1);
		INIT_HLIST_NODE(&tvlv_handler->list);

		spin_lock_bh(&bat_priv->tvlv.handler_list_lock);
		hlist_add_head_rcu(&tvlv_handler->list, &bat_priv->tvlv.handler_list);
		spin_unlock_bh(&bat_priv->tvlv.handler_list_lock);
		}

		/**
		* batadv_tvlv_handler_unregister - unregister tvlv handler based on the
		* provided type and version (both need to match)
		* @bat_priv: the bat priv with all the soft interface information
		* @type: tvlv handler type to be unregistered
		* @version: tvlv handler version to be unregistered
		*/
		void batadv_tvlv_handler_unregister(struct batadv_priv *bat_priv,
		uint8_t type, uint8_t version)
		{
		struct batadv_tvlv_handler *tvlv_handler;

		tvlv_handler = batadv_tvlv_handler_get(bat_priv, type, version);
		if (!tvlv_handler)
		return;

		batadv_tvlv_handler_free_ref(tvlv_handler);
		spin_lock_bh(&bat_priv->tvlv.handler_list_lock);
		hlist_del_rcu(&tvlv_handler->list);
		spin_unlock_bh(&bat_priv->tvlv.handler_list_lock);
		batadv_tvlv_handler_free_ref(tvlv_handler);
		}

		/**
		* batadv_tvlv_unicast_send - send a unicast packet with tvlv payload to the
		* specified host
		* @bat_priv: the bat priv with all the soft interface information
		* @src: source mac address of the unicast packet
		* @dst: destination mac address of the unicast packet
		* @type: tvlv type
		* @version: tvlv version
		* @tvlv_value: tvlv content
		* @tvlv_value_len: tvlv content length
		*/
		void batadv_tvlv_unicast_send(struct batadv_priv bat_priv, uint8_t src,
		uint8_t *dst, uint8_t type, uint8_t version,
		void *tvlv_value, uint16_t tvlv_value_len)
		{
		struct batadv_unicast_tvlv_packet *unicast_tvlv_packet;
		struct batadv_tvlv_hdr *tvlv_hdr;
		struct batadv_orig_node *orig_node;
		struct sk_buff *skb = NULL;
		unsigned char *tvlv_buff;
		unsigned int tvlv_len;
		ssize_t hdr_len = sizeof(*unicast_tvlv_packet);
		bool ret = false;

		orig_node = batadv_orig_hash_find(bat_priv, dst);
		if (!orig_node)
		goto out;

		tvlv_len = sizeof(*tvlv_hdr) + tvlv_value_len;

		skb = netdev_alloc_skb_ip_align(NULL, ETH_HLEN + hdr_len + tvlv_len);
		if (!skb)
		goto out;

		skb->priority = TC_PRIO_CONTROL;
		skb_reserve(skb, ETH_HLEN);
		tvlv_buff = skb_put(skb, sizeof(*unicast_tvlv_packet) + tvlv_len);
		unicast_tvlv_packet = (struct batadv_unicast_tvlv_packet *)tvlv_buff;
		unicast_tvlv_packet->header.packet_type = BATADV_UNICAST_TVLV;
		unicast_tvlv_packet->header.version = BATADV_COMPAT_VERSION;
		unicast_tvlv_packet->header.ttl = BATADV_TTL;
		unicast_tvlv_packet->reserved = 0;
		unicast_tvlv_packet->tvlv_len = htons(tvlv_len);
		unicast_tvlv_packet->align = 0;
		memcpy(unicast_tvlv_packet->src, src, ETH_ALEN);
		memcpy(unicast_tvlv_packet->dst, dst, ETH_ALEN);

		tvlv_buff = (unsigned char *)(unicast_tvlv_packet + 1);
		tvlv_hdr = (struct batadv_tvlv_hdr *)tvlv_buff;
		tvlv_hdr->version = version;
		tvlv_hdr->type = type;
		tvlv_hdr->len = htons(tvlv_value_len);
		tvlv_buff += sizeof(*tvlv_hdr);
		memcpy(tvlv_buff, tvlv_value, tvlv_value_len);

		if (batadv_send_skb_to_orig(skb, orig_node, NULL) != NET_XMIT_DROP)
		ret = true;

		out:
		if (skb && !ret)
		kfree_skb(skb);
		if (orig_node)
		batadv_orig_node_free_ref(orig_node);
		}

		static int batadv_param_set_ra(const char val, const struct kernel_param kp)
		{
		struct batadv_algo_ops *bat_algo_ops;

net/batman-adv/main.h

+35 −0

Original line number	Diff line number	Diff line
		@@ -326,4 +326,39 @@ static inline uint64_t batadv_sum_counter(struct batadv_priv *bat_priv,
		*/
		#define BATADV_SKB_CB(__skb) ((struct batadv_skb_cb *)&((__skb)->cb[0]))

		void batadv_tvlv_container_register(struct batadv_priv *bat_priv,
		uint8_t type, uint8_t version,
		void *tvlv_value, uint16_t tvlv_value_len);
		uint16_t batadv_tvlv_container_ogm_append(struct batadv_priv *bat_priv,
		unsigned char **packet_buff,
		int *packet_buff_len,
		int packet_min_len);
		void batadv_tvlv_ogm_receive(struct batadv_priv *bat_priv,
		struct batadv_ogm_packet *batadv_ogm_packet,
		struct batadv_orig_node *orig_node);
		void batadv_tvlv_container_unregister(struct batadv_priv *bat_priv,
		uint8_t type, uint8_t version);

		void batadv_tvlv_handler_register(struct batadv_priv *bat_priv,
		void (optr)(struct batadv_priv bat_priv,
		struct batadv_orig_node *orig,
		uint8_t flags,
		void *tvlv_value,
		uint16_t tvlv_value_len),
		int (uptr)(struct batadv_priv bat_priv,
		uint8_t src, uint8_t dst,
		void *tvlv_value,
		uint16_t tvlv_value_len),
		uint8_t type, uint8_t version, uint8_t flags);
		void batadv_tvlv_handler_unregister(struct batadv_priv *bat_priv,
		uint8_t type, uint8_t version);
		int batadv_tvlv_containers_process(struct batadv_priv *bat_priv,
		bool ogm_source,
		struct batadv_orig_node *orig_node,
		uint8_t src, uint8_t dst,
		void *tvlv_buff, uint16_t tvlv_buff_len);
		void batadv_tvlv_unicast_send(struct batadv_priv bat_priv, uint8_t src,
		uint8_t *dst, uint8_t type, uint8_t version,
		void *tvlv_value, uint16_t tvlv_value_len);

		#endif /* _NET_BATMAN_ADV_MAIN_H_ */

net/batman-adv/packet.h

+41 −0

File changed.

Preview size limit exceeded, changes collapsed.

net/batman-adv/routing.c

+48 −0

File changed.

Preview size limit exceeded, changes collapsed.

Admin message