2106 lines · 56.4 KB · C
RawDownload
// SPDX-License-Identifier: GPL-2.0-only#include <linux/kernel.h>#include <linux/skbuff.h>#include <linux/export.h>#include <linux/ip.h>#include <linux/ipv6.h>#include <linux/if_vlan.h>#include <linux/filter.h>#include <net/dsa.h>#include <net/dst_metadata.h>#include <net/ip.h>#include <net/ipv6.h>#include <net/gre.h>#include <net/pptp.h>#include <net/tipc.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>#include <linux/stddef.h>#include <linux/if_ether.h>#include <linux/if_hsr.h>#include <linux/mpls.h>#include <linux/tcp.h>#include <linux/ptp_classify.h>#include <net/flow_dissector.h>#include <net/pkt_cls.h>#include <scsi/fc/fc_fcoe.h>#include <uapi/linux/batadv_packet.h>#include <linux/bpf.h>#if IS_ENABLED(CONFIG_NF_CONNTRACK)#include <net/netfilter/nf_conntrack_core.h>#include <net/netfilter/nf_conntrack_labels.h>#endif#include <linux/bpf-netns.h> static void dissector_set_key(struct flow_dissector *flow_dissector,			      enum flow_dissector_key_id key_id){	flow_dissector->used_keys |= (1ULL << key_id);} void skb_flow_dissector_init(struct flow_dissector *flow_dissector,			     const struct flow_dissector_key *key,			     unsigned int key_count){	unsigned int i; 	memset(flow_dissector, 0, sizeof(*flow_dissector)); 	for (i = 0; i < key_count; i++, key++) {		/* User should make sure that every key target offset is within		 * boundaries of unsigned short.		 */		BUG_ON(key->offset > USHRT_MAX);		BUG_ON(dissector_uses_key(flow_dissector,					  key->key_id)); 		dissector_set_key(flow_dissector, key->key_id);		flow_dissector->offset[key->key_id] = key->offset;	} 	/* Ensure that the dissector always includes control and basic key.	 * That way we are able to avoid handling lack of these in fast path.	 */	BUG_ON(!dissector_uses_key(flow_dissector,				   FLOW_DISSECTOR_KEY_CONTROL));	BUG_ON(!dissector_uses_key(flow_dissector,				   FLOW_DISSECTOR_KEY_BASIC));}EXPORT_SYMBOL(skb_flow_dissector_init); #ifdef CONFIG_BPF_SYSCALLint flow_dissector_bpf_prog_attach_check(struct net *net,					 struct bpf_prog *prog){	enum netns_bpf_attach_type type = NETNS_BPF_FLOW_DISSECTOR; 	if (net == &init_net) {		/* BPF flow dissector in the root namespace overrides		 * any per-net-namespace one. When attaching to root,		 * make sure we don't have any BPF program attached		 * to the non-root namespaces.		 */		struct net *ns; 		for_each_net(ns) {			if (ns == &init_net)				continue;			if (rcu_access_pointer(ns->bpf.run_array[type]))				return -EEXIST;		}	} else {		/* Make sure root flow dissector is not attached		 * when attaching to the non-root namespace.		 */		if (rcu_access_pointer(init_net.bpf.run_array[type]))			return -EEXIST;	} 	return 0;}#endif /* CONFIG_BPF_SYSCALL */ /** * skb_flow_get_ports - extract the upper layer ports and return them * @skb: sk_buff to extract the ports from * @thoff: transport header offset * @ip_proto: protocol for which to get port offset * @data: raw buffer pointer to the packet, if NULL use skb->data * @hlen: packet header length, if @data is NULL use skb_headlen(skb) * * The function will try to retrieve the ports at offset thoff + poff where poff * is the protocol port offset returned from proto_ports_offset */__be32 skb_flow_get_ports(const struct sk_buff *skb, int thoff, u8 ip_proto,			  const void *data, int hlen){	int poff = proto_ports_offset(ip_proto); 	if (!data) {		data = skb->data;		hlen = skb_headlen(skb);	} 	if (poff >= 0) {		__be32 *ports, _ports; 		ports = __skb_header_pointer(skb, thoff + poff,					     sizeof(_ports), data, hlen, &_ports);		if (ports)			return *ports;	} 	return 0;}EXPORT_SYMBOL(skb_flow_get_ports); static bool icmp_has_id(u8 type){	switch (type) {	case ICMP_ECHO:	case ICMP_ECHOREPLY:	case ICMP_TIMESTAMP:	case ICMP_TIMESTAMPREPLY:	case ICMPV6_ECHO_REQUEST:	case ICMPV6_ECHO_REPLY:		return true;	} 	return false;} /** * skb_flow_get_icmp_tci - extract ICMP(6) Type, Code and Identifier fields * @skb: sk_buff to extract from * @key_icmp: struct flow_dissector_key_icmp to fill * @data: raw buffer pointer to the packet * @thoff: offset to extract at * @hlen: packet header length */void skb_flow_get_icmp_tci(const struct sk_buff *skb,			   struct flow_dissector_key_icmp *key_icmp,			   const void *data, int thoff, int hlen){	struct icmphdr *ih, _ih; 	ih = __skb_header_pointer(skb, thoff, sizeof(_ih), data, hlen, &_ih);	if (!ih)		return; 	key_icmp->type = ih->type;	key_icmp->code = ih->code; 	/* As we use 0 to signal that the Id field is not present,	 * avoid confusion with packets without such field	 */	if (icmp_has_id(ih->type))		key_icmp->id = ih->un.echo.id ? ntohs(ih->un.echo.id) : 1;	else		key_icmp->id = 0;}EXPORT_SYMBOL(skb_flow_get_icmp_tci); /* If FLOW_DISSECTOR_KEY_ICMP is set, dissect an ICMP packet * using skb_flow_get_icmp_tci(). */static void __skb_flow_dissect_icmp(const struct sk_buff *skb,				    struct flow_dissector *flow_dissector,				    void *target_container, const void *data,				    int thoff, int hlen){	struct flow_dissector_key_icmp *key_icmp; 	if (!dissector_uses_key(flow_dissector, FLOW_DISSECTOR_KEY_ICMP))		return; 	key_icmp = skb_flow_dissector_target(flow_dissector,					     FLOW_DISSECTOR_KEY_ICMP,					     target_container); 	skb_flow_get_icmp_tci(skb, key_icmp, data, thoff, hlen);} static void __skb_flow_dissect_ah(const struct sk_buff *skb,				  struct flow_dissector *flow_dissector,				  void *target_container, const void *data,				  int nhoff, int hlen){	struct flow_dissector_key_ipsec *key_ah;	struct ip_auth_hdr _hdr, *hdr; 	if (!dissector_uses_key(flow_dissector, FLOW_DISSECTOR_KEY_IPSEC))		return; 	hdr = __skb_header_pointer(skb, nhoff, sizeof(_hdr), data, hlen, &_hdr);	if (!hdr)		return; 	key_ah = skb_flow_dissector_target(flow_dissector,					   FLOW_DISSECTOR_KEY_IPSEC,					   target_container); 	key_ah->spi = hdr->spi;} static void __skb_flow_dissect_esp(const struct sk_buff *skb,				   struct flow_dissector *flow_dissector,				   void *target_container, const void *data,				   int nhoff, int hlen){	struct flow_dissector_key_ipsec *key_esp;	struct ip_esp_hdr _hdr, *hdr; 	if (!dissector_uses_key(flow_dissector, FLOW_DISSECTOR_KEY_IPSEC))		return; 	hdr = __skb_header_pointer(skb, nhoff, sizeof(_hdr), data, hlen, &_hdr);	if (!hdr)		return; 	key_esp = skb_flow_dissector_target(flow_dissector,					    FLOW_DISSECTOR_KEY_IPSEC,					    target_container); 	key_esp->spi = hdr->spi;} static void __skb_flow_dissect_l2tpv3(const struct sk_buff *skb,				      struct flow_dissector *flow_dissector,				      void *target_container, const void *data,				      int nhoff, int hlen){	struct flow_dissector_key_l2tpv3 *key_l2tpv3;	struct {		__be32 session_id;	} *hdr, _hdr; 	if (!dissector_uses_key(flow_dissector, FLOW_DISSECTOR_KEY_L2TPV3))		return; 	hdr = __skb_header_pointer(skb, nhoff, sizeof(_hdr), data, hlen, &_hdr);	if (!hdr)		return; 	key_l2tpv3 = skb_flow_dissector_target(flow_dissector,					       FLOW_DISSECTOR_KEY_L2TPV3,					       target_container); 	key_l2tpv3->session_id = hdr->session_id;} void skb_flow_dissect_meta(const struct sk_buff *skb,			   struct flow_dissector *flow_dissector,			   void *target_container){	struct flow_dissector_key_meta *meta; 	if (!dissector_uses_key(flow_dissector, FLOW_DISSECTOR_KEY_META))		return; 	meta = skb_flow_dissector_target(flow_dissector,					 FLOW_DISSECTOR_KEY_META,					 target_container);	meta->ingress_ifindex = skb->skb_iif;#if IS_ENABLED(CONFIG_NET_TC_SKB_EXT)	if (tc_skb_ext_tc_enabled()) {		struct tc_skb_ext *ext; 		ext = skb_ext_find(skb, TC_SKB_EXT);		if (ext)			meta->l2_miss = ext->l2_miss;	}#endif}EXPORT_SYMBOL(skb_flow_dissect_meta); static voidskb_flow_dissect_set_enc_control(enum flow_dissector_key_id type,				 u32 ctrl_flags,				 struct flow_dissector *flow_dissector,				 void *target_container){	struct flow_dissector_key_control *ctrl; 	if (!dissector_uses_key(flow_dissector, FLOW_DISSECTOR_KEY_ENC_CONTROL))		return; 	ctrl = skb_flow_dissector_target(flow_dissector,					 FLOW_DISSECTOR_KEY_ENC_CONTROL,					 target_container);	ctrl->addr_type = type;	ctrl->flags = ctrl_flags;} voidskb_flow_dissect_ct(const struct sk_buff *skb,		    struct flow_dissector *flow_dissector,		    void *target_container, u16 *ctinfo_map,		    size_t mapsize, bool post_ct, u16 zone){#if IS_ENABLED(CONFIG_NF_CONNTRACK)	struct flow_dissector_key_ct *key;	enum ip_conntrack_info ctinfo;	struct nf_conn_labels *cl;	struct nf_conn *ct; 	if (!dissector_uses_key(flow_dissector, FLOW_DISSECTOR_KEY_CT))		return; 	ct = nf_ct_get(skb, &ctinfo);	if (!ct && !post_ct)		return; 	key = skb_flow_dissector_target(flow_dissector,					FLOW_DISSECTOR_KEY_CT,					target_container); 	if (!ct) {		key->ct_state = TCA_FLOWER_KEY_CT_FLAGS_TRACKED |				TCA_FLOWER_KEY_CT_FLAGS_INVALID;		key->ct_zone = zone;		return;	} 	if (ctinfo < mapsize)		key->ct_state = ctinfo_map[ctinfo];#if IS_ENABLED(CONFIG_NF_CONNTRACK_ZONES)	key->ct_zone = ct->zone.id;#endif#if IS_ENABLED(CONFIG_NF_CONNTRACK_MARK)	key->ct_mark = READ_ONCE(ct->mark);#endif 	cl = nf_ct_labels_find(ct);	if (cl)		memcpy(key->ct_labels, cl->bits, sizeof(key->ct_labels));#endif /* CONFIG_NF_CONNTRACK */}EXPORT_SYMBOL(skb_flow_dissect_ct); voidskb_flow_dissect_tunnel_info(const struct sk_buff *skb,			     struct flow_dissector *flow_dissector,			     void *target_container){	struct ip_tunnel_info *info;	struct ip_tunnel_key *key;	u32 ctrl_flags = 0; 	/* A quick check to see if there might be something to do. */	if (!dissector_uses_key(flow_dissector,				FLOW_DISSECTOR_KEY_ENC_KEYID) &&	    !dissector_uses_key(flow_dissector,				FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS) &&	    !dissector_uses_key(flow_dissector,				FLOW_DISSECTOR_KEY_ENC_IPV6_ADDRS) &&	    !dissector_uses_key(flow_dissector,				FLOW_DISSECTOR_KEY_ENC_CONTROL) &&	    !dissector_uses_key(flow_dissector,				FLOW_DISSECTOR_KEY_ENC_PORTS) &&	    !dissector_uses_key(flow_dissector,				FLOW_DISSECTOR_KEY_ENC_IP) &&	    !dissector_uses_key(flow_dissector,				FLOW_DISSECTOR_KEY_ENC_OPTS))		return; 	info = skb_tunnel_info(skb);	if (!info)		return; 	key = &info->key; 	if (test_bit(IP_TUNNEL_CSUM_BIT, key->tun_flags))		ctrl_flags |= FLOW_DIS_F_TUNNEL_CSUM;	if (test_bit(IP_TUNNEL_DONT_FRAGMENT_BIT, key->tun_flags))		ctrl_flags |= FLOW_DIS_F_TUNNEL_DONT_FRAGMENT;	if (test_bit(IP_TUNNEL_OAM_BIT, key->tun_flags))		ctrl_flags |= FLOW_DIS_F_TUNNEL_OAM;	if (test_bit(IP_TUNNEL_CRIT_OPT_BIT, key->tun_flags))		ctrl_flags |= FLOW_DIS_F_TUNNEL_CRIT_OPT; 	switch (ip_tunnel_info_af(info)) {	case AF_INET:		skb_flow_dissect_set_enc_control(FLOW_DISSECTOR_KEY_IPV4_ADDRS,						 ctrl_flags, flow_dissector,						 target_container);		if (dissector_uses_key(flow_dissector,				       FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS)) {			struct flow_dissector_key_ipv4_addrs *ipv4; 			ipv4 = skb_flow_dissector_target(flow_dissector,							 FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS,							 target_container);			ipv4->src = key->u.ipv4.src;			ipv4->dst = key->u.ipv4.dst;		}		break;	case AF_INET6:		skb_flow_dissect_set_enc_control(FLOW_DISSECTOR_KEY_IPV6_ADDRS,						 ctrl_flags, flow_dissector,						 target_container);		if (dissector_uses_key(flow_dissector,				       FLOW_DISSECTOR_KEY_ENC_IPV6_ADDRS)) {			struct flow_dissector_key_ipv6_addrs *ipv6; 			ipv6 = skb_flow_dissector_target(flow_dissector,							 FLOW_DISSECTOR_KEY_ENC_IPV6_ADDRS,							 target_container);			ipv6->src = key->u.ipv6.src;			ipv6->dst = key->u.ipv6.dst;		}		break;	default:		skb_flow_dissect_set_enc_control(0, ctrl_flags, flow_dissector,						 target_container);		break;	} 	if (dissector_uses_key(flow_dissector, FLOW_DISSECTOR_KEY_ENC_KEYID)) {		struct flow_dissector_key_keyid *keyid; 		keyid = skb_flow_dissector_target(flow_dissector,						  FLOW_DISSECTOR_KEY_ENC_KEYID,						  target_container);		keyid->keyid = tunnel_id_to_key32(key->tun_id);	} 	if (dissector_uses_key(flow_dissector, FLOW_DISSECTOR_KEY_ENC_PORTS)) {		struct flow_dissector_key_ports *tp; 		tp = skb_flow_dissector_target(flow_dissector,					       FLOW_DISSECTOR_KEY_ENC_PORTS,					       target_container);		tp->src = key->tp_src;		tp->dst = key->tp_dst;	} 	if (dissector_uses_key(flow_dissector, FLOW_DISSECTOR_KEY_ENC_IP)) {		struct flow_dissector_key_ip *ip; 		ip = skb_flow_dissector_target(flow_dissector,					       FLOW_DISSECTOR_KEY_ENC_IP,					       target_container);		ip->tos = key->tos;		ip->ttl = key->ttl;	} 	if (dissector_uses_key(flow_dissector, FLOW_DISSECTOR_KEY_ENC_OPTS)) {		struct flow_dissector_key_enc_opts *enc_opt;		IP_TUNNEL_DECLARE_FLAGS(flags) = { };		u32 val; 		enc_opt = skb_flow_dissector_target(flow_dissector,						    FLOW_DISSECTOR_KEY_ENC_OPTS,						    target_container); 		if (!info->options_len)			return; 		enc_opt->len = info->options_len;		ip_tunnel_info_opts_get(enc_opt->data, info); 		ip_tunnel_set_options_present(flags);		ip_tunnel_flags_and(flags, info->key.tun_flags, flags); 		val = find_next_bit(flags, __IP_TUNNEL_FLAG_NUM,				    IP_TUNNEL_GENEVE_OPT_BIT);		enc_opt->dst_opt_type = val < __IP_TUNNEL_FLAG_NUM ? val : 0;	}}EXPORT_SYMBOL(skb_flow_dissect_tunnel_info); void skb_flow_dissect_hash(const struct sk_buff *skb,			   struct flow_dissector *flow_dissector,			   void *target_container){

Lines 1–500 of 2106.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t