[B.A.T.M.A.N.] [RFC 5/6] batman-adv: Generalize snooping mechanism in order to suport NDP too

[mihail.costea2005@gmail.com]

From: Mihail Costea <mihail.costea90@gmail.com>

Generalize snooping functions in order to support Neighbor Advertisement
and Neighbor Solicitation too. Adds snooping functions to generic
struct so there won't be a need for switch-cases.

Signed-off-by: Mihail Costea <mihail.costea90@gmail.com>
Signed-off-by: Stefan Popa <Stefan.A.Popa@intel.com>
Reviewed-by: Stefan Popa <Stefan.A.Popa@intel.com>

---
 distributed-arp-table.c |  438 +++++++++++++++++++++++++++++++++++------------
 types.h                 |   69 ++++++++
 2 files changed, 401 insertions(+), 106 deletions(-)

diff --git a/distributed-arp-table.c b/distributed-arp-table.c
index d0b9e95..1a5749b 100644
--- a/distributed-arp-table.c
+++ b/distributed-arp-table.c
@@ -33,21 +33,55 @@
 #include "types.h"
 #include "translation-table.h"
 
+static void batadv_dat_purge(struct work_struct *work);
+
+static bool batadv_dat_snoop_arp_pkt(struct batadv_priv *bat_priv,
+				     struct sk_buff *skb, int hdr_size,
+				     uint16_t pkt_type, uint8_t pkt_dir_type,
+				     uint8_t **hw_src, void **ip_src,
+				     uint8_t **hw_dst, void **ip_dst);
+
+static struct sk_buff *
+batadv_dat_create_arp_reply(struct batadv_priv *bat_priv,
+			    struct batadv_dat_entry *dat_entry,
+			    uint8_t *hw_src, void *ip_src, void *ip_dst)
+{
+	return arp_create(ARPOP_REPLY, ETH_P_ARP, *(__be32 *)ip_src,
+			  bat_priv->soft_iface, *(__be32 *)ip_dst,
+			  hw_src, dat_entry->mac_addr, hw_src);
+}
+
+#if IS_ENABLED(CONFIG_IPV6)
+static bool batadv_dat_snoop_ndisc_pkt(struct batadv_priv *bat_priv,
+				       struct sk_buff *skb, int hdr_size,
+				       uint16_t pkt_type, uint8_t pkt_dir_type,
+				       uint8_t **hw_src, void **ip_src,
+				       uint8_t **hw_dst, void **ip_dst);
+
+static struct sk_buff *
+batadv_dat_create_ndisc_na(struct batadv_priv *bat_priv,
+			   struct batadv_dat_entry *dat_entry,
+			   uint8_t *hw_src, void *ip_src, void *ip_dst);
+
+#endif
+
 static struct batadv_dat_type_info batadv_dat_types_info[] = {
 	{
 		.size = sizeof(__be32),
 		.str_fmt = "%pI4",
+		.snoop_pkt = batadv_dat_snoop_arp_pkt,
+		.create_skb = batadv_dat_create_arp_reply,
 	},
 #if IS_ENABLED(CONFIG_IPV6)
 	{
 		.size = sizeof(struct in6_addr),
 		.str_fmt = "%pI6c",
+		.snoop_pkt = batadv_dat_snoop_ndisc_pkt,
+		.create_skb = batadv_dat_create_ndisc_na,
 	},
 #endif
 };
 
-static void batadv_dat_purge(struct work_struct *work);
-
 /**
  * batadv_dat_data_to_str: transforms DAT data to string
  * @data: the DAT data
@@ -61,7 +95,7 @@ static char *batadv_dat_data_to_str(void *data, uint8_t type,
 				    char *buf, size_t buf_len)
 {
 	snprintf(buf, buf_len, batadv_dat_types_info[type].str_fmt, data);
-return buf;
+	return buf;
 }
 
 /**
@@ -221,9 +255,9 @@ static uint8_t *batadv_arp_hw_src(struct sk_buff *skb, int hdr_size)
  *
  * Returns the value of the ip_src field in the ARP packet.
  */
-static __be32 batadv_arp_ip_src(struct sk_buff *skb, int hdr_size)
+static __be32 *batadv_arp_ip_src(struct sk_buff *skb, int hdr_size)
 {
-	return *(__be32 *)(batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN);
+	return (__be32 *)(batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN);
 }
 
 /**
@@ -245,9 +279,9 @@ static uint8_t *batadv_arp_hw_dst(struct sk_buff *skb, int hdr_size)
  *
  * Returns the value of the ip_dst field in the ARP packet.
  */
