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