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 : : * Implementation of the Transmission Control Protocol(TCP).
8 : : *
9 : : * IPv4 specific functions
10 : : *
11 : : * code split from:
12 : : * linux/ipv4/tcp.c
13 : : * linux/ipv4/tcp_input.c
14 : : * linux/ipv4/tcp_output.c
15 : : *
16 : : * See tcp.c for author information
17 : : */
18 : :
19 : : /*
20 : : * Changes:
21 : : * David S. Miller : New socket lookup architecture.
22 : : * This code is dedicated to John Dyson.
23 : : * David S. Miller : Change semantics of established hash,
24 : : * half is devoted to TIME_WAIT sockets
25 : : * and the rest go in the other half.
26 : : * Andi Kleen : Add support for syncookies and fixed
27 : : * some bugs: ip options weren't passed to
28 : : * the TCP layer, missed a check for an
29 : : * ACK bit.
30 : : * Andi Kleen : Implemented fast path mtu discovery.
31 : : * Fixed many serious bugs in the
32 : : * request_sock handling and moved
33 : : * most of it into the af independent code.
34 : : * Added tail drop and some other bugfixes.
35 : : * Added new listen semantics.
36 : : * Mike McLagan : Routing by source
37 : : * Juan Jose Ciarlante: ip_dynaddr bits
38 : : * Andi Kleen: various fixes.
39 : : * Vitaly E. Lavrov : Transparent proxy revived after year
40 : : * coma.
41 : : * Andi Kleen : Fix new listen.
42 : : * Andi Kleen : Fix accept error reporting.
43 : : * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which
44 : : * Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind
45 : : * a single port at the same time.
46 : : */
47 : :
48 : : #define pr_fmt(fmt) "TCP: " fmt
49 : :
50 : : #include <linux/bottom_half.h>
51 : : #include <linux/types.h>
52 : : #include <linux/fcntl.h>
53 : : #include <linux/module.h>
54 : : #include <linux/random.h>
55 : : #include <linux/cache.h>
56 : : #include <linux/jhash.h>
57 : : #include <linux/init.h>
58 : : #include <linux/times.h>
59 : : #include <linux/slab.h>
60 : :
61 : : #include <net/net_namespace.h>
62 : : #include <net/icmp.h>
63 : : #include <net/inet_hashtables.h>
64 : : #include <net/tcp.h>
65 : : #include <net/transp_v6.h>
66 : : #include <net/ipv6.h>
67 : : #include <net/inet_common.h>
68 : : #include <net/timewait_sock.h>
69 : : #include <net/xfrm.h>
70 : : #include <net/secure_seq.h>
71 : : #include <net/busy_poll.h>
72 : :
73 : : #include <linux/inet.h>
74 : : #include <linux/ipv6.h>
75 : : #include <linux/stddef.h>
76 : : #include <linux/proc_fs.h>
77 : : #include <linux/seq_file.h>
78 : : #include <linux/inetdevice.h>
79 : :
80 : : #include <crypto/hash.h>
81 : : #include <linux/scatterlist.h>
82 : :
83 : : #include <trace/events/tcp.h>
84 : :
85 : : #ifdef CONFIG_TCP_MD5SIG
86 : : static int tcp_v4_md5_hash_hdr(char *md5_hash, const struct tcp_md5sig_key *key,
87 : : __be32 daddr, __be32 saddr, const struct tcphdr *th);
88 : : #endif
89 : :
90 : : struct inet_hashinfo tcp_hashinfo;
91 : : EXPORT_SYMBOL(tcp_hashinfo);
92 : :
93 : 0 : static u32 tcp_v4_init_seq(const struct sk_buff *skb)
94 : : {
95 : 0 : return secure_tcp_seq(ip_hdr(skb)->daddr,
96 : : ip_hdr(skb)->saddr,
97 : : tcp_hdr(skb)->dest,
98 : : tcp_hdr(skb)->source);
99 : : }
100 : :
101 : 0 : static u32 tcp_v4_init_ts_off(const struct net *net, const struct sk_buff *skb)
102 : : {
103 : 0 : return secure_tcp_ts_off(net, ip_hdr(skb)->daddr, ip_hdr(skb)->saddr);
104 : : }
105 : :
106 : 0 : int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp)
107 : : {
108 : : const struct inet_timewait_sock *tw = inet_twsk(sktw);
109 : : const struct tcp_timewait_sock *tcptw = tcp_twsk(sktw);
110 : : struct tcp_sock *tp = tcp_sk(sk);
111 : 0 : int reuse = sock_net(sk)->ipv4.sysctl_tcp_tw_reuse;
112 : :
113 : 0 : if (reuse == 2) {
114 : : /* Still does not detect *everything* that goes through
115 : : * lo, since we require a loopback src or dst address
116 : : * or direct binding to 'lo' interface.
117 : : */
118 : : bool loopback = false;
119 : 0 : if (tw->tw_bound_dev_if == LOOPBACK_IFINDEX)
120 : : loopback = true;
121 : : #if IS_ENABLED(CONFIG_IPV6)
122 : 0 : if (tw->tw_family == AF_INET6) {
123 : 0 : if (ipv6_addr_loopback(&tw->tw_v6_daddr) ||
124 : 0 : (ipv6_addr_v4mapped(&tw->tw_v6_daddr) &&
125 : 0 : (tw->tw_v6_daddr.s6_addr[12] == 127)) ||
126 : 0 : ipv6_addr_loopback(&tw->tw_v6_rcv_saddr) ||
127 : 0 : (ipv6_addr_v4mapped(&tw->tw_v6_rcv_saddr) &&
128 : 0 : (tw->tw_v6_rcv_saddr.s6_addr[12] == 127)))
129 : : loopback = true;
130 : : } else
131 : : #endif
132 : : {
133 : 0 : if (ipv4_is_loopback(tw->tw_daddr) ||
134 : 0 : ipv4_is_loopback(tw->tw_rcv_saddr))
135 : : loopback = true;
136 : : }
137 : 0 : if (!loopback)
138 : : reuse = 0;
139 : : }
140 : :
141 : : /* With PAWS, it is safe from the viewpoint
142 : : of data integrity. Even without PAWS it is safe provided sequence
143 : : spaces do not overlap i.e. at data rates <= 80Mbit/sec.
144 : :
145 : : Actually, the idea is close to VJ's one, only timestamp cache is
146 : : held not per host, but per port pair and TW bucket is used as state
147 : : holder.
148 : :
149 : : If TW bucket has been already destroyed we fall back to VJ's scheme
150 : : and use initial timestamp retrieved from peer table.
151 : : */
152 : 0 : if (tcptw->tw_ts_recent_stamp &&
153 : 0 : (!twp || (reuse && time_after32(ktime_get_seconds(),
154 : : tcptw->tw_ts_recent_stamp)))) {
155 : : /* In case of repair and re-using TIME-WAIT sockets we still
156 : : * want to be sure that it is safe as above but honor the
157 : : * sequence numbers and time stamps set as part of the repair
158 : : * process.
159 : : *
160 : : * Without this check re-using a TIME-WAIT socket with TCP
161 : : * repair would accumulate a -1 on the repair assigned
162 : : * sequence number. The first time it is reused the sequence
163 : : * is -1, the second time -2, etc. This fixes that issue
164 : : * without appearing to create any others.
165 : : */
166 : 0 : if (likely(!tp->repair)) {
167 : 0 : u32 seq = tcptw->tw_snd_nxt + 65535 + 2;
168 : :
169 : 0 : if (!seq)
170 : : seq = 1;
171 : : WRITE_ONCE(tp->write_seq, seq);
172 : 0 : tp->rx_opt.ts_recent = tcptw->tw_ts_recent;
173 : 0 : tp->rx_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp;
174 : : }
175 : : sock_hold(sktw);
176 : 0 : return 1;
177 : : }
178 : :
179 : : return 0;
180 : : }
181 : : EXPORT_SYMBOL_GPL(tcp_twsk_unique);
182 : :
183 : 1 : static int tcp_v4_pre_connect(struct sock *sk, struct sockaddr *uaddr,
184 : : int addr_len)
185 : : {
186 : : /* This check is replicated from tcp_v4_connect() and intended to
187 : : * prevent BPF program called below from accessing bytes that are out
188 : : * of the bound specified by user in addr_len.
189 : : */
190 : 1 : if (addr_len < sizeof(struct sockaddr_in))
191 : : return -EINVAL;
192 : :
193 : : sock_owned_by_me(sk);
194 : :
195 : 1 : return BPF_CGROUP_RUN_PROG_INET4_CONNECT(sk, uaddr);
196 : : }
197 : :
198 : : /* This will initiate an outgoing connection. */
199 : 1 : int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
200 : : {
201 : : struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
202 : : struct inet_sock *inet = inet_sk(sk);
203 : : struct tcp_sock *tp = tcp_sk(sk);
204 : : __be16 orig_sport, orig_dport;
205 : : __be32 daddr, nexthop;
206 : : struct flowi4 *fl4;
207 : : struct rtable *rt;
208 : : int err;
209 : : struct ip_options_rcu *inet_opt;
210 : 1 : struct inet_timewait_death_row *tcp_death_row = &sock_net(sk)->ipv4.tcp_death_row;
211 : :
212 : 1 : if (addr_len < sizeof(struct sockaddr_in))
213 : : return -EINVAL;
214 : :
215 : 1 : if (usin->sin_family != AF_INET)
216 : : return -EAFNOSUPPORT;
217 : :
218 : 1 : nexthop = daddr = usin->sin_addr.s_addr;
219 : 1 : inet_opt = rcu_dereference_protected(inet->inet_opt,
220 : : lockdep_sock_is_held(sk));
221 : 1 : if (inet_opt && inet_opt->opt.srr) {
222 : 0 : if (!daddr)
223 : : return -EINVAL;
224 : 0 : nexthop = inet_opt->opt.faddr;
225 : : }
226 : :
227 : 1 : orig_sport = inet->inet_sport;
228 : 1 : orig_dport = usin->sin_port;
229 : 1 : fl4 = &inet->cork.fl.u.ip4;
230 : 1 : rt = ip_route_connect(fl4, nexthop, inet->inet_saddr,
231 : 1 : RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
232 : : IPPROTO_TCP,
233 : : orig_sport, orig_dport, sk);
234 : 1 : if (IS_ERR(rt)) {
235 : 0 : err = PTR_ERR(rt);
236 : 0 : if (err == -ENETUNREACH)
237 : 0 : IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTNOROUTES);
238 : 0 : return err;
239 : : }
240 : :
241 : 1 : if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
242 : : ip_rt_put(rt);
243 : 0 : return -ENETUNREACH;
244 : : }
245 : :
246 : 1 : if (!inet_opt || !inet_opt->opt.srr)
247 : 1 : daddr = fl4->daddr;
248 : :
249 : 1 : if (!inet->inet_saddr)
250 : 1 : inet->inet_saddr = fl4->saddr;
251 : 1 : sk_rcv_saddr_set(sk, inet->inet_saddr);
252 : :
253 : 1 : if (tp->rx_opt.ts_recent_stamp && inet->inet_daddr != daddr) {
254 : : /* Reset inherited state */
255 : 0 : tp->rx_opt.ts_recent = 0;
256 : 0 : tp->rx_opt.ts_recent_stamp = 0;
257 : 0 : if (likely(!tp->repair))
258 : : WRITE_ONCE(tp->write_seq, 0);
259 : : }
260 : :
261 : 1 : inet->inet_dport = usin->sin_port;
262 : : sk_daddr_set(sk, daddr);
263 : :
264 : 1 : inet_csk(sk)->icsk_ext_hdr_len = 0;
265 : 1 : if (inet_opt)
266 : 0 : inet_csk(sk)->icsk_ext_hdr_len = inet_opt->opt.optlen;
267 : :
268 : 1 : tp->rx_opt.mss_clamp = TCP_MSS_DEFAULT;
269 : :
270 : : /* Socket identity is still unknown (sport may be zero).
271 : : * However we set state to SYN-SENT and not releasing socket
272 : : * lock select source port, enter ourselves into the hash tables and
273 : : * complete initialization after this.
274 : : */
275 : 1 : tcp_set_state(sk, TCP_SYN_SENT);
276 : 1 : err = inet_hash_connect(tcp_death_row, sk);
277 : 1 : if (err)
278 : : goto failure;
279 : :
280 : : sk_set_txhash(sk);
281 : :
282 : 1 : rt = ip_route_newports(fl4, rt, orig_sport, orig_dport,
283 : : inet->inet_sport, inet->inet_dport, sk);
284 : 1 : if (IS_ERR(rt)) {
285 : 0 : err = PTR_ERR(rt);
286 : : rt = NULL;
287 : 0 : goto failure;
288 : : }
289 : : /* OK, now commit destination to socket. */
290 : 1 : sk->sk_gso_type = SKB_GSO_TCPV4;
291 : 1 : sk_setup_caps(sk, &rt->dst);
292 : : rt = NULL;
293 : :
294 : 1 : if (likely(!tp->repair)) {
295 : 1 : if (!tp->write_seq)
296 : 1 : WRITE_ONCE(tp->write_seq,
297 : : secure_tcp_seq(inet->inet_saddr,
298 : : inet->inet_daddr,
299 : : inet->inet_sport,
300 : : usin->sin_port));
301 : 1 : tp->tsoffset = secure_tcp_ts_off(sock_net(sk),
302 : : inet->inet_saddr,
303 : : inet->inet_daddr);
304 : : }
305 : :
306 : 1 : inet->inet_id = prandom_u32();
307 : :
308 : 1 : if (tcp_fastopen_defer_connect(sk, &err))
309 : 0 : return err;
310 : 1 : if (err)
311 : : goto failure;
312 : :
313 : 1 : err = tcp_connect(sk);
314 : :
315 : 1 : if (err)
316 : : goto failure;
317 : :
318 : : return 0;
319 : :
320 : : failure:
321 : : /*
322 : : * This unhashes the socket and releases the local port,
323 : : * if necessary.
324 : : */
325 : 0 : tcp_set_state(sk, TCP_CLOSE);
326 : : ip_rt_put(rt);
327 : 0 : sk->sk_route_caps = 0;
328 : 0 : inet->inet_dport = 0;
329 : 0 : return err;
330 : : }
331 : : EXPORT_SYMBOL(tcp_v4_connect);
332 : :
333 : : /*
334 : : * This routine reacts to ICMP_FRAG_NEEDED mtu indications as defined in RFC1191.
335 : : * It can be called through tcp_release_cb() if socket was owned by user
336 : : * at the time tcp_v4_err() was called to handle ICMP message.
337 : : */
338 : 0 : void tcp_v4_mtu_reduced(struct sock *sk)
339 : : {
340 : : struct inet_sock *inet = inet_sk(sk);
341 : : struct dst_entry *dst;
342 : : u32 mtu;
343 : :
344 : 0 : if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
345 : : return;
346 : 0 : mtu = tcp_sk(sk)->mtu_info;
347 : 0 : dst = inet_csk_update_pmtu(sk, mtu);
348 : 0 : if (!dst)
349 : : return;
350 : :
351 : : /* Something is about to be wrong... Remember soft error
352 : : * for the case, if this connection will not able to recover.
353 : : */
354 : 0 : if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
355 : 0 : sk->sk_err_soft = EMSGSIZE;
356 : :
357 : : mtu = dst_mtu(dst);
358 : :
359 : 0 : if (inet->pmtudisc != IP_PMTUDISC_DONT &&
360 : 0 : ip_sk_accept_pmtu(sk) &&
361 : 0 : inet_csk(sk)->icsk_pmtu_cookie > mtu) {
362 : 0 : tcp_sync_mss(sk, mtu);
363 : :
364 : : /* Resend the TCP packet because it's
365 : : * clear that the old packet has been
366 : : * dropped. This is the new "fast" path mtu
367 : : * discovery.
368 : : */
369 : 0 : tcp_simple_retransmit(sk);
370 : : } /* else let the usual retransmit timer handle it */
371 : : }
372 : : EXPORT_SYMBOL(tcp_v4_mtu_reduced);
373 : :
374 : 0 : static void do_redirect(struct sk_buff *skb, struct sock *sk)
375 : : {
376 : 0 : struct dst_entry *dst = __sk_dst_check(sk, 0);
377 : :
378 : 0 : if (dst)
379 : 0 : dst->ops->redirect(dst, sk, skb);
380 : 0 : }
381 : :
382 : :
383 : : /* handle ICMP messages on TCP_NEW_SYN_RECV request sockets */
384 : 0 : void tcp_req_err(struct sock *sk, u32 seq, bool abort)
385 : : {
386 : : struct request_sock *req = inet_reqsk(sk);
387 : : struct net *net = sock_net(sk);
388 : :
389 : : /* ICMPs are not backlogged, hence we cannot get
390 : : * an established socket here.
391 : : */
392 : 0 : if (seq != tcp_rsk(req)->snt_isn) {
393 : 0 : __NET_INC_STATS(net, LINUX_MIB_OUTOFWINDOWICMPS);
394 : 0 : } else if (abort) {
395 : : /*
396 : : * Still in SYN_RECV, just remove it silently.
397 : : * There is no good way to pass the error to the newly
398 : : * created socket, and POSIX does not want network
399 : : * errors returned from accept().
400 : : */
401 : 0 : inet_csk_reqsk_queue_drop(req->rsk_listener, req);
402 : 0 : tcp_listendrop(req->rsk_listener);
403 : : }
404 : 0 : reqsk_put(req);
405 : 0 : }
406 : : EXPORT_SYMBOL(tcp_req_err);
407 : :
408 : : /*
409 : : * This routine is called by the ICMP module when it gets some
410 : : * sort of error condition. If err < 0 then the socket should
411 : : * be closed and the error returned to the user. If err > 0
412 : : * it's just the icmp type << 8 | icmp code. After adjustment
413 : : * header points to the first 8 bytes of the tcp header. We need
414 : : * to find the appropriate port.
415 : : *
416 : : * The locking strategy used here is very "optimistic". When
417 : : * someone else accesses the socket the ICMP is just dropped
418 : : * and for some paths there is no check at all.
419 : : * A more general error queue to queue errors for later handling
420 : : * is probably better.
421 : : *
422 : : */
423 : :
424 : 0 : int tcp_v4_err(struct sk_buff *icmp_skb, u32 info)
425 : : {
426 : 0 : const struct iphdr *iph = (const struct iphdr *)icmp_skb->data;
427 : 0 : struct tcphdr *th = (struct tcphdr *)(icmp_skb->data + (iph->ihl << 2));
428 : : struct inet_connection_sock *icsk;
429 : : struct tcp_sock *tp;
430 : : struct inet_sock *inet;
431 : 0 : const int type = icmp_hdr(icmp_skb)->type;
432 : 0 : const int code = icmp_hdr(icmp_skb)->code;
433 : : struct sock *sk;
434 : : struct sk_buff *skb;
435 : : struct request_sock *fastopen;
436 : : u32 seq, snd_una;
437 : : s32 remaining;
438 : : u32 delta_us;
439 : : int err;
440 : 0 : struct net *net = dev_net(icmp_skb->dev);
441 : :
442 : 0 : sk = __inet_lookup_established(net, &tcp_hashinfo, iph->daddr,
443 : : th->dest, iph->saddr, ntohs(th->source),
444 : : inet_iif(icmp_skb), 0);
445 : 0 : if (!sk) {
446 : 0 : __ICMP_INC_STATS(net, ICMP_MIB_INERRORS);
447 : 0 : return -ENOENT;
448 : : }
449 : 0 : if (sk->sk_state == TCP_TIME_WAIT) {
450 : 0 : inet_twsk_put(inet_twsk(sk));
451 : 0 : return 0;
452 : : }
453 : 0 : seq = ntohl(th->seq);
454 : 0 : if (sk->sk_state == TCP_NEW_SYN_RECV) {
455 : 0 : tcp_req_err(sk, seq, type == ICMP_PARAMETERPROB ||
456 : 0 : type == ICMP_TIME_EXCEEDED ||
457 : 0 : (type == ICMP_DEST_UNREACH &&
458 : 0 : (code == ICMP_NET_UNREACH ||
459 : : code == ICMP_HOST_UNREACH)));
460 : 0 : return 0;
461 : : }
462 : :
463 : : bh_lock_sock(sk);
464 : : /* If too many ICMPs get dropped on busy
465 : : * servers this needs to be solved differently.
466 : : * We do take care of PMTU discovery (RFC1191) special case :
467 : : * we can receive locally generated ICMP messages while socket is held.
468 : : */
469 : 0 : if (sock_owned_by_user(sk)) {
470 : 0 : if (!(type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED))
471 : 0 : __NET_INC_STATS(net, LINUX_MIB_LOCKDROPPEDICMPS);
472 : : }
473 : 0 : if (sk->sk_state == TCP_CLOSE)
474 : : goto out;
475 : :
476 : 0 : if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
477 : 0 : __NET_INC_STATS(net, LINUX_MIB_TCPMINTTLDROP);
478 : : goto out;
479 : : }
480 : :
481 : : icsk = inet_csk(sk);
482 : : tp = tcp_sk(sk);
483 : : /* XXX (TFO) - tp->snd_una should be ISN (tcp_create_openreq_child() */
484 : 0 : fastopen = rcu_dereference(tp->fastopen_rsk);
485 : 0 : snd_una = fastopen ? tcp_rsk(fastopen)->snt_isn : tp->snd_una;
486 : 0 : if (sk->sk_state != TCP_LISTEN &&
487 : 0 : !between(seq, snd_una, tp->snd_nxt)) {
488 : 0 : __NET_INC_STATS(net, LINUX_MIB_OUTOFWINDOWICMPS);
489 : : goto out;
490 : : }
491 : :
492 : 0 : switch (type) {
493 : : case ICMP_REDIRECT:
494 : 0 : if (!sock_owned_by_user(sk))
495 : 0 : do_redirect(icmp_skb, sk);
496 : : goto out;
497 : : case ICMP_SOURCE_QUENCH:
498 : : /* Just silently ignore these. */
499 : : goto out;
500 : : case ICMP_PARAMETERPROB:
501 : : err = EPROTO;
502 : : break;
503 : : case ICMP_DEST_UNREACH:
504 : 0 : if (code > NR_ICMP_UNREACH)
505 : : goto out;
506 : :
507 : 0 : if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
508 : : /* We are not interested in TCP_LISTEN and open_requests
509 : : * (SYN-ACKs send out by Linux are always <576bytes so
510 : : * they should go through unfragmented).
511 : : */
512 : 0 : if (sk->sk_state == TCP_LISTEN)
513 : : goto out;
514 : :
515 : 0 : tp->mtu_info = info;
516 : 0 : if (!sock_owned_by_user(sk)) {
517 : 0 : tcp_v4_mtu_reduced(sk);
518 : : } else {
519 : 0 : if (!test_and_set_bit(TCP_MTU_REDUCED_DEFERRED, &sk->sk_tsq_flags))
520 : : sock_hold(sk);
521 : : }
522 : : goto out;
523 : : }
524 : :
525 : 0 : err = icmp_err_convert[code].errno;
526 : : /* check if icmp_skb allows revert of backoff
527 : : * (see draft-zimmermann-tcp-lcd) */
528 : 0 : if (code != ICMP_NET_UNREACH && code != ICMP_HOST_UNREACH)
529 : : break;
530 : 0 : if (seq != tp->snd_una || !icsk->icsk_retransmits ||
531 : 0 : !icsk->icsk_backoff || fastopen)
532 : : break;
533 : :
534 : 0 : if (sock_owned_by_user(sk))
535 : : break;
536 : :
537 : : skb = tcp_rtx_queue_head(sk);
538 : 0 : if (WARN_ON_ONCE(!skb))
539 : : break;
540 : :
541 : 0 : icsk->icsk_backoff--;
542 : 0 : icsk->icsk_rto = tp->srtt_us ? __tcp_set_rto(tp) :
543 : : TCP_TIMEOUT_INIT;
544 : 0 : icsk->icsk_rto = inet_csk_rto_backoff(icsk, TCP_RTO_MAX);
545 : :
546 : :
547 : 0 : tcp_mstamp_refresh(tp);
548 : 0 : delta_us = (u32)(tp->tcp_mstamp - tcp_skb_timestamp_us(skb));
549 : 0 : remaining = icsk->icsk_rto -
550 : : usecs_to_jiffies(delta_us);
551 : :
552 : 0 : if (remaining > 0) {
553 : 0 : inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
554 : : remaining, TCP_RTO_MAX);
555 : : } else {
556 : : /* RTO revert clocked out retransmission.
557 : : * Will retransmit now */
558 : 0 : tcp_retransmit_timer(sk);
559 : : }
560 : :
561 : : break;
562 : : case ICMP_TIME_EXCEEDED:
563 : : err = EHOSTUNREACH;
564 : 0 : break;
565 : : default:
566 : : goto out;
567 : : }
568 : :
569 : 0 : switch (sk->sk_state) {
570 : : case TCP_SYN_SENT:
571 : : case TCP_SYN_RECV:
572 : : /* Only in fast or simultaneous open. If a fast open socket is
573 : : * is already accepted it is treated as a connected one below.
574 : : */
575 : 0 : if (fastopen && !fastopen->sk)
576 : : break;
577 : :
578 : 0 : if (!sock_owned_by_user(sk)) {
579 : 0 : sk->sk_err = err;
580 : :
581 : 0 : sk->sk_error_report(sk);
582 : :
583 : 0 : tcp_done(sk);
584 : : } else {
585 : 0 : sk->sk_err_soft = err;
586 : : }
587 : : goto out;
588 : : }
589 : :
590 : : /* If we've already connected we will keep trying
591 : : * until we time out, or the user gives up.
592 : : *
593 : : * rfc1122 4.2.3.9 allows to consider as hard errors
594 : : * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
595 : : * but it is obsoleted by pmtu discovery).
596 : : *
597 : : * Note, that in modern internet, where routing is unreliable
598 : : * and in each dark corner broken firewalls sit, sending random
599 : : * errors ordered by their masters even this two messages finally lose
600 : : * their original sense (even Linux sends invalid PORT_UNREACHs)
601 : : *
602 : : * Now we are in compliance with RFCs.
603 : : * --ANK (980905)
604 : : */
605 : :
606 : : inet = inet_sk(sk);
607 : 0 : if (!sock_owned_by_user(sk) && inet->recverr) {
608 : 0 : sk->sk_err = err;
609 : 0 : sk->sk_error_report(sk);
610 : : } else { /* Only an error on timeout */
611 : 0 : sk->sk_err_soft = err;
612 : : }
613 : :
614 : : out:
615 : : bh_unlock_sock(sk);
616 : 0 : sock_put(sk);
617 : 0 : return 0;
618 : : }
619 : :
620 : 1 : void __tcp_v4_send_check(struct sk_buff *skb, __be32 saddr, __be32 daddr)
621 : : {
622 : : struct tcphdr *th = tcp_hdr(skb);
623 : :
624 : 1 : th->check = ~tcp_v4_check(skb->len, saddr, daddr, 0);
625 : 1 : skb->csum_start = skb_transport_header(skb) - skb->head;
626 : 1 : skb->csum_offset = offsetof(struct tcphdr, check);
627 : 1 : }
628 : :
629 : : /* This routine computes an IPv4 TCP checksum. */
630 : 1 : void tcp_v4_send_check(struct sock *sk, struct sk_buff *skb)
631 : : {
632 : : const struct inet_sock *inet = inet_sk(sk);
633 : :
634 : 1 : __tcp_v4_send_check(skb, inet->inet_saddr, inet->inet_daddr);
635 : 1 : }
636 : : EXPORT_SYMBOL(tcp_v4_send_check);
637 : :
638 : : /*
639 : : * This routine will send an RST to the other tcp.
640 : : *
641 : : * Someone asks: why I NEVER use socket parameters (TOS, TTL etc.)
642 : : * for reset.
643 : : * Answer: if a packet caused RST, it is not for a socket
644 : : * existing in our system, if it is matched to a socket,
645 : : * it is just duplicate segment or bug in other side's TCP.
646 : : * So that we build reply only basing on parameters
647 : : * arrived with segment.
648 : : * Exception: precedence violation. We do not implement it in any case.
649 : : */
650 : :
651 : 3 : static void tcp_v4_send_reset(const struct sock *sk, struct sk_buff *skb)
652 : : {
653 : : const struct tcphdr *th = tcp_hdr(skb);
654 : : struct {
655 : : struct tcphdr th;
656 : : #ifdef CONFIG_TCP_MD5SIG
657 : : __be32 opt[(TCPOLEN_MD5SIG_ALIGNED >> 2)];
658 : : #endif
659 : : } rep;
660 : : struct ip_reply_arg arg;
661 : : #ifdef CONFIG_TCP_MD5SIG
662 : : struct tcp_md5sig_key *key = NULL;
663 : : const __u8 *hash_location = NULL;
664 : : unsigned char newhash[16];
665 : : int genhash;
666 : : struct sock *sk1 = NULL;
667 : : #endif
668 : : u64 transmit_time = 0;
669 : : struct sock *ctl_sk;
670 : : struct net *net;
671 : :
672 : : /* Never send a reset in response to a reset. */
673 : 3 : if (th->rst)
674 : 1 : return;
675 : :
676 : : /* If sk not NULL, it means we did a successful lookup and incoming
677 : : * route had to be correct. prequeue might have dropped our dst.
678 : : */
679 : 3 : if (!sk && skb_rtable(skb)->rt_type != RTN_LOCAL)
680 : : return;
681 : :
682 : : /* Swap the send and the receive. */
683 : 3 : memset(&rep, 0, sizeof(rep));
684 : 3 : rep.th.dest = th->source;
685 : 3 : rep.th.source = th->dest;
686 : 3 : rep.th.doff = sizeof(struct tcphdr) / 4;
687 : 3 : rep.th.rst = 1;
688 : :
689 : 3 : if (th->ack) {
690 : 3 : rep.th.seq = th->ack_seq;
691 : : } else {
692 : 0 : rep.th.ack = 1;
693 : 0 : rep.th.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
694 : : skb->len - (th->doff << 2));
695 : : }
696 : :
697 : 3 : memset(&arg, 0, sizeof(arg));
698 : 3 : arg.iov[0].iov_base = (unsigned char *)&rep;
699 : 3 : arg.iov[0].iov_len = sizeof(rep.th);
700 : :
701 : 3 : net = sk ? sock_net(sk) : dev_net(skb_dst(skb)->dev);
702 : : #ifdef CONFIG_TCP_MD5SIG
703 : : rcu_read_lock();
704 : : hash_location = tcp_parse_md5sig_option(th);
705 : : if (sk && sk_fullsock(sk)) {
706 : : key = tcp_md5_do_lookup(sk, (union tcp_md5_addr *)
707 : : &ip_hdr(skb)->saddr, AF_INET);
708 : : } else if (hash_location) {
709 : : /*
710 : : * active side is lost. Try to find listening socket through
711 : : * source port, and then find md5 key through listening socket.
712 : : * we are not loose security here:
713 : : * Incoming packet is checked with md5 hash with finding key,
714 : : * no RST generated if md5 hash doesn't match.
715 : : */
716 : : sk1 = __inet_lookup_listener(net, &tcp_hashinfo, NULL, 0,
717 : : ip_hdr(skb)->saddr,
718 : : th->source, ip_hdr(skb)->daddr,
719 : : ntohs(th->source), inet_iif(skb),
720 : : tcp_v4_sdif(skb));
721 : : /* don't send rst if it can't find key */
722 : : if (!sk1)
723 : : goto out;
724 : :
725 : : key = tcp_md5_do_lookup(sk1, (union tcp_md5_addr *)
726 : : &ip_hdr(skb)->saddr, AF_INET);
727 : : if (!key)
728 : : goto out;
729 : :
730 : :
731 : : genhash = tcp_v4_md5_hash_skb(newhash, key, NULL, skb);
732 : : if (genhash || memcmp(hash_location, newhash, 16) != 0)
733 : : goto out;
734 : :
735 : : }
736 : :
737 : : if (key) {
738 : : rep.opt[0] = htonl((TCPOPT_NOP << 24) |
739 : : (TCPOPT_NOP << 16) |
740 : : (TCPOPT_MD5SIG << 8) |
741 : : TCPOLEN_MD5SIG);
742 : : /* Update length and the length the header thinks exists */
743 : : arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
744 : : rep.th.doff = arg.iov[0].iov_len / 4;
745 : :
746 : : tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[1],
747 : : key, ip_hdr(skb)->saddr,
748 : : ip_hdr(skb)->daddr, &rep.th);
749 : : }
750 : : #endif
751 : 3 : arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
752 : : ip_hdr(skb)->saddr, /* XXX */
753 : : arg.iov[0].iov_len, IPPROTO_TCP, 0);
754 : 3 : arg.csumoffset = offsetof(struct tcphdr, check) / 2;
755 : 3 : arg.flags = (sk && inet_sk_transparent(sk)) ? IP_REPLY_ARG_NOSRCCHECK : 0;
756 : :
757 : : /* When socket is gone, all binding information is lost.
758 : : * routing might fail in this case. No choice here, if we choose to force
759 : : * input interface, we will misroute in case of asymmetric route.
760 : : */
761 : 3 : if (sk) {
762 : 1 : arg.bound_dev_if = sk->sk_bound_dev_if;
763 : 1 : if (sk_fullsock(sk))
764 : 0 : trace_tcp_send_reset(sk, skb);
765 : : }
766 : :
767 : : BUILD_BUG_ON(offsetof(struct sock, sk_bound_dev_if) !=
768 : : offsetof(struct inet_timewait_sock, tw_bound_dev_if));
769 : :
770 : 3 : arg.tos = ip_hdr(skb)->tos;
771 : 3 : arg.uid = sock_net_uid(net, sk && sk_fullsock(sk) ? sk : NULL);
772 : : local_bh_disable();
773 : 3 : ctl_sk = this_cpu_read(*net->ipv4.tcp_sk);
774 : 3 : if (sk) {
775 : 1 : ctl_sk->sk_mark = (sk->sk_state == TCP_TIME_WAIT) ?
776 : 1 : inet_twsk(sk)->tw_mark : sk->sk_mark;
777 : 1 : ctl_sk->sk_priority = (sk->sk_state == TCP_TIME_WAIT) ?
778 : 1 : inet_twsk(sk)->tw_priority : sk->sk_priority;
779 : 1 : transmit_time = tcp_transmit_time(sk);
780 : : }
781 : 3 : ip_send_unicast_reply(ctl_sk,
782 : 3 : skb, &TCP_SKB_CB(skb)->header.h4.opt,
783 : : ip_hdr(skb)->saddr, ip_hdr(skb)->daddr,
784 : : &arg, arg.iov[0].iov_len,
785 : : transmit_time);
786 : :
787 : 3 : ctl_sk->sk_mark = 0;
788 : 3 : __TCP_INC_STATS(net, TCP_MIB_OUTSEGS);
789 : 3 : __TCP_INC_STATS(net, TCP_MIB_OUTRSTS);
790 : : local_bh_enable();
791 : :
792 : : #ifdef CONFIG_TCP_MD5SIG
793 : : out:
794 : : rcu_read_unlock();
795 : : #endif
796 : : }
797 : :
798 : : /* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
799 : : outside socket context is ugly, certainly. What can I do?
800 : : */
801 : :
802 : 1 : static void tcp_v4_send_ack(const struct sock *sk,
803 : : struct sk_buff *skb, u32 seq, u32 ack,
804 : : u32 win, u32 tsval, u32 tsecr, int oif,
805 : : struct tcp_md5sig_key *key,
806 : : int reply_flags, u8 tos)
807 : : {
808 : : const struct tcphdr *th = tcp_hdr(skb);
809 : : struct {
810 : : struct tcphdr th;
811 : : __be32 opt[(TCPOLEN_TSTAMP_ALIGNED >> 2)
812 : : #ifdef CONFIG_TCP_MD5SIG
813 : : + (TCPOLEN_MD5SIG_ALIGNED >> 2)
814 : : #endif
815 : : ];
816 : : } rep;
817 : : struct net *net = sock_net(sk);
818 : : struct ip_reply_arg arg;
819 : : struct sock *ctl_sk;
820 : : u64 transmit_time;
821 : :
822 : 1 : memset(&rep.th, 0, sizeof(struct tcphdr));
823 : 1 : memset(&arg, 0, sizeof(arg));
824 : :
825 : 1 : arg.iov[0].iov_base = (unsigned char *)&rep;
826 : 1 : arg.iov[0].iov_len = sizeof(rep.th);
827 : 1 : if (tsecr) {
828 : 0 : rep.opt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
829 : : (TCPOPT_TIMESTAMP << 8) |
830 : : TCPOLEN_TIMESTAMP);
831 : 0 : rep.opt[1] = htonl(tsval);
832 : 0 : rep.opt[2] = htonl(tsecr);
833 : 0 : arg.iov[0].iov_len += TCPOLEN_TSTAMP_ALIGNED;
834 : : }
835 : :
836 : : /* Swap the send and the receive. */
837 : 1 : rep.th.dest = th->source;
838 : 1 : rep.th.source = th->dest;
839 : 1 : rep.th.doff = arg.iov[0].iov_len / 4;
840 : 1 : rep.th.seq = htonl(seq);
841 : 1 : rep.th.ack_seq = htonl(ack);
842 : 1 : rep.th.ack = 1;
843 : 1 : rep.th.window = htons(win);
844 : :
845 : : #ifdef CONFIG_TCP_MD5SIG
846 : : if (key) {
847 : : int offset = (tsecr) ? 3 : 0;
848 : :
849 : : rep.opt[offset++] = htonl((TCPOPT_NOP << 24) |
850 : : (TCPOPT_NOP << 16) |
851 : : (TCPOPT_MD5SIG << 8) |
852 : : TCPOLEN_MD5SIG);
853 : : arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
854 : : rep.th.doff = arg.iov[0].iov_len/4;
855 : :
856 : : tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[offset],
857 : : key, ip_hdr(skb)->saddr,
858 : : ip_hdr(skb)->daddr, &rep.th);
859 : : }
860 : : #endif
861 : 1 : arg.flags = reply_flags;
862 : 1 : arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
863 : : ip_hdr(skb)->saddr, /* XXX */
864 : : arg.iov[0].iov_len, IPPROTO_TCP, 0);
865 : 1 : arg.csumoffset = offsetof(struct tcphdr, check) / 2;
866 : 1 : if (oif)
867 : 0 : arg.bound_dev_if = oif;
868 : 1 : arg.tos = tos;
869 : 1 : arg.uid = sock_net_uid(net, sk_fullsock(sk) ? sk : NULL);
870 : : local_bh_disable();
871 : 1 : ctl_sk = this_cpu_read(*net->ipv4.tcp_sk);
872 : 1 : ctl_sk->sk_mark = (sk->sk_state == TCP_TIME_WAIT) ?
873 : 1 : inet_twsk(sk)->tw_mark : sk->sk_mark;
874 : 1 : ctl_sk->sk_priority = (sk->sk_state == TCP_TIME_WAIT) ?
875 : 1 : inet_twsk(sk)->tw_priority : sk->sk_priority;
876 : 1 : transmit_time = tcp_transmit_time(sk);
877 : 1 : ip_send_unicast_reply(ctl_sk,
878 : 1 : skb, &TCP_SKB_CB(skb)->header.h4.opt,
879 : : ip_hdr(skb)->saddr, ip_hdr(skb)->daddr,
880 : : &arg, arg.iov[0].iov_len,
881 : : transmit_time);
882 : :
883 : 1 : ctl_sk->sk_mark = 0;
884 : 1 : __TCP_INC_STATS(net, TCP_MIB_OUTSEGS);
885 : : local_bh_enable();
886 : 1 : }
887 : :
888 : 1 : static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
889 : : {
890 : : struct inet_timewait_sock *tw = inet_twsk(sk);
891 : : struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
892 : :
893 : 1 : tcp_v4_send_ack(sk, skb,
894 : : tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
895 : 1 : tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
896 : 1 : tcp_time_stamp_raw() + tcptw->tw_ts_offset,
897 : : tcptw->tw_ts_recent,
898 : : tw->tw_bound_dev_if,
899 : : tcp_twsk_md5_key(tcptw),
900 : 1 : tw->tw_transparent ? IP_REPLY_ARG_NOSRCCHECK : 0,
901 : : tw->tw_tos
902 : : );
903 : :
904 : 1 : inet_twsk_put(tw);
905 : 1 : }
906 : :
907 : 0 : static void tcp_v4_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb,
908 : : struct request_sock *req)
909 : : {
910 : : /* sk->sk_state == TCP_LISTEN -> for regular TCP_SYN_RECV
911 : : * sk->sk_state == TCP_SYN_RECV -> for Fast Open.
912 : : */
913 : 0 : u32 seq = (sk->sk_state == TCP_LISTEN) ? tcp_rsk(req)->snt_isn + 1 :
914 : : tcp_sk(sk)->snd_nxt;
915 : :
916 : : /* RFC 7323 2.3
917 : : * The window field (SEG.WND) of every outgoing segment, with the
918 : : * exception of <SYN> segments, MUST be right-shifted by
919 : : * Rcv.Wind.Shift bits:
920 : : */
921 : 0 : tcp_v4_send_ack(sk, skb, seq,
922 : : tcp_rsk(req)->rcv_nxt,
923 : 0 : req->rsk_rcv_wnd >> inet_rsk(req)->rcv_wscale,
924 : 0 : tcp_time_stamp_raw() + tcp_rsk(req)->ts_off,
925 : : req->ts_recent,
926 : : 0,
927 : : tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&ip_hdr(skb)->saddr,
928 : : AF_INET),
929 : 0 : inet_rsk(req)->no_srccheck ? IP_REPLY_ARG_NOSRCCHECK : 0,
930 : : ip_hdr(skb)->tos);
931 : 0 : }
932 : :
933 : : /*
934 : : * Send a SYN-ACK after having received a SYN.
935 : : * This still operates on a request_sock only, not on a big
936 : : * socket.
937 : : */
938 : 0 : static int tcp_v4_send_synack(const struct sock *sk, struct dst_entry *dst,
939 : : struct flowi *fl,
940 : : struct request_sock *req,
941 : : struct tcp_fastopen_cookie *foc,
942 : : enum tcp_synack_type synack_type)
943 : : {
944 : : const struct inet_request_sock *ireq = inet_rsk(req);
945 : : struct flowi4 fl4;
946 : : int err = -1;
947 : : struct sk_buff *skb;
948 : :
949 : : /* First, grab a route. */
950 : 0 : if (!dst && (dst = inet_csk_route_req(sk, &fl4, req)) == NULL)
951 : : return -1;
952 : :
953 : 0 : skb = tcp_make_synack(sk, dst, req, foc, synack_type);
954 : :
955 : 0 : if (skb) {
956 : 0 : __tcp_v4_send_check(skb, ireq->ir_loc_addr, ireq->ir_rmt_addr);
957 : :
958 : : rcu_read_lock();
959 : 0 : err = ip_build_and_send_pkt(skb, sk, ireq->ir_loc_addr,
960 : : ireq->ir_rmt_addr,
961 : 0 : rcu_dereference(ireq->ireq_opt));
962 : : rcu_read_unlock();
963 : 0 : err = net_xmit_eval(err);
964 : : }
965 : :
966 : 0 : return err;
967 : : }
968 : :
969 : : /*
970 : : * IPv4 request_sock destructor.
971 : : */
972 : 0 : static void tcp_v4_reqsk_destructor(struct request_sock *req)
973 : : {
974 : 0 : kfree(rcu_dereference_protected(inet_rsk(req)->ireq_opt, 1));
975 : 0 : }
976 : :
977 : : #ifdef CONFIG_TCP_MD5SIG
978 : : /*
979 : : * RFC2385 MD5 checksumming requires a mapping of
980 : : * IP address->MD5 Key.
981 : : * We need to maintain these in the sk structure.
982 : : */
983 : :
984 : : DEFINE_STATIC_KEY_FALSE(tcp_md5_needed);
985 : : EXPORT_SYMBOL(tcp_md5_needed);
986 : :
987 : : /* Find the Key structure for an address. */
988 : : struct tcp_md5sig_key *__tcp_md5_do_lookup(const struct sock *sk,
989 : : const union tcp_md5_addr *addr,
990 : : int family)
991 : : {
992 : : const struct tcp_sock *tp = tcp_sk(sk);
993 : : struct tcp_md5sig_key *key;
994 : : const struct tcp_md5sig_info *md5sig;
995 : : __be32 mask;
996 : : struct tcp_md5sig_key *best_match = NULL;
997 : : bool match;
998 : :
999 : : /* caller either holds rcu_read_lock() or socket lock */
1000 : : md5sig = rcu_dereference_check(tp->md5sig_info,
1001 : : lockdep_sock_is_held(sk));
1002 : : if (!md5sig)
1003 : : return NULL;
1004 : :
1005 : : hlist_for_each_entry_rcu(key, &md5sig->head, node) {
1006 : : if (key->family != family)
1007 : : continue;
1008 : :
1009 : : if (family == AF_INET) {
1010 : : mask = inet_make_mask(key->prefixlen);
1011 : : match = (key->addr.a4.s_addr & mask) ==
1012 : : (addr->a4.s_addr & mask);
1013 : : #if IS_ENABLED(CONFIG_IPV6)
1014 : : } else if (family == AF_INET6) {
1015 : : match = ipv6_prefix_equal(&key->addr.a6, &addr->a6,
1016 : : key->prefixlen);
1017 : : #endif
1018 : : } else {
1019 : : match = false;
1020 : : }
1021 : :
1022 : : if (match && (!best_match ||
1023 : : key->prefixlen > best_match->prefixlen))
1024 : : best_match = key;
1025 : : }
1026 : : return best_match;
1027 : : }
1028 : : EXPORT_SYMBOL(__tcp_md5_do_lookup);
1029 : :
1030 : : static struct tcp_md5sig_key *tcp_md5_do_lookup_exact(const struct sock *sk,
1031 : : const union tcp_md5_addr *addr,
1032 : : int family, u8 prefixlen)
1033 : : {
1034 : : const struct tcp_sock *tp = tcp_sk(sk);
1035 : : struct tcp_md5sig_key *key;
1036 : : unsigned int size = sizeof(struct in_addr);
1037 : : const struct tcp_md5sig_info *md5sig;
1038 : :
1039 : : /* caller either holds rcu_read_lock() or socket lock */
1040 : : md5sig = rcu_dereference_check(tp->md5sig_info,
1041 : : lockdep_sock_is_held(sk));
1042 : : if (!md5sig)
1043 : : return NULL;
1044 : : #if IS_ENABLED(CONFIG_IPV6)
1045 : : if (family == AF_INET6)
1046 : : size = sizeof(struct in6_addr);
1047 : : #endif
1048 : : hlist_for_each_entry_rcu(key, &md5sig->head, node) {
1049 : : if (key->family != family)
1050 : : continue;
1051 : : if (!memcmp(&key->addr, addr, size) &&
1052 : : key->prefixlen == prefixlen)
1053 : : return key;
1054 : : }
1055 : : return NULL;
1056 : : }
1057 : :
1058 : : struct tcp_md5sig_key *tcp_v4_md5_lookup(const struct sock *sk,
1059 : : const struct sock *addr_sk)
1060 : : {
1061 : : const union tcp_md5_addr *addr;
1062 : :
1063 : : addr = (const union tcp_md5_addr *)&addr_sk->sk_daddr;
1064 : : return tcp_md5_do_lookup(sk, addr, AF_INET);
1065 : : }
1066 : : EXPORT_SYMBOL(tcp_v4_md5_lookup);
1067 : :
1068 : : /* This can be called on a newly created socket, from other files */
1069 : : int tcp_md5_do_add(struct sock *sk, const union tcp_md5_addr *addr,
1070 : : int family, u8 prefixlen, const u8 *newkey, u8 newkeylen,
1071 : : gfp_t gfp)
1072 : : {
1073 : : /* Add Key to the list */
1074 : : struct tcp_md5sig_key *key;
1075 : : struct tcp_sock *tp = tcp_sk(sk);
1076 : : struct tcp_md5sig_info *md5sig;
1077 : :
1078 : : key = tcp_md5_do_lookup_exact(sk, addr, family, prefixlen);
1079 : : if (key) {
1080 : : /* Pre-existing entry - just update that one.
1081 : : * Note that the key might be used concurrently.
1082 : : */
1083 : : memcpy(key->key, newkey, newkeylen);
1084 : :
1085 : : /* Pairs with READ_ONCE() in tcp_md5_hash_key().
1086 : : * Also note that a reader could catch new key->keylen value
1087 : : * but old key->key[], this is the reason we use __GFP_ZERO
1088 : : * at sock_kmalloc() time below these lines.
1089 : : */
1090 : : WRITE_ONCE(key->keylen, newkeylen);
1091 : :
1092 : : return 0;
1093 : : }
1094 : :
1095 : : md5sig = rcu_dereference_protected(tp->md5sig_info,
1096 : : lockdep_sock_is_held(sk));
1097 : : if (!md5sig) {
1098 : : md5sig = kmalloc(sizeof(*md5sig), gfp);
1099 : : if (!md5sig)
1100 : : return -ENOMEM;
1101 : :
1102 : : sk_nocaps_add(sk, NETIF_F_GSO_MASK);
1103 : : INIT_HLIST_HEAD(&md5sig->head);
1104 : : rcu_assign_pointer(tp->md5sig_info, md5sig);
1105 : : }
1106 : :
1107 : : key = sock_kmalloc(sk, sizeof(*key), gfp | __GFP_ZERO);
1108 : : if (!key)
1109 : : return -ENOMEM;
1110 : : if (!tcp_alloc_md5sig_pool()) {
1111 : : sock_kfree_s(sk, key, sizeof(*key));
1112 : : return -ENOMEM;
1113 : : }
1114 : :
1115 : : memcpy(key->key, newkey, newkeylen);
1116 : : key->keylen = newkeylen;
1117 : : key->family = family;
1118 : : key->prefixlen = prefixlen;
1119 : : memcpy(&key->addr, addr,
1120 : : (family == AF_INET6) ? sizeof(struct in6_addr) :
1121 : : sizeof(struct in_addr));
1122 : : hlist_add_head_rcu(&key->node, &md5sig->head);
1123 : : return 0;
1124 : : }
1125 : : EXPORT_SYMBOL(tcp_md5_do_add);
1126 : :
1127 : : int tcp_md5_do_del(struct sock *sk, const union tcp_md5_addr *addr, int family,
1128 : : u8 prefixlen)
1129 : : {
1130 : : struct tcp_md5sig_key *key;
1131 : :
1132 : : key = tcp_md5_do_lookup_exact(sk, addr, family, prefixlen);
1133 : : if (!key)
1134 : : return -ENOENT;
1135 : : hlist_del_rcu(&key->node);
1136 : : atomic_sub(sizeof(*key), &sk->sk_omem_alloc);
1137 : : kfree_rcu(key, rcu);
1138 : : return 0;
1139 : : }
1140 : : EXPORT_SYMBOL(tcp_md5_do_del);
1141 : :
1142 : : static void tcp_clear_md5_list(struct sock *sk)
1143 : : {
1144 : : struct tcp_sock *tp = tcp_sk(sk);
1145 : : struct tcp_md5sig_key *key;
1146 : : struct hlist_node *n;
1147 : : struct tcp_md5sig_info *md5sig;
1148 : :
1149 : : md5sig = rcu_dereference_protected(tp->md5sig_info, 1);
1150 : :
1151 : : hlist_for_each_entry_safe(key, n, &md5sig->head, node) {
1152 : : hlist_del_rcu(&key->node);
1153 : : atomic_sub(sizeof(*key), &sk->sk_omem_alloc);
1154 : : kfree_rcu(key, rcu);
1155 : : }
1156 : : }
1157 : :
1158 : : static int tcp_v4_parse_md5_keys(struct sock *sk, int optname,
1159 : : char __user *optval, int optlen)
1160 : : {
1161 : : struct tcp_md5sig cmd;
1162 : : struct sockaddr_in *sin = (struct sockaddr_in *)&cmd.tcpm_addr;
1163 : : u8 prefixlen = 32;
1164 : :
1165 : : if (optlen < sizeof(cmd))
1166 : : return -EINVAL;
1167 : :
1168 : : if (copy_from_user(&cmd, optval, sizeof(cmd)))
1169 : : return -EFAULT;
1170 : :
1171 : : if (sin->sin_family != AF_INET)
1172 : : return -EINVAL;
1173 : :
1174 : : if (optname == TCP_MD5SIG_EXT &&
1175 : : cmd.tcpm_flags & TCP_MD5SIG_FLAG_PREFIX) {
1176 : : prefixlen = cmd.tcpm_prefixlen;
1177 : : if (prefixlen > 32)
1178 : : return -EINVAL;
1179 : : }
1180 : :
1181 : : if (!cmd.tcpm_keylen)
1182 : : return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin->sin_addr.s_addr,
1183 : : AF_INET, prefixlen);
1184 : :
1185 : : if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
1186 : : return -EINVAL;
1187 : :
1188 : : return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin->sin_addr.s_addr,
1189 : : AF_INET, prefixlen, cmd.tcpm_key, cmd.tcpm_keylen,
1190 : : GFP_KERNEL);
1191 : : }
1192 : :
1193 : : static int tcp_v4_md5_hash_headers(struct tcp_md5sig_pool *hp,
1194 : : __be32 daddr, __be32 saddr,
1195 : : const struct tcphdr *th, int nbytes)
1196 : : {
1197 : : struct tcp4_pseudohdr *bp;
1198 : : struct scatterlist sg;
1199 : : struct tcphdr *_th;
1200 : :
1201 : : bp = hp->scratch;
1202 : : bp->saddr = saddr;
1203 : : bp->daddr = daddr;
1204 : : bp->pad = 0;
1205 : : bp->protocol = IPPROTO_TCP;
1206 : : bp->len = cpu_to_be16(nbytes);
1207 : :
1208 : : _th = (struct tcphdr *)(bp + 1);
1209 : : memcpy(_th, th, sizeof(*th));
1210 : : _th->check = 0;
1211 : :
1212 : : sg_init_one(&sg, bp, sizeof(*bp) + sizeof(*th));
1213 : : ahash_request_set_crypt(hp->md5_req, &sg, NULL,
1214 : : sizeof(*bp) + sizeof(*th));
1215 : : return crypto_ahash_update(hp->md5_req);
1216 : : }
1217 : :
1218 : : static int tcp_v4_md5_hash_hdr(char *md5_hash, const struct tcp_md5sig_key *key,
1219 : : __be32 daddr, __be32 saddr, const struct tcphdr *th)
1220 : : {
1221 : : struct tcp_md5sig_pool *hp;
1222 : : struct ahash_request *req;
1223 : :
1224 : : hp = tcp_get_md5sig_pool();
1225 : : if (!hp)
1226 : : goto clear_hash_noput;
1227 : : req = hp->md5_req;
1228 : :
1229 : : if (crypto_ahash_init(req))
1230 : : goto clear_hash;
1231 : : if (tcp_v4_md5_hash_headers(hp, daddr, saddr, th, th->doff << 2))
1232 : : goto clear_hash;
1233 : : if (tcp_md5_hash_key(hp, key))
1234 : : goto clear_hash;
1235 : : ahash_request_set_crypt(req, NULL, md5_hash, 0);
1236 : : if (crypto_ahash_final(req))
1237 : : goto clear_hash;
1238 : :
1239 : : tcp_put_md5sig_pool();
1240 : : return 0;
1241 : :
1242 : : clear_hash:
1243 : : tcp_put_md5sig_pool();
1244 : : clear_hash_noput:
1245 : : memset(md5_hash, 0, 16);
1246 : : return 1;
1247 : : }
1248 : :
1249 : : int tcp_v4_md5_hash_skb(char *md5_hash, const struct tcp_md5sig_key *key,
1250 : : const struct sock *sk,
1251 : : const struct sk_buff *skb)
1252 : : {
1253 : : struct tcp_md5sig_pool *hp;
1254 : : struct ahash_request *req;
1255 : : const struct tcphdr *th = tcp_hdr(skb);
1256 : : __be32 saddr, daddr;
1257 : :
1258 : : if (sk) { /* valid for establish/request sockets */
1259 : : saddr = sk->sk_rcv_saddr;
1260 : : daddr = sk->sk_daddr;
1261 : : } else {
1262 : : const struct iphdr *iph = ip_hdr(skb);
1263 : : saddr = iph->saddr;
1264 : : daddr = iph->daddr;
1265 : : }
1266 : :
1267 : : hp = tcp_get_md5sig_pool();
1268 : : if (!hp)
1269 : : goto clear_hash_noput;
1270 : : req = hp->md5_req;
1271 : :
1272 : : if (crypto_ahash_init(req))
1273 : : goto clear_hash;
1274 : :
1275 : : if (tcp_v4_md5_hash_headers(hp, daddr, saddr, th, skb->len))
1276 : : goto clear_hash;
1277 : : if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
1278 : : goto clear_hash;
1279 : : if (tcp_md5_hash_key(hp, key))
1280 : : goto clear_hash;
1281 : : ahash_request_set_crypt(req, NULL, md5_hash, 0);
1282 : : if (crypto_ahash_final(req))
1283 : : goto clear_hash;
1284 : :
1285 : : tcp_put_md5sig_pool();
1286 : : return 0;
1287 : :
1288 : : clear_hash:
1289 : : tcp_put_md5sig_pool();
1290 : : clear_hash_noput:
1291 : : memset(md5_hash, 0, 16);
1292 : : return 1;
1293 : : }
1294 : : EXPORT_SYMBOL(tcp_v4_md5_hash_skb);
1295 : :
1296 : : #endif
1297 : :
1298 : : /* Called with rcu_read_lock() */
1299 : : static bool tcp_v4_inbound_md5_hash(const struct sock *sk,
1300 : : const struct sk_buff *skb)
1301 : : {
1302 : : #ifdef CONFIG_TCP_MD5SIG
1303 : : /*
1304 : : * This gets called for each TCP segment that arrives
1305 : : * so we want to be efficient.
1306 : : * We have 3 drop cases:
1307 : : * o No MD5 hash and one expected.
1308 : : * o MD5 hash and we're not expecting one.
1309 : : * o MD5 hash and its wrong.
1310 : : */
1311 : : const __u8 *hash_location = NULL;
1312 : : struct tcp_md5sig_key *hash_expected;
1313 : : const struct iphdr *iph = ip_hdr(skb);
1314 : : const struct tcphdr *th = tcp_hdr(skb);
1315 : : int genhash;
1316 : : unsigned char newhash[16];
1317 : :
1318 : : hash_expected = tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&iph->saddr,
1319 : : AF_INET);
1320 : : hash_location = tcp_parse_md5sig_option(th);
1321 : :
1322 : : /* We've parsed the options - do we have a hash? */
1323 : : if (!hash_expected && !hash_location)
1324 : : return false;
1325 : :
1326 : : if (hash_expected && !hash_location) {
1327 : : NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
1328 : : return true;
1329 : : }
1330 : :
1331 : : if (!hash_expected && hash_location) {
1332 : : NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
1333 : : return true;
1334 : : }
1335 : :
1336 : : /* Okay, so this is hash_expected and hash_location -
1337 : : * so we need to calculate the checksum.
1338 : : */
1339 : : genhash = tcp_v4_md5_hash_skb(newhash,
1340 : : hash_expected,
1341 : : NULL, skb);
1342 : :
1343 : : if (genhash || memcmp(hash_location, newhash, 16) != 0) {
1344 : : NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMD5FAILURE);
1345 : : net_info_ratelimited("MD5 Hash failed for (%pI4, %d)->(%pI4, %d)%s\n",
1346 : : &iph->saddr, ntohs(th->source),
1347 : : &iph->daddr, ntohs(th->dest),
1348 : : genhash ? " tcp_v4_calc_md5_hash failed"
1349 : : : "");
1350 : : return true;
1351 : : }
1352 : : return false;
1353 : : #endif
1354 : : return false;
1355 : : }
1356 : :
1357 : 0 : static void tcp_v4_init_req(struct request_sock *req,
1358 : : const struct sock *sk_listener,
1359 : : struct sk_buff *skb)
1360 : : {
1361 : : struct inet_request_sock *ireq = inet_rsk(req);
1362 : : struct net *net = sock_net(sk_listener);
1363 : :
1364 : 0 : sk_rcv_saddr_set(req_to_sk(req), ip_hdr(skb)->daddr);
1365 : 0 : sk_daddr_set(req_to_sk(req), ip_hdr(skb)->saddr);
1366 : 0 : RCU_INIT_POINTER(ireq->ireq_opt, tcp_v4_save_options(net, skb));
1367 : 0 : }
1368 : :
1369 : 0 : static struct dst_entry *tcp_v4_route_req(const struct sock *sk,
1370 : : struct flowi *fl,
1371 : : const struct request_sock *req)
1372 : : {
1373 : 0 : return inet_csk_route_req(sk, &fl->u.ip4, req);
1374 : : }
1375 : :
1376 : : struct request_sock_ops tcp_request_sock_ops __read_mostly = {
1377 : : .family = PF_INET,
1378 : : .obj_size = sizeof(struct tcp_request_sock),
1379 : : .rtx_syn_ack = tcp_rtx_synack,
1380 : : .send_ack = tcp_v4_reqsk_send_ack,
1381 : : .destructor = tcp_v4_reqsk_destructor,
1382 : : .send_reset = tcp_v4_send_reset,
1383 : : .syn_ack_timeout = tcp_syn_ack_timeout,
1384 : : };
1385 : :
1386 : : static const struct tcp_request_sock_ops tcp_request_sock_ipv4_ops = {
1387 : : .mss_clamp = TCP_MSS_DEFAULT,
1388 : : #ifdef CONFIG_TCP_MD5SIG
1389 : : .req_md5_lookup = tcp_v4_md5_lookup,
1390 : : .calc_md5_hash = tcp_v4_md5_hash_skb,
1391 : : #endif
1392 : : .init_req = tcp_v4_init_req,
1393 : : #ifdef CONFIG_SYN_COOKIES
1394 : : .cookie_init_seq = cookie_v4_init_sequence,
1395 : : #endif
1396 : : .route_req = tcp_v4_route_req,
1397 : : .init_seq = tcp_v4_init_seq,
1398 : : .init_ts_off = tcp_v4_init_ts_off,
1399 : : .send_synack = tcp_v4_send_synack,
1400 : : };
1401 : :
1402 : 0 : int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1403 : : {
1404 : : /* Never answer to SYNs send to broadcast or multicast */
1405 : 0 : if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
1406 : : goto drop;
1407 : :
1408 : 0 : return tcp_conn_request(&tcp_request_sock_ops,
1409 : : &tcp_request_sock_ipv4_ops, sk, skb);
1410 : :
1411 : : drop:
1412 : 0 : tcp_listendrop(sk);
1413 : 0 : return 0;
1414 : : }
1415 : : EXPORT_SYMBOL(tcp_v4_conn_request);
1416 : :
1417 : :
1418 : : /*
1419 : : * The three way handshake has completed - we got a valid synack -
1420 : : * now create the new socket.
1421 : : */
1422 : 0 : struct sock *tcp_v4_syn_recv_sock(const struct sock *sk, struct sk_buff *skb,
1423 : : struct request_sock *req,
1424 : : struct dst_entry *dst,
1425 : : struct request_sock *req_unhash,
1426 : : bool *own_req)
1427 : : {
1428 : : struct inet_request_sock *ireq;
1429 : : struct inet_sock *newinet;
1430 : : struct tcp_sock *newtp;
1431 : : struct sock *newsk;
1432 : : #ifdef CONFIG_TCP_MD5SIG
1433 : : struct tcp_md5sig_key *key;
1434 : : #endif
1435 : : struct ip_options_rcu *inet_opt;
1436 : :
1437 : 0 : if (sk_acceptq_is_full(sk))
1438 : : goto exit_overflow;
1439 : :
1440 : 0 : newsk = tcp_create_openreq_child(sk, req, skb);
1441 : 0 : if (!newsk)
1442 : : goto exit_nonewsk;
1443 : :
1444 : 0 : newsk->sk_gso_type = SKB_GSO_TCPV4;
1445 : 0 : inet_sk_rx_dst_set(newsk, skb);
1446 : :
1447 : : newtp = tcp_sk(newsk);
1448 : : newinet = inet_sk(newsk);
1449 : : ireq = inet_rsk(req);
1450 : 0 : sk_daddr_set(newsk, ireq->ir_rmt_addr);
1451 : 0 : sk_rcv_saddr_set(newsk, ireq->ir_loc_addr);
1452 : 0 : newsk->sk_bound_dev_if = ireq->ir_iif;
1453 : 0 : newinet->inet_saddr = ireq->ir_loc_addr;
1454 : 0 : inet_opt = rcu_dereference(ireq->ireq_opt);
1455 : : RCU_INIT_POINTER(newinet->inet_opt, inet_opt);
1456 : 0 : newinet->mc_index = inet_iif(skb);
1457 : 0 : newinet->mc_ttl = ip_hdr(skb)->ttl;
1458 : 0 : newinet->rcv_tos = ip_hdr(skb)->tos;
1459 : 0 : inet_csk(newsk)->icsk_ext_hdr_len = 0;
1460 : 0 : if (inet_opt)
1461 : 0 : inet_csk(newsk)->icsk_ext_hdr_len = inet_opt->opt.optlen;
1462 : 0 : newinet->inet_id = prandom_u32();
1463 : :
1464 : 0 : if (!dst) {
1465 : 0 : dst = inet_csk_route_child_sock(sk, newsk, req);
1466 : 0 : if (!dst)
1467 : : goto put_and_exit;
1468 : : } else {
1469 : : /* syncookie case : see end of cookie_v4_check() */
1470 : : }
1471 : 0 : sk_setup_caps(newsk, dst);
1472 : :
1473 : 0 : tcp_ca_openreq_child(newsk, dst);
1474 : :
1475 : 0 : tcp_sync_mss(newsk, dst_mtu(dst));
1476 : 0 : newtp->advmss = tcp_mss_clamp(tcp_sk(sk), dst_metric_advmss(dst));
1477 : :
1478 : 0 : tcp_initialize_rcv_mss(newsk);
1479 : :
1480 : : #ifdef CONFIG_TCP_MD5SIG
1481 : : /* Copy over the MD5 key from the original socket */
1482 : : key = tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&newinet->inet_daddr,
1483 : : AF_INET);
1484 : : if (key) {
1485 : : /*
1486 : : * We're using one, so create a matching key
1487 : : * on the newsk structure. If we fail to get
1488 : : * memory, then we end up not copying the key
1489 : : * across. Shucks.
1490 : : */
1491 : : tcp_md5_do_add(newsk, (union tcp_md5_addr *)&newinet->inet_daddr,
1492 : : AF_INET, 32, key->key, key->keylen, GFP_ATOMIC);
1493 : : sk_nocaps_add(newsk, NETIF_F_GSO_MASK);
1494 : : }
1495 : : #endif
1496 : :
1497 : 0 : if (__inet_inherit_port(sk, newsk) < 0)
1498 : : goto put_and_exit;
1499 : 0 : *own_req = inet_ehash_nolisten(newsk, req_to_sk(req_unhash));
1500 : 0 : if (likely(*own_req)) {
1501 : : tcp_move_syn(newtp, req);
1502 : 0 : ireq->ireq_opt = NULL;
1503 : : } else {
1504 : 0 : newinet->inet_opt = NULL;
1505 : : }
1506 : 0 : return newsk;
1507 : :
1508 : : exit_overflow:
1509 : 0 : NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
1510 : : exit_nonewsk:
1511 : 0 : dst_release(dst);
1512 : : exit:
1513 : 0 : tcp_listendrop(sk);
1514 : 0 : return NULL;
1515 : : put_and_exit:
1516 : 0 : newinet->inet_opt = NULL;
1517 : 0 : inet_csk_prepare_forced_close(newsk);
1518 : 0 : tcp_done(newsk);
1519 : 0 : goto exit;
1520 : : }
1521 : : EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
1522 : :
1523 : 0 : static struct sock *tcp_v4_cookie_check(struct sock *sk, struct sk_buff *skb)
1524 : : {
1525 : : #ifdef CONFIG_SYN_COOKIES
1526 : : const struct tcphdr *th = tcp_hdr(skb);
1527 : :
1528 : 0 : if (!th->syn)
1529 : 0 : sk = cookie_v4_check(sk, skb);
1530 : : #endif
1531 : 0 : return sk;
1532 : : }
1533 : :
1534 : 0 : u16 tcp_v4_get_syncookie(struct sock *sk, struct iphdr *iph,
1535 : : struct tcphdr *th, u32 *cookie)
1536 : : {
1537 : 0 : u16 mss = 0;
1538 : : #ifdef CONFIG_SYN_COOKIES
1539 : 0 : mss = tcp_get_syncookie_mss(&tcp_request_sock_ops,
1540 : : &tcp_request_sock_ipv4_ops, sk, th);
1541 : 0 : if (mss) {
1542 : 0 : *cookie = __cookie_v4_init_sequence(iph, th, &mss);
1543 : 0 : tcp_synq_overflow(sk);
1544 : : }
1545 : : #endif
1546 : 0 : return mss;
1547 : : }
1548 : :
1549 : : /* The socket must have it's spinlock held when we get
1550 : : * here, unless it is a TCP_LISTEN socket.
1551 : : *
1552 : : * We have a potential double-lock case here, so even when
1553 : : * doing backlog processing we use the BH locking scheme.
1554 : : * This is because we cannot sleep with the original spinlock
1555 : : * held.
1556 : : */
1557 : 1 : int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1558 : : {
1559 : : struct sock *rsk;
1560 : :
1561 : 1 : if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1562 : 1 : struct dst_entry *dst = sk->sk_rx_dst;
1563 : :
1564 : : sock_rps_save_rxhash(sk, skb);
1565 : : sk_mark_napi_id(sk, skb);
1566 : 1 : if (dst) {
1567 : 1 : if (inet_sk(sk)->rx_dst_ifindex != skb->skb_iif ||
1568 : 1 : !dst->ops->check(dst, 0)) {
1569 : 0 : dst_release(dst);
1570 : 0 : sk->sk_rx_dst = NULL;
1571 : : }
1572 : : }
1573 : 1 : tcp_rcv_established(sk, skb);
1574 : 1 : return 0;
1575 : : }
1576 : :
1577 : 1 : if (tcp_checksum_complete(skb))
1578 : : goto csum_err;
1579 : :
1580 : 1 : if (sk->sk_state == TCP_LISTEN) {
1581 : 0 : struct sock *nsk = tcp_v4_cookie_check(sk, skb);
1582 : :
1583 : 0 : if (!nsk)
1584 : : goto discard;
1585 : 0 : if (nsk != sk) {
1586 : 0 : if (tcp_child_process(sk, nsk, skb)) {
1587 : : rsk = nsk;
1588 : : goto reset;
1589 : : }
1590 : : return 0;
1591 : : }
1592 : : } else
1593 : : sock_rps_save_rxhash(sk, skb);
1594 : :
1595 : 1 : if (tcp_rcv_state_process(sk, skb)) {
1596 : : rsk = sk;
1597 : : goto reset;
1598 : : }
1599 : : return 0;
1600 : :
1601 : : reset:
1602 : 0 : tcp_v4_send_reset(rsk, skb);
1603 : : discard:
1604 : 0 : kfree_skb(skb);
1605 : : /* Be careful here. If this function gets more complicated and
1606 : : * gcc suffers from register pressure on the x86, sk (in %ebx)
1607 : : * might be destroyed here. This current version compiles correctly,
1608 : : * but you have been warned.
1609 : : */
1610 : 0 : return 0;
1611 : :
1612 : : csum_err:
1613 : 0 : TCP_INC_STATS(sock_net(sk), TCP_MIB_CSUMERRORS);
1614 : 0 : TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
1615 : : goto discard;
1616 : : }
1617 : : EXPORT_SYMBOL(tcp_v4_do_rcv);
1618 : :
1619 : 3 : int tcp_v4_early_demux(struct sk_buff *skb)
1620 : : {
1621 : : const struct iphdr *iph;
1622 : : const struct tcphdr *th;
1623 : : struct sock *sk;
1624 : :
1625 : 3 : if (skb->pkt_type != PACKET_HOST)
1626 : : return 0;
1627 : :
1628 : 3 : if (!pskb_may_pull(skb, skb_transport_offset(skb) + sizeof(struct tcphdr)))
1629 : : return 0;
1630 : :
1631 : : iph = ip_hdr(skb);
1632 : : th = tcp_hdr(skb);
1633 : :
1634 : 3 : if (th->doff < sizeof(struct tcphdr) / 4)
1635 : : return 0;
1636 : :
1637 : 3 : sk = __inet_lookup_established(dev_net(skb->dev), &tcp_hashinfo,
1638 : : iph->saddr, th->source,
1639 : : iph->daddr, ntohs(th->dest),
1640 : : skb->skb_iif, inet_sdif(skb));
1641 : 3 : if (sk) {
1642 : 1 : skb->sk = sk;
1643 : 1 : skb->destructor = sock_edemux;
1644 : 1 : if (sk_fullsock(sk)) {
1645 : 1 : struct dst_entry *dst = READ_ONCE(sk->sk_rx_dst);
1646 : :
1647 : 1 : if (dst)
1648 : : dst = dst_check(dst, 0);
1649 : 1 : if (dst &&
1650 : 1 : inet_sk(sk)->rx_dst_ifindex == skb->skb_iif)
1651 : : skb_dst_set_noref(skb, dst);
1652 : : }
1653 : : }
1654 : : return 0;
1655 : : }
1656 : :
1657 : 1 : bool tcp_add_backlog(struct sock *sk, struct sk_buff *skb)
1658 : : {
1659 : 1 : u32 limit = READ_ONCE(sk->sk_rcvbuf) + READ_ONCE(sk->sk_sndbuf);
1660 : : struct skb_shared_info *shinfo;
1661 : : const struct tcphdr *th;
1662 : : struct tcphdr *thtail;
1663 : : struct sk_buff *tail;
1664 : : unsigned int hdrlen;
1665 : : bool fragstolen;
1666 : : u32 gso_segs;
1667 : : int delta;
1668 : :
1669 : : /* In case all data was pulled from skb frags (in __pskb_pull_tail()),
1670 : : * we can fix skb->truesize to its real value to avoid future drops.
1671 : : * This is valid because skb is not yet charged to the socket.
1672 : : * It has been noticed pure SACK packets were sometimes dropped
1673 : : * (if cooked by drivers without copybreak feature).
1674 : : */
1675 : 1 : skb_condense(skb);
1676 : :
1677 : 1 : skb_dst_drop(skb);
1678 : :
1679 : 1 : if (unlikely(tcp_checksum_complete(skb))) {
1680 : : bh_unlock_sock(sk);
1681 : 0 : __TCP_INC_STATS(sock_net(sk), TCP_MIB_CSUMERRORS);
1682 : 0 : __TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
1683 : 0 : return true;
1684 : : }
1685 : :
1686 : : /* Attempt coalescing to last skb in backlog, even if we are
1687 : : * above the limits.
1688 : : * This is okay because skb capacity is limited to MAX_SKB_FRAGS.
1689 : : */
1690 : 1 : th = (const struct tcphdr *)skb->data;
1691 : 1 : hdrlen = th->doff * 4;
1692 : : shinfo = skb_shinfo(skb);
1693 : :
1694 : 1 : if (!shinfo->gso_size)
1695 : 1 : shinfo->gso_size = skb->len - hdrlen;
1696 : :
1697 : 1 : if (!shinfo->gso_segs)
1698 : 1 : shinfo->gso_segs = 1;
1699 : :
1700 : 1 : tail = sk->sk_backlog.tail;
1701 : 1 : if (!tail)
1702 : : goto no_coalesce;
1703 : 1 : thtail = (struct tcphdr *)tail->data;
1704 : :
1705 : 1 : if (TCP_SKB_CB(tail)->end_seq != TCP_SKB_CB(skb)->seq ||
1706 : 1 : TCP_SKB_CB(tail)->ip_dsfield != TCP_SKB_CB(skb)->ip_dsfield ||
1707 : 1 : ((TCP_SKB_CB(tail)->tcp_flags |
1708 : 1 : TCP_SKB_CB(skb)->tcp_flags) & (TCPHDR_SYN | TCPHDR_RST | TCPHDR_URG)) ||
1709 : : !((TCP_SKB_CB(tail)->tcp_flags &
1710 : 1 : TCP_SKB_CB(skb)->tcp_flags) & TCPHDR_ACK) ||
1711 : : ((TCP_SKB_CB(tail)->tcp_flags ^
1712 : 1 : TCP_SKB_CB(skb)->tcp_flags) & (TCPHDR_ECE | TCPHDR_CWR)) ||
1713 : : #ifdef CONFIG_TLS_DEVICE
1714 : : tail->decrypted != skb->decrypted ||
1715 : : #endif
1716 : 1 : thtail->doff != th->doff ||
1717 : 1 : memcmp(thtail + 1, th + 1, hdrlen - sizeof(*th)))
1718 : : goto no_coalesce;
1719 : :
1720 : 1 : __skb_pull(skb, hdrlen);
1721 : 1 : if (skb_try_coalesce(tail, skb, &fragstolen, &delta)) {
1722 : 1 : thtail->window = th->window;
1723 : :
1724 : 1 : TCP_SKB_CB(tail)->end_seq = TCP_SKB_CB(skb)->end_seq;
1725 : :
1726 : 1 : if (after(TCP_SKB_CB(skb)->ack_seq, TCP_SKB_CB(tail)->ack_seq))
1727 : 0 : TCP_SKB_CB(tail)->ack_seq = TCP_SKB_CB(skb)->ack_seq;
1728 : :
1729 : : /* We have to update both TCP_SKB_CB(tail)->tcp_flags and
1730 : : * thtail->fin, so that the fast path in tcp_rcv_established()
1731 : : * is not entered if we append a packet with a FIN.
1732 : : * SYN, RST, URG are not present.
1733 : : * ACK is set on both packets.
1734 : : * PSH : we do not really care in TCP stack,
1735 : : * at least for 'GRO' packets.
1736 : : */
1737 : 1 : thtail->fin |= th->fin;
1738 : 1 : TCP_SKB_CB(tail)->tcp_flags |= TCP_SKB_CB(skb)->tcp_flags;
1739 : :
1740 : 1 : if (TCP_SKB_CB(skb)->has_rxtstamp) {
1741 : 0 : TCP_SKB_CB(tail)->has_rxtstamp = true;
1742 : 0 : tail->tstamp = skb->tstamp;
1743 : 0 : skb_hwtstamps(tail)->hwtstamp = skb_hwtstamps(skb)->hwtstamp;
1744 : : }
1745 : :
1746 : : /* Not as strict as GRO. We only need to carry mss max value */
1747 : 1 : skb_shinfo(tail)->gso_size = max(shinfo->gso_size,
1748 : : skb_shinfo(tail)->gso_size);
1749 : :
1750 : 1 : gso_segs = skb_shinfo(tail)->gso_segs + shinfo->gso_segs;
1751 : 1 : skb_shinfo(tail)->gso_segs = min_t(u32, gso_segs, 0xFFFF);
1752 : :
1753 : 1 : sk->sk_backlog.len += delta;
1754 : 1 : __NET_INC_STATS(sock_net(sk),
1755 : : LINUX_MIB_TCPBACKLOGCOALESCE);
1756 : 1 : kfree_skb_partial(skb, fragstolen);
1757 : 1 : return false;
1758 : : }
1759 : : __skb_push(skb, hdrlen);
1760 : :
1761 : : no_coalesce:
1762 : : /* Only socket owner can try to collapse/prune rx queues
1763 : : * to reduce memory overhead, so add a little headroom here.
1764 : : * Few sockets backlog are possibly concurrently non empty.
1765 : : */
1766 : 1 : limit += 64*1024;
1767 : :
1768 : 1 : if (unlikely(sk_add_backlog(sk, skb, limit))) {
1769 : : bh_unlock_sock(sk);
1770 : 0 : __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPBACKLOGDROP);
1771 : 0 : return true;
1772 : : }
1773 : : return false;
1774 : : }
1775 : : EXPORT_SYMBOL(tcp_add_backlog);
1776 : :
1777 : 0 : int tcp_filter(struct sock *sk, struct sk_buff *skb)
1778 : : {
1779 : 1 : struct tcphdr *th = (struct tcphdr *)skb->data;
1780 : :
1781 : 1 : return sk_filter_trim_cap(sk, skb, th->doff * 4);
1782 : : }
1783 : : EXPORT_SYMBOL(tcp_filter);
1784 : :
1785 : : static void tcp_v4_restore_cb(struct sk_buff *skb)
1786 : : {
1787 : 0 : memmove(IPCB(skb), &TCP_SKB_CB(skb)->header.h4,
1788 : : sizeof(struct inet_skb_parm));
1789 : : }
1790 : :
1791 : 3 : static void tcp_v4_fill_cb(struct sk_buff *skb, const struct iphdr *iph,
1792 : : const struct tcphdr *th)
1793 : : {
1794 : : /* This is tricky : We move IPCB at its correct location into TCP_SKB_CB()
1795 : : * barrier() makes sure compiler wont play fool^Waliasing games.
1796 : : */
1797 : 3 : memmove(&TCP_SKB_CB(skb)->header.h4, IPCB(skb),
1798 : : sizeof(struct inet_skb_parm));
1799 : 3 : barrier();
1800 : :
1801 : 3 : TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1802 : 3 : TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1803 : 3 : skb->len - th->doff * 4);
1804 : 3 : TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1805 : 3 : TCP_SKB_CB(skb)->tcp_flags = tcp_flag_byte(th);
1806 : 3 : TCP_SKB_CB(skb)->tcp_tw_isn = 0;
1807 : 3 : TCP_SKB_CB(skb)->ip_dsfield = ipv4_get_dsfield(iph);
1808 : 3 : TCP_SKB_CB(skb)->sacked = 0;
1809 : 3 : TCP_SKB_CB(skb)->has_rxtstamp =
1810 : 3 : skb->tstamp || skb_hwtstamps(skb)->hwtstamp;
1811 : 3 : }
1812 : :
1813 : : /*
1814 : : * From tcp_input.c
1815 : : */
1816 : :
1817 : 3 : int tcp_v4_rcv(struct sk_buff *skb)
1818 : : {
1819 : 3 : struct net *net = dev_net(skb->dev);
1820 : : struct sk_buff *skb_to_free;
1821 : : int sdif = inet_sdif(skb);
1822 : : const struct iphdr *iph;
1823 : : const struct tcphdr *th;
1824 : : bool refcounted;
1825 : : struct sock *sk;
1826 : : int ret;
1827 : :
1828 : 3 : if (skb->pkt_type != PACKET_HOST)
1829 : : goto discard_it;
1830 : :
1831 : : /* Count it even if it's bad */
1832 : 3 : __TCP_INC_STATS(net, TCP_MIB_INSEGS);
1833 : :
1834 : 3 : if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1835 : : goto discard_it;
1836 : :
1837 : 3 : th = (const struct tcphdr *)skb->data;
1838 : :
1839 : 3 : if (unlikely(th->doff < sizeof(struct tcphdr) / 4))
1840 : : goto bad_packet;
1841 : 3 : if (!pskb_may_pull(skb, th->doff * 4))
1842 : : goto discard_it;
1843 : :
1844 : : /* An explanation is required here, I think.
1845 : : * Packet length and doff are validated by header prediction,
1846 : : * provided case of th->doff==0 is eliminated.
1847 : : * So, we defer the checks. */
1848 : :
1849 : 3 : if (skb_checksum_init(skb, IPPROTO_TCP, inet_compute_pseudo))
1850 : : goto csum_error;
1851 : :
1852 : 3 : th = (const struct tcphdr *)skb->data;
1853 : : iph = ip_hdr(skb);
1854 : : lookup:
1855 : 3 : sk = __inet_lookup_skb(&tcp_hashinfo, skb, __tcp_hdrlen(th), th->source,
1856 : : th->dest, sdif, &refcounted);
1857 : 3 : if (!sk)
1858 : : goto no_tcp_socket;
1859 : :
1860 : : process:
1861 : 1 : if (sk->sk_state == TCP_TIME_WAIT)
1862 : : goto do_time_wait;
1863 : :
1864 : 1 : if (sk->sk_state == TCP_NEW_SYN_RECV) {
1865 : : struct request_sock *req = inet_reqsk(sk);
1866 : 0 : bool req_stolen = false;
1867 : : struct sock *nsk;
1868 : :
1869 : 0 : sk = req->rsk_listener;
1870 : : if (unlikely(tcp_v4_inbound_md5_hash(sk, skb))) {
1871 : : sk_drops_add(sk, skb);
1872 : : reqsk_put(req);
1873 : : goto discard_it;
1874 : : }
1875 : 0 : if (tcp_checksum_complete(skb)) {
1876 : 0 : reqsk_put(req);
1877 : 0 : goto csum_error;
1878 : : }
1879 : 0 : if (unlikely(sk->sk_state != TCP_LISTEN)) {
1880 : 0 : inet_csk_reqsk_queue_drop_and_put(sk, req);
1881 : 0 : goto lookup;
1882 : : }
1883 : : /* We own a reference on the listener, increase it again
1884 : : * as we might lose it too soon.
1885 : : */
1886 : : sock_hold(sk);
1887 : 0 : refcounted = true;
1888 : : nsk = NULL;
1889 : 0 : if (!tcp_filter(sk, skb)) {
1890 : 0 : th = (const struct tcphdr *)skb->data;
1891 : : iph = ip_hdr(skb);
1892 : 0 : tcp_v4_fill_cb(skb, iph, th);
1893 : 0 : nsk = tcp_check_req(sk, skb, req, false, &req_stolen);
1894 : : }
1895 : 0 : if (!nsk) {
1896 : 0 : reqsk_put(req);
1897 : 0 : if (req_stolen) {
1898 : : /* Another cpu got exclusive access to req
1899 : : * and created a full blown socket.
1900 : : * Try to feed this packet to this socket
1901 : : * instead of discarding it.
1902 : : */
1903 : : tcp_v4_restore_cb(skb);
1904 : 0 : sock_put(sk);
1905 : 0 : goto lookup;
1906 : : }
1907 : 0 : goto discard_and_relse;
1908 : : }
1909 : 0 : if (nsk == sk) {
1910 : 0 : reqsk_put(req);
1911 : : tcp_v4_restore_cb(skb);
1912 : 0 : } else if (tcp_child_process(sk, nsk, skb)) {
1913 : 0 : tcp_v4_send_reset(nsk, skb);
1914 : 0 : goto discard_and_relse;
1915 : : } else {
1916 : 0 : sock_put(sk);
1917 : 0 : return 0;
1918 : : }
1919 : : }
1920 : 1 : if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
1921 : 0 : __NET_INC_STATS(net, LINUX_MIB_TCPMINTTLDROP);
1922 : : goto discard_and_relse;
1923 : : }
1924 : :
1925 : 1 : if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1926 : : goto discard_and_relse;
1927 : :
1928 : : if (tcp_v4_inbound_md5_hash(sk, skb))
1929 : : goto discard_and_relse;
1930 : :
1931 : : nf_reset_ct(skb);
1932 : :
1933 : 1 : if (tcp_filter(sk, skb))
1934 : : goto discard_and_relse;
1935 : 1 : th = (const struct tcphdr *)skb->data;
1936 : : iph = ip_hdr(skb);
1937 : 1 : tcp_v4_fill_cb(skb, iph, th);
1938 : :
1939 : 1 : skb->dev = NULL;
1940 : :
1941 : 1 : if (sk->sk_state == TCP_LISTEN) {
1942 : 0 : ret = tcp_v4_do_rcv(sk, skb);
1943 : 0 : goto put_and_return;
1944 : : }
1945 : :
1946 : : sk_incoming_cpu_update(sk);
1947 : :
1948 : 1 : bh_lock_sock_nested(sk);
1949 : 1 : tcp_segs_in(tcp_sk(sk), skb);
1950 : : ret = 0;
1951 : 1 : if (!sock_owned_by_user(sk)) {
1952 : 1 : skb_to_free = sk->sk_rx_skb_cache;
1953 : 1 : sk->sk_rx_skb_cache = NULL;
1954 : 1 : ret = tcp_v4_do_rcv(sk, skb);
1955 : : } else {
1956 : 1 : if (tcp_add_backlog(sk, skb))
1957 : : goto discard_and_relse;
1958 : : skb_to_free = NULL;
1959 : : }
1960 : : bh_unlock_sock(sk);
1961 : 1 : if (skb_to_free)
1962 : 0 : __kfree_skb(skb_to_free);
1963 : :
1964 : : put_and_return:
1965 : 1 : if (refcounted)
1966 : 1 : sock_put(sk);
1967 : :
1968 : 1 : return ret;
1969 : :
1970 : : no_tcp_socket:
1971 : 3 : if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1972 : : goto discard_it;
1973 : :
1974 : 3 : tcp_v4_fill_cb(skb, iph, th);
1975 : :
1976 : 3 : if (tcp_checksum_complete(skb)) {
1977 : : csum_error:
1978 : 0 : __TCP_INC_STATS(net, TCP_MIB_CSUMERRORS);
1979 : : bad_packet:
1980 : 0 : __TCP_INC_STATS(net, TCP_MIB_INERRS);
1981 : : } else {
1982 : 3 : tcp_v4_send_reset(NULL, skb);
1983 : : }
1984 : :
1985 : : discard_it:
1986 : : /* Discard frame. */
1987 : 3 : kfree_skb(skb);
1988 : 3 : return 0;
1989 : :
1990 : : discard_and_relse:
1991 : 0 : sk_drops_add(sk, skb);
1992 : 0 : if (refcounted)
1993 : 0 : sock_put(sk);
1994 : : goto discard_it;
1995 : :
1996 : : do_time_wait:
1997 : 1 : if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1998 : 0 : inet_twsk_put(inet_twsk(sk));
1999 : 0 : goto discard_it;
2000 : : }
2001 : :
2002 : 1 : tcp_v4_fill_cb(skb, iph, th);
2003 : :
2004 : 1 : if (tcp_checksum_complete(skb)) {
2005 : 0 : inet_twsk_put(inet_twsk(sk));
2006 : 0 : goto csum_error;
2007 : : }
2008 : 1 : switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
2009 : : case TCP_TW_SYN: {
2010 : 0 : struct sock *sk2 = inet_lookup_listener(dev_net(skb->dev),
2011 : : &tcp_hashinfo, skb,
2012 : : __tcp_hdrlen(th),
2013 : : iph->saddr, th->source,
2014 : : iph->daddr, th->dest,
2015 : : inet_iif(skb),
2016 : : sdif);
2017 : 0 : if (sk2) {
2018 : 0 : inet_twsk_deschedule_put(inet_twsk(sk));
2019 : : sk = sk2;
2020 : : tcp_v4_restore_cb(skb);
2021 : 0 : refcounted = false;
2022 : 0 : goto process;
2023 : : }
2024 : : }
2025 : : /* to ACK */
2026 : : /* fall through */
2027 : : case TCP_TW_ACK:
2028 : 1 : tcp_v4_timewait_ack(sk, skb);
2029 : 1 : break;
2030 : : case TCP_TW_RST:
2031 : 1 : tcp_v4_send_reset(sk, skb);
2032 : 1 : inet_twsk_deschedule_put(inet_twsk(sk));
2033 : 1 : goto discard_it;
2034 : : case TCP_TW_SUCCESS:;
2035 : : }
2036 : : goto discard_it;
2037 : : }
2038 : :
2039 : : static struct timewait_sock_ops tcp_timewait_sock_ops = {
2040 : : .twsk_obj_size = sizeof(struct tcp_timewait_sock),
2041 : : .twsk_unique = tcp_twsk_unique,
2042 : : .twsk_destructor= tcp_twsk_destructor,
2043 : : };
2044 : :
2045 : 1 : void inet_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb)
2046 : : {
2047 : : struct dst_entry *dst = skb_dst(skb);
2048 : :
2049 : 1 : if (dst && dst_hold_safe(dst)) {
2050 : 1 : sk->sk_rx_dst = dst;
2051 : 1 : inet_sk(sk)->rx_dst_ifindex = skb->skb_iif;
2052 : : }
2053 : 1 : }
2054 : : EXPORT_SYMBOL(inet_sk_rx_dst_set);
2055 : :
2056 : : const struct inet_connection_sock_af_ops ipv4_specific = {
2057 : : .queue_xmit = ip_queue_xmit,
2058 : : .send_check = tcp_v4_send_check,
2059 : : .rebuild_header = inet_sk_rebuild_header,
2060 : : .sk_rx_dst_set = inet_sk_rx_dst_set,
2061 : : .conn_request = tcp_v4_conn_request,
2062 : : .syn_recv_sock = tcp_v4_syn_recv_sock,
2063 : : .net_header_len = sizeof(struct iphdr),
2064 : : .setsockopt = ip_setsockopt,
2065 : : .getsockopt = ip_getsockopt,
2066 : : .addr2sockaddr = inet_csk_addr2sockaddr,
2067 : : .sockaddr_len = sizeof(struct sockaddr_in),
2068 : : #ifdef CONFIG_COMPAT
2069 : : .compat_setsockopt = compat_ip_setsockopt,
2070 : : .compat_getsockopt = compat_ip_getsockopt,
2071 : : #endif
2072 : : .mtu_reduced = tcp_v4_mtu_reduced,
2073 : : };
2074 : : EXPORT_SYMBOL(ipv4_specific);
2075 : :
2076 : : #ifdef CONFIG_TCP_MD5SIG
2077 : : static const struct tcp_sock_af_ops tcp_sock_ipv4_specific = {
2078 : : .md5_lookup = tcp_v4_md5_lookup,
2079 : : .calc_md5_hash = tcp_v4_md5_hash_skb,
2080 : : .md5_parse = tcp_v4_parse_md5_keys,
2081 : : };
2082 : : #endif
2083 : :
2084 : : /* NOTE: A lot of things set to zero explicitly by call to
2085 : : * sk_alloc() so need not be done here.
2086 : : */
2087 : 1 : static int tcp_v4_init_sock(struct sock *sk)
2088 : : {
2089 : : struct inet_connection_sock *icsk = inet_csk(sk);
2090 : :
2091 : 1 : tcp_init_sock(sk);
2092 : :
2093 : 1 : icsk->icsk_af_ops = &ipv4_specific;
2094 : :
2095 : : #ifdef CONFIG_TCP_MD5SIG
2096 : : tcp_sk(sk)->af_specific = &tcp_sock_ipv4_specific;
2097 : : #endif
2098 : :
2099 : 1 : return 0;
2100 : : }
2101 : :
2102 : 1 : void tcp_v4_destroy_sock(struct sock *sk)
2103 : : {
2104 : : struct tcp_sock *tp = tcp_sk(sk);
2105 : :
2106 : 1 : trace_tcp_destroy_sock(sk);
2107 : :
2108 : 1 : tcp_clear_xmit_timers(sk);
2109 : :
2110 : 1 : tcp_cleanup_congestion_control(sk);
2111 : :
2112 : 1 : tcp_cleanup_ulp(sk);
2113 : :
2114 : : /* Cleanup up the write buffer. */
2115 : 1 : tcp_write_queue_purge(sk);
2116 : :
2117 : : /* Check if we want to disable active TFO */
2118 : 1 : tcp_fastopen_active_disable_ofo_check(sk);
2119 : :
2120 : : /* Cleans up our, hopefully empty, out_of_order_queue. */
2121 : 1 : skb_rbtree_purge(&tp->out_of_order_queue);
2122 : :
2123 : : #ifdef CONFIG_TCP_MD5SIG
2124 : : /* Clean up the MD5 key list, if any */
2125 : : if (tp->md5sig_info) {
2126 : : tcp_clear_md5_list(sk);
2127 : : kfree_rcu(rcu_dereference_protected(tp->md5sig_info, 1), rcu);
2128 : : tp->md5sig_info = NULL;
2129 : : }
2130 : : #endif
2131 : :
2132 : : /* Clean up a referenced TCP bind bucket. */
2133 : 1 : if (inet_csk(sk)->icsk_bind_hash)
2134 : 0 : inet_put_port(sk);
2135 : :
2136 : 1 : BUG_ON(rcu_access_pointer(tp->fastopen_rsk));
2137 : :
2138 : : /* If socket is aborted during connect operation */
2139 : 1 : tcp_free_fastopen_req(tp);
2140 : 1 : tcp_fastopen_destroy_cipher(sk);
2141 : : tcp_saved_syn_free(tp);
2142 : :
2143 : 1 : sk_sockets_allocated_dec(sk);
2144 : 1 : }
2145 : : EXPORT_SYMBOL(tcp_v4_destroy_sock);
2146 : :
2147 : : #ifdef CONFIG_PROC_FS
2148 : : /* Proc filesystem TCP sock list dumping. */
2149 : :
2150 : : /*
2151 : : * Get next listener socket follow cur. If cur is NULL, get first socket
2152 : : * starting from bucket given in st->bucket; when st->bucket is zero the
2153 : : * very first socket in the hash table is returned.
2154 : : */
2155 : 0 : static void *listening_get_next(struct seq_file *seq, void *cur)
2156 : : {
2157 : 0 : struct tcp_seq_afinfo *afinfo = PDE_DATA(file_inode(seq->file));
2158 : 0 : struct tcp_iter_state *st = seq->private;
2159 : : struct net *net = seq_file_net(seq);
2160 : : struct inet_listen_hashbucket *ilb;
2161 : : struct hlist_nulls_node *node;
2162 : : struct sock *sk = cur;
2163 : :
2164 : 0 : if (!sk) {
2165 : : get_head:
2166 : 0 : ilb = &tcp_hashinfo.listening_hash[st->bucket];
2167 : : spin_lock(&ilb->lock);
2168 : 0 : sk = sk_nulls_head(&ilb->nulls_head);
2169 : 0 : st->offset = 0;
2170 : 0 : goto get_sk;
2171 : : }
2172 : 0 : ilb = &tcp_hashinfo.listening_hash[st->bucket];
2173 : 0 : ++st->num;
2174 : 0 : ++st->offset;
2175 : :
2176 : : sk = sk_nulls_next(sk);
2177 : : get_sk:
2178 : 0 : sk_nulls_for_each_from(sk, node) {
2179 : 0 : if (!net_eq(sock_net(sk), net))
2180 : 0 : continue;
2181 : 0 : if (sk->sk_family == afinfo->family)
2182 : 0 : return sk;
2183 : : }
2184 : : spin_unlock(&ilb->lock);
2185 : 0 : st->offset = 0;
2186 : 0 : if (++st->bucket < INET_LHTABLE_SIZE)
2187 : : goto get_head;
2188 : : return NULL;
2189 : : }
2190 : :
2191 : 0 : static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
2192 : : {
2193 : 0 : struct tcp_iter_state *st = seq->private;
2194 : : void *rc;
2195 : :
2196 : 0 : st->bucket = 0;
2197 : 0 : st->offset = 0;
2198 : 0 : rc = listening_get_next(seq, NULL);
2199 : :
2200 : 0 : while (rc && *pos) {
2201 : 0 : rc = listening_get_next(seq, rc);
2202 : 0 : --*pos;
2203 : : }
2204 : 0 : return rc;
2205 : : }
2206 : :
2207 : : static inline bool empty_bucket(const struct tcp_iter_state *st)
2208 : : {
2209 : 0 : return hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].chain);
2210 : : }
2211 : :
2212 : : /*
2213 : : * Get first established socket starting from bucket given in st->bucket.
2214 : : * If st->bucket is zero, the very first socket in the hash is returned.
2215 : : */
2216 : 0 : static void *established_get_first(struct seq_file *seq)
2217 : : {
2218 : 0 : struct tcp_seq_afinfo *afinfo = PDE_DATA(file_inode(seq->file));
2219 : 0 : struct tcp_iter_state *st = seq->private;
2220 : : struct net *net = seq_file_net(seq);
2221 : : void *rc = NULL;
2222 : :
2223 : 0 : st->offset = 0;
2224 : 0 : for (; st->bucket <= tcp_hashinfo.ehash_mask; ++st->bucket) {
2225 : : struct sock *sk;
2226 : : struct hlist_nulls_node *node;
2227 : : spinlock_t *lock = inet_ehash_lockp(&tcp_hashinfo, st->bucket);
2228 : :
2229 : : /* Lockless fast path for the common case of empty buckets */
2230 : 0 : if (empty_bucket(st))
2231 : 0 : continue;
2232 : :
2233 : : spin_lock_bh(lock);
2234 : 0 : sk_nulls_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
2235 : 0 : if (sk->sk_family != afinfo->family ||
2236 : : !net_eq(sock_net(sk), net)) {
2237 : 0 : continue;
2238 : : }
2239 : 0 : rc = sk;
2240 : 0 : goto out;
2241 : : }
2242 : : spin_unlock_bh(lock);
2243 : : }
2244 : : out:
2245 : 0 : return rc;
2246 : : }
2247 : :
2248 : 0 : static void *established_get_next(struct seq_file *seq, void *cur)
2249 : : {
2250 : 0 : struct tcp_seq_afinfo *afinfo = PDE_DATA(file_inode(seq->file));
2251 : : struct sock *sk = cur;
2252 : : struct hlist_nulls_node *node;
2253 : 0 : struct tcp_iter_state *st = seq->private;
2254 : : struct net *net = seq_file_net(seq);
2255 : :
2256 : 0 : ++st->num;
2257 : 0 : ++st->offset;
2258 : :
2259 : : sk = sk_nulls_next(sk);
2260 : :
2261 : 0 : sk_nulls_for_each_from(sk, node) {
2262 : 0 : if (sk->sk_family == afinfo->family &&
2263 : : net_eq(sock_net(sk), net))
2264 : 0 : return sk;
2265 : : }
2266 : :
2267 : 0 : spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
2268 : 0 : ++st->bucket;
2269 : 0 : return established_get_first(seq);
2270 : : }
2271 : :
2272 : 0 : static void *established_get_idx(struct seq_file *seq, loff_t pos)
2273 : : {
2274 : 0 : struct tcp_iter_state *st = seq->private;
2275 : : void *rc;
2276 : :
2277 : 0 : st->bucket = 0;
2278 : 0 : rc = established_get_first(seq);
2279 : :
2280 : 0 : while (rc && pos) {
2281 : 0 : rc = established_get_next(seq, rc);
2282 : 0 : --pos;
2283 : : }
2284 : 0 : return rc;
2285 : : }
2286 : :
2287 : 0 : static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
2288 : : {
2289 : : void *rc;
2290 : 0 : struct tcp_iter_state *st = seq->private;
2291 : :
2292 : 0 : st->state = TCP_SEQ_STATE_LISTENING;
2293 : 0 : rc = listening_get_idx(seq, &pos);
2294 : :
2295 : 0 : if (!rc) {
2296 : 0 : st->state = TCP_SEQ_STATE_ESTABLISHED;
2297 : 0 : rc = established_get_idx(seq, pos);
2298 : : }
2299 : :
2300 : 0 : return rc;
2301 : : }
2302 : :
2303 : 0 : static void *tcp_seek_last_pos(struct seq_file *seq)
2304 : : {
2305 : 0 : struct tcp_iter_state *st = seq->private;
2306 : 0 : int offset = st->offset;
2307 : 0 : int orig_num = st->num;
2308 : : void *rc = NULL;
2309 : :
2310 : 0 : switch (st->state) {
2311 : : case TCP_SEQ_STATE_LISTENING:
2312 : 0 : if (st->bucket >= INET_LHTABLE_SIZE)
2313 : : break;
2314 : 0 : st->state = TCP_SEQ_STATE_LISTENING;
2315 : 0 : rc = listening_get_next(seq, NULL);
2316 : 0 : while (offset-- && rc)
2317 : 0 : rc = listening_get_next(seq, rc);
2318 : 0 : if (rc)
2319 : : break;
2320 : 0 : st->bucket = 0;
2321 : 0 : st->state = TCP_SEQ_STATE_ESTABLISHED;
2322 : : /* Fallthrough */
2323 : : case TCP_SEQ_STATE_ESTABLISHED:
2324 : 0 : if (st->bucket > tcp_hashinfo.ehash_mask)
2325 : : break;
2326 : 0 : rc = established_get_first(seq);
2327 : 0 : while (offset-- && rc)
2328 : 0 : rc = established_get_next(seq, rc);
2329 : : }
2330 : :
2331 : 0 : st->num = orig_num;
2332 : :
2333 : 0 : return rc;
2334 : : }
2335 : :
2336 : 0 : void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
2337 : : {
2338 : 0 : struct tcp_iter_state *st = seq->private;
2339 : : void *rc;
2340 : :
2341 : 0 : if (*pos && *pos == st->last_pos) {
2342 : 0 : rc = tcp_seek_last_pos(seq);
2343 : 0 : if (rc)
2344 : : goto out;
2345 : : }
2346 : :
2347 : 0 : st->state = TCP_SEQ_STATE_LISTENING;
2348 : 0 : st->num = 0;
2349 : 0 : st->bucket = 0;
2350 : 0 : st->offset = 0;
2351 : 0 : rc = *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2352 : :
2353 : : out:
2354 : 0 : st->last_pos = *pos;
2355 : 0 : return rc;
2356 : : }
2357 : : EXPORT_SYMBOL(tcp_seq_start);
2358 : :
2359 : 0 : void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2360 : : {
2361 : 0 : struct tcp_iter_state *st = seq->private;
2362 : : void *rc = NULL;
2363 : :
2364 : 0 : if (v == SEQ_START_TOKEN) {
2365 : 0 : rc = tcp_get_idx(seq, 0);
2366 : 0 : goto out;
2367 : : }
2368 : :
2369 : 0 : switch (st->state) {
2370 : : case TCP_SEQ_STATE_LISTENING:
2371 : 0 : rc = listening_get_next(seq, v);
2372 : 0 : if (!rc) {
2373 : 0 : st->state = TCP_SEQ_STATE_ESTABLISHED;
2374 : 0 : st->bucket = 0;
2375 : 0 : st->offset = 0;
2376 : 0 : rc = established_get_first(seq);
2377 : : }
2378 : : break;
2379 : : case TCP_SEQ_STATE_ESTABLISHED:
2380 : 0 : rc = established_get_next(seq, v);
2381 : 0 : break;
2382 : : }
2383 : : out:
2384 : 0 : ++*pos;
2385 : 0 : st->last_pos = *pos;
2386 : 0 : return rc;
2387 : : }
2388 : : EXPORT_SYMBOL(tcp_seq_next);
2389 : :
2390 : 0 : void tcp_seq_stop(struct seq_file *seq, void *v)
2391 : : {
2392 : 0 : struct tcp_iter_state *st = seq->private;
2393 : :
2394 : 0 : switch (st->state) {
2395 : : case TCP_SEQ_STATE_LISTENING:
2396 : 0 : if (v != SEQ_START_TOKEN)
2397 : 0 : spin_unlock(&tcp_hashinfo.listening_hash[st->bucket].lock);
2398 : : break;
2399 : : case TCP_SEQ_STATE_ESTABLISHED:
2400 : 0 : if (v)
2401 : 0 : spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
2402 : : break;
2403 : : }
2404 : 0 : }
2405 : : EXPORT_SYMBOL(tcp_seq_stop);
2406 : :
2407 : 0 : static void get_openreq4(const struct request_sock *req,
2408 : : struct seq_file *f, int i)
2409 : : {
2410 : : const struct inet_request_sock *ireq = inet_rsk(req);
2411 : 0 : long delta = req->rsk_timer.expires - jiffies;
2412 : :
2413 : 0 : seq_printf(f, "%4d: %08X:%04X %08X:%04X"
2414 : : " %02X %08X:%08X %02X:%08lX %08X %5u %8d %u %d %pK",
2415 : : i,
2416 : : ireq->ir_loc_addr,
2417 : 0 : ireq->ir_num,
2418 : : ireq->ir_rmt_addr,
2419 : 0 : ntohs(ireq->ir_rmt_port),
2420 : : TCP_SYN_RECV,
2421 : : 0, 0, /* could print option size, but that is af dependent. */
2422 : : 1, /* timers active (only the expire timer) */
2423 : : jiffies_delta_to_clock_t(delta),
2424 : 0 : req->num_timeout,
2425 : : from_kuid_munged(seq_user_ns(f),
2426 : : sock_i_uid(req->rsk_listener)),
2427 : : 0, /* non standard timer */
2428 : : 0, /* open_requests have no inode */
2429 : : 0,
2430 : : req);
2431 : 0 : }
2432 : :
2433 : 0 : static void get_tcp4_sock(struct sock *sk, struct seq_file *f, int i)
2434 : : {
2435 : : int timer_active;
2436 : : unsigned long timer_expires;
2437 : : const struct tcp_sock *tp = tcp_sk(sk);
2438 : : const struct inet_connection_sock *icsk = inet_csk(sk);
2439 : : const struct inet_sock *inet = inet_sk(sk);
2440 : : const struct fastopen_queue *fastopenq = &icsk->icsk_accept_queue.fastopenq;
2441 : 0 : __be32 dest = inet->inet_daddr;
2442 : 0 : __be32 src = inet->inet_rcv_saddr;
2443 : 0 : __u16 destp = ntohs(inet->inet_dport);
2444 : 0 : __u16 srcp = ntohs(inet->inet_sport);
2445 : : int rx_queue;
2446 : : int state;
2447 : :
2448 : 0 : if (icsk->icsk_pending == ICSK_TIME_RETRANS ||
2449 : 0 : icsk->icsk_pending == ICSK_TIME_REO_TIMEOUT ||
2450 : : icsk->icsk_pending == ICSK_TIME_LOSS_PROBE) {
2451 : : timer_active = 1;
2452 : 0 : timer_expires = icsk->icsk_timeout;
2453 : 0 : } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
2454 : : timer_active = 4;
2455 : 0 : timer_expires = icsk->icsk_timeout;
2456 : 0 : } else if (timer_pending(&sk->sk_timer)) {
2457 : : timer_active = 2;
2458 : 0 : timer_expires = sk->sk_timer.expires;
2459 : : } else {
2460 : : timer_active = 0;
2461 : 0 : timer_expires = jiffies;
2462 : : }
2463 : :
2464 : : state = inet_sk_state_load(sk);
2465 : 0 : if (state == TCP_LISTEN)
2466 : 0 : rx_queue = sk->sk_ack_backlog;
2467 : : else
2468 : : /* Because we don't lock the socket,
2469 : : * we might find a transient negative value.
2470 : : */
2471 : 0 : rx_queue = max_t(int, READ_ONCE(tp->rcv_nxt) -
2472 : : READ_ONCE(tp->copied_seq), 0);
2473 : :
2474 : 0 : seq_printf(f, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
2475 : : "%08X %5u %8d %lu %d %pK %lu %lu %u %u %d",
2476 : : i, src, srcp, dest, destp, state,
2477 : 0 : READ_ONCE(tp->write_seq) - tp->snd_una,
2478 : : rx_queue,
2479 : : timer_active,
2480 : 0 : jiffies_delta_to_clock_t(timer_expires - jiffies),
2481 : 0 : icsk->icsk_retransmits,
2482 : : from_kuid_munged(seq_user_ns(f), sock_i_uid(sk)),
2483 : 0 : icsk->icsk_probes_out,
2484 : : sock_i_ino(sk),
2485 : : refcount_read(&sk->sk_refcnt), sk,
2486 : 0 : jiffies_to_clock_t(icsk->icsk_rto),
2487 : 0 : jiffies_to_clock_t(icsk->icsk_ack.ato),
2488 : 0 : (icsk->icsk_ack.quick << 1) | inet_csk_in_pingpong_mode(sk),
2489 : : tp->snd_cwnd,
2490 : : state == TCP_LISTEN ?
2491 : 0 : fastopenq->max_qlen :
2492 : 0 : (tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh));
2493 : 0 : }
2494 : :
2495 : 0 : static void get_timewait4_sock(const struct inet_timewait_sock *tw,
2496 : : struct seq_file *f, int i)
2497 : : {
2498 : 0 : long delta = tw->tw_timer.expires - jiffies;
2499 : : __be32 dest, src;
2500 : : __u16 destp, srcp;
2501 : :
2502 : 0 : dest = tw->tw_daddr;
2503 : 0 : src = tw->tw_rcv_saddr;
2504 : 0 : destp = ntohs(tw->tw_dport);
2505 : 0 : srcp = ntohs(tw->tw_sport);
2506 : :
2507 : 0 : seq_printf(f, "%4d: %08X:%04X %08X:%04X"
2508 : : " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK",
2509 : 0 : i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
2510 : : 3, jiffies_delta_to_clock_t(delta), 0, 0, 0, 0,
2511 : : refcount_read(&tw->tw_refcnt), tw);
2512 : 0 : }
2513 : :
2514 : : #define TMPSZ 150
2515 : :
2516 : 0 : static int tcp4_seq_show(struct seq_file *seq, void *v)
2517 : : {
2518 : : struct tcp_iter_state *st;
2519 : : struct sock *sk = v;
2520 : :
2521 : : seq_setwidth(seq, TMPSZ - 1);
2522 : 0 : if (v == SEQ_START_TOKEN) {
2523 : 0 : seq_puts(seq, " sl local_address rem_address st tx_queue "
2524 : : "rx_queue tr tm->when retrnsmt uid timeout "
2525 : : "inode");
2526 : 0 : goto out;
2527 : : }
2528 : 0 : st = seq->private;
2529 : :
2530 : 0 : if (sk->sk_state == TCP_TIME_WAIT)
2531 : 0 : get_timewait4_sock(v, seq, st->num);
2532 : 0 : else if (sk->sk_state == TCP_NEW_SYN_RECV)
2533 : 0 : get_openreq4(v, seq, st->num);
2534 : : else
2535 : 0 : get_tcp4_sock(v, seq, st->num);
2536 : : out:
2537 : 0 : seq_pad(seq, '\n');
2538 : 0 : return 0;
2539 : : }
2540 : :
2541 : : static const struct seq_operations tcp4_seq_ops = {
2542 : : .show = tcp4_seq_show,
2543 : : .start = tcp_seq_start,
2544 : : .next = tcp_seq_next,
2545 : : .stop = tcp_seq_stop,
2546 : : };
2547 : :
2548 : : static struct tcp_seq_afinfo tcp4_seq_afinfo = {
2549 : : .family = AF_INET,
2550 : : };
2551 : :
2552 : 3 : static int __net_init tcp4_proc_init_net(struct net *net)
2553 : : {
2554 : 3 : if (!proc_create_net_data("tcp", 0444, net->proc_net, &tcp4_seq_ops,
2555 : : sizeof(struct tcp_iter_state), &tcp4_seq_afinfo))
2556 : : return -ENOMEM;
2557 : 3 : return 0;
2558 : : }
2559 : :
2560 : 1 : static void __net_exit tcp4_proc_exit_net(struct net *net)
2561 : : {
2562 : 1 : remove_proc_entry("tcp", net->proc_net);
2563 : 1 : }
2564 : :
2565 : : static struct pernet_operations tcp4_net_ops = {
2566 : : .init = tcp4_proc_init_net,
2567 : : .exit = tcp4_proc_exit_net,
2568 : : };
2569 : :
2570 : 3 : int __init tcp4_proc_init(void)
2571 : : {
2572 : 3 : return register_pernet_subsys(&tcp4_net_ops);
2573 : : }
2574 : :
2575 : 0 : void tcp4_proc_exit(void)
2576 : : {
2577 : 0 : unregister_pernet_subsys(&tcp4_net_ops);
2578 : 0 : }
2579 : : #endif /* CONFIG_PROC_FS */
2580 : :
2581 : : struct proto tcp_prot = {
2582 : : .name = "TCP",
2583 : : .owner = THIS_MODULE,
2584 : : .close = tcp_close,
2585 : : .pre_connect = tcp_v4_pre_connect,
2586 : : .connect = tcp_v4_connect,
2587 : : .disconnect = tcp_disconnect,
2588 : : .accept = inet_csk_accept,
2589 : : .ioctl = tcp_ioctl,
2590 : : .init = tcp_v4_init_sock,
2591 : : .destroy = tcp_v4_destroy_sock,
2592 : : .shutdown = tcp_shutdown,
2593 : : .setsockopt = tcp_setsockopt,
2594 : : .getsockopt = tcp_getsockopt,
2595 : : .keepalive = tcp_set_keepalive,
2596 : : .recvmsg = tcp_recvmsg,
2597 : : .sendmsg = tcp_sendmsg,
2598 : : .sendpage = tcp_sendpage,
2599 : : .backlog_rcv = tcp_v4_do_rcv,
2600 : : .release_cb = tcp_release_cb,
2601 : : .hash = inet_hash,
2602 : : .unhash = inet_unhash,
2603 : : .get_port = inet_csk_get_port,
2604 : : .enter_memory_pressure = tcp_enter_memory_pressure,
2605 : : .leave_memory_pressure = tcp_leave_memory_pressure,
2606 : : .stream_memory_free = tcp_stream_memory_free,
2607 : : .sockets_allocated = &tcp_sockets_allocated,
2608 : : .orphan_count = &tcp_orphan_count,
2609 : : .memory_allocated = &tcp_memory_allocated,
2610 : : .memory_pressure = &tcp_memory_pressure,
2611 : : .sysctl_mem = sysctl_tcp_mem,
2612 : : .sysctl_wmem_offset = offsetof(struct net, ipv4.sysctl_tcp_wmem),
2613 : : .sysctl_rmem_offset = offsetof(struct net, ipv4.sysctl_tcp_rmem),
2614 : : .max_header = MAX_TCP_HEADER,
2615 : : .obj_size = sizeof(struct tcp_sock),
2616 : : .slab_flags = SLAB_TYPESAFE_BY_RCU,
2617 : : .twsk_prot = &tcp_timewait_sock_ops,
2618 : : .rsk_prot = &tcp_request_sock_ops,
2619 : : .h.hashinfo = &tcp_hashinfo,
2620 : : .no_autobind = true,
2621 : : #ifdef CONFIG_COMPAT
2622 : : .compat_setsockopt = compat_tcp_setsockopt,
2623 : : .compat_getsockopt = compat_tcp_getsockopt,
2624 : : #endif
2625 : : .diag_destroy = tcp_abort,
2626 : : };
2627 : : EXPORT_SYMBOL(tcp_prot);
2628 : :
2629 : 1 : static void __net_exit tcp_sk_exit(struct net *net)
2630 : : {
2631 : : int cpu;
2632 : :
2633 : 1 : if (net->ipv4.tcp_congestion_control)
2634 : 1 : module_put(net->ipv4.tcp_congestion_control->owner);
2635 : :
2636 : 1 : for_each_possible_cpu(cpu)
2637 : 1 : inet_ctl_sock_destroy(*per_cpu_ptr(net->ipv4.tcp_sk, cpu));
2638 : 1 : free_percpu(net->ipv4.tcp_sk);
2639 : 1 : }
2640 : :
2641 : 3 : static int __net_init tcp_sk_init(struct net *net)
2642 : : {
2643 : : int res, cpu, cnt;
2644 : :
2645 : 3 : net->ipv4.tcp_sk = alloc_percpu(struct sock *);
2646 : 3 : if (!net->ipv4.tcp_sk)
2647 : : return -ENOMEM;
2648 : :
2649 : 3 : for_each_possible_cpu(cpu) {
2650 : : struct sock *sk;
2651 : :
2652 : 3 : res = inet_ctl_sock_create(&sk, PF_INET, SOCK_RAW,
2653 : : IPPROTO_TCP, net);
2654 : 3 : if (res)
2655 : : goto fail;
2656 : 3 : sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
2657 : :
2658 : : /* Please enforce IP_DF and IPID==0 for RST and
2659 : : * ACK sent in SYN-RECV and TIME-WAIT state.
2660 : : */
2661 : 3 : inet_sk(sk)->pmtudisc = IP_PMTUDISC_DO;
2662 : :
2663 : 3 : *per_cpu_ptr(net->ipv4.tcp_sk, cpu) = sk;
2664 : : }
2665 : :
2666 : 3 : net->ipv4.sysctl_tcp_ecn = 2;
2667 : 3 : net->ipv4.sysctl_tcp_ecn_fallback = 1;
2668 : :
2669 : 3 : net->ipv4.sysctl_tcp_base_mss = TCP_BASE_MSS;
2670 : 3 : net->ipv4.sysctl_tcp_min_snd_mss = TCP_MIN_SND_MSS;
2671 : 3 : net->ipv4.sysctl_tcp_probe_threshold = TCP_PROBE_THRESHOLD;
2672 : 3 : net->ipv4.sysctl_tcp_probe_interval = TCP_PROBE_INTERVAL;
2673 : 3 : net->ipv4.sysctl_tcp_mtu_probe_floor = TCP_MIN_SND_MSS;
2674 : :
2675 : 3 : net->ipv4.sysctl_tcp_keepalive_time = TCP_KEEPALIVE_TIME;
2676 : 3 : net->ipv4.sysctl_tcp_keepalive_probes = TCP_KEEPALIVE_PROBES;
2677 : 3 : net->ipv4.sysctl_tcp_keepalive_intvl = TCP_KEEPALIVE_INTVL;
2678 : :
2679 : 3 : net->ipv4.sysctl_tcp_syn_retries = TCP_SYN_RETRIES;
2680 : 3 : net->ipv4.sysctl_tcp_synack_retries = TCP_SYNACK_RETRIES;
2681 : 3 : net->ipv4.sysctl_tcp_syncookies = 1;
2682 : 3 : net->ipv4.sysctl_tcp_reordering = TCP_FASTRETRANS_THRESH;
2683 : 3 : net->ipv4.sysctl_tcp_retries1 = TCP_RETR1;
2684 : 3 : net->ipv4.sysctl_tcp_retries2 = TCP_RETR2;
2685 : 3 : net->ipv4.sysctl_tcp_orphan_retries = 0;
2686 : 3 : net->ipv4.sysctl_tcp_fin_timeout = TCP_FIN_TIMEOUT;
2687 : 3 : net->ipv4.sysctl_tcp_notsent_lowat = UINT_MAX;
2688 : 3 : net->ipv4.sysctl_tcp_tw_reuse = 2;
2689 : :
2690 : 3 : cnt = tcp_hashinfo.ehash_mask + 1;
2691 : 3 : net->ipv4.tcp_death_row.sysctl_max_tw_buckets = cnt / 2;
2692 : 3 : net->ipv4.tcp_death_row.hashinfo = &tcp_hashinfo;
2693 : :
2694 : 3 : net->ipv4.sysctl_max_syn_backlog = max(128, cnt / 128);
2695 : 3 : net->ipv4.sysctl_tcp_sack = 1;
2696 : 3 : net->ipv4.sysctl_tcp_window_scaling = 1;
2697 : 3 : net->ipv4.sysctl_tcp_timestamps = 1;
2698 : 3 : net->ipv4.sysctl_tcp_early_retrans = 3;
2699 : 3 : net->ipv4.sysctl_tcp_recovery = TCP_RACK_LOSS_DETECTION;
2700 : 3 : net->ipv4.sysctl_tcp_slow_start_after_idle = 1; /* By default, RFC2861 behavior. */
2701 : 3 : net->ipv4.sysctl_tcp_retrans_collapse = 1;
2702 : 3 : net->ipv4.sysctl_tcp_max_reordering = 300;
2703 : 3 : net->ipv4.sysctl_tcp_dsack = 1;
2704 : 3 : net->ipv4.sysctl_tcp_app_win = 31;
2705 : 3 : net->ipv4.sysctl_tcp_adv_win_scale = 1;
2706 : 3 : net->ipv4.sysctl_tcp_frto = 2;
2707 : 3 : net->ipv4.sysctl_tcp_moderate_rcvbuf = 1;
2708 : : /* This limits the percentage of the congestion window which we
2709 : : * will allow a single TSO frame to consume. Building TSO frames
2710 : : * which are too large can cause TCP streams to be bursty.
2711 : : */
2712 : 3 : net->ipv4.sysctl_tcp_tso_win_divisor = 3;
2713 : : /* Default TSQ limit of 16 TSO segments */
2714 : 3 : net->ipv4.sysctl_tcp_limit_output_bytes = 16 * 65536;
2715 : : /* rfc5961 challenge ack rate limiting */
2716 : 3 : net->ipv4.sysctl_tcp_challenge_ack_limit = 1000;
2717 : 3 : net->ipv4.sysctl_tcp_min_tso_segs = 2;
2718 : 3 : net->ipv4.sysctl_tcp_min_rtt_wlen = 300;
2719 : 3 : net->ipv4.sysctl_tcp_autocorking = 1;
2720 : 3 : net->ipv4.sysctl_tcp_invalid_ratelimit = HZ/2;
2721 : 3 : net->ipv4.sysctl_tcp_pacing_ss_ratio = 200;
2722 : 3 : net->ipv4.sysctl_tcp_pacing_ca_ratio = 120;
2723 : 3 : if (net != &init_net) {
2724 : 1 : memcpy(net->ipv4.sysctl_tcp_rmem,
2725 : : init_net.ipv4.sysctl_tcp_rmem,
2726 : : sizeof(init_net.ipv4.sysctl_tcp_rmem));
2727 : 1 : memcpy(net->ipv4.sysctl_tcp_wmem,
2728 : : init_net.ipv4.sysctl_tcp_wmem,
2729 : : sizeof(init_net.ipv4.sysctl_tcp_wmem));
2730 : : }
2731 : 3 : net->ipv4.sysctl_tcp_comp_sack_delay_ns = NSEC_PER_MSEC;
2732 : 3 : net->ipv4.sysctl_tcp_comp_sack_nr = 44;
2733 : 3 : net->ipv4.sysctl_tcp_fastopen = TFO_CLIENT_ENABLE;
2734 : 3 : spin_lock_init(&net->ipv4.tcp_fastopen_ctx_lock);
2735 : 3 : net->ipv4.sysctl_tcp_fastopen_blackhole_timeout = 60 * 60;
2736 : : atomic_set(&net->ipv4.tfo_active_disable_times, 0);
2737 : :
2738 : : /* Reno is always built in */
2739 : 3 : if (!net_eq(net, &init_net) &&
2740 : 1 : try_module_get(init_net.ipv4.tcp_congestion_control->owner))
2741 : 1 : net->ipv4.tcp_congestion_control = init_net.ipv4.tcp_congestion_control;
2742 : : else
2743 : 3 : net->ipv4.tcp_congestion_control = &tcp_reno;
2744 : :
2745 : : return 0;
2746 : : fail:
2747 : 0 : tcp_sk_exit(net);
2748 : :
2749 : 0 : return res;
2750 : : }
2751 : :
2752 : 1 : static void __net_exit tcp_sk_exit_batch(struct list_head *net_exit_list)
2753 : : {
2754 : : struct net *net;
2755 : :
2756 : 1 : inet_twsk_purge(&tcp_hashinfo, AF_INET);
2757 : :
2758 : 1 : list_for_each_entry(net, net_exit_list, exit_list)
2759 : 1 : tcp_fastopen_ctx_destroy(net);
2760 : 1 : }
2761 : :
2762 : : static struct pernet_operations __net_initdata tcp_sk_ops = {
2763 : : .init = tcp_sk_init,
2764 : : .exit = tcp_sk_exit,
2765 : : .exit_batch = tcp_sk_exit_batch,
2766 : : };
2767 : :
2768 : 3 : void __init tcp_v4_init(void)
2769 : : {
2770 : 3 : if (register_pernet_subsys(&tcp_sk_ops))
2771 : 0 : panic("Failed to create the TCP control socket.\n");
2772 : 3 : }
|