-static __be32 batadv_arp_ip_dst(struct sk_buff *skb, int hdr_size)
+static __be32 *batadv_arp_ip_dst(struct sk_buff *skb, int hdr_size)
 {
-	return *(__be32 *)(batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN * 2 + 4);
+	return (__be32 *)(batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN * 2 + 4);
 }
 
 /**
@@ -411,8 +445,8 @@ static void batadv_dbg_arp(struct batadv_priv *bat_priv, struct sk_buff *skb,
 	if (msg)
 		batadv_dbg(BATADV_DBG_DAT, bat_priv, "%s\n", msg);
 
-	ip_src = batadv_arp_ip_src(skb, hdr_size);
-	ip_dst = batadv_arp_ip_dst(skb, hdr_size);
+	ip_src = *batadv_arp_ip_src(skb, hdr_size);
+	ip_dst = *batadv_arp_ip_dst(skb, hdr_size);
 	batadv_dbg(BATADV_DBG_DAT, bat_priv,
 		   "ARP MSG = [src: %pM-%pI4 dst: %pM-%pI4]\n",
 		   batadv_arp_hw_src(skb, hdr_size), &ip_src,
@@ -867,7 +901,7 @@ int batadv_dat_cache_seq_print_text(struct seq_file *seq, void *offset)
 			last_seen_msecs = last_seen_msecs % 60000;
 			last_seen_secs = last_seen_msecs / 1000;
 
-			seq_printf(seq, " * %40s %15pM %6i:%02i\n",
+			seq_printf(seq, " * %-40s %15pM %6i:%02i\n",
 				   batadv_dat_data_to_str(dat_entry->data,
 							  dat_entry->type,
 							  dbg_data,
@@ -933,8 +967,8 @@ static uint16_t batadv_arp_get_type(struct batadv_priv *bat_priv,
 	/* Check for bad reply/request. If the ARP message is not sane, DAT
 	 * will simply ignore it
 	 */
-	ip_src = batadv_arp_ip_src(skb, hdr_size);
-	ip_dst = batadv_arp_ip_dst(skb, hdr_size);
+	ip_src = *batadv_arp_ip_src(skb, hdr_size);
+	ip_dst = *batadv_arp_ip_dst(skb, hdr_size);
 	if (ipv4_is_loopback(ip_src) || ipv4_is_multicast(ip_src) ||
 	    ipv4_is_loopback(ip_dst) || ipv4_is_multicast(ip_dst) ||
 	    ipv4_is_zeronet(ip_src) || ipv4_is_lbcast(ip_src) ||
@@ -958,6 +992,40 @@ out:
 	return type;
 }
 
