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 inet_sock
8  *
9  * Authors:	Many, reorganised here by
10  * 		Arnaldo Carvalho de Melo <acme@mandriva.com>
11  */
12 #ifndef _INET_SOCK_H
13 #define _INET_SOCK_H
14 
15 #include <linux/bitops.h>
16 #include <linux/string.h>
17 #include <linux/types.h>
18 #include <linux/jhash.h>
19 #include <linux/netdevice.h>
20 
21 #include <net/flow.h>
22 #include <net/sock.h>
23 #include <net/request_sock.h>
24 #include <net/netns/hash.h>
25 #include <net/tcp_states.h>
26 #include <net/l3mdev.h>
27 
28 /** struct ip_options - IP Options
29  *
30  * @faddr - Saved first hop address
31  * @nexthop - Saved nexthop address in LSRR and SSRR
32  * @is_strictroute - Strict source route
33  * @srr_is_hit - Packet destination addr was our one
34  * @is_changed - IP checksum more not valid
35  * @rr_needaddr - Need to record addr of outgoing dev
36  * @ts_needtime - Need to record timestamp
37  * @ts_needaddr - Need to record addr of outgoing dev
38  */
39 struct ip_options {
40 	__be32		faddr;
41 	__be32		nexthop;
42 	unsigned char	optlen;
43 	unsigned char	srr;
44 	unsigned char	rr;
45 	unsigned char	ts;
46 	unsigned char	is_strictroute:1,
47 			srr_is_hit:1,
48 			is_changed:1,
49 			rr_needaddr:1,
50 			ts_needtime:1,
51 			ts_needaddr:1;
52 	unsigned char	router_alert;
53 	unsigned char	cipso;
54 	unsigned char	__pad2;
55 	unsigned char	__data[];
56 };
57 
58 struct ip_options_rcu {
59 	struct rcu_head rcu;
60 	struct ip_options opt;
61 };
62 
63 struct ip_options_data {
64 	struct ip_options_rcu	opt;
65 	char			data[40];
66 };
67 
68 struct inet_request_sock {
69 	struct request_sock	req;
70 #define ir_loc_addr		req.__req_common.skc_rcv_saddr
71 #define ir_rmt_addr		req.__req_common.skc_daddr
72 #define ir_num			req.__req_common.skc_num
73 #define ir_rmt_port		req.__req_common.skc_dport
74 #define ir_v6_rmt_addr		req.__req_common.skc_v6_daddr
75 #define ir_v6_loc_addr		req.__req_common.skc_v6_rcv_saddr
76 #define ir_iif			req.__req_common.skc_bound_dev_if
77 #define ir_cookie		req.__req_common.skc_cookie
78 #define ireq_net		req.__req_common.skc_net
79 #define ireq_state		req.__req_common.skc_state
80 #define ireq_family		req.__req_common.skc_family
81 
82 	u16			snd_wscale : 4,
83 				rcv_wscale : 4,
84 				tstamp_ok  : 1,
85 				sack_ok	   : 1,
86 				wscale_ok  : 1,
87 				ecn_ok	   : 1,
88 				acked	   : 1,
89 				no_srccheck: 1,
90 				smc_ok	   : 1;
91 	u32                     ir_mark;
92 	union {
93 		struct ip_options_rcu __rcu	*ireq_opt;
94 #if IS_ENABLED(CONFIG_IPV6)
95 		struct {
96 			struct ipv6_txoptions	*ipv6_opt;
97 			struct sk_buff		*pktopts;
98 		};
99 #endif
100 	};
101 };
102 
inet_rsk(const struct request_sock * sk)103 static inline struct inet_request_sock *inet_rsk(const struct request_sock *sk)
104 {
105 	return (struct inet_request_sock *)sk;
106 }
107 
inet_request_mark(const struct sock * sk,struct sk_buff * skb)108 static inline u32 inet_request_mark(const struct sock *sk, struct sk_buff *skb)
109 {
110 	u32 mark = READ_ONCE(sk->sk_mark);
111 
112 	if (!mark && READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_fwmark_accept))
113 		return skb->mark;
114 
115 	return mark;
116 }
117 
inet_request_bound_dev_if(const struct sock * sk,struct sk_buff * skb)118 static inline int inet_request_bound_dev_if(const struct sock *sk,
119 					    struct sk_buff *skb)
120 {
121 	int bound_dev_if = READ_ONCE(sk->sk_bound_dev_if);
122 #ifdef CONFIG_NET_L3_MASTER_DEV
123 	struct net *net = sock_net(sk);
124 
125 	if (!bound_dev_if && READ_ONCE(net->ipv4.sysctl_tcp_l3mdev_accept))
126 		return l3mdev_master_ifindex_by_index(net, skb->skb_iif);
127 #endif
128 
129 	return bound_dev_if;
130 }
131 
inet_sk_bound_l3mdev(const struct sock * sk)132 static inline int inet_sk_bound_l3mdev(const struct sock *sk)
133 {
134 #ifdef CONFIG_NET_L3_MASTER_DEV
135 	struct net *net = sock_net(sk);
136 
137 	if (!READ_ONCE(net->ipv4.sysctl_tcp_l3mdev_accept))
138 		return l3mdev_master_ifindex_by_index(net,
139 						      sk->sk_bound_dev_if);
140 #endif
141 
142 	return 0;
143 }
144 
inet_bound_dev_eq(bool l3mdev_accept,int bound_dev_if,int dif,int sdif)145 static inline bool inet_bound_dev_eq(bool l3mdev_accept, int bound_dev_if,
146 				     int dif, int sdif)
147 {
148 	if (!bound_dev_if)
149 		return !sdif || l3mdev_accept;
150 	return bound_dev_if == dif || bound_dev_if == sdif;
151 }
152 
inet_sk_bound_dev_eq(struct net * net,int bound_dev_if,int dif,int sdif)153 static inline bool inet_sk_bound_dev_eq(struct net *net, int bound_dev_if,
154 					int dif, int sdif)
155 {
156 #if IS_ENABLED(CONFIG_NET_L3_MASTER_DEV)
157 	return inet_bound_dev_eq(!!READ_ONCE(net->ipv4.sysctl_tcp_l3mdev_accept),
158 				 bound_dev_if, dif, sdif);
159 #else
160 	return inet_bound_dev_eq(true, bound_dev_if, dif, sdif);
161 #endif
162 }
163 
164 struct inet_cork {
165 	unsigned int		flags;
166 	__be32			addr;
167 	struct ip_options	*opt;
168 	unsigned int		fragsize;
169 	int			length; /* Total length of all frames */
170 	struct dst_entry	*dst;
171 	u8			tx_flags;
172 	__u8			ttl;
173 	__s16			tos;
174 	char			priority;
175 	__u16			gso_size;
176 	u64			transmit_time;
177 	u32			mark;
178 };
179 
180 struct inet_cork_full {
181 	struct inet_cork	base;
182 	struct flowi		fl;
183 };
184 
185 struct ip_mc_socklist;
186 struct ipv6_pinfo;
187 struct rtable;
188 
189 /** struct inet_sock - representation of INET sockets
190  *
191  * @sk - ancestor class
192  * @pinet6 - pointer to IPv6 control block
193  * @inet_daddr - Foreign IPv4 addr
194  * @inet_rcv_saddr - Bound local IPv4 addr
195  * @inet_dport - Destination port
196  * @inet_num - Local port
197  * @inet_flags - various atomic flags
198  * @inet_saddr - Sending source
199  * @uc_ttl - Unicast TTL
200  * @inet_sport - Source port
201  * @inet_id - ID counter for DF pkts
202  * @tos - TOS
203  * @mc_ttl - Multicasting TTL
204  * @uc_index - Unicast outgoing device index
205  * @mc_index - Multicast device index
206  * @mc_list - Group array
207  * @cork - info to build ip hdr on each ip frag while socket is corked
208  */
209 struct inet_sock {
210 	/* sk and pinet6 has to be the first two members of inet_sock */
211 	struct sock		sk;
212 #if IS_ENABLED(CONFIG_IPV6)
213 	struct ipv6_pinfo	*pinet6;
214 #endif
215 	/* Socket demultiplex comparisons on incoming packets. */
216 #define inet_daddr		sk.__sk_common.skc_daddr
217 #define inet_rcv_saddr		sk.__sk_common.skc_rcv_saddr
218 #define inet_dport		sk.__sk_common.skc_dport
219 #define inet_num		sk.__sk_common.skc_num
220 
221 	unsigned long		inet_flags;
222 	__be32			inet_saddr;
223 	__s16			uc_ttl;
224 	__be16			inet_sport;
225 	struct ip_options_rcu __rcu	*inet_opt;
226 	atomic_t		inet_id;
227 
228 	__u8			tos;
229 	__u8			min_ttl;
230 	__u8			mc_ttl;
231 	__u8			pmtudisc;
232 	__u8			rcv_tos;
233 	__u8			convert_csum;
234 	int			uc_index;
235 	int			mc_index;
236 	__be32			mc_addr;
237 	struct {
238 		__u16 lo;
239 		__u16 hi;
240 	}			local_port_range;
241 
242 	struct ip_mc_socklist __rcu	*mc_list;
243 	struct inet_cork_full	cork;
244 };
245 
246 #define IPCORK_OPT	1	/* ip-options has been held in ipcork.opt */
247 #define IPCORK_ALLFRAG	2	/* always fragment (for ipv6 for now) */
248 
249 enum {
250 	INET_FLAGS_PKTINFO	= 0,
251 	INET_FLAGS_TTL		= 1,
252 	INET_FLAGS_TOS		= 2,
253 	INET_FLAGS_RECVOPTS	= 3,
254 	INET_FLAGS_RETOPTS	= 4,
255 	INET_FLAGS_PASSSEC	= 5,
256 	INET_FLAGS_ORIGDSTADDR	= 6,
257 	INET_FLAGS_CHECKSUM	= 7,
258 	INET_FLAGS_RECVFRAGSIZE	= 8,
259 
260 	INET_FLAGS_RECVERR	= 9,
261 	INET_FLAGS_RECVERR_RFC4884 = 10,
262 	INET_FLAGS_FREEBIND	= 11,
263 	INET_FLAGS_HDRINCL	= 12,
264 	INET_FLAGS_MC_LOOP	= 13,
265 	INET_FLAGS_MC_ALL	= 14,
266 	INET_FLAGS_TRANSPARENT	= 15,
267 	INET_FLAGS_IS_ICSK	= 16,
268 	INET_FLAGS_NODEFRAG	= 17,
269 	INET_FLAGS_BIND_ADDRESS_NO_PORT = 18,
270 	INET_FLAGS_DEFER_CONNECT = 19,
271 };
272 
273 /* cmsg flags for inet */
274 #define IP_CMSG_PKTINFO		BIT(INET_FLAGS_PKTINFO)
275 #define IP_CMSG_TTL		BIT(INET_FLAGS_TTL)
276 #define IP_CMSG_TOS		BIT(INET_FLAGS_TOS)
277 #define IP_CMSG_RECVOPTS	BIT(INET_FLAGS_RECVOPTS)
278 #define IP_CMSG_RETOPTS		BIT(INET_FLAGS_RETOPTS)
279 #define IP_CMSG_PASSSEC		BIT(INET_FLAGS_PASSSEC)
280 #define IP_CMSG_ORIGDSTADDR	BIT(INET_FLAGS_ORIGDSTADDR)
281 #define IP_CMSG_CHECKSUM	BIT(INET_FLAGS_CHECKSUM)
282 #define IP_CMSG_RECVFRAGSIZE	BIT(INET_FLAGS_RECVFRAGSIZE)
283 
284 #define IP_CMSG_ALL	(IP_CMSG_PKTINFO | IP_CMSG_TTL |		\
285 			 IP_CMSG_TOS | IP_CMSG_RECVOPTS |		\
286 			 IP_CMSG_RETOPTS | IP_CMSG_PASSSEC |		\
287 			 IP_CMSG_ORIGDSTADDR | IP_CMSG_CHECKSUM |	\
288 			 IP_CMSG_RECVFRAGSIZE)
289 
inet_cmsg_flags(const struct inet_sock * inet)290 static inline unsigned long inet_cmsg_flags(const struct inet_sock *inet)
291 {
292 	return READ_ONCE(inet->inet_flags) & IP_CMSG_ALL;
293 }
294 
295 #define inet_test_bit(nr, sk)			\
296 	test_bit(INET_FLAGS_##nr, &inet_sk(sk)->inet_flags)
297 #define inet_set_bit(nr, sk)			\
298 	set_bit(INET_FLAGS_##nr, &inet_sk(sk)->inet_flags)
299 #define inet_clear_bit(nr, sk)			\
300 	clear_bit(INET_FLAGS_##nr, &inet_sk(sk)->inet_flags)
301 #define inet_assign_bit(nr, sk, val)		\
302 	assign_bit(INET_FLAGS_##nr, &inet_sk(sk)->inet_flags, val)
303 
304 /**
305  * sk_to_full_sk - Access to a full socket
306  * @sk: pointer to a socket
307  *
308  * SYNACK messages might be attached to request sockets.
309  * Some places want to reach the listener in this case.
310  */
sk_to_full_sk(struct sock * sk)311 static inline struct sock *sk_to_full_sk(struct sock *sk)
312 {
313 #ifdef CONFIG_INET
314 	if (sk && sk->sk_state == TCP_NEW_SYN_RECV)
315 		sk = inet_reqsk(sk)->rsk_listener;
316 #endif
317 	return sk;
318 }
319 
320 /* sk_to_full_sk() variant with a const argument */
sk_const_to_full_sk(const struct sock * sk)321 static inline const struct sock *sk_const_to_full_sk(const struct sock *sk)
322 {
323 #ifdef CONFIG_INET
324 	if (sk && sk->sk_state == TCP_NEW_SYN_RECV)
325 		sk = ((const struct request_sock *)sk)->rsk_listener;
326 #endif
327 	return sk;
328 }
329 
skb_to_full_sk(const struct sk_buff * skb)330 static inline struct sock *skb_to_full_sk(const struct sk_buff *skb)
331 {
332 	return sk_to_full_sk(skb->sk);
333 }
334 
335 #define inet_sk(ptr) container_of_const(ptr, struct inet_sock, sk)
336 
__inet_sk_copy_descendant(struct sock * sk_to,const struct sock * sk_from,const int ancestor_size)337 static inline void __inet_sk_copy_descendant(struct sock *sk_to,
338 					     const struct sock *sk_from,
339 					     const int ancestor_size)
340 {
341 	memcpy(inet_sk(sk_to) + 1, inet_sk(sk_from) + 1,
342 	       sk_from->sk_prot->obj_size - ancestor_size);
343 }
344 
345 int inet_sk_rebuild_header(struct sock *sk);
346 
347 /**
348  * inet_sk_state_load - read sk->sk_state for lockless contexts
349  * @sk: socket pointer
350  *
351  * Paired with inet_sk_state_store(). Used in places we don't hold socket lock:
352  * tcp_diag_get_info(), tcp_get_info(), tcp_poll(), get_tcp4_sock() ...
353  */
inet_sk_state_load(const struct sock * sk)354 static inline int inet_sk_state_load(const struct sock *sk)
355 {
356 	/* state change might impact lockless readers. */
357 	return smp_load_acquire(&sk->sk_state);
358 }
359 
360 /**
361  * inet_sk_state_store - update sk->sk_state
362  * @sk: socket pointer
363  * @newstate: new state
364  *
365  * Paired with inet_sk_state_load(). Should be used in contexts where
366  * state change might impact lockless readers.
367  */
368 void inet_sk_state_store(struct sock *sk, int newstate);
369 
370 void inet_sk_set_state(struct sock *sk, int state);
371 
__inet_ehashfn(const __be32 laddr,const __u16 lport,const __be32 faddr,const __be16 fport,u32 initval)372 static inline unsigned int __inet_ehashfn(const __be32 laddr,
373 					  const __u16 lport,
374 					  const __be32 faddr,
375 					  const __be16 fport,
376 					  u32 initval)
377 {
378 	return jhash_3words((__force __u32) laddr,
379 			    (__force __u32) faddr,
380 			    ((__u32) lport) << 16 | (__force __u32)fport,
381 			    initval);
382 }
383 
384 struct request_sock *inet_reqsk_alloc(const struct request_sock_ops *ops,
385 				      struct sock *sk_listener,
386 				      bool attach_listener);
387 
inet_sk_flowi_flags(const struct sock * sk)388 static inline __u8 inet_sk_flowi_flags(const struct sock *sk)
389 {
390 	__u8 flags = 0;
391 
392 	if (inet_test_bit(TRANSPARENT, sk) || inet_test_bit(HDRINCL, sk))
393 		flags |= FLOWI_FLAG_ANYSRC;
394 	return flags;
395 }
396 
inet_inc_convert_csum(struct sock * sk)397 static inline void inet_inc_convert_csum(struct sock *sk)
398 {
399 	inet_sk(sk)->convert_csum++;
400 }
401 
inet_dec_convert_csum(struct sock * sk)402 static inline void inet_dec_convert_csum(struct sock *sk)
403 {
404 	if (inet_sk(sk)->convert_csum > 0)
405 		inet_sk(sk)->convert_csum--;
406 }
407 
inet_get_convert_csum(struct sock * sk)408 static inline bool inet_get_convert_csum(struct sock *sk)
409 {
410 	return !!inet_sk(sk)->convert_csum;
411 }
412 
413 
inet_can_nonlocal_bind(struct net * net,struct inet_sock * inet)414 static inline bool inet_can_nonlocal_bind(struct net *net,
415 					  struct inet_sock *inet)
416 {
417 	return READ_ONCE(net->ipv4.sysctl_ip_nonlocal_bind) ||
418 		test_bit(INET_FLAGS_FREEBIND, &inet->inet_flags) ||
419 		test_bit(INET_FLAGS_TRANSPARENT, &inet->inet_flags);
420 }
421 
inet_addr_valid_or_nonlocal(struct net * net,struct inet_sock * inet,__be32 addr,int addr_type)422 static inline bool inet_addr_valid_or_nonlocal(struct net *net,
423 					       struct inet_sock *inet,
424 					       __be32 addr,
425 					       int addr_type)
426 {
427 	return inet_can_nonlocal_bind(net, inet) ||
428 		addr == htonl(INADDR_ANY) ||
429 		addr_type == RTN_LOCAL ||
430 		addr_type == RTN_MULTICAST ||
431 		addr_type == RTN_BROADCAST;
432 }
433 
434 #endif	/* _INET_SOCK_H */
435