net: flow_dissector: add __skb_get_poff to get a start offset to payload

__skb_get_poff() returns the offset to the payload as far as it could
be dissected. The main user is currently BPF, so that we can dynamically
truncate packets without needing to push actual payload to the user
space and instead can analyze headers only.

Suggested-by: Eric Dumazet <edumazet@google.com>
Signed-off-by: Daniel Borkmann <dborkman@redhat.com>
Acked-by: Eric Dumazet <edumazet@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index b66ecc6ef10257536c57922d5ca0ff360f49ab4f..497412165b1c935efcc8b7e79afad250d85c6f05 100644 (file)
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -2840,6 +2840,8 @@ static inline void skb_checksum_none_assert(const struct sk_buff *skb)
 
 bool skb_partial_csum_set(struct sk_buff *skb, u16 start, u16 off);
 
+u32 __skb_get_poff(const struct sk_buff *skb);
+
 /**
  * skb_head_is_locked - Determine if the skb->head is locked down
  * @skb: skb to check

diff --git a/net/core/flow_dissector.c b/net/core/flow_dissector.c
index f4be293bab9e5f2e01136f822852d4403727d5cd..00ee068efc1c2374bc0195d9458eca00392359c6 100644 (file)
--- a/net/core/flow_dissector.c
+++ b/net/core/flow_dissector.c
@@ -5,6 +5,10 @@
 #include <linux/if_vlan.h>
 #include <net/ip.h>
 #include <net/ipv6.h>
+#include <linux/igmp.h>
+#include <linux/icmp.h>
+#include <linux/sctp.h>
+#include <linux/dccp.h>
 #include <linux/if_tunnel.h>
 #include <linux/if_pppox.h>
 #include <linux/ppp_defs.h>
@@ -228,6 +232,59 @@ u16 __skb_tx_hash(const struct net_device *dev, const struct sk_buff *skb,
 }
 EXPORT_SYMBOL(__skb_tx_hash);
 
+/* __skb_get_poff() returns the offset to the payload as far as it could
+ * be dissected. The main user is currently BPF, so that we can dynamically
+ * truncate packets without needing to push actual payload to the user
+ * space and can analyze headers only, instead.
+ */
+u32 __skb_get_poff(const struct sk_buff *skb)
+{
+       struct flow_keys keys;
+       u32 poff = 0;
+
+       if (!skb_flow_dissect(skb, &keys))
+               return 0;
+
+       poff += keys.thoff;
+       switch (keys.ip_proto) {
+       case IPPROTO_TCP: {
+               const struct tcphdr *tcph;
+               struct tcphdr _tcph;
+
+               tcph = skb_header_pointer(skb, poff, sizeof(_tcph), &_tcph);
+               if (!tcph)
+                       return poff;
+
+               poff += max_t(u32, sizeof(struct tcphdr), tcph->doff * 4);
+               break;
+       }
+       case IPPROTO_UDP:
+       case IPPROTO_UDPLITE:
+               poff += sizeof(struct udphdr);
+               break;
+       /* For the rest, we do not really care about header
+        * extensions at this point for now.
+        */
+       case IPPROTO_ICMP:
+               poff += sizeof(struct icmphdr);
+               break;
+       case IPPROTO_ICMPV6:
+               poff += sizeof(struct icmp6hdr);
+               break;
+       case IPPROTO_IGMP:
+               poff += sizeof(struct igmphdr);
+               break;
+       case IPPROTO_DCCP:
+               poff += sizeof(struct dccp_hdr);
+               break;
+       case IPPROTO_SCTP:
+               poff += sizeof(struct sctphdr);
+               break;
+       }
+
+       return poff;
+}
+
 static inline u16 dev_cap_txqueue(struct net_device *dev, u16 queue_index)
 {
        if (unlikely(queue_index >= dev->real_num_tx_queues)) {