+static bool batadv_dat_snoop_arp_pkt(struct batadv_priv *bat_priv,
+				     struct sk_buff *skb, int hdr_size,
+				     uint16_t pkt_type, uint8_t pkt_dir_type,
+				     uint8_t **hw_src, void **ip_src,
+				     uint8_t **hw_dst, void **ip_dst)
+{
+	if ((pkt_dir_type == BATADV_DAT_OUTGOING_PKT_REQUEST ||
+	     pkt_dir_type == BATADV_DAT_INCOMING_PKT_REQUEST ||
+	     pkt_dir_type == BATADV_DAT_BROADCAST_FALLBACK) &&
+	    pkt_type != ARPOP_REQUEST)
+		return false;
+	if ((pkt_dir_type == BATADV_DAT_OUTGOING_PKT_REPLY ||
+	     pkt_dir_type == BATADV_DAT_INCOMING_PKT_REPLY) &&
+	    pkt_type != ARPOP_REPLY)
+		return false;
+
+	if (hw_src)
+		*hw_src = batadv_arp_hw_src(skb, hdr_size);
+	if (ip_src)
+		*ip_src = batadv_arp_ip_src(skb, hdr_size);
+	if (hw_dst)
+		*hw_dst = batadv_arp_hw_dst(skb, hdr_size);
+	if (ip_dst)
+		*ip_dst = batadv_arp_ip_dst(skb, hdr_size);
+
+	if (pkt_type == ARPOP_REQUEST)
+		batadv_dbg_arp(bat_priv, skb, pkt_type, hdr_size,
+			       "Parsing ARP REQUEST");
+	else if (pkt_type == ARPOP_REPLY)
+		batadv_dbg_arp(bat_priv, skb, pkt_type, hdr_size,
+			       "Parsing ARP REPLY");
+
+	return true;
+}
 /**
  * batadv_dat_get_vid - extract the VLAN identifier from skb if any
  * @skb: the buffer containing the packet to extract the VID from
@@ -1135,7 +1203,7 @@ out:
  * @bat_priv: the bat priv with all the soft interface information
  * @skb: packet to check
  * @hdr_size: size of the encapsulation header
- * @ndisc_type: type of ndisc packet to check
+ * @type: type of ndisc packet to check
  *
  * Check if all IPs are valid (source, destination, target) and if
  * options hw address is valid too.
@@ -1146,17 +1214,14 @@ out:
  */
 static bool batadv_ndisc_is_valid(struct batadv_priv *bat_priv,
 				  struct sk_buff *skb, int hdr_size,
-				  int ndisc_type)
+				  uint16_t type)
 {
 	uint8_t *hw_target = NULL;
 	struct in6_addr *ipv6_src, *ipv6_dst, *ipv6_target;
-	__u8 type = batadv_ndisc_get_type(bat_priv, skb, hdr_size);
 	int ndisc_hdr_len = hdr_size + ETH_HLEN + sizeof(struct ipv6hdr) +
 			    sizeof(struct icmp6hdr) + sizeof(struct in6_addr) +
 			    8; /* ndisc options length */
 
-	if (type != ndisc_type)
-		return false;
 	if (unlikely(!pskb_may_pull(skb, ndisc_hdr_len)))
 		return false;
 
@@ -1169,6 +1234,8 @@ static bool batadv_ndisc_is_valid(struct batadv_priv *bat_priv,
 	else if (type == NDISC_NEIGHBOUR_ADVERTISEMENT)
 		hw_target = batadv_ndisc_hw_opt(skb, hdr_size,
 						ND_OPT_TARGET_LL_ADDR);
+	else
+		return false;
 
 	if (!hw_target || is_zero_ether_addr(hw_target) ||
 	    is_multicast_ether_addr(hw_target))
@@ -1298,11 +1365,155 @@ sk_buff *batadv_ndisc_create_na(struct net_device *dev,
 
 	return skb;
 }
+
+struct sk_buff *
+batadv_dat_create_ndisc_na(struct batadv_priv *bat_priv,
+			   struct batadv_dat_entry *dat_entry,
+			   uint8_t *hw_src, void *ip_src, void *ip_dst)
+{
+	/* TODO calculate router and override parameters */
+	return batadv_ndisc_create_na(bat_priv->soft_iface,
+				      ip_src, ip_dst,
+				      hw_src, dat_entry->mac_addr,
+				      0, 1, 1);
+}
+
+/**
+ * batadv_dat_snoop_ndisc_addr - snoop addresses from NA / NS messages
+ * @skb: packet to snoop
+ * @hdr_size: size of the encapsulation header
+ * @target_address_type: type of target address
+ * (ND_OPT_SOURCE_LL_ADDR or ND_OPT_TARGET_LL_ADDR)
+ * @hw_src: source HW Address
+ * @ipv6_src: source IPv6
+ * @hw_dst: destination HW Address
+ * @ipv6_dst: destination IPv6
+ * @hw_target: target HW Address
+ * @ipv6_target: target IPv6
+ *
+ * If an address parameter is NULL, then the correspondent field is not
+ * snooped. The fields might be different depending on packet type (NS / NA).
+ *
+ * Return true if snooping was successful.
+ */
+static bool batadv_dat_snoop_ndisc_addr(struct sk_buff *skb, int hdr_size,
+					uint8_t target_address_type,
+					uint8_t **hw_src, void **ipv6_src,
+					uint8_t **hw_dst, void **ipv6_dst,
+					uint8_t **hw_target, void **ipv6_target)
+{
+	if (hw_src)
+		*hw_src = batadv_ndisc_hw_src(skb, hdr_size);
+	if (ipv6_src)
+		*ipv6_src = batadv_ndisc_ipv6_src(skb, hdr_size);
+	if (hw_dst)
+		*hw_dst = batadv_ndisc_hw_dst(skb, hdr_size);
+	if (ipv6_dst)
+		*ipv6_dst = batadv_ndisc_ipv6_dst(skb, hdr_size);
+	if (hw_target) {
+		*hw_target = batadv_ndisc_hw_opt(skb, hdr_size,
+						 target_address_type);
+		if (!*hw_target)
+			return false;
+	}
+	if (ipv6_target)
+		*ipv6_target = batadv_ndisc_ipv6_target(skb, hdr_size);
+
+	return true;
+}
+
+static bool batadv_dat_snoop_ndisc_pkt(struct batadv_priv *bat_priv,
+				       struct sk_buff *skb, int hdr_size,
+				       uint16_t pkt_type, uint8_t pkt_dir_type,
+				       uint8_t **hw_src, void **ip_src,
+				       uint8_t **hw_dst, void **ip_dst)
+{
+	if (batadv_ndisc_is_valid(bat_priv, skb, hdr_size, pkt_type)) {
+		if ((pkt_dir_type == BATADV_DAT_OUTGOING_PKT_REQUEST ||
+		     pkt_dir_type == BATADV_DAT_INCOMING_PKT_REQUEST ||
+		     pkt_dir_type == BATADV_DAT_BROADCAST_FALLBACK) &&
+		    pkt_type == NDISC_NEIGHBOUR_SOLICITATION) {
+			if (!batadv_dat_snoop_ndisc_addr(skb, hdr_size,
+							 ND_OPT_SOURCE_LL_ADDR,
+							 NULL, ip_src,
+							 hw_dst, NULL,
+							 hw_src, ip_dst))
+				return false;
+
+			if (pkt_dir_type != BATADV_DAT_BROADCAST_FALLBACK)
+				batadv_dbg(BATADV_DBG_DAT, bat_priv,
+					   "Parsing NS = [src: %pM / %pI6c -> "
+						"target: %pM / %pI6c]\n",
+					   *hw_src, *ip_src, *hw_dst, *ip_dst);
+			return true;
+		}
+
+		if ((pkt_dir_type == BATADV_DAT_OUTGOING_PKT_REPLY ||
+		     pkt_dir_type == BATADV_DAT_INCOMING_PKT_REPLY) &&
+		    pkt_type == NDISC_NEIGHBOUR_ADVERTISEMENT) {
+			if (!batadv_dat_snoop_ndisc_addr(skb, hdr_size,
+							 ND_OPT_TARGET_LL_ADDR,
+							 NULL, NULL,
+							 hw_dst, ip_dst,
+							 hw_src, ip_src))
+				return false;
+
+			batadv_dbg(BATADV_DBG_DAT, bat_priv,
+				   "Parsing NA = [src: %pM / %pI6c -> "
+					"target: %pM / %pI6c]\n",
+				   *hw_src, *ip_src, *hw_dst, *ip_dst);
+			return true;
+
+			/* ignore multicast address for unsolicited NA */
+			if (ipv6_addr_is_multicast(*ip_dst))
+				*ip_dst = NULL;
+		}
+	}
+
+	return false;
+}
+#endif
+
+/**
+ * batadv_dat_get_pair_type : gets packet and data types
+ * @bat_priv: the bat priv with all the soft interface information
+ * @skb: packet to snoop
+ * @hdr_size: size of the encapsulation header
+ *
+ * Returns the packet and types, or -1 for data_type if invalid.
+ */
+static struct batadv_dat_pair_type
+batadv_dat_get_pair_type(struct batadv_priv *bat_priv,
+			 struct sk_buff *skb, int hdr_size)
+{
+	struct batadv_dat_pair_type pair_type = {
+		.data_type = -1,
+	};
+
+	uint16_t arp_type;
+	__u8 ndisc_type;
+
+	arp_type = batadv_arp_get_type(bat_priv, skb, hdr_size);
+	if (arp_type == ARPOP_REQUEST || arp_type == ARPOP_REPLY) {
+		pair_type.pkt_type = arp_type;
+		pair_type.data_type = BATADV_DAT_IPV4;
+	}
+
+#if IS_ENABLED(CONFIG_IPV6)
+	ndisc_type = batadv_ndisc_get_type(bat_priv, skb, hdr_size);
+	if (ndisc_type == NDISC_NEIGHBOUR_SOLICITATION ||
+	    ndisc_type == NDISC_NEIGHBOUR_ADVERTISEMENT) {
+		pair_type.pkt_type = ndisc_type;
+		pair_type.data_type = BATADV_DAT_IPV6;
+	}
 #endif
 
+	return pair_type;
+}
+
 /**
- * batadv_dat_snoop_outgoing_pkt_request - snoop the ARP request and try to
- * answer using DAT
+ * batadv_dat_snoop_outgoing_pkt_request - snoop the ARP request / NS
+ * and try to answer using DAT
  * @bat_priv: the bat priv with all the soft interface information
  * @skb: packet to check
  *
@@ -1313,37 +1524,37 @@ sk_buff *batadv_ndisc_create_na(struct net_device *dev,
 bool batadv_dat_snoop_outgoing_pkt_request(struct batadv_priv *bat_priv,
 					   struct sk_buff *skb)
 {
-	uint16_t type = 0;
-	__be32 ip_dst, ip_src;
-	uint8_t *hw_src;
+	void *ip_src, *ip_dst;
+	uint8_t *hw_src, *hw_dst;
 	bool ret = false;
 	struct batadv_dat_entry *dat_entry = NULL;
 	struct sk_buff *skb_new;
 	int hdr_size = 0;
 	unsigned short vid;
+	struct batadv_dat_pair_type dat_pair_type;
 
 	if (!atomic_read(&bat_priv->distributed_arp_table))
 		goto out;
 
 	vid = batadv_dat_get_vid(skb, &hdr_size);
 
-	type = batadv_arp_get_type(bat_priv, skb, hdr_size);
-	/* If the node gets an ARP_REQUEST it has to send a DHT_GET unicast
+	/* If the node gets an ARP_REQUEST / NS it has to send a DHT_GET unicast
 	 * message to the selected DHT candidates
 	 */
-	if (type != ARPOP_REQUEST)
+	dat_pair_type = batadv_dat_get_pair_type(bat_priv, skb, hdr_size);
+	if (dat_pair_type.data_type < 0)
+		goto out;
+	if (!batadv_dat_types_info[dat_pair_type.data_type].snoop_pkt(
+			bat_priv, skb, hdr_size, dat_pair_type.pkt_type,
+			BATADV_DAT_OUTGOING_PKT_REQUEST,
+			&hw_src, &ip_src, &hw_dst, &ip_dst))
 		goto out;
 
-	batadv_dbg_arp(bat_priv, skb, type, 0, "Parsing outgoing ARP REQUEST");
-
-	ip_src = batadv_arp_ip_src(skb, 0);
-	hw_src = batadv_arp_hw_src(skb, 0);
-	ip_dst = batadv_arp_ip_dst(skb, 0);
-
-	batadv_dat_entry_add(bat_priv, &ip_src, BATADV_DAT_IPV4, hw_src, vid);
+	batadv_dat_entry_add(bat_priv, ip_src, dat_pair_type.data_type,
+			     hw_src, vid);
 
-	dat_entry = batadv_dat_entry_hash_find(bat_priv, &ip_dst,
-					       BATADV_DAT_IPV4, vid);
+	dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst,
+					       dat_pair_type.data_type, vid);
 	if (dat_entry) {
 		/* If the ARP request is destined for a local client the local
 		 * client will answer itself. DAT would only generate a
@@ -1359,9 +1570,9 @@ bool batadv_dat_snoop_outgoing_pkt_request(struct batadv_priv *bat_priv,
 			goto out;
 		}
 
-		skb_new = arp_create(ARPOP_REPLY, ETH_P_ARP, ip_src,
-				     bat_priv->soft_iface, ip_dst, hw_src,
-				     dat_entry->mac_addr, hw_src);
+		skb_new = batadv_dat_types_info[dat_pair_type.data_type].
+				create_skb(bat_priv, dat_entry,
+					   hw_src, ip_src, ip_dst);
 		if (!skb_new)
 			goto out;
 
@@ -1373,12 +1584,13 @@ bool batadv_dat_snoop_outgoing_pkt_request(struct batadv_priv *bat_priv,
 		bat_priv->soft_iface->last_rx = jiffies;
 
 		netif_rx(skb_new);
-		batadv_dbg(BATADV_DBG_DAT, bat_priv, "ARP request replied locally\n");
+		batadv_dbg(BATADV_DBG_DAT, bat_priv,
+			   "ARP request / NS replied locally\n");
 		ret = true;
 	} else {
 		/* Send the request to the DHT */
-		ret = batadv_dat_send_data(bat_priv, skb, &ip_dst,
-					   BATADV_DAT_IPV4,
+		ret = batadv_dat_send_data(bat_priv, skb, ip_dst,
+					   dat_pair_type.data_type,
 					   BATADV_P_DAT_DHT_GET);
 	}
 out:
@@ -1388,8 +1600,8 @@ out:
 }
 
 /**
- * batadv_dat_snoop_incoming_pkt_request - snoop the ARP request and try to
- * answer using the local DAT storage
+ * batadv_dat_snoop_incoming_pkt_request - snoop the ARP request / NS and try
+ * to answer using the local DAT storage
  * @bat_priv: the bat priv with all the soft interface information
  * @skb: packet to check
  * @hdr_size: size of the encapsulation header
@@ -1399,42 +1611,39 @@ out:
 bool batadv_dat_snoop_incoming_pkt_request(struct batadv_priv *bat_priv,
 					   struct sk_buff *skb, int hdr_size)
 {
-	uint16_t type;
-	__be32 ip_src, ip_dst;
-	uint8_t *hw_src;
+	void *ip_src, *ip_dst;
+	uint8_t *hw_src, *hw_dst;
 	struct sk_buff *skb_new;
 	struct batadv_dat_entry *dat_entry = NULL;
 	bool ret = false;
 	unsigned short vid;
 	int err;
+	struct batadv_dat_pair_type dat_pair_type;
 
 	if (!atomic_read(&bat_priv->distributed_arp_table))
 		goto out;
 
 	vid = batadv_dat_get_vid(skb, &hdr_size);
 
-	type = batadv_arp_get_type(bat_priv, skb, hdr_size);
-	if (type != ARPOP_REQUEST)
+	dat_pair_type = batadv_dat_get_pair_type(bat_priv, skb, hdr_size);
+	if (dat_pair_type.data_type < 0)
+		goto out;
+	if (!batadv_dat_types_info[dat_pair_type.data_type].snoop_pkt(
+			bat_priv, skb, hdr_size, dat_pair_type.pkt_type,
+			BATADV_DAT_INCOMING_PKT_REQUEST,
+			&hw_src, &ip_src, &hw_dst, &ip_dst))
 		goto out;
 
-	hw_src = batadv_arp_hw_src(skb, hdr_size);
-	ip_src = batadv_arp_ip_src(skb, hdr_size);
-	ip_dst = batadv_arp_ip_dst(skb, hdr_size);
-
-	batadv_dbg_arp(bat_priv, skb, type, hdr_size,
-		       "Parsing incoming ARP REQUEST");
-
-	batadv_dat_entry_add(bat_priv, &ip_src, BATADV_DAT_IPV4, hw_src, vid);
+	batadv_dat_entry_add(bat_priv, ip_src, dat_pair_type.data_type,
+			     hw_src, vid);
 
-	dat_entry = batadv_dat_entry_hash_find(bat_priv, &ip_dst,
-					       BATADV_DAT_IPV4, vid);
+	dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst,
+					       dat_pair_type.data_type, vid);
 	if (!dat_entry)
 		goto out;
 
-	skb_new = arp_create(ARPOP_REPLY, ETH_P_ARP, ip_src,
-			     bat_priv->soft_iface, ip_dst, hw_src,
-			     dat_entry->mac_addr, hw_src);
-
+	skb_new = batadv_dat_types_info[dat_pair_type.data_type].create_skb(
+			bat_priv, dat_entry, hw_src, ip_src, ip_dst);
 	if (!skb_new)
 		goto out;
 
@@ -1462,49 +1671,55 @@ out:
 }
 
 /**
- * batadv_dat_snoop_outgoing_pkt_reply - snoop the ARP reply and fill the DHT
+ * batadv_dat_snoop_outgoing_pkt_reply - snoop the ARP reply / NA and fill
+ * the DHT
  * @bat_priv: the bat priv with all the soft interface information
  * @skb: packet to check
  */
 void batadv_dat_snoop_outgoing_pkt_reply(struct batadv_priv *bat_priv,
 					 struct sk_buff *skb)
 {
-	uint16_t type;
-	__be32 ip_src, ip_dst;
+	void *ip_src, *ip_dst;
 	uint8_t *hw_src, *hw_dst;
 	int hdr_size = 0;
 	unsigned short vid;
+	struct batadv_dat_pair_type dat_pair_type;
 
 	if (!atomic_read(&bat_priv->distributed_arp_table))
 		return;
 
 	vid = batadv_dat_get_vid(skb, &hdr_size);
 
-	type = batadv_arp_get_type(bat_priv, skb, hdr_size);
-	if (type != ARPOP_REPLY)
+	dat_pair_type = batadv_dat_get_pair_type(bat_priv, skb, hdr_size);
+	if (dat_pair_type.data_type < 0)
+		return;
+	if (!batadv_dat_types_info[dat_pair_type.data_type].snoop_pkt(
+			bat_priv, skb, hdr_size, dat_pair_type.pkt_type,
+			BATADV_DAT_OUTGOING_PKT_REPLY,
+			&hw_src, &ip_src, &hw_dst, &ip_dst))
 		return;
-
-	batadv_dbg_arp(bat_priv, skb, type, 0, "Parsing outgoing ARP REPLY");
-
-	hw_src = batadv_arp_hw_src(skb, hdr_size);
-	ip_src = batadv_arp_ip_src(skb, hdr_size);
-	hw_dst = batadv_arp_hw_dst(skb, hdr_size);
-	ip_dst = batadv_arp_ip_dst(skb, hdr_size);
-
-	batadv_dat_entry_add(bat_priv, &ip_src, BATADV_DAT_IPV4, hw_src, vid);
-	batadv_dat_entry_add(bat_priv, &ip_dst, BATADV_DAT_IPV4, hw_dst, vid);
 
 	/* Send the ARP reply to the candidates for both the IP addresses that
 	 * the node obtained from the ARP reply
 	 */
-	batadv_dat_send_data(bat_priv, skb, &ip_src, BATADV_DAT_IPV4,
-			     BATADV_P_DAT_DHT_PUT);
-	batadv_dat_send_data(bat_priv, skb, &ip_dst, BATADV_DAT_IPV4,
+	batadv_dat_entry_add(bat_priv, ip_src, dat_pair_type.data_type,
+			     hw_src, vid);
+	batadv_dat_send_data(bat_priv, skb, ip_src, dat_pair_type.data_type,
 			     BATADV_P_DAT_DHT_PUT);
+
+	/* not a solicited advertisement (see snooping mechanism) */
+	if (ip_dst) {
+		batadv_dat_entry_add(bat_priv, ip_dst, dat_pair_type.data_type,
+				     hw_dst, vid);
+		batadv_dat_send_data(bat_priv, skb, ip_dst,
+				     dat_pair_type.data_type,
+				     BATADV_P_DAT_DHT_PUT);
+	}
 }
+
 /**
- * batadv_dat_snoop_incoming_pkt_reply - snoop the ARP reply and fill the local
- * DAT storage only
+ * batadv_dat_snoop_incoming_pkt_reply - snoop the ARP reply / NA and fill
+ * the local DAT storage only
  * @bat_priv: the bat priv with all the soft interface information
  * @skb: packet to check
  * @hdr_size: size of the encapsulation header
@@ -1512,34 +1727,35 @@ void batadv_dat_snoop_outgoing_pkt_reply(struct batadv_priv *bat_priv,
 bool batadv_dat_snoop_incoming_pkt_reply(struct batadv_priv *bat_priv,
 					 struct sk_buff *skb, int hdr_size)
 {
-	uint16_t type;
-	__be32 ip_src, ip_dst;
+	void *ip_src, *ip_dst;
 	uint8_t *hw_src, *hw_dst;
 	bool ret = false;
 	unsigned short vid;
+	struct batadv_dat_pair_type dat_pair_type;
 
 	if (!atomic_read(&bat_priv->distributed_arp_table))
 		goto out;
 
 	vid = batadv_dat_get_vid(skb, &hdr_size);
 
-	type = batadv_arp_get_type(bat_priv, skb, hdr_size);
-	if (type != ARPOP_REPLY)
+	dat_pair_type = batadv_dat_get_pair_type(bat_priv, skb, hdr_size);
+	if (dat_pair_type.data_type < 0)
+		goto out;
+	if (!batadv_dat_types_info[dat_pair_type.data_type].snoop_pkt(
+			bat_priv, skb, hdr_size, dat_pair_type.pkt_type,
+			BATADV_DAT_INCOMING_PKT_REPLY,
+			&hw_src, &ip_src, &hw_dst, &ip_dst))
 		goto out;
-
-	batadv_dbg_arp(bat_priv, skb, type, hdr_size,
-		       "Parsing incoming ARP REPLY");
-
-	hw_src = batadv_arp_hw_src(skb, hdr_size);
-	ip_src = batadv_arp_ip_src(skb, hdr_size);
-	hw_dst = batadv_arp_hw_dst(skb, hdr_size);
-	ip_dst = batadv_arp_ip_dst(skb, hdr_size);
 
 	/* Update our internal cache with both the IP addresses the node got
 	 * within the ARP reply
 	 */
-	batadv_dat_entry_add(bat_priv, &ip_src, BATADV_DAT_IPV4, hw_src, vid);
-	batadv_dat_entry_add(bat_priv, &ip_dst, BATADV_DAT_IPV4, hw_dst, vid);
+	batadv_dat_entry_add(bat_priv, ip_src, dat_pair_type.data_type,
+			     hw_src, vid);
+	/* not a solicited advertisement (see snooping mechanism) */
+	if (ip_dst)
+		batadv_dat_entry_add(bat_priv, ip_dst,
+				     dat_pair_type.data_type, hw_dst, vid);
 
 	/* if this REPLY is directed to a client of mine, let's deliver the
 	 * packet to the interface
@@ -1553,8 +1769,8 @@ out:
 }
 
 /**
- * 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
+ * batadv_dat_drop_broadcast_packet - check if an ARP request / NA has to be
+ * dropped (because the node has already obtained the reply via DAT) or not
  * @bat_priv: the bat priv with all the soft interface information
  * @forw_packet: the broadcast packet
  *
@@ -1563,12 +1779,13 @@ out:
 bool batadv_dat_drop_broadcast_packet(struct batadv_priv *bat_priv,
 				      struct batadv_forw_packet *forw_packet)
 {
-	uint16_t type;
-	__be32 ip_dst;
+	void *ip_dst;
 	struct batadv_dat_entry *dat_entry = NULL;
 	bool ret = false;
 	int hdr_size = sizeof(struct batadv_bcast_packet);
 	unsigned short vid;
+	struct batadv_dat_pair_type dat_pair_type;
+	char dbg_data[BATADV_DAT_DATA_MAX_LEN];
 
 	if (!atomic_read(&bat_priv->distributed_arp_table))
 		goto out;
@@ -1581,22 +1798,31 @@ bool batadv_dat_drop_broadcast_packet(struct batadv_priv *bat_priv,
 
 	vid = batadv_dat_get_vid(forw_packet->skb, &hdr_size);
 
-	type = batadv_arp_get_type(bat_priv, forw_packet->skb, hdr_size);
-	if (type != ARPOP_REQUEST)
+	dat_pair_type = batadv_dat_get_pair_type(bat_priv, forw_packet->skb,
+						 hdr_size);
+	if (dat_pair_type.data_type < 0)
 		goto out;
+	if (!batadv_dat_types_info[dat_pair_type.data_type].snoop_pkt(
+			bat_priv, forw_packet->skb, hdr_size,
+			dat_pair_type.pkt_type,
+			BATADV_DAT_BROADCAST_FALLBACK,
+			NULL, NULL, NULL, &ip_dst))
+		goto out;
+
+	dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst,
+					       dat_pair_type.data_type, vid);
 
-	ip_dst = batadv_arp_ip_dst(forw_packet->skb, hdr_size);
-	dat_entry = batadv_dat_entry_hash_find(bat_priv, &ip_dst,
-					       BATADV_DAT_IPV4, vid);
 	/* check if the node already got this entry */
+	batadv_dat_data_to_str(ip_dst, dat_pair_type.data_type,
+			       dbg_data, sizeof(dbg_data));
 	if (!dat_entry) {
 		batadv_dbg(BATADV_DBG_DAT, bat_priv,
-			   "ARP Request for %pI4: fallback\n", &ip_dst);
+			   "ARP Request for %s: fallback\n", dbg_data);
 		goto out;
 	}
 
 	batadv_dbg(BATADV_DBG_DAT, bat_priv,
-		   "ARP Request for %pI4: fallback prevented\n", &ip_dst);
+		   "ARP Request for %s fallback prevented\n", dbg_data);
 	ret = true;
 
 out:
