cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

ip.h (22570B)


      1/* SPDX-License-Identifier: GPL-2.0-or-later */
      2/*
      3 * INET		An implementation of the TCP/IP protocol suite for the LINUX
      4 *		operating system.  INET is implemented using the  BSD Socket
      5 *		interface as the means of communication with the user level.
      6 *
      7 *		Definitions for the IP module.
      8 *
      9 * Version:	@(#)ip.h	1.0.2	05/07/93
     10 *
     11 * Authors:	Ross Biro
     12 *		Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
     13 *		Alan Cox, <gw4pts@gw4pts.ampr.org>
     14 *
     15 * Changes:
     16 *		Mike McLagan    :       Routing by source
     17 */
     18#ifndef _IP_H
     19#define _IP_H
     20
     21#include <linux/types.h>
     22#include <linux/ip.h>
     23#include <linux/in.h>
     24#include <linux/skbuff.h>
     25#include <linux/jhash.h>
     26#include <linux/sockptr.h>
     27#include <linux/static_key.h>
     28
     29#include <net/inet_sock.h>
     30#include <net/route.h>
     31#include <net/snmp.h>
     32#include <net/flow.h>
     33#include <net/flow_dissector.h>
     34#include <net/netns/hash.h>
     35#include <net/lwtunnel.h>
     36
     37#define IPV4_MAX_PMTU		65535U		/* RFC 2675, Section 5.1 */
     38#define IPV4_MIN_MTU		68			/* RFC 791 */
     39
     40extern unsigned int sysctl_fib_sync_mem;
     41extern unsigned int sysctl_fib_sync_mem_min;
     42extern unsigned int sysctl_fib_sync_mem_max;
     43
     44struct sock;
     45
     46struct inet_skb_parm {
     47	int			iif;
     48	struct ip_options	opt;		/* Compiled IP options		*/
     49	u16			flags;
     50
     51#define IPSKB_FORWARDED		BIT(0)
     52#define IPSKB_XFRM_TUNNEL_SIZE	BIT(1)
     53#define IPSKB_XFRM_TRANSFORMED	BIT(2)
     54#define IPSKB_FRAG_COMPLETE	BIT(3)
     55#define IPSKB_REROUTED		BIT(4)
     56#define IPSKB_DOREDIRECT	BIT(5)
     57#define IPSKB_FRAG_PMTU		BIT(6)
     58#define IPSKB_L3SLAVE		BIT(7)
     59#define IPSKB_NOPOLICY		BIT(8)
     60
     61	u16			frag_max_size;
     62};
     63
     64static inline bool ipv4_l3mdev_skb(u16 flags)
     65{
     66	return !!(flags & IPSKB_L3SLAVE);
     67}
     68
     69static inline unsigned int ip_hdrlen(const struct sk_buff *skb)
     70{
     71	return ip_hdr(skb)->ihl * 4;
     72}
     73
     74struct ipcm_cookie {
     75	struct sockcm_cookie	sockc;
     76	__be32			addr;
     77	int			oif;
     78	struct ip_options_rcu	*opt;
     79	__u8			ttl;
     80	__s16			tos;
     81	char			priority;
     82	__u16			gso_size;
     83};
     84
     85static inline void ipcm_init(struct ipcm_cookie *ipcm)
     86{
     87	*ipcm = (struct ipcm_cookie) { .tos = -1 };
     88}
     89
     90static inline void ipcm_init_sk(struct ipcm_cookie *ipcm,
     91				const struct inet_sock *inet)
     92{
     93	ipcm_init(ipcm);
     94
     95	ipcm->sockc.mark = inet->sk.sk_mark;
     96	ipcm->sockc.tsflags = inet->sk.sk_tsflags;
     97	ipcm->oif = READ_ONCE(inet->sk.sk_bound_dev_if);
     98	ipcm->addr = inet->inet_saddr;
     99}
    100
    101#define IPCB(skb) ((struct inet_skb_parm*)((skb)->cb))
    102#define PKTINFO_SKB_CB(skb) ((struct in_pktinfo *)((skb)->cb))
    103
    104/* return enslaved device index if relevant */
    105static inline int inet_sdif(const struct sk_buff *skb)
    106{
    107#if IS_ENABLED(CONFIG_NET_L3_MASTER_DEV)
    108	if (skb && ipv4_l3mdev_skb(IPCB(skb)->flags))
    109		return IPCB(skb)->iif;
    110#endif
    111	return 0;
    112}
    113
    114/* Special input handler for packets caught by router alert option.
    115   They are selected only by protocol field, and then processed likely
    116   local ones; but only if someone wants them! Otherwise, router
    117   not running rsvpd will kill RSVP.
    118
    119   It is user level problem, what it will make with them.
    120   I have no idea, how it will masquearde or NAT them (it is joke, joke :-)),
    121   but receiver should be enough clever f.e. to forward mtrace requests,
    122   sent to multicast group to reach destination designated router.
    123 */
    124
    125struct ip_ra_chain {
    126	struct ip_ra_chain __rcu *next;
    127	struct sock		*sk;
    128	union {
    129		void			(*destructor)(struct sock *);
    130		struct sock		*saved_sk;
    131	};
    132	struct rcu_head		rcu;
    133};
    134
    135/* IP flags. */
    136#define IP_CE		0x8000		/* Flag: "Congestion"		*/
    137#define IP_DF		0x4000		/* Flag: "Don't Fragment"	*/
    138#define IP_MF		0x2000		/* Flag: "More Fragments"	*/
    139#define IP_OFFSET	0x1FFF		/* "Fragment Offset" part	*/
    140
    141#define IP_FRAG_TIME	(30 * HZ)		/* fragment lifetime	*/
    142
    143struct msghdr;
    144struct net_device;
    145struct packet_type;
    146struct rtable;
    147struct sockaddr;
    148
    149int igmp_mc_init(void);
    150
    151/*
    152 *	Functions provided by ip.c
    153 */
    154
    155int ip_build_and_send_pkt(struct sk_buff *skb, const struct sock *sk,
    156			  __be32 saddr, __be32 daddr,
    157			  struct ip_options_rcu *opt, u8 tos);
    158int ip_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt,
    159	   struct net_device *orig_dev);
    160void ip_list_rcv(struct list_head *head, struct packet_type *pt,
    161		 struct net_device *orig_dev);
    162int ip_local_deliver(struct sk_buff *skb);
    163void ip_protocol_deliver_rcu(struct net *net, struct sk_buff *skb, int proto);
    164int ip_mr_input(struct sk_buff *skb);
    165int ip_output(struct net *net, struct sock *sk, struct sk_buff *skb);
    166int ip_mc_output(struct net *net, struct sock *sk, struct sk_buff *skb);
    167int ip_do_fragment(struct net *net, struct sock *sk, struct sk_buff *skb,
    168		   int (*output)(struct net *, struct sock *, struct sk_buff *));
    169
    170struct ip_fraglist_iter {
    171	struct sk_buff	*frag;
    172	struct iphdr	*iph;
    173	int		offset;
    174	unsigned int	hlen;
    175};
    176
    177void ip_fraglist_init(struct sk_buff *skb, struct iphdr *iph,
    178		      unsigned int hlen, struct ip_fraglist_iter *iter);
    179void ip_fraglist_prepare(struct sk_buff *skb, struct ip_fraglist_iter *iter);
    180
    181static inline struct sk_buff *ip_fraglist_next(struct ip_fraglist_iter *iter)
    182{
    183	struct sk_buff *skb = iter->frag;
    184
    185	iter->frag = skb->next;
    186	skb_mark_not_on_list(skb);
    187
    188	return skb;
    189}
    190
    191struct ip_frag_state {
    192	bool		DF;
    193	unsigned int	hlen;
    194	unsigned int	ll_rs;
    195	unsigned int	mtu;
    196	unsigned int	left;
    197	int		offset;
    198	int		ptr;
    199	__be16		not_last_frag;
    200};
    201
    202void ip_frag_init(struct sk_buff *skb, unsigned int hlen, unsigned int ll_rs,
    203		  unsigned int mtu, bool DF, struct ip_frag_state *state);
    204struct sk_buff *ip_frag_next(struct sk_buff *skb,
    205			     struct ip_frag_state *state);
    206
    207void ip_send_check(struct iphdr *ip);
    208int __ip_local_out(struct net *net, struct sock *sk, struct sk_buff *skb);
    209int ip_local_out(struct net *net, struct sock *sk, struct sk_buff *skb);
    210
    211int __ip_queue_xmit(struct sock *sk, struct sk_buff *skb, struct flowi *fl,
    212		    __u8 tos);
    213void ip_init(void);
    214int ip_append_data(struct sock *sk, struct flowi4 *fl4,
    215		   int getfrag(void *from, char *to, int offset, int len,
    216			       int odd, struct sk_buff *skb),
    217		   void *from, int len, int protolen,
    218		   struct ipcm_cookie *ipc,
    219		   struct rtable **rt,
    220		   unsigned int flags);
    221int ip_generic_getfrag(void *from, char *to, int offset, int len, int odd,
    222		       struct sk_buff *skb);
    223ssize_t ip_append_page(struct sock *sk, struct flowi4 *fl4, struct page *page,
    224		       int offset, size_t size, int flags);
    225struct sk_buff *__ip_make_skb(struct sock *sk, struct flowi4 *fl4,
    226			      struct sk_buff_head *queue,
    227			      struct inet_cork *cork);
    228int ip_send_skb(struct net *net, struct sk_buff *skb);
    229int ip_push_pending_frames(struct sock *sk, struct flowi4 *fl4);
    230void ip_flush_pending_frames(struct sock *sk);
    231struct sk_buff *ip_make_skb(struct sock *sk, struct flowi4 *fl4,
    232			    int getfrag(void *from, char *to, int offset,
    233					int len, int odd, struct sk_buff *skb),
    234			    void *from, int length, int transhdrlen,
    235			    struct ipcm_cookie *ipc, struct rtable **rtp,
    236			    struct inet_cork *cork, unsigned int flags);
    237
    238int ip_queue_xmit(struct sock *sk, struct sk_buff *skb, struct flowi *fl);
    239
    240static inline struct sk_buff *ip_finish_skb(struct sock *sk, struct flowi4 *fl4)
    241{
    242	return __ip_make_skb(sk, fl4, &sk->sk_write_queue, &inet_sk(sk)->cork.base);
    243}
    244
    245static inline __u8 get_rttos(struct ipcm_cookie* ipc, struct inet_sock *inet)
    246{
    247	return (ipc->tos != -1) ? RT_TOS(ipc->tos) : RT_TOS(inet->tos);
    248}
    249
    250static inline __u8 get_rtconn_flags(struct ipcm_cookie* ipc, struct sock* sk)
    251{
    252	return (ipc->tos != -1) ? RT_CONN_FLAGS_TOS(sk, ipc->tos) : RT_CONN_FLAGS(sk);
    253}
    254
    255/* datagram.c */
    256int __ip4_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len);
    257int ip4_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len);
    258
    259void ip4_datagram_release_cb(struct sock *sk);
    260
    261struct ip_reply_arg {
    262	struct kvec iov[1];
    263	int	    flags;
    264	__wsum 	    csum;
    265	int	    csumoffset; /* u16 offset of csum in iov[0].iov_base */
    266				/* -1 if not needed */
    267	int	    bound_dev_if;
    268	u8  	    tos;
    269	kuid_t	    uid;
    270};
    271
    272#define IP_REPLY_ARG_NOSRCCHECK 1
    273
    274static inline __u8 ip_reply_arg_flowi_flags(const struct ip_reply_arg *arg)
    275{
    276	return (arg->flags & IP_REPLY_ARG_NOSRCCHECK) ? FLOWI_FLAG_ANYSRC : 0;
    277}
    278
    279void ip_send_unicast_reply(struct sock *sk, struct sk_buff *skb,
    280			   const struct ip_options *sopt,
    281			   __be32 daddr, __be32 saddr,
    282			   const struct ip_reply_arg *arg,
    283			   unsigned int len, u64 transmit_time);
    284
    285#define IP_INC_STATS(net, field)	SNMP_INC_STATS64((net)->mib.ip_statistics, field)
    286#define __IP_INC_STATS(net, field)	__SNMP_INC_STATS64((net)->mib.ip_statistics, field)
    287#define IP_ADD_STATS(net, field, val)	SNMP_ADD_STATS64((net)->mib.ip_statistics, field, val)
    288#define __IP_ADD_STATS(net, field, val) __SNMP_ADD_STATS64((net)->mib.ip_statistics, field, val)
    289#define IP_UPD_PO_STATS(net, field, val) SNMP_UPD_PO_STATS64((net)->mib.ip_statistics, field, val)
    290#define __IP_UPD_PO_STATS(net, field, val) __SNMP_UPD_PO_STATS64((net)->mib.ip_statistics, field, val)
    291#define NET_INC_STATS(net, field)	SNMP_INC_STATS((net)->mib.net_statistics, field)
    292#define __NET_INC_STATS(net, field)	__SNMP_INC_STATS((net)->mib.net_statistics, field)
    293#define NET_ADD_STATS(net, field, adnd)	SNMP_ADD_STATS((net)->mib.net_statistics, field, adnd)
    294#define __NET_ADD_STATS(net, field, adnd) __SNMP_ADD_STATS((net)->mib.net_statistics, field, adnd)
    295
    296static inline u64 snmp_get_cpu_field(void __percpu *mib, int cpu, int offt)
    297{
    298	return  *(((unsigned long *)per_cpu_ptr(mib, cpu)) + offt);
    299}
    300
    301unsigned long snmp_fold_field(void __percpu *mib, int offt);
    302#if BITS_PER_LONG==32
    303u64 snmp_get_cpu_field64(void __percpu *mib, int cpu, int offct,
    304			 size_t syncp_offset);
    305u64 snmp_fold_field64(void __percpu *mib, int offt, size_t sync_off);
    306#else
    307static inline u64  snmp_get_cpu_field64(void __percpu *mib, int cpu, int offct,
    308					size_t syncp_offset)
    309{
    310	return snmp_get_cpu_field(mib, cpu, offct);
    311
    312}
    313
    314static inline u64 snmp_fold_field64(void __percpu *mib, int offt, size_t syncp_off)
    315{
    316	return snmp_fold_field(mib, offt);
    317}
    318#endif
    319
    320#define snmp_get_cpu_field64_batch(buff64, stats_list, mib_statistic, offset) \
    321{ \
    322	int i, c; \
    323	for_each_possible_cpu(c) { \
    324		for (i = 0; stats_list[i].name; i++) \
    325			buff64[i] += snmp_get_cpu_field64( \
    326					mib_statistic, \
    327					c, stats_list[i].entry, \
    328					offset); \
    329	} \
    330}
    331
    332#define snmp_get_cpu_field_batch(buff, stats_list, mib_statistic) \
    333{ \
    334	int i, c; \
    335	for_each_possible_cpu(c) { \
    336		for (i = 0; stats_list[i].name; i++) \
    337			buff[i] += snmp_get_cpu_field( \
    338						mib_statistic, \
    339						c, stats_list[i].entry); \
    340	} \
    341}
    342
    343void inet_get_local_port_range(struct net *net, int *low, int *high);
    344
    345#ifdef CONFIG_SYSCTL
    346static inline bool inet_is_local_reserved_port(struct net *net, unsigned short port)
    347{
    348	if (!net->ipv4.sysctl_local_reserved_ports)
    349		return false;
    350	return test_bit(port, net->ipv4.sysctl_local_reserved_ports);
    351}
    352
    353static inline bool sysctl_dev_name_is_allowed(const char *name)
    354{
    355	return strcmp(name, "default") != 0  && strcmp(name, "all") != 0;
    356}
    357
    358static inline bool inet_port_requires_bind_service(struct net *net, unsigned short port)
    359{
    360	return port < net->ipv4.sysctl_ip_prot_sock;
    361}
    362
    363#else
    364static inline bool inet_is_local_reserved_port(struct net *net, unsigned short port)
    365{
    366	return false;
    367}
    368
    369static inline bool inet_port_requires_bind_service(struct net *net, unsigned short port)
    370{
    371	return port < PROT_SOCK;
    372}
    373#endif
    374
    375__be32 inet_current_timestamp(void);
    376
    377/* From inetpeer.c */
    378extern int inet_peer_threshold;
    379extern int inet_peer_minttl;
    380extern int inet_peer_maxttl;
    381
    382void ipfrag_init(void);
    383
    384void ip_static_sysctl_init(void);
    385
    386#define IP4_REPLY_MARK(net, mark) \
    387	((net)->ipv4.sysctl_fwmark_reflect ? (mark) : 0)
    388
    389static inline bool ip_is_fragment(const struct iphdr *iph)
    390{
    391	return (iph->frag_off & htons(IP_MF | IP_OFFSET)) != 0;
    392}
    393
    394#ifdef CONFIG_INET
    395#include <net/dst.h>
    396
    397/* The function in 2.2 was invalid, producing wrong result for
    398 * check=0xFEFF. It was noticed by Arthur Skawina _year_ ago. --ANK(000625) */
    399static inline
    400int ip_decrease_ttl(struct iphdr *iph)
    401{
    402	u32 check = (__force u32)iph->check;
    403	check += (__force u32)htons(0x0100);
    404	iph->check = (__force __sum16)(check + (check>=0xFFFF));
    405	return --iph->ttl;
    406}
    407
    408static inline int ip_mtu_locked(const struct dst_entry *dst)
    409{
    410	const struct rtable *rt = (const struct rtable *)dst;
    411
    412	return rt->rt_mtu_locked || dst_metric_locked(dst, RTAX_MTU);
    413}
    414
    415static inline
    416int ip_dont_fragment(const struct sock *sk, const struct dst_entry *dst)
    417{
    418	u8 pmtudisc = READ_ONCE(inet_sk(sk)->pmtudisc);
    419
    420	return  pmtudisc == IP_PMTUDISC_DO ||
    421		(pmtudisc == IP_PMTUDISC_WANT &&
    422		 !ip_mtu_locked(dst));
    423}
    424
    425static inline bool ip_sk_accept_pmtu(const struct sock *sk)
    426{
    427	return inet_sk(sk)->pmtudisc != IP_PMTUDISC_INTERFACE &&
    428	       inet_sk(sk)->pmtudisc != IP_PMTUDISC_OMIT;
    429}
    430
    431static inline bool ip_sk_use_pmtu(const struct sock *sk)
    432{
    433	return inet_sk(sk)->pmtudisc < IP_PMTUDISC_PROBE;
    434}
    435
    436static inline bool ip_sk_ignore_df(const struct sock *sk)
    437{
    438	return inet_sk(sk)->pmtudisc < IP_PMTUDISC_DO ||
    439	       inet_sk(sk)->pmtudisc == IP_PMTUDISC_OMIT;
    440}
    441
    442static inline unsigned int ip_dst_mtu_maybe_forward(const struct dst_entry *dst,
    443						    bool forwarding)
    444{
    445	const struct rtable *rt = container_of(dst, struct rtable, dst);
    446	struct net *net = dev_net(dst->dev);
    447	unsigned int mtu;
    448
    449	if (net->ipv4.sysctl_ip_fwd_use_pmtu ||
    450	    ip_mtu_locked(dst) ||
    451	    !forwarding) {
    452		mtu = rt->rt_pmtu;
    453		if (mtu && time_before(jiffies, rt->dst.expires))
    454			goto out;
    455	}
    456
    457	/* 'forwarding = true' case should always honour route mtu */
    458	mtu = dst_metric_raw(dst, RTAX_MTU);
    459	if (mtu)
    460		goto out;
    461
    462	mtu = READ_ONCE(dst->dev->mtu);
    463
    464	if (unlikely(ip_mtu_locked(dst))) {
    465		if (rt->rt_uses_gateway && mtu > 576)
    466			mtu = 576;
    467	}
    468
    469out:
    470	mtu = min_t(unsigned int, mtu, IP_MAX_MTU);
    471
    472	return mtu - lwtunnel_headroom(dst->lwtstate, mtu);
    473}
    474
    475static inline unsigned int ip_skb_dst_mtu(struct sock *sk,
    476					  const struct sk_buff *skb)
    477{
    478	unsigned int mtu;
    479
    480	if (!sk || !sk_fullsock(sk) || ip_sk_use_pmtu(sk)) {
    481		bool forwarding = IPCB(skb)->flags & IPSKB_FORWARDED;
    482
    483		return ip_dst_mtu_maybe_forward(skb_dst(skb), forwarding);
    484	}
    485
    486	mtu = min(READ_ONCE(skb_dst(skb)->dev->mtu), IP_MAX_MTU);
    487	return mtu - lwtunnel_headroom(skb_dst(skb)->lwtstate, mtu);
    488}
    489
    490struct dst_metrics *ip_fib_metrics_init(struct net *net, struct nlattr *fc_mx,
    491					int fc_mx_len,
    492					struct netlink_ext_ack *extack);
    493static inline void ip_fib_metrics_put(struct dst_metrics *fib_metrics)
    494{
    495	if (fib_metrics != &dst_default_metrics &&
    496	    refcount_dec_and_test(&fib_metrics->refcnt))
    497		kfree(fib_metrics);
    498}
    499
    500/* ipv4 and ipv6 both use refcounted metrics if it is not the default */
    501static inline
    502void ip_dst_init_metrics(struct dst_entry *dst, struct dst_metrics *fib_metrics)
    503{
    504	dst_init_metrics(dst, fib_metrics->metrics, true);
    505
    506	if (fib_metrics != &dst_default_metrics) {
    507		dst->_metrics |= DST_METRICS_REFCOUNTED;
    508		refcount_inc(&fib_metrics->refcnt);
    509	}
    510}
    511
    512static inline
    513void ip_dst_metrics_put(struct dst_entry *dst)
    514{
    515	struct dst_metrics *p = (struct dst_metrics *)DST_METRICS_PTR(dst);
    516
    517	if (p != &dst_default_metrics && refcount_dec_and_test(&p->refcnt))
    518		kfree(p);
    519}
    520
    521void __ip_select_ident(struct net *net, struct iphdr *iph, int segs);
    522
    523static inline void ip_select_ident_segs(struct net *net, struct sk_buff *skb,
    524					struct sock *sk, int segs)
    525{
    526	struct iphdr *iph = ip_hdr(skb);
    527
    528	/* We had many attacks based on IPID, use the private
    529	 * generator as much as we can.
    530	 */
    531	if (sk && inet_sk(sk)->inet_daddr) {
    532		iph->id = htons(inet_sk(sk)->inet_id);
    533		inet_sk(sk)->inet_id += segs;
    534		return;
    535	}
    536	if ((iph->frag_off & htons(IP_DF)) && !skb->ignore_df) {
    537		iph->id = 0;
    538	} else {
    539		/* Unfortunately we need the big hammer to get a suitable IPID */
    540		__ip_select_ident(net, iph, segs);
    541	}
    542}
    543
    544static inline void ip_select_ident(struct net *net, struct sk_buff *skb,
    545				   struct sock *sk)
    546{
    547	ip_select_ident_segs(net, skb, sk, 1);
    548}
    549
    550static inline __wsum inet_compute_pseudo(struct sk_buff *skb, int proto)
    551{
    552	return csum_tcpudp_nofold(ip_hdr(skb)->saddr, ip_hdr(skb)->daddr,
    553				  skb->len, proto, 0);
    554}
    555
    556/* copy IPv4 saddr & daddr to flow_keys, possibly using 64bit load/store
    557 * Equivalent to :	flow->v4addrs.src = iph->saddr;
    558 *			flow->v4addrs.dst = iph->daddr;
    559 */
    560static inline void iph_to_flow_copy_v4addrs(struct flow_keys *flow,
    561					    const struct iphdr *iph)
    562{
    563	BUILD_BUG_ON(offsetof(typeof(flow->addrs), v4addrs.dst) !=
    564		     offsetof(typeof(flow->addrs), v4addrs.src) +
    565			      sizeof(flow->addrs.v4addrs.src));
    566	memcpy(&flow->addrs.v4addrs, &iph->saddr, sizeof(flow->addrs.v4addrs));
    567	flow->control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
    568}
    569
    570/*
    571 *	Map a multicast IP onto multicast MAC for type ethernet.
    572 */
    573
    574static inline void ip_eth_mc_map(__be32 naddr, char *buf)
    575{
    576	__u32 addr=ntohl(naddr);
    577	buf[0]=0x01;
    578	buf[1]=0x00;
    579	buf[2]=0x5e;
    580	buf[5]=addr&0xFF;
    581	addr>>=8;
    582	buf[4]=addr&0xFF;
    583	addr>>=8;
    584	buf[3]=addr&0x7F;
    585}
    586
    587/*
    588 *	Map a multicast IP onto multicast MAC for type IP-over-InfiniBand.
    589 *	Leave P_Key as 0 to be filled in by driver.
    590 */
    591
    592static inline void ip_ib_mc_map(__be32 naddr, const unsigned char *broadcast, char *buf)
    593{
    594	__u32 addr;
    595	unsigned char scope = broadcast[5] & 0xF;
    596
    597	buf[0]  = 0;		/* Reserved */
    598	buf[1]  = 0xff;		/* Multicast QPN */
    599	buf[2]  = 0xff;
    600	buf[3]  = 0xff;
    601	addr    = ntohl(naddr);
    602	buf[4]  = 0xff;
    603	buf[5]  = 0x10 | scope;	/* scope from broadcast address */
    604	buf[6]  = 0x40;		/* IPv4 signature */
    605	buf[7]  = 0x1b;
    606	buf[8]  = broadcast[8];		/* P_Key */
    607	buf[9]  = broadcast[9];
    608	buf[10] = 0;
    609	buf[11] = 0;
    610	buf[12] = 0;
    611	buf[13] = 0;
    612	buf[14] = 0;
    613	buf[15] = 0;
    614	buf[19] = addr & 0xff;
    615	addr  >>= 8;
    616	buf[18] = addr & 0xff;
    617	addr  >>= 8;
    618	buf[17] = addr & 0xff;
    619	addr  >>= 8;
    620	buf[16] = addr & 0x0f;
    621}
    622
    623static inline void ip_ipgre_mc_map(__be32 naddr, const unsigned char *broadcast, char *buf)
    624{
    625	if ((broadcast[0] | broadcast[1] | broadcast[2] | broadcast[3]) != 0)
    626		memcpy(buf, broadcast, 4);
    627	else
    628		memcpy(buf, &naddr, sizeof(naddr));
    629}
    630
    631#if IS_ENABLED(CONFIG_IPV6)
    632#include <linux/ipv6.h>
    633#endif
    634
    635static __inline__ void inet_reset_saddr(struct sock *sk)
    636{
    637	inet_sk(sk)->inet_rcv_saddr = inet_sk(sk)->inet_saddr = 0;
    638#if IS_ENABLED(CONFIG_IPV6)
    639	if (sk->sk_family == PF_INET6) {
    640		struct ipv6_pinfo *np = inet6_sk(sk);
    641
    642		memset(&np->saddr, 0, sizeof(np->saddr));
    643		memset(&sk->sk_v6_rcv_saddr, 0, sizeof(sk->sk_v6_rcv_saddr));
    644	}
    645#endif
    646}
    647
    648#endif
    649
    650static inline unsigned int ipv4_addr_hash(__be32 ip)
    651{
    652	return (__force unsigned int) ip;
    653}
    654
    655static inline u32 ipv4_portaddr_hash(const struct net *net,
    656				     __be32 saddr,
    657				     unsigned int port)
    658{
    659	return jhash_1word((__force u32)saddr, net_hash_mix(net)) ^ port;
    660}
    661
    662bool ip_call_ra_chain(struct sk_buff *skb);
    663
    664/*
    665 *	Functions provided by ip_fragment.c
    666 */
    667
    668enum ip_defrag_users {
    669	IP_DEFRAG_LOCAL_DELIVER,
    670	IP_DEFRAG_CALL_RA_CHAIN,
    671	IP_DEFRAG_CONNTRACK_IN,
    672	__IP_DEFRAG_CONNTRACK_IN_END	= IP_DEFRAG_CONNTRACK_IN + USHRT_MAX,
    673	IP_DEFRAG_CONNTRACK_OUT,
    674	__IP_DEFRAG_CONNTRACK_OUT_END	= IP_DEFRAG_CONNTRACK_OUT + USHRT_MAX,
    675	IP_DEFRAG_CONNTRACK_BRIDGE_IN,
    676	__IP_DEFRAG_CONNTRACK_BRIDGE_IN = IP_DEFRAG_CONNTRACK_BRIDGE_IN + USHRT_MAX,
    677	IP_DEFRAG_VS_IN,
    678	IP_DEFRAG_VS_OUT,
    679	IP_DEFRAG_VS_FWD,
    680	IP_DEFRAG_AF_PACKET,
    681	IP_DEFRAG_MACVLAN,
    682};
    683
    684/* Return true if the value of 'user' is between 'lower_bond'
    685 * and 'upper_bond' inclusively.
    686 */
    687static inline bool ip_defrag_user_in_between(u32 user,
    688					     enum ip_defrag_users lower_bond,
    689					     enum ip_defrag_users upper_bond)
    690{
    691	return user >= lower_bond && user <= upper_bond;
    692}
    693
    694int ip_defrag(struct net *net, struct sk_buff *skb, u32 user);
    695#ifdef CONFIG_INET
    696struct sk_buff *ip_check_defrag(struct net *net, struct sk_buff *skb, u32 user);
    697#else
    698static inline struct sk_buff *ip_check_defrag(struct net *net, struct sk_buff *skb, u32 user)
    699{
    700	return skb;
    701}
    702#endif
    703
    704/*
    705 *	Functions provided by ip_forward.c
    706 */
    707
    708int ip_forward(struct sk_buff *skb);
    709
    710/*
    711 *	Functions provided by ip_options.c
    712 */
    713
    714void ip_options_build(struct sk_buff *skb, struct ip_options *opt,
    715		      __be32 daddr, struct rtable *rt);
    716
    717int __ip_options_echo(struct net *net, struct ip_options *dopt,
    718		      struct sk_buff *skb, const struct ip_options *sopt);
    719static inline int ip_options_echo(struct net *net, struct ip_options *dopt,
    720				  struct sk_buff *skb)
    721{
    722	return __ip_options_echo(net, dopt, skb, &IPCB(skb)->opt);
    723}
    724
    725void ip_options_fragment(struct sk_buff *skb);
    726int __ip_options_compile(struct net *net, struct ip_options *opt,
    727			 struct sk_buff *skb, __be32 *info);
    728int ip_options_compile(struct net *net, struct ip_options *opt,
    729		       struct sk_buff *skb);
    730int ip_options_get(struct net *net, struct ip_options_rcu **optp,
    731		   sockptr_t data, int optlen);
    732void ip_options_undo(struct ip_options *opt);
    733void ip_forward_options(struct sk_buff *skb);
    734int ip_options_rcv_srr(struct sk_buff *skb, struct net_device *dev);
    735
    736/*
    737 *	Functions provided by ip_sockglue.c
    738 */
    739
    740void ipv4_pktinfo_prepare(const struct sock *sk, struct sk_buff *skb);
    741void ip_cmsg_recv_offset(struct msghdr *msg, struct sock *sk,
    742			 struct sk_buff *skb, int tlen, int offset);
    743int ip_cmsg_send(struct sock *sk, struct msghdr *msg,
    744		 struct ipcm_cookie *ipc, bool allow_ipv6);
    745DECLARE_STATIC_KEY_FALSE(ip4_min_ttl);
    746int ip_setsockopt(struct sock *sk, int level, int optname, sockptr_t optval,
    747		  unsigned int optlen);
    748int ip_getsockopt(struct sock *sk, int level, int optname, char __user *optval,
    749		  int __user *optlen);
    750int ip_ra_control(struct sock *sk, unsigned char on,
    751		  void (*destructor)(struct sock *));
    752
    753int ip_recv_error(struct sock *sk, struct msghdr *msg, int len, int *addr_len);
    754void ip_icmp_error(struct sock *sk, struct sk_buff *skb, int err, __be16 port,
    755		   u32 info, u8 *payload);
    756void ip_local_error(struct sock *sk, int err, __be32 daddr, __be16 dport,
    757		    u32 info);
    758
    759static inline void ip_cmsg_recv(struct msghdr *msg, struct sk_buff *skb)
    760{
    761	ip_cmsg_recv_offset(msg, skb->sk, skb, 0, 0);
    762}
    763
    764bool icmp_global_allow(void);
    765extern int sysctl_icmp_msgs_per_sec;
    766extern int sysctl_icmp_msgs_burst;
    767
    768#ifdef CONFIG_PROC_FS
    769int ip_misc_proc_init(void);
    770#endif
    771
    772int rtm_getroute_parse_ip_proto(struct nlattr *attr, u8 *ip_proto, u8 family,
    773				struct netlink_ext_ack *extack);
    774
    775static inline bool inetdev_valid_mtu(unsigned int mtu)
    776{
    777	return likely(mtu >= IPV4_MIN_MTU);
    778}
    779
    780void ip_sock_set_freebind(struct sock *sk);
    781int ip_sock_set_mtu_discover(struct sock *sk, int val);
    782void ip_sock_set_pktinfo(struct sock *sk);
    783void ip_sock_set_recverr(struct sock *sk);
    784void ip_sock_set_tos(struct sock *sk, int val);
    785void  __ip_sock_set_tos(struct sock *sk, int val);
    786
    787#endif	/* _IP_H */