Branch data Line data Source code
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 : : * PF_INET protocol family socket handler.
8 : : *
9 : : * Authors: Ross Biro
10 : : * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
11 : : * Florian La Roche, <flla@stud.uni-sb.de>
12 : : * Alan Cox, <A.Cox@swansea.ac.uk>
13 : : *
14 : : * Changes (see also sock.c)
15 : : *
16 : : * piggy,
17 : : * Karl Knutson : Socket protocol table
18 : : * A.N.Kuznetsov : Socket death error in accept().
19 : : * John Richardson : Fix non blocking error in connect()
20 : : * so sockets that fail to connect
21 : : * don't return -EINPROGRESS.
22 : : * Alan Cox : Asynchronous I/O support
23 : : * Alan Cox : Keep correct socket pointer on sock
24 : : * structures
25 : : * when accept() ed
26 : : * Alan Cox : Semantics of SO_LINGER aren't state
27 : : * moved to close when you look carefully.
28 : : * With this fixed and the accept bug fixed
29 : : * some RPC stuff seems happier.
30 : : * Niibe Yutaka : 4.4BSD style write async I/O
31 : : * Alan Cox,
32 : : * Tony Gale : Fixed reuse semantics.
33 : : * Alan Cox : bind() shouldn't abort existing but dead
34 : : * sockets. Stops FTP netin:.. I hope.
35 : : * Alan Cox : bind() works correctly for RAW sockets.
36 : : * Note that FreeBSD at least was broken
37 : : * in this respect so be careful with
38 : : * compatibility tests...
39 : : * Alan Cox : routing cache support
40 : : * Alan Cox : memzero the socket structure for
41 : : * compactness.
42 : : * Matt Day : nonblock connect error handler
43 : : * Alan Cox : Allow large numbers of pending sockets
44 : : * (eg for big web sites), but only if
45 : : * specifically application requested.
46 : : * Alan Cox : New buffering throughout IP. Used
47 : : * dumbly.
48 : : * Alan Cox : New buffering now used smartly.
49 : : * Alan Cox : BSD rather than common sense
50 : : * interpretation of listen.
51 : : * Germano Caronni : Assorted small races.
52 : : * Alan Cox : sendmsg/recvmsg basic support.
53 : : * Alan Cox : Only sendmsg/recvmsg now supported.
54 : : * Alan Cox : Locked down bind (see security list).
55 : : * Alan Cox : Loosened bind a little.
56 : : * Mike McLagan : ADD/DEL DLCI Ioctls
57 : : * Willy Konynenberg : Transparent proxying support.
58 : : * David S. Miller : New socket lookup architecture.
59 : : * Some other random speedups.
60 : : * Cyrus Durgin : Cleaned up file for kmod hacks.
61 : : * Andi Kleen : Fix inet_stream_connect TCP race.
62 : : */
63 : :
64 : : #define pr_fmt(fmt) "IPv4: " fmt
65 : :
66 : : #include <linux/err.h>
67 : : #include <linux/errno.h>
68 : : #include <linux/types.h>
69 : : #include <linux/socket.h>
70 : : #include <linux/in.h>
71 : : #include <linux/kernel.h>
72 : : #include <linux/kmod.h>
73 : : #include <linux/sched.h>
74 : : #include <linux/timer.h>
75 : : #include <linux/string.h>
76 : : #include <linux/sockios.h>
77 : : #include <linux/net.h>
78 : : #include <linux/capability.h>
79 : : #include <linux/fcntl.h>
80 : : #include <linux/mm.h>
81 : : #include <linux/interrupt.h>
82 : : #include <linux/stat.h>
83 : : #include <linux/init.h>
84 : : #include <linux/poll.h>
85 : : #include <linux/netfilter_ipv4.h>
86 : : #include <linux/random.h>
87 : : #include <linux/slab.h>
88 : :
89 : : #include <linux/uaccess.h>
90 : :
91 : : #include <linux/inet.h>
92 : : #include <linux/igmp.h>
93 : : #include <linux/inetdevice.h>
94 : : #include <linux/netdevice.h>
95 : : #include <net/checksum.h>
96 : : #include <net/ip.h>
97 : : #include <net/protocol.h>
98 : : #include <net/arp.h>
99 : : #include <net/route.h>
100 : : #include <net/ip_fib.h>
101 : : #include <net/inet_connection_sock.h>
102 : : #include <net/tcp.h>
103 : : #include <net/udp.h>
104 : : #include <net/udplite.h>
105 : : #include <net/ping.h>
106 : : #include <linux/skbuff.h>
107 : : #include <net/sock.h>
108 : : #include <net/raw.h>
109 : : #include <net/icmp.h>
110 : : #include <net/inet_common.h>
111 : : #include <net/ip_tunnels.h>
112 : : #include <net/xfrm.h>
113 : : #include <net/net_namespace.h>
114 : : #include <net/secure_seq.h>
115 : : #ifdef CONFIG_IP_MROUTE
116 : : #include <linux/mroute.h>
117 : : #endif
118 : : #include <net/l3mdev.h>
119 : :
120 : : #include <trace/events/sock.h>
121 : :
122 : : /* The inetsw table contains everything that inet_create needs to
123 : : * build a new socket.
124 : : */
125 : : static struct list_head inetsw[SOCK_MAX];
126 : : static DEFINE_SPINLOCK(inetsw_lock);
127 : :
128 : : /* New destruction routine */
129 : :
130 : 6165 : void inet_sock_destruct(struct sock *sk)
131 : : {
132 : : struct inet_sock *inet = inet_sk(sk);
133 : :
134 : 6165 : __skb_queue_purge(&sk->sk_receive_queue);
135 [ - + ]: 6166 : if (sk->sk_rx_skb_cache) {
136 : 0 : __kfree_skb(sk->sk_rx_skb_cache);
137 : 0 : sk->sk_rx_skb_cache = NULL;
138 : : }
139 : 6166 : __skb_queue_purge(&sk->sk_error_queue);
140 : :
141 : 6165 : sk_mem_reclaim(sk);
142 : :
143 [ - + # # ]: 6170 : if (sk->sk_type == SOCK_STREAM && sk->sk_state != TCP_CLOSE) {
144 : 0 : pr_err("Attempt to release TCP socket in state %d %p\n",
145 : : sk->sk_state, sk);
146 : 0 : return;
147 : : }
148 [ - + ]: 6170 : if (!sock_flag(sk, SOCK_DEAD)) {
149 : 0 : pr_err("Attempt to release alive inet socket %p\n", sk);
150 : 0 : return;
151 : : }
152 : :
153 [ - + ]: 6170 : WARN_ON(atomic_read(&sk->sk_rmem_alloc));
154 [ - + ]: 6170 : WARN_ON(refcount_read(&sk->sk_wmem_alloc));
155 [ - + ]: 6170 : WARN_ON(sk->sk_wmem_queued);
156 [ - + ]: 6170 : WARN_ON(sk->sk_forward_alloc);
157 : :
158 : 6170 : kfree(rcu_dereference_protected(inet->inet_opt, 1));
159 : 6170 : dst_release(rcu_dereference_protected(sk->sk_dst_cache, 1));
160 : 6169 : dst_release(sk->sk_rx_dst);
161 : : sk_refcnt_debug_dec(sk);
162 : : }
163 : : EXPORT_SYMBOL(inet_sock_destruct);
164 : :
165 : : /*
166 : : * The routines beyond this point handle the behaviour of an AF_INET
167 : : * socket object. Mostly it punts to the subprotocols of IP to do
168 : : * the work.
169 : : */
170 : :
171 : : /*
172 : : * Automatically bind an unbound socket.
173 : : */
174 : :
175 : 6003 : static int inet_autobind(struct sock *sk)
176 : : {
177 : : struct inet_sock *inet;
178 : : /* We may need to bind the socket. */
179 : : lock_sock(sk);
180 : : inet = inet_sk(sk);
181 [ + - ]: 6003 : if (!inet->inet_num) {
182 [ - + ]: 6003 : if (sk->sk_prot->get_port(sk, 0)) {
183 : 0 : release_sock(sk);
184 : 0 : return -EAGAIN;
185 : : }
186 : 6003 : inet->inet_sport = htons(inet->inet_num);
187 : : }
188 : 6003 : release_sock(sk);
189 : 6003 : return 0;
190 : : }
191 : :
192 : : /*
193 : : * Move a socket into listening state.
194 : : */
195 : 0 : int inet_listen(struct socket *sock, int backlog)
196 : : {
197 : 0 : struct sock *sk = sock->sk;
198 : : unsigned char old_state;
199 : : int err, tcp_fastopen;
200 : :
201 : : lock_sock(sk);
202 : :
203 : : err = -EINVAL;
204 [ # # # # ]: 0 : if (sock->state != SS_UNCONNECTED || sock->type != SOCK_STREAM)
205 : : goto out;
206 : :
207 : 0 : old_state = sk->sk_state;
208 [ # # ]: 0 : if (!((1 << old_state) & (TCPF_CLOSE | TCPF_LISTEN)))
209 : : goto out;
210 : :
211 : 0 : sk->sk_max_ack_backlog = backlog;
212 : : /* Really, if the socket is already in listen state
213 : : * we can only allow the backlog to be adjusted.
214 : : */
215 [ # # ]: 0 : if (old_state != TCP_LISTEN) {
216 : : /* Enable TFO w/o requiring TCP_FASTOPEN socket option.
217 : : * Note that only TCP sockets (SOCK_STREAM) will reach here.
218 : : * Also fastopen backlog may already been set via the option
219 : : * because the socket was in TCP_LISTEN state previously but
220 : : * was shutdown() rather than close().
221 : : */
222 : 0 : tcp_fastopen = sock_net(sk)->ipv4.sysctl_tcp_fastopen;
223 [ # # ]: 0 : if ((tcp_fastopen & TFO_SERVER_WO_SOCKOPT1) &&
224 [ # # ]: 0 : (tcp_fastopen & TFO_SERVER_ENABLE) &&
225 : 0 : !inet_csk(sk)->icsk_accept_queue.fastopenq.max_qlen) {
226 : : fastopen_queue_tune(sk, backlog);
227 : 0 : tcp_fastopen_init_key_once(sock_net(sk));
228 : : }
229 : :
230 : 0 : err = inet_csk_listen_start(sk, backlog);
231 [ # # ]: 0 : if (err)
232 : : goto out;
233 : 0 : tcp_call_bpf(sk, BPF_SOCK_OPS_TCP_LISTEN_CB, 0, NULL);
234 : : }
235 : : err = 0;
236 : :
237 : : out:
238 : 0 : release_sock(sk);
239 : 0 : return err;
240 : : }
241 : : EXPORT_SYMBOL(inet_listen);
242 : :
243 : : /*
244 : : * Create an inet socket.
245 : : */
246 : :
247 : 8655 : static int inet_create(struct net *net, struct socket *sock, int protocol,
248 : : int kern)
249 : : {
250 : : struct sock *sk;
251 : : struct inet_protosw *answer;
252 : : struct inet_sock *inet;
253 : : struct proto *answer_prot;
254 : : unsigned char answer_flags;
255 : : int try_loading_module = 0;
256 : : int err;
257 : :
258 [ + - ]: 8655 : if (protocol < 0 || protocol >= IPPROTO_MAX)
259 : : return -EINVAL;
260 : :
261 : 8655 : sock->state = SS_UNCONNECTED;
262 : :
263 : : /* Look for the requested type/protocol pair. */
264 : : lookup_protocol:
265 : : err = -ESOCKTNOSUPPORT;
266 : : rcu_read_lock();
267 [ + - ]: 17310 : list_for_each_entry_rcu(answer, &inetsw[sock->type], list) {
268 : :
269 : : err = 0;
270 : : /* Check the non-wild match. */
271 [ + + ]: 8655 : if (protocol == answer->protocol) {
272 [ - + ]: 207 : if (protocol != IPPROTO_IP)
273 : : break;
274 : : } else {
275 : : /* Check for the two wild cases. */
276 [ + + ]: 8448 : if (IPPROTO_IP == protocol) {
277 : 6792 : protocol = answer->protocol;
278 : 6792 : break;
279 : : }
280 [ - + ]: 1656 : if (IPPROTO_IP == answer->protocol)
281 : : break;
282 : : }
283 : : err = -EPROTONOSUPPORT;
284 : : }
285 : :
286 [ - + ]: 8655 : if (unlikely(err)) {
287 [ # # ]: 0 : if (try_loading_module < 2) {
288 : : rcu_read_unlock();
289 : : /*
290 : : * Be more specific, e.g. net-pf-2-proto-132-type-1
291 : : * (net-pf-PF_INET-proto-IPPROTO_SCTP-type-SOCK_STREAM)
292 : : */
293 [ # # ]: 0 : if (++try_loading_module == 1)
294 : 0 : request_module("net-pf-%d-proto-%d-type-%d",
295 : : PF_INET, protocol, sock->type);
296 : : /*
297 : : * Fall back to generic, e.g. net-pf-2-proto-132
298 : : * (net-pf-PF_INET-proto-IPPROTO_SCTP)
299 : : */
300 : : else
301 : 0 : request_module("net-pf-%d-proto-%d",
302 : : PF_INET, protocol);
303 : : goto lookup_protocol;
304 : : } else
305 : : goto out_rcu_unlock;
306 : : }
307 : :
308 : : err = -EPERM;
309 [ + + - + : 8655 : if (sock->type == SOCK_RAW && !kern &&
# # ]
310 : 0 : !ns_capable(net->user_ns, CAP_NET_RAW))
311 : : goto out_rcu_unlock;
312 : :
313 : 8655 : sock->ops = answer->ops;
314 : 8655 : answer_prot = answer->prot;
315 : 8655 : answer_flags = answer->flags;
316 : : rcu_read_unlock();
317 : :
318 [ - + ]: 8655 : WARN_ON(!answer_prot->slab);
319 : :
320 : : err = -ENOBUFS;
321 : 8655 : sk = sk_alloc(net, PF_INET, GFP_KERNEL, answer_prot, kern);
322 [ + - ]: 8655 : if (!sk)
323 : : goto out;
324 : :
325 : : err = 0;
326 [ + + ]: 8655 : if (INET_PROTOSW_REUSE & answer_flags)
327 : 1656 : sk->sk_reuse = SK_CAN_REUSE;
328 : :
329 : : inet = inet_sk(sk);
330 : 8655 : inet->is_icsk = (INET_PROTOSW_ICSK & answer_flags) != 0;
331 : :
332 : 8655 : inet->nodefrag = 0;
333 : :
334 [ + + ]: 8655 : if (SOCK_RAW == sock->type) {
335 : 1656 : inet->inet_num = protocol;
336 [ - + ]: 1656 : if (IPPROTO_RAW == protocol)
337 : 0 : inet->hdrincl = 1;
338 : : }
339 : :
340 [ - + ]: 8655 : if (net->ipv4.sysctl_ip_no_pmtu_disc)
341 : 0 : inet->pmtudisc = IP_PMTUDISC_DONT;
342 : : else
343 : 8655 : inet->pmtudisc = IP_PMTUDISC_WANT;
344 : :
345 : 8655 : inet->inet_id = 0;
346 : :
347 : 8655 : sock_init_data(sock, sk);
348 : :
349 : 8655 : sk->sk_destruct = inet_sock_destruct;
350 : 8655 : sk->sk_protocol = protocol;
351 : 8655 : sk->sk_backlog_rcv = sk->sk_prot->backlog_rcv;
352 : :
353 : 8655 : inet->uc_ttl = -1;
354 : 8655 : inet->mc_loop = 1;
355 : 8655 : inet->mc_ttl = 1;
356 : 8655 : inet->mc_all = 1;
357 : 8655 : inet->mc_index = 0;
358 : 8655 : inet->mc_list = NULL;
359 : 8655 : inet->rcv_tos = 0;
360 : :
361 : : sk_refcnt_debug_inc(sk);
362 : :
363 [ + + ]: 8655 : if (inet->inet_num) {
364 : : /* It assumes that any protocol which allows
365 : : * the user to assign a number at socket
366 : : * creation time automatically
367 : : * shares.
368 : : */
369 : 1656 : inet->inet_sport = htons(inet->inet_num);
370 : : /* Add to protocol hash chains. */
371 : 1656 : err = sk->sk_prot->hash(sk);
372 [ - + ]: 1656 : if (err) {
373 : 0 : sk_common_release(sk);
374 : 0 : goto out;
375 : : }
376 : : }
377 : :
378 [ + - ]: 8655 : if (sk->sk_prot->init) {
379 : 8655 : err = sk->sk_prot->init(sk);
380 [ - + ]: 8655 : if (err) {
381 : 0 : sk_common_release(sk);
382 : 0 : goto out;
383 : : }
384 : : }
385 : :
386 [ + + ]: 8655 : if (!kern) {
387 [ + - ]: 6792 : err = BPF_CGROUP_RUN_PROG_INET_SOCK(sk);
388 [ - + ]: 6792 : if (err) {
389 : 0 : sk_common_release(sk);
390 : 0 : goto out;
391 : : }
392 : : }
393 : : out:
394 : 8655 : return err;
395 : : out_rcu_unlock:
396 : : rcu_read_unlock();
397 : : goto out;
398 : : }
399 : :
400 : :
401 : : /*
402 : : * The peer socket should always be NULL (or else). When we call this
403 : : * function we are destroying the object and from then on nobody
404 : : * should refer to it.
405 : : */
406 : 6170 : int inet_release(struct socket *sock)
407 : : {
408 : 6170 : struct sock *sk = sock->sk;
409 : :
410 [ + - ]: 6170 : if (sk) {
411 : : long timeout;
412 : :
413 : : /* Applications forget to leave groups before exiting */
414 : 6170 : ip_mc_drop_socket(sk);
415 : :
416 : : /* If linger is set, we don't return until the close
417 : : * is complete. Otherwise we return immediately. The
418 : : * actually closing is done the same either way.
419 : : *
420 : : * If the close is due to the process exiting, we never
421 : : * linger..
422 : : */
423 : : timeout = 0;
424 [ - + # # ]: 6168 : if (sock_flag(sk, SOCK_LINGER) &&
425 : 0 : !(current->flags & PF_EXITING))
426 : 0 : timeout = sk->sk_lingertime;
427 : 6168 : sk->sk_prot->close(sk, timeout);
428 : 6170 : sock->sk = NULL;
429 : : }
430 : 6170 : return 0;
431 : : }
432 : : EXPORT_SYMBOL(inet_release);
433 : :
434 : 1037 : int inet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
435 : : {
436 : 1037 : struct sock *sk = sock->sk;
437 : : int err;
438 : :
439 : : /* If the socket has its own bind function then use it. (RAW) */
440 [ - + ]: 1037 : if (sk->sk_prot->bind) {
441 : 0 : return sk->sk_prot->bind(sk, uaddr, addr_len);
442 : : }
443 [ + - ]: 1037 : if (addr_len < sizeof(struct sockaddr_in))
444 : : return -EINVAL;
445 : :
446 : : /* BPF prog is run before any checks are done so that if the prog
447 : : * changes context in a wrong way it will be caught.
448 : : */
449 [ + - ]: 1037 : err = BPF_CGROUP_RUN_PROG_INET4_BIND(sk, uaddr);
450 [ + - ]: 1037 : if (err)
451 : : return err;
452 : :
453 : 1037 : return __inet_bind(sk, uaddr, addr_len, false, true);
454 : : }
455 : : EXPORT_SYMBOL(inet_bind);
456 : :
457 : 1037 : int __inet_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len,
458 : : bool force_bind_address_no_port, bool with_lock)
459 : : {
460 : : struct sockaddr_in *addr = (struct sockaddr_in *)uaddr;
461 : : struct inet_sock *inet = inet_sk(sk);
462 : : struct net *net = sock_net(sk);
463 : : unsigned short snum;
464 : : int chk_addr_ret;
465 : : u32 tb_id = RT_TABLE_LOCAL;
466 : : int err;
467 : :
468 [ - + ]: 1037 : if (addr->sin_family != AF_INET) {
469 : : /* Compatibility games : accept AF_UNSPEC (mapped to AF_INET)
470 : : * only if s_addr is INADDR_ANY.
471 : : */
472 : : err = -EAFNOSUPPORT;
473 [ # # # # ]: 0 : if (addr->sin_family != AF_UNSPEC ||
474 : 0 : addr->sin_addr.s_addr != htonl(INADDR_ANY))
475 : : goto out;
476 : : }
477 : :
478 [ - + ]: 1037 : tb_id = l3mdev_fib_table_by_index(net, sk->sk_bound_dev_if) ? : tb_id;
479 : 1037 : chk_addr_ret = inet_addr_type_table(net, addr->sin_addr.s_addr, tb_id);
480 : :
481 : : /* Not specified by any standard per-se, however it breaks too
482 : : * many applications when removed. It is unfortunate since
483 : : * allowing applications to make a non-local bind solves
484 : : * several problems with systems using dynamic addressing.
485 : : * (ie. your servers still start up even if your ISDN link
486 : : * is temporarily down)
487 : : */
488 : : err = -EADDRNOTAVAIL;
489 [ + - - + ]: 2074 : if (!inet_can_nonlocal_bind(net, inet) &&
490 : 1037 : addr->sin_addr.s_addr != htonl(INADDR_ANY) &&
491 [ # # ]: 0 : chk_addr_ret != RTN_LOCAL &&
492 [ # # ]: 0 : chk_addr_ret != RTN_MULTICAST &&
493 : : chk_addr_ret != RTN_BROADCAST)
494 : : goto out;
495 : :
496 : 1037 : snum = ntohs(addr->sin_port);
497 : : err = -EACCES;
498 [ + + + + : 1658 : if (snum && snum < inet_prot_sock(net) &&
+ - ]
499 : 207 : !ns_capable(net->user_ns, CAP_NET_BIND_SERVICE))
500 : : goto out;
501 : :
502 : : /* We keep a pair of addresses. rcv_saddr is the one
503 : : * used by hash lookups, and saddr is used for transmit.
504 : : *
505 : : * In the BSD API these are the same except where it
506 : : * would be illegal to use them (multicast/broadcast) in
507 : : * which case the sending device address is used.
508 : : */
509 [ + - ]: 1037 : if (with_lock)
510 : : lock_sock(sk);
511 : :
512 : : /* Check these errors (active socket, double bind). */
513 : : err = -EINVAL;
514 [ + - + - ]: 1037 : if (sk->sk_state != TCP_CLOSE || inet->inet_num)
515 : : goto out_release_sock;
516 : :
517 : 1037 : inet->inet_rcv_saddr = inet->inet_saddr = addr->sin_addr.s_addr;
518 [ + - ]: 1037 : if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST)
519 : 1037 : inet->inet_saddr = 0; /* Use device */
520 : :
521 : : /* Make sure we are allowed to bind here. */
522 [ + + + - : 1037 : if (snum || !(inet->bind_address_no_port ||
+ - ]
523 : : force_bind_address_no_port)) {
524 [ - + ]: 1037 : if (sk->sk_prot->get_port(sk, snum)) {
525 : 0 : inet->inet_saddr = inet->inet_rcv_saddr = 0;
526 : : err = -EADDRINUSE;
527 : 0 : goto out_release_sock;
528 : : }
529 [ + - ]: 1037 : err = BPF_CGROUP_RUN_PROG_INET4_POST_BIND(sk);
530 [ - + ]: 1037 : if (err) {
531 : 0 : inet->inet_saddr = inet->inet_rcv_saddr = 0;
532 : 0 : goto out_release_sock;
533 : : }
534 : : }
535 : :
536 [ - + ]: 1037 : if (inet->inet_rcv_saddr)
537 : 0 : sk->sk_userlocks |= SOCK_BINDADDR_LOCK;
538 [ + + ]: 1037 : if (snum)
539 : 414 : sk->sk_userlocks |= SOCK_BINDPORT_LOCK;
540 : 1037 : inet->inet_sport = htons(inet->inet_num);
541 : 1037 : inet->inet_daddr = 0;
542 : 1037 : inet->inet_dport = 0;
543 : : sk_dst_reset(sk);
544 : : err = 0;
545 : : out_release_sock:
546 [ + - ]: 1037 : if (with_lock)
547 : 1037 : release_sock(sk);
548 : : out:
549 : 1037 : return err;
550 : : }
551 : :
552 : 7284 : int inet_dgram_connect(struct socket *sock, struct sockaddr *uaddr,
553 : : int addr_len, int flags)
554 : : {
555 : 7284 : struct sock *sk = sock->sk;
556 : : int err;
557 : :
558 [ + - ]: 7284 : if (addr_len < sizeof(uaddr->sa_family))
559 : : return -EINVAL;
560 [ + + ]: 7284 : if (uaddr->sa_family == AF_UNSPEC)
561 : 1281 : return sk->sk_prot->disconnect(sk, flags);
562 : :
563 [ + - + - ]: 6003 : if (BPF_CGROUP_PRE_CONNECT_ENABLED(sk)) {
564 : 6003 : err = sk->sk_prot->pre_connect(sk, uaddr, addr_len);
565 [ + - ]: 6003 : if (err)
566 : : return err;
567 : : }
568 : :
569 [ + - + - ]: 6003 : if (!inet_sk(sk)->inet_num && inet_autobind(sk))
570 : : return -EAGAIN;
571 : 6003 : return sk->sk_prot->connect(sk, uaddr, addr_len);
572 : : }
573 : : EXPORT_SYMBOL(inet_dgram_connect);
574 : :
575 : 0 : static long inet_wait_for_connect(struct sock *sk, long timeo, int writebias)
576 : : {
577 : 0 : DEFINE_WAIT_FUNC(wait, woken_wake_function);
578 : :
579 : 0 : add_wait_queue(sk_sleep(sk), &wait);
580 : 0 : sk->sk_write_pending += writebias;
581 : :
582 : : /* Basic assumption: if someone sets sk->sk_err, he _must_
583 : : * change state of the socket from TCP_SYN_*.
584 : : * Connect() does not allow to get error notifications
585 : : * without closing the socket.
586 : : */
587 [ # # ]: 0 : while ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) {
588 : 0 : release_sock(sk);
589 : 0 : timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
590 : : lock_sock(sk);
591 [ # # # # ]: 0 : if (signal_pending(current) || !timeo)
592 : : break;
593 : : }
594 : 0 : remove_wait_queue(sk_sleep(sk), &wait);
595 : 0 : sk->sk_write_pending -= writebias;
596 : 0 : return timeo;
597 : : }
598 : :
599 : : /*
600 : : * Connect to a remote host. There is regrettably still a little
601 : : * TCP 'magic' in here.
602 : : */
603 : 0 : int __inet_stream_connect(struct socket *sock, struct sockaddr *uaddr,
604 : : int addr_len, int flags, int is_sendmsg)
605 : : {
606 : 0 : struct sock *sk = sock->sk;
607 : : int err;
608 : : long timeo;
609 : :
610 : : /*
611 : : * uaddr can be NULL and addr_len can be 0 if:
612 : : * sk is a TCP fastopen active socket and
613 : : * TCP_FASTOPEN_CONNECT sockopt is set and
614 : : * we already have a valid cookie for this socket.
615 : : * In this case, user can call write() after connect().
616 : : * write() will invoke tcp_sendmsg_fastopen() which calls
617 : : * __inet_stream_connect().
618 : : */
619 [ # # ]: 0 : if (uaddr) {
620 [ # # ]: 0 : if (addr_len < sizeof(uaddr->sa_family))
621 : : return -EINVAL;
622 : :
623 [ # # ]: 0 : if (uaddr->sa_family == AF_UNSPEC) {
624 : 0 : err = sk->sk_prot->disconnect(sk, flags);
625 [ # # ]: 0 : sock->state = err ? SS_DISCONNECTING : SS_UNCONNECTED;
626 : 0 : goto out;
627 : : }
628 : : }
629 : :
630 [ # # # # ]: 0 : switch (sock->state) {
631 : : default:
632 : : err = -EINVAL;
633 : : goto out;
634 : : case SS_CONNECTED:
635 : : err = -EISCONN;
636 : 0 : goto out;
637 : : case SS_CONNECTING:
638 [ # # ]: 0 : if (inet_sk(sk)->defer_connect)
639 [ # # ]: 0 : err = is_sendmsg ? -EINPROGRESS : -EISCONN;
640 : : else
641 : : err = -EALREADY;
642 : : /* Fall out of switch with err, set for this state */
643 : : break;
644 : : case SS_UNCONNECTED:
645 : : err = -EISCONN;
646 [ # # ]: 0 : if (sk->sk_state != TCP_CLOSE)
647 : : goto out;
648 : :
649 [ # # # # ]: 0 : if (BPF_CGROUP_PRE_CONNECT_ENABLED(sk)) {
650 : 0 : err = sk->sk_prot->pre_connect(sk, uaddr, addr_len);
651 [ # # ]: 0 : if (err)
652 : : goto out;
653 : : }
654 : :
655 : 0 : err = sk->sk_prot->connect(sk, uaddr, addr_len);
656 [ # # ]: 0 : if (err < 0)
657 : : goto out;
658 : :
659 : 0 : sock->state = SS_CONNECTING;
660 : :
661 [ # # # # ]: 0 : if (!err && inet_sk(sk)->defer_connect)
662 : : goto out;
663 : :
664 : : /* Just entered SS_CONNECTING state; the only
665 : : * difference is that return value in non-blocking
666 : : * case is EINPROGRESS, rather than EALREADY.
667 : : */
668 : : err = -EINPROGRESS;
669 : : break;
670 : : }
671 : :
672 : 0 : timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
673 : :
674 [ # # ]: 0 : if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) {
675 [ # # ]: 0 : int writebias = (sk->sk_protocol == IPPROTO_TCP) &&
676 : 0 : tcp_sk(sk)->fastopen_req &&
677 [ # # # # ]: 0 : tcp_sk(sk)->fastopen_req->data ? 1 : 0;
678 : :
679 : : /* Error code is set above */
680 [ # # # # ]: 0 : if (!timeo || !inet_wait_for_connect(sk, timeo, writebias))
681 : : goto out;
682 : :
683 : : err = sock_intr_errno(timeo);
684 [ # # ]: 0 : if (signal_pending(current))
685 : : goto out;
686 : : }
687 : :
688 : : /* Connection was closed by RST, timeout, ICMP error
689 : : * or another process disconnected us.
690 : : */
691 [ # # ]: 0 : if (sk->sk_state == TCP_CLOSE)
692 : : goto sock_error;
693 : :
694 : : /* sk->sk_err may be not zero now, if RECVERR was ordered by user
695 : : * and error was received after socket entered established state.
696 : : * Hence, it is handled normally after connect() return successfully.
697 : : */
698 : :
699 : 0 : sock->state = SS_CONNECTED;
700 : : err = 0;
701 : : out:
702 : 0 : return err;
703 : :
704 : : sock_error:
705 [ # # ]: 0 : err = sock_error(sk) ? : -ECONNABORTED;
706 : 0 : sock->state = SS_UNCONNECTED;
707 [ # # ]: 0 : if (sk->sk_prot->disconnect(sk, flags))
708 : 0 : sock->state = SS_DISCONNECTING;
709 : : goto out;
710 : : }
711 : : EXPORT_SYMBOL(__inet_stream_connect);
712 : :
713 : 0 : int inet_stream_connect(struct socket *sock, struct sockaddr *uaddr,
714 : : int addr_len, int flags)
715 : : {
716 : : int err;
717 : :
718 : 0 : lock_sock(sock->sk);
719 : 0 : err = __inet_stream_connect(sock, uaddr, addr_len, flags, 0);
720 : 0 : release_sock(sock->sk);
721 : 0 : return err;
722 : : }
723 : : EXPORT_SYMBOL(inet_stream_connect);
724 : :
725 : : /*
726 : : * Accept a pending connection. The TCP layer now gives BSD semantics.
727 : : */
728 : :
729 : 0 : int inet_accept(struct socket *sock, struct socket *newsock, int flags,
730 : : bool kern)
731 : : {
732 : 0 : struct sock *sk1 = sock->sk;
733 : 0 : int err = -EINVAL;
734 : 0 : struct sock *sk2 = sk1->sk_prot->accept(sk1, flags, &err, kern);
735 : :
736 [ # # ]: 0 : if (!sk2)
737 : : goto do_err;
738 : :
739 : : lock_sock(sk2);
740 : :
741 : 0 : sock_rps_record_flow(sk2);
742 [ # # ]: 0 : WARN_ON(!((1 << sk2->sk_state) &
743 : : (TCPF_ESTABLISHED | TCPF_SYN_RECV |
744 : : TCPF_CLOSE_WAIT | TCPF_CLOSE)));
745 : :
746 : 0 : sock_graft(sk2, newsock);
747 : :
748 : 0 : newsock->state = SS_CONNECTED;
749 : 0 : err = 0;
750 : 0 : release_sock(sk2);
751 : : do_err:
752 : 0 : return err;
753 : : }
754 : : EXPORT_SYMBOL(inet_accept);
755 : :
756 : :
757 : : /*
758 : : * This does both peername and sockname.
759 : : */
760 : 672 : int inet_getname(struct socket *sock, struct sockaddr *uaddr,
761 : : int peer)
762 : : {
763 : 672 : struct sock *sk = sock->sk;
764 : : struct inet_sock *inet = inet_sk(sk);
765 : : DECLARE_SOCKADDR(struct sockaddr_in *, sin, uaddr);
766 : :
767 : 672 : sin->sin_family = AF_INET;
768 [ - + ]: 672 : if (peer) {
769 [ # # # # ]: 0 : if (!inet->inet_dport ||
770 [ # # ]: 0 : (((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_SYN_SENT)) &&
771 : : peer == 1))
772 : : return -ENOTCONN;
773 : 0 : sin->sin_port = inet->inet_dport;
774 : 0 : sin->sin_addr.s_addr = inet->inet_daddr;
775 : : } else {
776 : 672 : __be32 addr = inet->inet_rcv_saddr;
777 [ - + ]: 672 : if (!addr)
778 : 0 : addr = inet->inet_saddr;
779 : 672 : sin->sin_port = inet->inet_sport;
780 : 672 : sin->sin_addr.s_addr = addr;
781 : : }
782 : 672 : memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
783 : 672 : return sizeof(*sin);
784 : : }
785 : : EXPORT_SYMBOL(inet_getname);
786 : :
787 : 4907 : int inet_send_prepare(struct sock *sk)
788 : : {
789 : 4907 : sock_rps_record_flow(sk);
790 : :
791 : : /* We may need to bind the socket. */
792 [ - + # # : 4907 : if (!inet_sk(sk)->inet_num && !sk->sk_prot->no_autobind &&
# # ]
793 : 0 : inet_autobind(sk))
794 : : return -EAGAIN;
795 : :
796 : : return 0;
797 : : }
798 : : EXPORT_SYMBOL_GPL(inet_send_prepare);
799 : :
800 : 2926 : int inet_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
801 : : {
802 : 2926 : struct sock *sk = sock->sk;
803 : :
804 [ + - ]: 2926 : if (unlikely(inet_send_prepare(sk)))
805 : : return -EAGAIN;
806 : :
807 : 2926 : return INDIRECT_CALL_2(sk->sk_prot->sendmsg, tcp_sendmsg, udp_sendmsg,
808 : : sk, msg, size);
809 : : }
810 : : EXPORT_SYMBOL(inet_sendmsg);
811 : :
812 : 0 : ssize_t inet_sendpage(struct socket *sock, struct page *page, int offset,
813 : : size_t size, int flags)
814 : : {
815 : 0 : struct sock *sk = sock->sk;
816 : :
817 [ # # ]: 0 : if (unlikely(inet_send_prepare(sk)))
818 : : return -EAGAIN;
819 : :
820 [ # # ]: 0 : if (sk->sk_prot->sendpage)
821 : 0 : return sk->sk_prot->sendpage(sk, page, offset, size, flags);
822 : 0 : return sock_no_sendpage(sock, page, offset, size, flags);
823 : : }
824 : : EXPORT_SYMBOL(inet_sendpage);
825 : :
826 : : INDIRECT_CALLABLE_DECLARE(int udp_recvmsg(struct sock *, struct msghdr *,
827 : : size_t, int, int, int *));
828 : 3051 : int inet_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
829 : : int flags)
830 : : {
831 : 3051 : struct sock *sk = sock->sk;
832 : 3051 : int addr_len = 0;
833 : : int err;
834 : :
835 [ + - ]: 3051 : if (likely(!(flags & MSG_ERRQUEUE)))
836 : 3051 : sock_rps_record_flow(sk);
837 : :
838 : 3051 : err = INDIRECT_CALL_2(sk->sk_prot->recvmsg, tcp_recvmsg, udp_recvmsg,
839 : : sk, msg, size, flags & MSG_DONTWAIT,
840 : : flags & ~MSG_DONTWAIT, &addr_len);
841 [ + - ]: 3051 : if (err >= 0)
842 : 3051 : msg->msg_namelen = addr_len;
843 : 3051 : return err;
844 : : }
845 : : EXPORT_SYMBOL(inet_recvmsg);
846 : :
847 : 0 : int inet_shutdown(struct socket *sock, int how)
848 : : {
849 : 0 : struct sock *sk = sock->sk;
850 : : int err = 0;
851 : :
852 : : /* This should really check to make sure
853 : : * the socket is a TCP socket. (WHY AC...)
854 : : */
855 : 0 : how++; /* maps 0->1 has the advantage of making bit 1 rcvs and
856 : : 1->2 bit 2 snds.
857 : : 2->3 */
858 [ # # # # ]: 0 : if ((how & ~SHUTDOWN_MASK) || !how) /* MAXINT->0 */
859 : : return -EINVAL;
860 : :
861 : : lock_sock(sk);
862 [ # # ]: 0 : if (sock->state == SS_CONNECTING) {
863 [ # # ]: 0 : if ((1 << sk->sk_state) &
864 : : (TCPF_SYN_SENT | TCPF_SYN_RECV | TCPF_CLOSE))
865 : 0 : sock->state = SS_DISCONNECTING;
866 : : else
867 : 0 : sock->state = SS_CONNECTED;
868 : : }
869 : :
870 [ # # # # ]: 0 : switch (sk->sk_state) {
871 : : case TCP_CLOSE:
872 : : err = -ENOTCONN;
873 : : /* Hack to wake up other listeners, who can poll for
874 : : EPOLLHUP, even on eg. unconnected UDP sockets -- RR */
875 : : /* fall through */
876 : : default:
877 : 0 : sk->sk_shutdown |= how;
878 [ # # ]: 0 : if (sk->sk_prot->shutdown)
879 : 0 : sk->sk_prot->shutdown(sk, how);
880 : : break;
881 : :
882 : : /* Remaining two branches are temporary solution for missing
883 : : * close() in multithreaded environment. It is _not_ a good idea,
884 : : * but we have no choice until close() is repaired at VFS level.
885 : : */
886 : : case TCP_LISTEN:
887 [ # # ]: 0 : if (!(how & RCV_SHUTDOWN))
888 : : break;
889 : : /* fall through */
890 : : case TCP_SYN_SENT:
891 : 0 : err = sk->sk_prot->disconnect(sk, O_NONBLOCK);
892 [ # # ]: 0 : sock->state = err ? SS_DISCONNECTING : SS_UNCONNECTED;
893 : 0 : break;
894 : : }
895 : :
896 : : /* Wake up anyone sleeping in poll. */
897 : 0 : sk->sk_state_change(sk);
898 : 0 : release_sock(sk);
899 : 0 : return err;
900 : : }
901 : : EXPORT_SYMBOL(inet_shutdown);
902 : :
903 : : /*
904 : : * ioctl() calls you can issue on an INET socket. Most of these are
905 : : * device configuration and stuff and very rarely used. Some ioctls
906 : : * pass on to the socket itself.
907 : : *
908 : : * NOTE: I like the idea of a module for the config stuff. ie ifconfig
909 : : * loads the devconfigure module does its configuring and unloads it.
910 : : * There's a good 20K of config code hanging around the kernel.
911 : : */
912 : :
913 : 6499 : int inet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
914 : : {
915 : 6499 : struct sock *sk = sock->sk;
916 : : int err = 0;
917 : : struct net *net = sock_net(sk);
918 : 6499 : void __user *p = (void __user *)arg;
919 : : struct ifreq ifr;
920 : : struct rtentry rt;
921 : :
922 [ - - - + : 6499 : switch (cmd) {
+ - ]
923 : : case SIOCADDRT:
924 : : case SIOCDELRT:
925 [ # # ]: 0 : if (copy_from_user(&rt, p, sizeof(struct rtentry)))
926 : : return -EFAULT;
927 : 0 : err = ip_rt_ioctl(net, cmd, &rt);
928 : 0 : break;
929 : : case SIOCRTMSG:
930 : : err = -EINVAL;
931 : : break;
932 : : case SIOCDARP:
933 : : case SIOCGARP:
934 : : case SIOCSARP:
935 : 0 : err = arp_ioctl(net, cmd, (void __user *)arg);
936 : 0 : break;
937 : : case SIOCGIFADDR:
938 : : case SIOCGIFBRDADDR:
939 : : case SIOCGIFNETMASK:
940 : : case SIOCGIFDSTADDR:
941 : : case SIOCGIFPFLAGS:
942 [ # # ]: 0 : if (copy_from_user(&ifr, p, sizeof(struct ifreq)))
943 : : return -EFAULT;
944 : 0 : err = devinet_ioctl(net, cmd, &ifr);
945 [ # # # # ]: 0 : if (!err && copy_to_user(p, &ifr, sizeof(struct ifreq)))
946 : : err = -EFAULT;
947 : : break;
948 : :
949 : : case SIOCSIFADDR:
950 : : case SIOCSIFBRDADDR:
951 : : case SIOCSIFNETMASK:
952 : : case SIOCSIFDSTADDR:
953 : : case SIOCSIFPFLAGS:
954 : : case SIOCSIFFLAGS:
955 [ + - ]: 207 : if (copy_from_user(&ifr, p, sizeof(struct ifreq)))
956 : : return -EFAULT;
957 : 207 : err = devinet_ioctl(net, cmd, &ifr);
958 : 207 : break;
959 : : default:
960 [ + - ]: 6292 : if (sk->sk_prot->ioctl)
961 : 6292 : err = sk->sk_prot->ioctl(sk, cmd, arg);
962 : : else
963 : : err = -ENOIOCTLCMD;
964 : : break;
965 : : }
966 : 6499 : return err;
967 : : }
968 : : EXPORT_SYMBOL(inet_ioctl);
969 : :
970 : : #ifdef CONFIG_COMPAT
971 : : static int inet_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
972 : : {
973 : : struct sock *sk = sock->sk;
974 : : int err = -ENOIOCTLCMD;
975 : :
976 : : if (sk->sk_prot->compat_ioctl)
977 : : err = sk->sk_prot->compat_ioctl(sk, cmd, arg);
978 : :
979 : : return err;
980 : : }
981 : : #endif
982 : :
983 : : const struct proto_ops inet_stream_ops = {
984 : : .family = PF_INET,
985 : : .owner = THIS_MODULE,
986 : : .release = inet_release,
987 : : .bind = inet_bind,
988 : : .connect = inet_stream_connect,
989 : : .socketpair = sock_no_socketpair,
990 : : .accept = inet_accept,
991 : : .getname = inet_getname,
992 : : .poll = tcp_poll,
993 : : .ioctl = inet_ioctl,
994 : : .gettstamp = sock_gettstamp,
995 : : .listen = inet_listen,
996 : : .shutdown = inet_shutdown,
997 : : .setsockopt = sock_common_setsockopt,
998 : : .getsockopt = sock_common_getsockopt,
999 : : .sendmsg = inet_sendmsg,
1000 : : .recvmsg = inet_recvmsg,
1001 : : #ifdef CONFIG_MMU
1002 : : .mmap = tcp_mmap,
1003 : : #endif
1004 : : .sendpage = inet_sendpage,
1005 : : .splice_read = tcp_splice_read,
1006 : : .read_sock = tcp_read_sock,
1007 : : .sendmsg_locked = tcp_sendmsg_locked,
1008 : : .sendpage_locked = tcp_sendpage_locked,
1009 : : .peek_len = tcp_peek_len,
1010 : : #ifdef CONFIG_COMPAT
1011 : : .compat_setsockopt = compat_sock_common_setsockopt,
1012 : : .compat_getsockopt = compat_sock_common_getsockopt,
1013 : : .compat_ioctl = inet_compat_ioctl,
1014 : : #endif
1015 : : .set_rcvlowat = tcp_set_rcvlowat,
1016 : : };
1017 : : EXPORT_SYMBOL(inet_stream_ops);
1018 : :
1019 : : const struct proto_ops inet_dgram_ops = {
1020 : : .family = PF_INET,
1021 : : .owner = THIS_MODULE,
1022 : : .release = inet_release,
1023 : : .bind = inet_bind,
1024 : : .connect = inet_dgram_connect,
1025 : : .socketpair = sock_no_socketpair,
1026 : : .accept = sock_no_accept,
1027 : : .getname = inet_getname,
1028 : : .poll = udp_poll,
1029 : : .ioctl = inet_ioctl,
1030 : : .gettstamp = sock_gettstamp,
1031 : : .listen = sock_no_listen,
1032 : : .shutdown = inet_shutdown,
1033 : : .setsockopt = sock_common_setsockopt,
1034 : : .getsockopt = sock_common_getsockopt,
1035 : : .sendmsg = inet_sendmsg,
1036 : : .recvmsg = inet_recvmsg,
1037 : : .mmap = sock_no_mmap,
1038 : : .sendpage = inet_sendpage,
1039 : : .set_peek_off = sk_set_peek_off,
1040 : : #ifdef CONFIG_COMPAT
1041 : : .compat_setsockopt = compat_sock_common_setsockopt,
1042 : : .compat_getsockopt = compat_sock_common_getsockopt,
1043 : : .compat_ioctl = inet_compat_ioctl,
1044 : : #endif
1045 : : };
1046 : : EXPORT_SYMBOL(inet_dgram_ops);
1047 : :
1048 : : /*
1049 : : * For SOCK_RAW sockets; should be the same as inet_dgram_ops but without
1050 : : * udp_poll
1051 : : */
1052 : : static const struct proto_ops inet_sockraw_ops = {
1053 : : .family = PF_INET,
1054 : : .owner = THIS_MODULE,
1055 : : .release = inet_release,
1056 : : .bind = inet_bind,
1057 : : .connect = inet_dgram_connect,
1058 : : .socketpair = sock_no_socketpair,
1059 : : .accept = sock_no_accept,
1060 : : .getname = inet_getname,
1061 : : .poll = datagram_poll,
1062 : : .ioctl = inet_ioctl,
1063 : : .gettstamp = sock_gettstamp,
1064 : : .listen = sock_no_listen,
1065 : : .shutdown = inet_shutdown,
1066 : : .setsockopt = sock_common_setsockopt,
1067 : : .getsockopt = sock_common_getsockopt,
1068 : : .sendmsg = inet_sendmsg,
1069 : : .recvmsg = inet_recvmsg,
1070 : : .mmap = sock_no_mmap,
1071 : : .sendpage = inet_sendpage,
1072 : : #ifdef CONFIG_COMPAT
1073 : : .compat_setsockopt = compat_sock_common_setsockopt,
1074 : : .compat_getsockopt = compat_sock_common_getsockopt,
1075 : : .compat_ioctl = inet_compat_ioctl,
1076 : : #endif
1077 : : };
1078 : :
1079 : : static const struct net_proto_family inet_family_ops = {
1080 : : .family = PF_INET,
1081 : : .create = inet_create,
1082 : : .owner = THIS_MODULE,
1083 : : };
1084 : :
1085 : : /* Upon startup we insert all the elements in inetsw_array[] into
1086 : : * the linked list inetsw.
1087 : : */
1088 : : static struct inet_protosw inetsw_array[] =
1089 : : {
1090 : : {
1091 : : .type = SOCK_STREAM,
1092 : : .protocol = IPPROTO_TCP,
1093 : : .prot = &tcp_prot,
1094 : : .ops = &inet_stream_ops,
1095 : : .flags = INET_PROTOSW_PERMANENT |
1096 : : INET_PROTOSW_ICSK,
1097 : : },
1098 : :
1099 : : {
1100 : : .type = SOCK_DGRAM,
1101 : : .protocol = IPPROTO_UDP,
1102 : : .prot = &udp_prot,
1103 : : .ops = &inet_dgram_ops,
1104 : : .flags = INET_PROTOSW_PERMANENT,
1105 : : },
1106 : :
1107 : : {
1108 : : .type = SOCK_DGRAM,
1109 : : .protocol = IPPROTO_ICMP,
1110 : : .prot = &ping_prot,
1111 : : .ops = &inet_sockraw_ops,
1112 : : .flags = INET_PROTOSW_REUSE,
1113 : : },
1114 : :
1115 : : {
1116 : : .type = SOCK_RAW,
1117 : : .protocol = IPPROTO_IP, /* wild card */
1118 : : .prot = &raw_prot,
1119 : : .ops = &inet_sockraw_ops,
1120 : : .flags = INET_PROTOSW_REUSE,
1121 : : }
1122 : : };
1123 : :
1124 : : #define INETSW_ARRAY_LEN ARRAY_SIZE(inetsw_array)
1125 : :
1126 : 1035 : void inet_register_protosw(struct inet_protosw *p)
1127 : : {
1128 : : struct list_head *lh;
1129 : : struct inet_protosw *answer;
1130 : 1035 : int protocol = p->protocol;
1131 : : struct list_head *last_perm;
1132 : :
1133 : : spin_lock_bh(&inetsw_lock);
1134 : :
1135 [ + - ]: 1035 : if (p->type >= SOCK_MAX)
1136 : : goto out_illegal;
1137 : :
1138 : : /* If we are trying to override a permanent protocol, bail. */
1139 : 1035 : last_perm = &inetsw[p->type];
1140 [ + + ]: 1449 : list_for_each(lh, &inetsw[p->type]) {
1141 : : answer = list_entry(lh, struct inet_protosw, list);
1142 : : /* Check only the non-wild match. */
1143 [ + + ]: 621 : if ((INET_PROTOSW_PERMANENT & answer->flags) == 0)
1144 : : break;
1145 [ + - ]: 414 : if (protocol == answer->protocol)
1146 : : goto out_permanent;
1147 : : last_perm = lh;
1148 : : }
1149 : :
1150 : : /* Add the new entry after the last permanent entry if any, so that
1151 : : * the new entry does not override a permanent entry when matched with
1152 : : * a wild-card protocol. But it is allowed to override any existing
1153 : : * non-permanent entry. This means that when we remove this entry, the
1154 : : * system automatically returns to the old behavior.
1155 : : */
1156 : 1035 : list_add_rcu(&p->list, last_perm);
1157 : : out:
1158 : : spin_unlock_bh(&inetsw_lock);
1159 : :
1160 : 1035 : return;
1161 : :
1162 : : out_permanent:
1163 : 0 : pr_err("Attempt to override permanent protocol %d\n", protocol);
1164 : 0 : goto out;
1165 : :
1166 : : out_illegal:
1167 : 0 : pr_err("Ignoring attempt to register invalid socket type %d\n",
1168 : : p->type);
1169 : 0 : goto out;
1170 : : }
1171 : : EXPORT_SYMBOL(inet_register_protosw);
1172 : :
1173 : 0 : void inet_unregister_protosw(struct inet_protosw *p)
1174 : : {
1175 [ # # ]: 0 : if (INET_PROTOSW_PERMANENT & p->flags) {
1176 : 0 : pr_err("Attempt to unregister permanent protocol %d\n",
1177 : : p->protocol);
1178 : : } else {
1179 : : spin_lock_bh(&inetsw_lock);
1180 : : list_del_rcu(&p->list);
1181 : : spin_unlock_bh(&inetsw_lock);
1182 : :
1183 : 0 : synchronize_net();
1184 : : }
1185 : 0 : }
1186 : : EXPORT_SYMBOL(inet_unregister_protosw);
1187 : :
1188 : 0 : static int inet_sk_reselect_saddr(struct sock *sk)
1189 : : {
1190 : : struct inet_sock *inet = inet_sk(sk);
1191 : 0 : __be32 old_saddr = inet->inet_saddr;
1192 : 0 : __be32 daddr = inet->inet_daddr;
1193 : : struct flowi4 *fl4;
1194 : : struct rtable *rt;
1195 : : __be32 new_saddr;
1196 : : struct ip_options_rcu *inet_opt;
1197 : :
1198 : 0 : inet_opt = rcu_dereference_protected(inet->inet_opt,
1199 : : lockdep_sock_is_held(sk));
1200 [ # # # # ]: 0 : if (inet_opt && inet_opt->opt.srr)
1201 : 0 : daddr = inet_opt->opt.faddr;
1202 : :
1203 : : /* Query new route. */
1204 : 0 : fl4 = &inet->cork.fl.u.ip4;
1205 : 0 : rt = ip_route_connect(fl4, daddr, 0, RT_CONN_FLAGS(sk),
1206 : : sk->sk_bound_dev_if, sk->sk_protocol,
1207 : : inet->inet_sport, inet->inet_dport, sk);
1208 [ # # ]: 0 : if (IS_ERR(rt))
1209 : 0 : return PTR_ERR(rt);
1210 : :
1211 : 0 : sk_setup_caps(sk, &rt->dst);
1212 : :
1213 : 0 : new_saddr = fl4->saddr;
1214 : :
1215 [ # # ]: 0 : if (new_saddr == old_saddr)
1216 : : return 0;
1217 : :
1218 [ # # ]: 0 : if (sock_net(sk)->ipv4.sysctl_ip_dynaddr > 1) {
1219 : 0 : pr_info("%s(): shifting inet->saddr from %pI4 to %pI4\n",
1220 : : __func__, &old_saddr, &new_saddr);
1221 : : }
1222 : :
1223 : 0 : inet->inet_saddr = inet->inet_rcv_saddr = new_saddr;
1224 : :
1225 : : /*
1226 : : * XXX The only one ugly spot where we need to
1227 : : * XXX really change the sockets identity after
1228 : : * XXX it has entered the hashes. -DaveM
1229 : : *
1230 : : * Besides that, it does not check for connection
1231 : : * uniqueness. Wait for troubles.
1232 : : */
1233 : 0 : return __sk_prot_rehash(sk);
1234 : : }
1235 : :
1236 : 0 : int inet_sk_rebuild_header(struct sock *sk)
1237 : : {
1238 : : struct inet_sock *inet = inet_sk(sk);
1239 : 0 : struct rtable *rt = (struct rtable *)__sk_dst_check(sk, 0);
1240 : : __be32 daddr;
1241 : : struct ip_options_rcu *inet_opt;
1242 : : struct flowi4 *fl4;
1243 : : int err;
1244 : :
1245 : : /* Route is OK, nothing to do. */
1246 [ # # ]: 0 : if (rt)
1247 : : return 0;
1248 : :
1249 : : /* Reroute. */
1250 : : rcu_read_lock();
1251 : 0 : inet_opt = rcu_dereference(inet->inet_opt);
1252 : 0 : daddr = inet->inet_daddr;
1253 [ # # # # ]: 0 : if (inet_opt && inet_opt->opt.srr)
1254 : 0 : daddr = inet_opt->opt.faddr;
1255 : : rcu_read_unlock();
1256 : 0 : fl4 = &inet->cork.fl.u.ip4;
1257 : 0 : rt = ip_route_output_ports(sock_net(sk), fl4, sk, daddr, inet->inet_saddr,
1258 : : inet->inet_dport, inet->inet_sport,
1259 : 0 : sk->sk_protocol, RT_CONN_FLAGS(sk),
1260 : : sk->sk_bound_dev_if);
1261 [ # # ]: 0 : if (!IS_ERR(rt)) {
1262 : : err = 0;
1263 : 0 : sk_setup_caps(sk, &rt->dst);
1264 : : } else {
1265 : : err = PTR_ERR(rt);
1266 : :
1267 : : /* Routing failed... */
1268 : 0 : sk->sk_route_caps = 0;
1269 : : /*
1270 : : * Other protocols have to map its equivalent state to TCP_SYN_SENT.
1271 : : * DCCP maps its DCCP_REQUESTING state to TCP_SYN_SENT. -acme
1272 : : */
1273 [ # # # # ]: 0 : if (!sock_net(sk)->ipv4.sysctl_ip_dynaddr ||
1274 [ # # ]: 0 : sk->sk_state != TCP_SYN_SENT ||
1275 [ # # ]: 0 : (sk->sk_userlocks & SOCK_BINDADDR_LOCK) ||
1276 : : (err = inet_sk_reselect_saddr(sk)) != 0)
1277 : 0 : sk->sk_err_soft = -err;
1278 : : }
1279 : :
1280 : 0 : return err;
1281 : : }
1282 : : EXPORT_SYMBOL(inet_sk_rebuild_header);
1283 : :
1284 : 0 : void inet_sk_set_state(struct sock *sk, int state)
1285 : : {
1286 : 0 : trace_inet_sock_set_state(sk, sk->sk_state, state);
1287 : 0 : sk->sk_state = state;
1288 : 0 : }
1289 : : EXPORT_SYMBOL(inet_sk_set_state);
1290 : :
1291 : 0 : void inet_sk_state_store(struct sock *sk, int newstate)
1292 : : {
1293 : 0 : trace_inet_sock_set_state(sk, sk->sk_state, newstate);
1294 : 0 : smp_store_release(&sk->sk_state, newstate);
1295 : 0 : }
1296 : :
1297 : 0 : struct sk_buff *inet_gso_segment(struct sk_buff *skb,
1298 : : netdev_features_t features)
1299 : : {
1300 : : bool udpfrag = false, fixedid = false, gso_partial, encap;
1301 : : struct sk_buff *segs = ERR_PTR(-EINVAL);
1302 : : const struct net_offload *ops;
1303 : : unsigned int offset = 0;
1304 : : struct iphdr *iph;
1305 : : int proto, tot_len;
1306 : : int nhoff;
1307 : : int ihl;
1308 : : int id;
1309 : :
1310 : : skb_reset_network_header(skb);
1311 : 0 : nhoff = skb_network_header(skb) - skb_mac_header(skb);
1312 [ # # ]: 0 : if (unlikely(!pskb_may_pull(skb, sizeof(*iph))))
1313 : : goto out;
1314 : :
1315 : : iph = ip_hdr(skb);
1316 : 0 : ihl = iph->ihl * 4;
1317 [ # # ]: 0 : if (ihl < sizeof(*iph))
1318 : : goto out;
1319 : :
1320 : 0 : id = ntohs(iph->id);
1321 : 0 : proto = iph->protocol;
1322 : :
1323 : : /* Warning: after this point, iph might be no longer valid */
1324 [ # # ]: 0 : if (unlikely(!pskb_may_pull(skb, ihl)))
1325 : : goto out;
1326 : 0 : __skb_pull(skb, ihl);
1327 : :
1328 : 0 : encap = SKB_GSO_CB(skb)->encap_level > 0;
1329 [ # # ]: 0 : if (encap)
1330 : 0 : features &= skb->dev->hw_enc_features;
1331 : 0 : SKB_GSO_CB(skb)->encap_level += ihl;
1332 : :
1333 : : skb_reset_transport_header(skb);
1334 : :
1335 : : segs = ERR_PTR(-EPROTONOSUPPORT);
1336 : :
1337 [ # # # # ]: 0 : if (!skb->encapsulation || encap) {
1338 : 0 : udpfrag = !!(skb_shinfo(skb)->gso_type & SKB_GSO_UDP);
1339 : 0 : fixedid = !!(skb_shinfo(skb)->gso_type & SKB_GSO_TCP_FIXEDID);
1340 : :
1341 : : /* fixed ID is invalid if DF bit is not set */
1342 [ # # # # ]: 0 : if (fixedid && !(ip_hdr(skb)->frag_off & htons(IP_DF)))
1343 : : goto out;
1344 : : }
1345 : :
1346 : 0 : ops = rcu_dereference(inet_offloads[proto]);
1347 [ # # # # ]: 0 : if (likely(ops && ops->callbacks.gso_segment))
1348 : 0 : segs = ops->callbacks.gso_segment(skb, features);
1349 : :
1350 [ # # ]: 0 : if (IS_ERR_OR_NULL(segs))
1351 : : goto out;
1352 : :
1353 : 0 : gso_partial = !!(skb_shinfo(segs)->gso_type & SKB_GSO_PARTIAL);
1354 : :
1355 : : skb = segs;
1356 : : do {
1357 : 0 : iph = (struct iphdr *)(skb_mac_header(skb) + nhoff);
1358 [ # # ]: 0 : if (udpfrag) {
1359 : 0 : iph->frag_off = htons(offset >> 3);
1360 [ # # ]: 0 : if (skb->next)
1361 : 0 : iph->frag_off |= htons(IP_MF);
1362 : 0 : offset += skb->len - nhoff - ihl;
1363 : 0 : tot_len = skb->len - nhoff;
1364 [ # # ]: 0 : } else if (skb_is_gso(skb)) {
1365 [ # # ]: 0 : if (!fixedid) {
1366 : 0 : iph->id = htons(id);
1367 : 0 : id += skb_shinfo(skb)->gso_segs;
1368 : : }
1369 : :
1370 [ # # ]: 0 : if (gso_partial)
1371 : 0 : tot_len = skb_shinfo(skb)->gso_size +
1372 : 0 : SKB_GSO_CB(skb)->data_offset +
1373 : 0 : skb->head - (unsigned char *)iph;
1374 : : else
1375 : 0 : tot_len = skb->len - nhoff;
1376 : : } else {
1377 [ # # ]: 0 : if (!fixedid)
1378 : 0 : iph->id = htons(id++);
1379 : 0 : tot_len = skb->len - nhoff;
1380 : : }
1381 : 0 : iph->tot_len = htons(tot_len);
1382 : 0 : ip_send_check(iph);
1383 [ # # ]: 0 : if (encap)
1384 : : skb_reset_inner_headers(skb);
1385 : 0 : skb->network_header = (u8 *)iph - skb->head;
1386 : : skb_reset_mac_len(skb);
1387 [ # # ]: 0 : } while ((skb = skb->next));
1388 : :
1389 : : out:
1390 : 0 : return segs;
1391 : : }
1392 : : EXPORT_SYMBOL(inet_gso_segment);
1393 : :
1394 : 0 : static struct sk_buff *ipip_gso_segment(struct sk_buff *skb,
1395 : : netdev_features_t features)
1396 : : {
1397 [ # # ]: 0 : if (!(skb_shinfo(skb)->gso_type & SKB_GSO_IPXIP4))
1398 : : return ERR_PTR(-EINVAL);
1399 : :
1400 : 0 : return inet_gso_segment(skb, features);
1401 : : }
1402 : :
1403 : : INDIRECT_CALLABLE_DECLARE(struct sk_buff *tcp4_gro_receive(struct list_head *,
1404 : : struct sk_buff *));
1405 : : INDIRECT_CALLABLE_DECLARE(struct sk_buff *udp4_gro_receive(struct list_head *,
1406 : : struct sk_buff *));
1407 : 0 : struct sk_buff *inet_gro_receive(struct list_head *head, struct sk_buff *skb)
1408 : : {
1409 : : const struct net_offload *ops;
1410 : : struct sk_buff *pp = NULL;
1411 : : const struct iphdr *iph;
1412 : : struct sk_buff *p;
1413 : : unsigned int hlen;
1414 : : unsigned int off;
1415 : : unsigned int id;
1416 : : int flush = 1;
1417 : : int proto;
1418 : :
1419 : : off = skb_gro_offset(skb);
1420 : 0 : hlen = off + sizeof(*iph);
1421 : : iph = skb_gro_header_fast(skb, off);
1422 [ # # ]: 0 : if (skb_gro_header_hard(skb, hlen)) {
1423 : : iph = skb_gro_header_slow(skb, hlen, off);
1424 [ # # ]: 0 : if (unlikely(!iph))
1425 : : goto out;
1426 : : }
1427 : :
1428 : 0 : proto = iph->protocol;
1429 : :
1430 : : rcu_read_lock();
1431 : 0 : ops = rcu_dereference(inet_offloads[proto]);
1432 [ # # # # ]: 0 : if (!ops || !ops->callbacks.gro_receive)
1433 : : goto out_unlock;
1434 : :
1435 [ # # ]: 0 : if (*(u8 *)iph != 0x45)
1436 : : goto out_unlock;
1437 : :
1438 [ # # ]: 0 : if (ip_is_fragment(iph))
1439 : : goto out_unlock;
1440 : :
1441 [ # # ]: 0 : if (unlikely(ip_fast_csum((u8 *)iph, 5)))
1442 : : goto out_unlock;
1443 : :
1444 : 0 : id = ntohl(*(__be32 *)&iph->id);
1445 : 0 : flush = (u16)((ntohl(*(__be32 *)iph) ^ skb_gro_len(skb)) | (id & ~IP_DF));
1446 : 0 : id >>= 16;
1447 : :
1448 [ # # ]: 0 : list_for_each_entry(p, head, list) {
1449 : : struct iphdr *iph2;
1450 : : u16 flush_id;
1451 : :
1452 [ # # ]: 0 : if (!NAPI_GRO_CB(p)->same_flow)
1453 : 0 : continue;
1454 : :
1455 : 0 : iph2 = (struct iphdr *)(p->data + off);
1456 : : /* The above works because, with the exception of the top
1457 : : * (inner most) layer, we only aggregate pkts with the same
1458 : : * hdr length so all the hdrs we'll need to verify will start
1459 : : * at the same offset.
1460 : : */
1461 [ # # ]: 0 : if ((iph->protocol ^ iph2->protocol) |
1462 : 0 : ((__force u32)iph->saddr ^ (__force u32)iph2->saddr) |
1463 : 0 : ((__force u32)iph->daddr ^ (__force u32)iph2->daddr)) {
1464 : 0 : NAPI_GRO_CB(p)->same_flow = 0;
1465 : 0 : continue;
1466 : : }
1467 : :
1468 : : /* All fields must match except length and checksum. */
1469 : 0 : NAPI_GRO_CB(p)->flush |=
1470 : 0 : (iph->ttl ^ iph2->ttl) |
1471 : 0 : (iph->tos ^ iph2->tos) |
1472 : 0 : ((iph->frag_off ^ iph2->frag_off) & htons(IP_DF));
1473 : :
1474 : 0 : NAPI_GRO_CB(p)->flush |= flush;
1475 : :
1476 : : /* We need to store of the IP ID check to be included later
1477 : : * when we can verify that this packet does in fact belong
1478 : : * to a given flow.
1479 : : */
1480 : 0 : flush_id = (u16)(id - ntohs(iph2->id));
1481 : :
1482 : : /* This bit of code makes it much easier for us to identify
1483 : : * the cases where we are doing atomic vs non-atomic IP ID
1484 : : * checks. Specifically an atomic check can return IP ID
1485 : : * values 0 - 0xFFFF, while a non-atomic check can only
1486 : : * return 0 or 0xFFFF.
1487 : : */
1488 [ # # # # ]: 0 : if (!NAPI_GRO_CB(p)->is_atomic ||
1489 : 0 : !(iph->frag_off & htons(IP_DF))) {
1490 : 0 : flush_id ^= NAPI_GRO_CB(p)->count;
1491 [ # # ]: 0 : flush_id = flush_id ? 0xFFFF : 0;
1492 : : }
1493 : :
1494 : : /* If the previous IP ID value was based on an atomic
1495 : : * datagram we can overwrite the value and ignore it.
1496 : : */
1497 [ # # ]: 0 : if (NAPI_GRO_CB(skb)->is_atomic)
1498 : 0 : NAPI_GRO_CB(p)->flush_id = flush_id;
1499 : : else
1500 : 0 : NAPI_GRO_CB(p)->flush_id |= flush_id;
1501 : : }
1502 : :
1503 : 0 : NAPI_GRO_CB(skb)->is_atomic = !!(iph->frag_off & htons(IP_DF));
1504 : 0 : NAPI_GRO_CB(skb)->flush |= flush;
1505 : : skb_set_network_header(skb, off);
1506 : : /* The above will be needed by the transport layer if there is one
1507 : : * immediately following this IP hdr.
1508 : : */
1509 : :
1510 : : /* Note : No need to call skb_gro_postpull_rcsum() here,
1511 : : * as we already checked checksum over ipv4 header was 0
1512 : : */
1513 : : skb_gro_pull(skb, sizeof(*iph));
1514 : : skb_set_transport_header(skb, skb_gro_offset(skb));
1515 : :
1516 [ # # ]: 0 : pp = indirect_call_gro_receive(tcp4_gro_receive, udp4_gro_receive,
1517 : : ops->callbacks.gro_receive, head, skb);
1518 : :
1519 : : out_unlock:
1520 : : rcu_read_unlock();
1521 : :
1522 : : out:
1523 : : skb_gro_flush_final(skb, pp, flush);
1524 : :
1525 : 0 : return pp;
1526 : : }
1527 : : EXPORT_SYMBOL(inet_gro_receive);
1528 : :
1529 : 0 : static struct sk_buff *ipip_gro_receive(struct list_head *head,
1530 : : struct sk_buff *skb)
1531 : : {
1532 [ # # ]: 0 : if (NAPI_GRO_CB(skb)->encap_mark) {
1533 : 0 : NAPI_GRO_CB(skb)->flush = 1;
1534 : 0 : return NULL;
1535 : : }
1536 : :
1537 : 0 : NAPI_GRO_CB(skb)->encap_mark = 1;
1538 : :
1539 : 0 : return inet_gro_receive(head, skb);
1540 : : }
1541 : :
1542 : : #define SECONDS_PER_DAY 86400
1543 : :
1544 : : /* inet_current_timestamp - Return IP network timestamp
1545 : : *
1546 : : * Return milliseconds since midnight in network byte order.
1547 : : */
1548 : 0 : __be32 inet_current_timestamp(void)
1549 : : {
1550 : : u32 secs;
1551 : : u32 msecs;
1552 : : struct timespec64 ts;
1553 : :
1554 : 0 : ktime_get_real_ts64(&ts);
1555 : :
1556 : : /* Get secs since midnight. */
1557 : 0 : (void)div_u64_rem(ts.tv_sec, SECONDS_PER_DAY, &secs);
1558 : : /* Convert to msecs. */
1559 : 0 : msecs = secs * MSEC_PER_SEC;
1560 : : /* Convert nsec to msec. */
1561 : 0 : msecs += (u32)ts.tv_nsec / NSEC_PER_MSEC;
1562 : :
1563 : : /* Convert to network byte order. */
1564 : 0 : return htonl(msecs);
1565 : : }
1566 : : EXPORT_SYMBOL(inet_current_timestamp);
1567 : :
1568 : 0 : int inet_recv_error(struct sock *sk, struct msghdr *msg, int len, int *addr_len)
1569 : : {
1570 [ # # ]: 0 : if (sk->sk_family == AF_INET)
1571 : 0 : return ip_recv_error(sk, msg, len, addr_len);
1572 : : #if IS_ENABLED(CONFIG_IPV6)
1573 [ # # ]: 0 : if (sk->sk_family == AF_INET6)
1574 : 0 : return pingv6_ops.ipv6_recv_error(sk, msg, len, addr_len);
1575 : : #endif
1576 : : return -EINVAL;
1577 : : }
1578 : :
1579 : : INDIRECT_CALLABLE_DECLARE(int tcp4_gro_complete(struct sk_buff *, int));
1580 : : INDIRECT_CALLABLE_DECLARE(int udp4_gro_complete(struct sk_buff *, int));
1581 : 0 : int inet_gro_complete(struct sk_buff *skb, int nhoff)
1582 : : {
1583 : 0 : __be16 newlen = htons(skb->len - nhoff);
1584 : 0 : struct iphdr *iph = (struct iphdr *)(skb->data + nhoff);
1585 : : const struct net_offload *ops;
1586 : 0 : int proto = iph->protocol;
1587 : : int err = -ENOSYS;
1588 : :
1589 [ # # ]: 0 : if (skb->encapsulation) {
1590 : : skb_set_inner_protocol(skb, cpu_to_be16(ETH_P_IP));
1591 : : skb_set_inner_network_header(skb, nhoff);
1592 : : }
1593 : :
1594 : 0 : csum_replace2(&iph->check, iph->tot_len, newlen);
1595 : 0 : iph->tot_len = newlen;
1596 : :
1597 : : rcu_read_lock();
1598 : 0 : ops = rcu_dereference(inet_offloads[proto]);
1599 [ # # # # : 0 : if (WARN_ON(!ops || !ops->callbacks.gro_complete))
# # # # ]
1600 : : goto out_unlock;
1601 : :
1602 : : /* Only need to add sizeof(*iph) to get to the next hdr below
1603 : : * because any hdr with option will have been flushed in
1604 : : * inet_gro_receive().
1605 : : */
1606 : 0 : err = INDIRECT_CALL_2(ops->callbacks.gro_complete,
1607 : : tcp4_gro_complete, udp4_gro_complete,
1608 : : skb, nhoff + sizeof(*iph));
1609 : :
1610 : : out_unlock:
1611 : : rcu_read_unlock();
1612 : :
1613 : 0 : return err;
1614 : : }
1615 : : EXPORT_SYMBOL(inet_gro_complete);
1616 : :
1617 : 0 : static int ipip_gro_complete(struct sk_buff *skb, int nhoff)
1618 : : {
1619 : 0 : skb->encapsulation = 1;
1620 : 0 : skb_shinfo(skb)->gso_type |= SKB_GSO_IPXIP4;
1621 : 0 : return inet_gro_complete(skb, nhoff);
1622 : : }
1623 : :
1624 : 3519 : int inet_ctl_sock_create(struct sock **sk, unsigned short family,
1625 : : unsigned short type, unsigned char protocol,
1626 : : struct net *net)
1627 : : {
1628 : : struct socket *sock;
1629 : 3519 : int rc = sock_create_kern(net, family, type, protocol, &sock);
1630 : :
1631 [ + - ]: 3519 : if (rc == 0) {
1632 : 3519 : *sk = sock->sk;
1633 : 3519 : (*sk)->sk_allocation = GFP_ATOMIC;
1634 : : /*
1635 : : * Unhash it so that IP input processing does not even see it,
1636 : : * we do not wish this socket to see incoming packets.
1637 : : */
1638 : 3519 : (*sk)->sk_prot->unhash(*sk);
1639 : : }
1640 : 3519 : return rc;
1641 : : }
1642 : : EXPORT_SYMBOL_GPL(inet_ctl_sock_create);
1643 : :
1644 : 0 : u64 snmp_get_cpu_field(void __percpu *mib, int cpu, int offt)
1645 : : {
1646 : 0 : return *(((unsigned long *)per_cpu_ptr(mib, cpu)) + offt);
1647 : : }
1648 : : EXPORT_SYMBOL_GPL(snmp_get_cpu_field);
1649 : :
1650 : 0 : unsigned long snmp_fold_field(void __percpu *mib, int offt)
1651 : : {
1652 : : unsigned long res = 0;
1653 : : int i;
1654 : :
1655 [ # # ]: 0 : for_each_possible_cpu(i)
1656 : 0 : res += snmp_get_cpu_field(mib, i, offt);
1657 : 0 : return res;
1658 : : }
1659 : : EXPORT_SYMBOL_GPL(snmp_fold_field);
1660 : :
1661 : : #if BITS_PER_LONG==32
1662 : :
1663 : 596160 : u64 snmp_get_cpu_field64(void __percpu *mib, int cpu, int offt,
1664 : : size_t syncp_offset)
1665 : : {
1666 : : void *bhptr;
1667 : : struct u64_stats_sync *syncp;
1668 : : u64 v;
1669 : : unsigned int start;
1670 : :
1671 : 596160 : bhptr = per_cpu_ptr(mib, cpu);
1672 : 596160 : syncp = (struct u64_stats_sync *)(bhptr + syncp_offset);
1673 : : do {
1674 : : start = u64_stats_fetch_begin_irq(syncp);
1675 : 596160 : v = *(((u64 *)bhptr) + offt);
1676 [ # # - + ]: 596160 : } while (u64_stats_fetch_retry_irq(syncp, start));
1677 : :
1678 : 596160 : return v;
1679 : : }
1680 : : EXPORT_SYMBOL_GPL(snmp_get_cpu_field64);
1681 : :
1682 : 0 : u64 snmp_fold_field64(void __percpu *mib, int offt, size_t syncp_offset)
1683 : : {
1684 : : u64 res = 0;
1685 : : int cpu;
1686 : :
1687 [ # # ]: 0 : for_each_possible_cpu(cpu) {
1688 : 0 : res += snmp_get_cpu_field64(mib, cpu, offt, syncp_offset);
1689 : : }
1690 : 0 : return res;
1691 : : }
1692 : : EXPORT_SYMBOL_GPL(snmp_fold_field64);
1693 : : #endif
1694 : :
1695 : : #ifdef CONFIG_IP_MULTICAST
1696 : : static const struct net_protocol igmp_protocol = {
1697 : : .handler = igmp_rcv,
1698 : : .netns_ok = 1,
1699 : : };
1700 : : #endif
1701 : :
1702 : : /* thinking of making this const? Don't.
1703 : : * early_demux can change based on sysctl.
1704 : : */
1705 : : static struct net_protocol tcp_protocol = {
1706 : : .early_demux = tcp_v4_early_demux,
1707 : : .early_demux_handler = tcp_v4_early_demux,
1708 : : .handler = tcp_v4_rcv,
1709 : : .err_handler = tcp_v4_err,
1710 : : .no_policy = 1,
1711 : : .netns_ok = 1,
1712 : : .icmp_strict_tag_validation = 1,
1713 : : };
1714 : :
1715 : : /* thinking of making this const? Don't.
1716 : : * early_demux can change based on sysctl.
1717 : : */
1718 : : static struct net_protocol udp_protocol = {
1719 : : .early_demux = udp_v4_early_demux,
1720 : : .early_demux_handler = udp_v4_early_demux,
1721 : : .handler = udp_rcv,
1722 : : .err_handler = udp_err,
1723 : : .no_policy = 1,
1724 : : .netns_ok = 1,
1725 : : };
1726 : :
1727 : : static const struct net_protocol icmp_protocol = {
1728 : : .handler = icmp_rcv,
1729 : : .err_handler = icmp_err,
1730 : : .no_policy = 1,
1731 : : .netns_ok = 1,
1732 : : };
1733 : :
1734 : 207 : static __net_init int ipv4_mib_init_net(struct net *net)
1735 : : {
1736 : : int i;
1737 : :
1738 : 207 : net->mib.tcp_statistics = alloc_percpu(struct tcp_mib);
1739 [ + - ]: 207 : if (!net->mib.tcp_statistics)
1740 : : goto err_tcp_mib;
1741 : 207 : net->mib.ip_statistics = alloc_percpu(struct ipstats_mib);
1742 [ + - ]: 207 : if (!net->mib.ip_statistics)
1743 : : goto err_ip_mib;
1744 : :
1745 [ + + ]: 1035 : for_each_possible_cpu(i) {
1746 : : struct ipstats_mib *af_inet_stats;
1747 : 828 : af_inet_stats = per_cpu_ptr(net->mib.ip_statistics, i);
1748 : : u64_stats_init(&af_inet_stats->syncp);
1749 : : }
1750 : :
1751 : 207 : net->mib.net_statistics = alloc_percpu(struct linux_mib);
1752 [ + - ]: 207 : if (!net->mib.net_statistics)
1753 : : goto err_net_mib;
1754 : 207 : net->mib.udp_statistics = alloc_percpu(struct udp_mib);
1755 [ + - ]: 207 : if (!net->mib.udp_statistics)
1756 : : goto err_udp_mib;
1757 : 207 : net->mib.udplite_statistics = alloc_percpu(struct udp_mib);
1758 [ + - ]: 207 : if (!net->mib.udplite_statistics)
1759 : : goto err_udplite_mib;
1760 : 207 : net->mib.icmp_statistics = alloc_percpu(struct icmp_mib);
1761 [ + - ]: 207 : if (!net->mib.icmp_statistics)
1762 : : goto err_icmp_mib;
1763 : 207 : net->mib.icmpmsg_statistics = kzalloc(sizeof(struct icmpmsg_mib),
1764 : : GFP_KERNEL);
1765 [ + - ]: 207 : if (!net->mib.icmpmsg_statistics)
1766 : : goto err_icmpmsg_mib;
1767 : :
1768 : 207 : tcp_mib_init(net);
1769 : 207 : return 0;
1770 : :
1771 : : err_icmpmsg_mib:
1772 : 0 : free_percpu(net->mib.icmp_statistics);
1773 : : err_icmp_mib:
1774 : 0 : free_percpu(net->mib.udplite_statistics);
1775 : : err_udplite_mib:
1776 : 0 : free_percpu(net->mib.udp_statistics);
1777 : : err_udp_mib:
1778 : 0 : free_percpu(net->mib.net_statistics);
1779 : : err_net_mib:
1780 : 0 : free_percpu(net->mib.ip_statistics);
1781 : : err_ip_mib:
1782 : 0 : free_percpu(net->mib.tcp_statistics);
1783 : : err_tcp_mib:
1784 : : return -ENOMEM;
1785 : : }
1786 : :
1787 : 0 : static __net_exit void ipv4_mib_exit_net(struct net *net)
1788 : : {
1789 : 0 : kfree(net->mib.icmpmsg_statistics);
1790 : 0 : free_percpu(net->mib.icmp_statistics);
1791 : 0 : free_percpu(net->mib.udplite_statistics);
1792 : 0 : free_percpu(net->mib.udp_statistics);
1793 : 0 : free_percpu(net->mib.net_statistics);
1794 : 0 : free_percpu(net->mib.ip_statistics);
1795 : 0 : free_percpu(net->mib.tcp_statistics);
1796 : 0 : }
1797 : :
1798 : : static __net_initdata struct pernet_operations ipv4_mib_ops = {
1799 : : .init = ipv4_mib_init_net,
1800 : : .exit = ipv4_mib_exit_net,
1801 : : };
1802 : :
1803 : 207 : static int __init init_ipv4_mibs(void)
1804 : : {
1805 : 207 : return register_pernet_subsys(&ipv4_mib_ops);
1806 : : }
1807 : :
1808 : 207 : static __net_init int inet_init_net(struct net *net)
1809 : : {
1810 : : /*
1811 : : * Set defaults for local port range
1812 : : */
1813 : 207 : seqlock_init(&net->ipv4.ip_local_ports.lock);
1814 : 207 : net->ipv4.ip_local_ports.range[0] = 32768;
1815 : 207 : net->ipv4.ip_local_ports.range[1] = 60999;
1816 : :
1817 : 207 : seqlock_init(&net->ipv4.ping_group_range.lock);
1818 : : /*
1819 : : * Sane defaults - nobody may create ping sockets.
1820 : : * Boot scripts should set this to distro-specific group.
1821 : : */
1822 : 207 : net->ipv4.ping_group_range.range[0] = make_kgid(&init_user_ns, 1);
1823 : 207 : net->ipv4.ping_group_range.range[1] = make_kgid(&init_user_ns, 0);
1824 : :
1825 : : /* Default values for sysctl-controlled parameters.
1826 : : * We set them here, in case sysctl is not compiled.
1827 : : */
1828 : 207 : net->ipv4.sysctl_ip_default_ttl = IPDEFTTL;
1829 : 207 : net->ipv4.sysctl_ip_fwd_update_priority = 1;
1830 : 207 : net->ipv4.sysctl_ip_dynaddr = 0;
1831 : 207 : net->ipv4.sysctl_ip_early_demux = 1;
1832 : 207 : net->ipv4.sysctl_udp_early_demux = 1;
1833 : 207 : net->ipv4.sysctl_tcp_early_demux = 1;
1834 : : #ifdef CONFIG_SYSCTL
1835 : 207 : net->ipv4.sysctl_ip_prot_sock = PROT_SOCK;
1836 : : #endif
1837 : :
1838 : : /* Some igmp sysctl, whose values are always used */
1839 : 207 : net->ipv4.sysctl_igmp_max_memberships = 20;
1840 : 207 : net->ipv4.sysctl_igmp_max_msf = 10;
1841 : : /* IGMP reports for link-local multicast groups are enabled by default */
1842 : 207 : net->ipv4.sysctl_igmp_llm_reports = 1;
1843 : 207 : net->ipv4.sysctl_igmp_qrv = 2;
1844 : :
1845 : 207 : return 0;
1846 : : }
1847 : :
1848 : : static __net_initdata struct pernet_operations af_inet_ops = {
1849 : : .init = inet_init_net,
1850 : : };
1851 : :
1852 : 207 : static int __init init_inet_pernet_ops(void)
1853 : : {
1854 : 207 : return register_pernet_subsys(&af_inet_ops);
1855 : : }
1856 : :
1857 : : static int ipv4_proc_init(void);
1858 : :
1859 : : /*
1860 : : * IP protocol layer initialiser
1861 : : */
1862 : :
1863 : : static struct packet_offload ip_packet_offload __read_mostly = {
1864 : : .type = cpu_to_be16(ETH_P_IP),
1865 : : .callbacks = {
1866 : : .gso_segment = inet_gso_segment,
1867 : : .gro_receive = inet_gro_receive,
1868 : : .gro_complete = inet_gro_complete,
1869 : : },
1870 : : };
1871 : :
1872 : : static const struct net_offload ipip_offload = {
1873 : : .callbacks = {
1874 : : .gso_segment = ipip_gso_segment,
1875 : : .gro_receive = ipip_gro_receive,
1876 : : .gro_complete = ipip_gro_complete,
1877 : : },
1878 : : };
1879 : :
1880 : 207 : static int __init ipip_offload_init(void)
1881 : : {
1882 : 207 : return inet_add_offload(&ipip_offload, IPPROTO_IPIP);
1883 : : }
1884 : :
1885 : 207 : static int __init ipv4_offload_init(void)
1886 : : {
1887 : : /*
1888 : : * Add offloads
1889 : : */
1890 [ - + ]: 207 : if (udpv4_offload_init() < 0)
1891 : 0 : pr_crit("%s: Cannot add UDP protocol offload\n", __func__);
1892 [ - + ]: 207 : if (tcpv4_offload_init() < 0)
1893 : 0 : pr_crit("%s: Cannot add TCP protocol offload\n", __func__);
1894 [ - + ]: 207 : if (ipip_offload_init() < 0)
1895 : 0 : pr_crit("%s: Cannot add IPIP protocol offload\n", __func__);
1896 : :
1897 : 207 : dev_add_offload(&ip_packet_offload);
1898 : 207 : return 0;
1899 : : }
1900 : :
1901 : : fs_initcall(ipv4_offload_init);
1902 : :
1903 : : static struct packet_type ip_packet_type __read_mostly = {
1904 : : .type = cpu_to_be16(ETH_P_IP),
1905 : : .func = ip_rcv,
1906 : : .list_func = ip_list_rcv,
1907 : : };
1908 : :
1909 : 207 : static int __init inet_init(void)
1910 : : {
1911 : : struct inet_protosw *q;
1912 : : struct list_head *r;
1913 : : int rc = -EINVAL;
1914 : :
1915 : : sock_skb_cb_check_size(sizeof(struct inet_skb_parm));
1916 : :
1917 : 207 : rc = proto_register(&tcp_prot, 1);
1918 [ + - ]: 207 : if (rc)
1919 : : goto out;
1920 : :
1921 : 207 : rc = proto_register(&udp_prot, 1);
1922 [ + - ]: 207 : if (rc)
1923 : : goto out_unregister_tcp_proto;
1924 : :
1925 : 207 : rc = proto_register(&raw_prot, 1);
1926 [ + - ]: 207 : if (rc)
1927 : : goto out_unregister_udp_proto;
1928 : :
1929 : 207 : rc = proto_register(&ping_prot, 1);
1930 [ + - ]: 207 : if (rc)
1931 : : goto out_unregister_raw_proto;
1932 : :
1933 : : /*
1934 : : * Tell SOCKET that we are alive...
1935 : : */
1936 : :
1937 : 207 : (void)sock_register(&inet_family_ops);
1938 : :
1939 : : #ifdef CONFIG_SYSCTL
1940 : 207 : ip_static_sysctl_init();
1941 : : #endif
1942 : :
1943 : : /*
1944 : : * Add all the base protocols.
1945 : : */
1946 : :
1947 [ - + ]: 207 : if (inet_add_protocol(&icmp_protocol, IPPROTO_ICMP) < 0)
1948 : 0 : pr_crit("%s: Cannot add ICMP protocol\n", __func__);
1949 [ - + ]: 207 : if (inet_add_protocol(&udp_protocol, IPPROTO_UDP) < 0)
1950 : 0 : pr_crit("%s: Cannot add UDP protocol\n", __func__);
1951 [ - + ]: 207 : if (inet_add_protocol(&tcp_protocol, IPPROTO_TCP) < 0)
1952 : 0 : pr_crit("%s: Cannot add TCP protocol\n", __func__);
1953 : : #ifdef CONFIG_IP_MULTICAST
1954 [ - + ]: 207 : if (inet_add_protocol(&igmp_protocol, IPPROTO_IGMP) < 0)
1955 : 0 : pr_crit("%s: Cannot add IGMP protocol\n", __func__);
1956 : : #endif
1957 : :
1958 : : /* Register the socket-side information for inet_create. */
1959 [ + + ]: 2277 : for (r = &inetsw[0]; r < &inetsw[SOCK_MAX]; ++r)
1960 : : INIT_LIST_HEAD(r);
1961 : :
1962 [ + + ]: 828 : for (q = inetsw_array; q < &inetsw_array[INETSW_ARRAY_LEN]; ++q)
1963 : 828 : inet_register_protosw(q);
1964 : :
1965 : : /*
1966 : : * Set the ARP module up
1967 : : */
1968 : :
1969 : 207 : arp_init();
1970 : :
1971 : : /*
1972 : : * Set the IP module up
1973 : : */
1974 : :
1975 : 207 : ip_init();
1976 : :
1977 : : /* Setup TCP slab cache for open requests. */
1978 : 207 : tcp_init();
1979 : :
1980 : : /* Setup UDP memory threshold */
1981 : 207 : udp_init();
1982 : :
1983 : : /* Add UDP-Lite (RFC 3828) */
1984 : 207 : udplite4_register();
1985 : :
1986 : 207 : raw_init();
1987 : :
1988 : 207 : ping_init();
1989 : :
1990 : : /*
1991 : : * Set the ICMP layer up
1992 : : */
1993 : :
1994 [ - + ]: 207 : if (icmp_init() < 0)
1995 : 0 : panic("Failed to create the ICMP control socket.\n");
1996 : :
1997 : : /*
1998 : : * Initialise the multicast router
1999 : : */
2000 : : #if defined(CONFIG_IP_MROUTE)
2001 [ - + ]: 207 : if (ip_mr_init())
2002 : 0 : pr_crit("%s: Cannot init ipv4 mroute\n", __func__);
2003 : : #endif
2004 : :
2005 [ - + ]: 207 : if (init_inet_pernet_ops())
2006 : 0 : pr_crit("%s: Cannot init ipv4 inet pernet ops\n", __func__);
2007 : : /*
2008 : : * Initialise per-cpu ipv4 mibs
2009 : : */
2010 : :
2011 [ - + ]: 207 : if (init_ipv4_mibs())
2012 : 0 : pr_crit("%s: Cannot init ipv4 mibs\n", __func__);
2013 : :
2014 : 207 : ipv4_proc_init();
2015 : :
2016 : 207 : ipfrag_init();
2017 : :
2018 : 207 : dev_add_pack(&ip_packet_type);
2019 : :
2020 : 207 : ip_tunnel_core_init();
2021 : :
2022 : : rc = 0;
2023 : : out:
2024 : 207 : return rc;
2025 : : out_unregister_raw_proto:
2026 : 0 : proto_unregister(&raw_prot);
2027 : : out_unregister_udp_proto:
2028 : 0 : proto_unregister(&udp_prot);
2029 : : out_unregister_tcp_proto:
2030 : 0 : proto_unregister(&tcp_prot);
2031 : 0 : goto out;
2032 : : }
2033 : :
2034 : : fs_initcall(inet_init);
2035 : :
2036 : : /* ------------------------------------------------------------------------ */
2037 : :
2038 : : #ifdef CONFIG_PROC_FS
2039 : 207 : static int __init ipv4_proc_init(void)
2040 : : {
2041 : : int rc = 0;
2042 : :
2043 [ + - ]: 207 : if (raw_proc_init())
2044 : : goto out_raw;
2045 [ + - ]: 207 : if (tcp4_proc_init())
2046 : : goto out_tcp;
2047 [ + - ]: 207 : if (udp4_proc_init())
2048 : : goto out_udp;
2049 [ + - ]: 207 : if (ping_proc_init())
2050 : : goto out_ping;
2051 [ + - ]: 207 : if (ip_misc_proc_init())
2052 : : goto out_misc;
2053 : : out:
2054 : 207 : return rc;
2055 : : out_misc:
2056 : 0 : ping_proc_exit();
2057 : : out_ping:
2058 : 0 : udp4_proc_exit();
2059 : : out_udp:
2060 : 0 : tcp4_proc_exit();
2061 : : out_tcp:
2062 : 0 : raw_proc_exit();
2063 : : out_raw:
2064 : : rc = -ENOMEM;
2065 : : goto out;
2066 : : }
2067 : :
2068 : : #else /* CONFIG_PROC_FS */
2069 : : static int __init ipv4_proc_init(void)
2070 : : {
2071 : : return 0;
2072 : : }
2073 : : #endif /* CONFIG_PROC_FS */
|