diff --git a/types.h b/types.h
index 60d2d64..6ad4500 100644
--- a/types.h
+++ b/types.h
@@ -964,13 +964,82 @@ enum batadv_dat_types {
 };
 
 /**
+ * batadv_dat_pkt_types - describe generic packet types
+ * @BATADV_DAT_OUTGOING_PKT_REQUEST: an outgoing packet request
+ * @BATADV_DAT_INCOMING_PKT_REQUEST: an incoming packet request
+ * @BATADV_DAT_OUTGOING_PKT_REPLY: an outgoing packet reply
+ * @BATADV_DAT_INCOMING_PKT_REPLY: an incoming packet reply
+ * @BATADV_DAT_BROADCAST_FALLBACK: used for broadcasts fallback;
+ * can any type of request packets
+ *
+ * The packets can be ARP Request / Reply, NS / NA or other packets.
+ */
+enum batadv_dat_pkt_types {
+	BATADV_DAT_OUTGOING_PKT_REQUEST,
+	BATADV_DAT_INCOMING_PKT_REQUEST,
+	BATADV_DAT_OUTGOING_PKT_REPLY,
+	BATADV_DAT_INCOMING_PKT_REPLY,
+	BATADV_DAT_BROADCAST_FALLBACK,
+};
+
+/**
+ * batadv_dat_pair_type - types needed for a dat packet
+ * @data_type the data type (negative values represents invalid values)
+ * @pkt_type: the packet type
+ */
+struct batadv_dat_pair_type {
+	int data_type;
+	uint16_t pkt_type;
+};
+
+/**
  * batadv_dat_type_info - info needed for a DAT type data
  * @size: the size of the type data
  * @str_fmt: string format used by the data
+ * @snoop_pkt: function used to snoop addresses from a packet
  */
 struct batadv_dat_type_info {
 	size_t size;
 	char *str_fmt;
+	/**
+	 * snoop_pkt - snooping mechanism for all packets that participate
+	 * in DAT
+	 * @bat_priv: the bat priv with all the soft interface information
+	 * @skb: packet to snoop
+	 * @hdr_size: size of the encapsulation header
+	 * @pkt_type: the packet type
+	 * @pkt_dir_type: outgoing / incoming message request / reply
+	 * @hw_src: source HW Address
+	 * @ip_src: source IP
+	 * @hw_dst: destination HW Address
+	 * @ip_dst: destination IP
+	 *
+	 * Any address pointer can be null if there is no need to memorize
+	 * calculate that address.
+	 *
+	 * Returns true if snooping was successful.
+	 */
+	bool (*snoop_pkt)(struct batadv_priv *bat_priv,
+			  struct sk_buff *skb, int hdr_size,
+			  uint16_t pkt_type, uint8_t pkt_dir_type,
+			  uint8_t **hw_src, void **ip_src,
+			  uint8_t **hw_dst, void **ip_dst);
+
+	/**
+	 * batadv_dat_create_skb - creates a skb as a reply to a message request
+	 * @bat_priv: the bat priv with all the soft interface information
+	 * @dat_entry: the DAT entry used for destination HW Address
+	 * @hw_src: source HW Address
+	 * @ip_src: source IP
+	 * @ip_dst: destination IP
+	 *
+	 * Returns the newly created skb, or NULL if any error.
+	 */
+	struct sk_buff *(*create_skb)(struct batadv_priv *bat_priv,
+				      struct batadv_dat_entry *dat_entry,
+				      uint8_t *hw_src, void *ip_src,
+				      void *ip_dst);
+
 };
 
 /**
-- 
1.7.10.4