blob: 32b048e524d6773538918eca175b3f422f9c2aa7 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * Implementation of the Transmission Control Protocol(TCP).
7 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 * IPv4 specific functions
9 *
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 * This program is free software; you can redistribute it and/or
19 * modify it under the terms of the GNU General Public License
20 * as published by the Free Software Foundation; either version
21 * 2 of the License, or (at your option) any later version.
22 */
23
24/*
25 * Changes:
26 * David S. Miller : New socket lookup architecture.
27 * This code is dedicated to John Dyson.
28 * David S. Miller : Change semantics of established hash,
29 * half is devoted to TIME_WAIT sockets
30 * and the rest go in the other half.
31 * Andi Kleen : Add support for syncookies and fixed
32 * some bugs: ip options weren't passed to
33 * the TCP layer, missed a check for an
34 * ACK bit.
35 * Andi Kleen : Implemented fast path mtu discovery.
36 * Fixed many serious bugs in the
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -070037 * request_sock handling and moved
Linus Torvalds1da177e2005-04-16 15:20:36 -070038 * most of it into the af independent code.
39 * Added tail drop and some other bugfixes.
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -080040 * Added new listen semantics.
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 * Mike McLagan : Routing by source
42 * Juan Jose Ciarlante: ip_dynaddr bits
43 * Andi Kleen: various fixes.
44 * Vitaly E. Lavrov : Transparent proxy revived after year
45 * coma.
46 * Andi Kleen : Fix new listen.
47 * Andi Kleen : Fix accept error reporting.
48 * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which
49 * Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind
50 * a single port at the same time.
51 */
52
Joe Perchesafd465032012-03-12 07:03:32 +000053#define pr_fmt(fmt) "TCP: " fmt
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
Herbert Xueb4dea52008-12-29 23:04:08 -080055#include <linux/bottom_half.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070056#include <linux/types.h>
57#include <linux/fcntl.h>
58#include <linux/module.h>
59#include <linux/random.h>
60#include <linux/cache.h>
61#include <linux/jhash.h>
62#include <linux/init.h>
63#include <linux/times.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090064#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020066#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070067#include <net/icmp.h>
Arnaldo Carvalho de Melo304a1612005-08-09 19:59:20 -070068#include <net/inet_hashtables.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070069#include <net/tcp.h>
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -030070#include <net/transp_v6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070071#include <net/ipv6.h>
72#include <net/inet_common.h>
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -080073#include <net/timewait_sock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070074#include <net/xfrm.h>
David S. Miller6e5714e2011-08-03 20:50:44 -070075#include <net/secure_seq.h>
Eliezer Tamir076bb0c2013-07-10 17:13:17 +030076#include <net/busy_poll.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
78#include <linux/inet.h>
79#include <linux/ipv6.h>
80#include <linux/stddef.h>
81#include <linux/proc_fs.h>
82#include <linux/seq_file.h>
83
Herbert Xucf80e0e2016-01-24 21:20:23 +080084#include <crypto/hash.h>
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080085#include <linux/scatterlist.h>
86
Brian Haleyab32ea52006-09-22 14:15:41 -070087int sysctl_tcp_tw_reuse __read_mostly;
88int sysctl_tcp_low_latency __read_mostly;
Eric Dumazet4bc2f182010-07-09 21:22:10 +000089EXPORT_SYMBOL(sysctl_tcp_low_latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080091#ifdef CONFIG_TCP_MD5SIG
Eric Dumazeta915da9b2012-01-31 05:18:33 +000092static int tcp_v4_md5_hash_hdr(char *md5_hash, const struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -040093 __be32 daddr, __be32 saddr, const struct tcphdr *th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080094#endif
95
Eric Dumazet5caea4e2008-11-20 00:40:07 -080096struct inet_hashinfo tcp_hashinfo;
Eric Dumazet4bc2f182010-07-09 21:22:10 +000097EXPORT_SYMBOL(tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -070098
Octavian Purdila936b8bd2014-06-25 17:09:57 +030099static __u32 tcp_v4_init_sequence(const struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700101 return secure_tcp_sequence_number(ip_hdr(skb)->daddr,
102 ip_hdr(skb)->saddr,
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700103 tcp_hdr(skb)->dest,
104 tcp_hdr(skb)->source);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105}
106
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800107int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp)
108{
109 const struct tcp_timewait_sock *tcptw = tcp_twsk(sktw);
110 struct tcp_sock *tp = tcp_sk(sk);
111
112 /* With PAWS, it is safe from the viewpoint
113 of data integrity. Even without PAWS it is safe provided sequence
114 spaces do not overlap i.e. at data rates <= 80Mbit/sec.
115
116 Actually, the idea is close to VJ's one, only timestamp cache is
117 held not per host, but per port pair and TW bucket is used as state
118 holder.
119
120 If TW bucket has been already destroyed we fall back to VJ's scheme
121 and use initial timestamp retrieved from peer table.
122 */
123 if (tcptw->tw_ts_recent_stamp &&
Ian Morris51456b22015-04-03 09:17:26 +0100124 (!twp || (sysctl_tcp_tw_reuse &&
James Morris9d729f72007-03-04 16:12:44 -0800125 get_seconds() - tcptw->tw_ts_recent_stamp > 1))) {
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800126 tp->write_seq = tcptw->tw_snd_nxt + 65535 + 2;
127 if (tp->write_seq == 0)
128 tp->write_seq = 1;
129 tp->rx_opt.ts_recent = tcptw->tw_ts_recent;
130 tp->rx_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp;
131 sock_hold(sktw);
132 return 1;
133 }
134
135 return 0;
136}
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800137EXPORT_SYMBOL_GPL(tcp_twsk_unique);
138
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139/* This will initiate an outgoing connection. */
140int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
141{
David S. Miller2d7192d2011-04-26 13:28:44 -0700142 struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 struct inet_sock *inet = inet_sk(sk);
144 struct tcp_sock *tp = tcp_sk(sk);
David S. Millerdca8b082011-02-24 13:38:12 -0800145 __be16 orig_sport, orig_dport;
Al Virobada8ad2006-09-26 21:27:15 -0700146 __be32 daddr, nexthop;
David S. Millerda905bd2011-05-06 16:11:19 -0700147 struct flowi4 *fl4;
David S. Miller2d7192d2011-04-26 13:28:44 -0700148 struct rtable *rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 int err;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000150 struct ip_options_rcu *inet_opt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151
152 if (addr_len < sizeof(struct sockaddr_in))
153 return -EINVAL;
154
155 if (usin->sin_family != AF_INET)
156 return -EAFNOSUPPORT;
157
158 nexthop = daddr = usin->sin_addr.s_addr;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000159 inet_opt = rcu_dereference_protected(inet->inet_opt,
Hannes Frederic Sowa1e1d04e2016-04-05 17:10:15 +0200160 lockdep_sock_is_held(sk));
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000161 if (inet_opt && inet_opt->opt.srr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 if (!daddr)
163 return -EINVAL;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000164 nexthop = inet_opt->opt.faddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 }
166
David S. Millerdca8b082011-02-24 13:38:12 -0800167 orig_sport = inet->inet_sport;
168 orig_dport = usin->sin_port;
David S. Millerda905bd2011-05-06 16:11:19 -0700169 fl4 = &inet->cork.fl.u.ip4;
170 rt = ip_route_connect(fl4, nexthop, inet->inet_saddr,
David S. Millerb23dd4f2011-03-02 14:31:35 -0800171 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
172 IPPROTO_TCP,
Steffen Klassert0e0d44a2013-08-28 08:04:14 +0200173 orig_sport, orig_dport, sk);
David S. Millerb23dd4f2011-03-02 14:31:35 -0800174 if (IS_ERR(rt)) {
175 err = PTR_ERR(rt);
176 if (err == -ENETUNREACH)
Eric Dumazetf1d8cba2013-11-28 09:51:22 -0800177 IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTNOROUTES);
David S. Millerb23dd4f2011-03-02 14:31:35 -0800178 return err;
Wei Dong584bdf82007-05-31 22:49:28 -0700179 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180
181 if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
182 ip_rt_put(rt);
183 return -ENETUNREACH;
184 }
185
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000186 if (!inet_opt || !inet_opt->opt.srr)
David S. Millerda905bd2011-05-06 16:11:19 -0700187 daddr = fl4->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000189 if (!inet->inet_saddr)
David S. Millerda905bd2011-05-06 16:11:19 -0700190 inet->inet_saddr = fl4->saddr;
Eric Dumazetd1e559d2015-03-18 14:05:35 -0700191 sk_rcv_saddr_set(sk, inet->inet_saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000193 if (tp->rx_opt.ts_recent_stamp && inet->inet_daddr != daddr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 /* Reset inherited state */
195 tp->rx_opt.ts_recent = 0;
196 tp->rx_opt.ts_recent_stamp = 0;
Pavel Emelyanovee995282012-04-19 03:40:39 +0000197 if (likely(!tp->repair))
198 tp->write_seq = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 }
200
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -0700201 if (tcp_death_row.sysctl_tw_recycle &&
David S. Miller81166dd2012-07-10 03:14:24 -0700202 !tp->rx_opt.ts_recent_stamp && fl4->daddr == daddr)
203 tcp_fetch_timewait_stamp(sk, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000205 inet->inet_dport = usin->sin_port;
Eric Dumazetd1e559d2015-03-18 14:05:35 -0700206 sk_daddr_set(sk, daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800208 inet_csk(sk)->icsk_ext_hdr_len = 0;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000209 if (inet_opt)
210 inet_csk(sk)->icsk_ext_hdr_len = inet_opt->opt.optlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211
William Allen Simpsonbee7ca92009-11-10 09:51:18 +0000212 tp->rx_opt.mss_clamp = TCP_MSS_DEFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
214 /* Socket identity is still unknown (sport may be zero).
215 * However we set state to SYN-SENT and not releasing socket
216 * lock select source port, enter ourselves into the hash tables and
217 * complete initialization after this.
218 */
219 tcp_set_state(sk, TCP_SYN_SENT);
Arnaldo Carvalho de Meloa7f5e7f2005-12-13 23:25:31 -0800220 err = inet_hash_connect(&tcp_death_row, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 if (err)
222 goto failure;
223
Tom Herbert877d1f62015-07-28 16:02:05 -0700224 sk_set_txhash(sk);
Sathya Perla9e7ceb02014-10-22 21:42:01 +0530225
David S. Millerda905bd2011-05-06 16:11:19 -0700226 rt = ip_route_newports(fl4, rt, orig_sport, orig_dport,
David S. Millerb23dd4f2011-03-02 14:31:35 -0800227 inet->inet_sport, inet->inet_dport, sk);
228 if (IS_ERR(rt)) {
229 err = PTR_ERR(rt);
230 rt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 goto failure;
David S. Millerb23dd4f2011-03-02 14:31:35 -0800232 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 /* OK, now commit destination to socket. */
Herbert Xubcd76112006-06-30 13:36:35 -0700234 sk->sk_gso_type = SKB_GSO_TCPV4;
Changli Gaod8d1f302010-06-10 23:31:35 -0700235 sk_setup_caps(sk, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236
Pavel Emelyanovee995282012-04-19 03:40:39 +0000237 if (!tp->write_seq && likely(!tp->repair))
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000238 tp->write_seq = secure_tcp_sequence_number(inet->inet_saddr,
239 inet->inet_daddr,
240 inet->inet_sport,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 usin->sin_port);
242
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000243 inet->inet_id = tp->write_seq ^ jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
Andrey Vagin2b916472012-11-22 01:13:58 +0000245 err = tcp_connect(sk);
Pavel Emelyanovee995282012-04-19 03:40:39 +0000246
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 rt = NULL;
248 if (err)
249 goto failure;
250
251 return 0;
252
253failure:
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200254 /*
255 * This unhashes the socket and releases the local port,
256 * if necessary.
257 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 tcp_set_state(sk, TCP_CLOSE);
259 ip_rt_put(rt);
260 sk->sk_route_caps = 0;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000261 inet->inet_dport = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 return err;
263}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000264EXPORT_SYMBOL(tcp_v4_connect);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266/*
Eric Dumazet563d34d2012-07-23 09:48:52 +0200267 * This routine reacts to ICMP_FRAG_NEEDED mtu indications as defined in RFC1191.
268 * It can be called through tcp_release_cb() if socket was owned by user
269 * at the time tcp_v4_err() was called to handle ICMP message.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 */
Neal Cardwell4fab9072014-08-14 12:40:05 -0400271void tcp_v4_mtu_reduced(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272{
273 struct dst_entry *dst;
274 struct inet_sock *inet = inet_sk(sk);
Eric Dumazet563d34d2012-07-23 09:48:52 +0200275 u32 mtu = tcp_sk(sk)->mtu_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276
David S. Miller80d0a692012-07-16 03:28:06 -0700277 dst = inet_csk_update_pmtu(sk, mtu);
278 if (!dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 return;
280
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 /* Something is about to be wrong... Remember soft error
282 * for the case, if this connection will not able to recover.
283 */
284 if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
285 sk->sk_err_soft = EMSGSIZE;
286
287 mtu = dst_mtu(dst);
288
289 if (inet->pmtudisc != IP_PMTUDISC_DONT &&
Hannes Frederic Sowa482fc602013-11-05 02:24:17 +0100290 ip_sk_accept_pmtu(sk) &&
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800291 inet_csk(sk)->icsk_pmtu_cookie > mtu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 tcp_sync_mss(sk, mtu);
293
294 /* Resend the TCP packet because it's
295 * clear that the old packet has been
296 * dropped. This is the new "fast" path mtu
297 * discovery.
298 */
299 tcp_simple_retransmit(sk);
300 } /* else let the usual retransmit timer handle it */
301}
Neal Cardwell4fab9072014-08-14 12:40:05 -0400302EXPORT_SYMBOL(tcp_v4_mtu_reduced);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
David S. Miller55be7a92012-07-11 21:27:49 -0700304static void do_redirect(struct sk_buff *skb, struct sock *sk)
305{
306 struct dst_entry *dst = __sk_dst_check(sk, 0);
307
David S. Miller1ed5c482012-07-12 00:41:25 -0700308 if (dst)
David S. Miller6700c272012-07-17 03:29:28 -0700309 dst->ops->redirect(dst, sk, skb);
David S. Miller55be7a92012-07-11 21:27:49 -0700310}
311
Eric Dumazet26e37362015-03-22 10:22:22 -0700312
313/* handle ICMP messages on TCP_NEW_SYN_RECV request sockets */
Eric Dumazet9cf74902016-02-02 19:31:12 -0800314void tcp_req_err(struct sock *sk, u32 seq, bool abort)
Eric Dumazet26e37362015-03-22 10:22:22 -0700315{
316 struct request_sock *req = inet_reqsk(sk);
317 struct net *net = sock_net(sk);
318
319 /* ICMPs are not backlogged, hence we cannot get
320 * an established socket here.
321 */
Eric Dumazet26e37362015-03-22 10:22:22 -0700322 if (seq != tcp_rsk(req)->snt_isn) {
Eric Dumazet02a1d6e2016-04-27 16:44:39 -0700323 __NET_INC_STATS(net, LINUX_MIB_OUTOFWINDOWICMPS);
Eric Dumazet9cf74902016-02-02 19:31:12 -0800324 } else if (abort) {
Eric Dumazet26e37362015-03-22 10:22:22 -0700325 /*
326 * Still in SYN_RECV, just remove it silently.
327 * There is no good way to pass the error to the newly
328 * created socket, and POSIX does not want network
329 * errors returned from accept().
330 */
Fan Duc6973662015-03-23 15:00:41 -0700331 inet_csk_reqsk_queue_drop(req->rsk_listener, req);
Eric Dumazet9caad862016-04-01 08:52:20 -0700332 tcp_listendrop(req->rsk_listener);
Eric Dumazet26e37362015-03-22 10:22:22 -0700333 }
Eric Dumazetef84d8c2015-10-14 11:16:26 -0700334 reqsk_put(req);
Eric Dumazet26e37362015-03-22 10:22:22 -0700335}
336EXPORT_SYMBOL(tcp_req_err);
337
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338/*
339 * This routine is called by the ICMP module when it gets some
340 * sort of error condition. If err < 0 then the socket should
341 * be closed and the error returned to the user. If err > 0
342 * it's just the icmp type << 8 | icmp code. After adjustment
343 * header points to the first 8 bytes of the tcp header. We need
344 * to find the appropriate port.
345 *
346 * The locking strategy used here is very "optimistic". When
347 * someone else accesses the socket the ICMP is just dropped
348 * and for some paths there is no check at all.
349 * A more general error queue to queue errors for later handling
350 * is probably better.
351 *
352 */
353
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000354void tcp_v4_err(struct sk_buff *icmp_skb, u32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000356 const struct iphdr *iph = (const struct iphdr *)icmp_skb->data;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000357 struct tcphdr *th = (struct tcphdr *)(icmp_skb->data + (iph->ihl << 2));
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000358 struct inet_connection_sock *icsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 struct tcp_sock *tp;
360 struct inet_sock *inet;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000361 const int type = icmp_hdr(icmp_skb)->type;
362 const int code = icmp_hdr(icmp_skb)->code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 struct sock *sk;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000364 struct sk_buff *skb;
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700365 struct request_sock *fastopen;
366 __u32 seq, snd_una;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000367 __u32 remaining;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 int err;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000369 struct net *net = dev_net(icmp_skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370
Eric Dumazet26e37362015-03-22 10:22:22 -0700371 sk = __inet_lookup_established(net, &tcp_hashinfo, iph->daddr,
372 th->dest, iph->saddr, ntohs(th->source),
373 inet_iif(icmp_skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 if (!sk) {
Eric Dumazet5d3848b2016-04-27 16:44:29 -0700375 __ICMP_INC_STATS(net, ICMP_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 return;
377 }
378 if (sk->sk_state == TCP_TIME_WAIT) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700379 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 return;
381 }
Eric Dumazet26e37362015-03-22 10:22:22 -0700382 seq = ntohl(th->seq);
383 if (sk->sk_state == TCP_NEW_SYN_RECV)
Eric Dumazet9cf74902016-02-02 19:31:12 -0800384 return tcp_req_err(sk, seq,
385 type == ICMP_PARAMETERPROB ||
386 type == ICMP_TIME_EXCEEDED ||
387 (type == ICMP_DEST_UNREACH &&
388 (code == ICMP_NET_UNREACH ||
389 code == ICMP_HOST_UNREACH)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390
391 bh_lock_sock(sk);
392 /* If too many ICMPs get dropped on busy
393 * servers this needs to be solved differently.
Eric Dumazet563d34d2012-07-23 09:48:52 +0200394 * We do take care of PMTU discovery (RFC1191) special case :
395 * we can receive locally generated ICMP messages while socket is held.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 */
Eric Dumazetb74aa932013-01-19 16:10:37 +0000397 if (sock_owned_by_user(sk)) {
398 if (!(type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED))
Eric Dumazet02a1d6e2016-04-27 16:44:39 -0700399 __NET_INC_STATS(net, LINUX_MIB_LOCKDROPPEDICMPS);
Eric Dumazetb74aa932013-01-19 16:10:37 +0000400 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 if (sk->sk_state == TCP_CLOSE)
402 goto out;
403
stephen hemminger97e3ecd12010-03-18 11:27:32 +0000404 if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
Eric Dumazet02a1d6e2016-04-27 16:44:39 -0700405 __NET_INC_STATS(net, LINUX_MIB_TCPMINTTLDROP);
stephen hemminger97e3ecd12010-03-18 11:27:32 +0000406 goto out;
407 }
408
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000409 icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 tp = tcp_sk(sk);
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700411 /* XXX (TFO) - tp->snd_una should be ISN (tcp_create_openreq_child() */
412 fastopen = tp->fastopen_rsk;
413 snd_una = fastopen ? tcp_rsk(fastopen)->snt_isn : tp->snd_una;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 if (sk->sk_state != TCP_LISTEN &&
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700415 !between(seq, snd_una, tp->snd_nxt)) {
Eric Dumazet02a1d6e2016-04-27 16:44:39 -0700416 __NET_INC_STATS(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 goto out;
418 }
419
420 switch (type) {
David S. Miller55be7a92012-07-11 21:27:49 -0700421 case ICMP_REDIRECT:
422 do_redirect(icmp_skb, sk);
423 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 case ICMP_SOURCE_QUENCH:
425 /* Just silently ignore these. */
426 goto out;
427 case ICMP_PARAMETERPROB:
428 err = EPROTO;
429 break;
430 case ICMP_DEST_UNREACH:
431 if (code > NR_ICMP_UNREACH)
432 goto out;
433
434 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
Eric Dumazet0d4f0602013-03-18 07:01:28 +0000435 /* We are not interested in TCP_LISTEN and open_requests
436 * (SYN-ACKs send out by Linux are always <576bytes so
437 * they should go through unfragmented).
438 */
439 if (sk->sk_state == TCP_LISTEN)
440 goto out;
441
Eric Dumazet563d34d2012-07-23 09:48:52 +0200442 tp->mtu_info = info;
Eric Dumazet144d56e2012-08-20 00:22:46 +0000443 if (!sock_owned_by_user(sk)) {
Eric Dumazet563d34d2012-07-23 09:48:52 +0200444 tcp_v4_mtu_reduced(sk);
Eric Dumazet144d56e2012-08-20 00:22:46 +0000445 } else {
446 if (!test_and_set_bit(TCP_MTU_REDUCED_DEFERRED, &tp->tsq_flags))
447 sock_hold(sk);
448 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 goto out;
450 }
451
452 err = icmp_err_convert[code].errno;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000453 /* check if icmp_skb allows revert of backoff
454 * (see draft-zimmermann-tcp-lcd) */
455 if (code != ICMP_NET_UNREACH && code != ICMP_HOST_UNREACH)
456 break;
457 if (seq != tp->snd_una || !icsk->icsk_retransmits ||
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700458 !icsk->icsk_backoff || fastopen)
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000459 break;
460
David S. Miller8f49c272010-11-12 13:35:00 -0800461 if (sock_owned_by_user(sk))
462 break;
463
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000464 icsk->icsk_backoff--;
Eric Dumazetfcdd1cf2014-09-22 13:19:44 -0700465 icsk->icsk_rto = tp->srtt_us ? __tcp_set_rto(tp) :
466 TCP_TIMEOUT_INIT;
467 icsk->icsk_rto = inet_csk_rto_backoff(icsk, TCP_RTO_MAX);
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000468
469 skb = tcp_write_queue_head(sk);
470 BUG_ON(!skb);
471
Eric Dumazet7faee5c2014-09-05 15:33:33 -0700472 remaining = icsk->icsk_rto -
473 min(icsk->icsk_rto,
474 tcp_time_stamp - tcp_skb_timestamp(skb));
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000475
476 if (remaining) {
477 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
478 remaining, TCP_RTO_MAX);
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000479 } else {
480 /* RTO revert clocked out retransmission.
481 * Will retransmit now */
482 tcp_retransmit_timer(sk);
483 }
484
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 break;
486 case ICMP_TIME_EXCEEDED:
487 err = EHOSTUNREACH;
488 break;
489 default:
490 goto out;
491 }
492
493 switch (sk->sk_state) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 case TCP_SYN_SENT:
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700495 case TCP_SYN_RECV:
496 /* Only in fast or simultaneous open. If a fast open socket is
497 * is already accepted it is treated as a connected one below.
498 */
Ian Morris51456b22015-04-03 09:17:26 +0100499 if (fastopen && !fastopen->sk)
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700500 break;
501
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 if (!sock_owned_by_user(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 sk->sk_err = err;
504
505 sk->sk_error_report(sk);
506
507 tcp_done(sk);
508 } else {
509 sk->sk_err_soft = err;
510 }
511 goto out;
512 }
513
514 /* If we've already connected we will keep trying
515 * until we time out, or the user gives up.
516 *
517 * rfc1122 4.2.3.9 allows to consider as hard errors
518 * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
519 * but it is obsoleted by pmtu discovery).
520 *
521 * Note, that in modern internet, where routing is unreliable
522 * and in each dark corner broken firewalls sit, sending random
523 * errors ordered by their masters even this two messages finally lose
524 * their original sense (even Linux sends invalid PORT_UNREACHs)
525 *
526 * Now we are in compliance with RFCs.
527 * --ANK (980905)
528 */
529
530 inet = inet_sk(sk);
531 if (!sock_owned_by_user(sk) && inet->recverr) {
532 sk->sk_err = err;
533 sk->sk_error_report(sk);
534 } else { /* Only an error on timeout */
535 sk->sk_err_soft = err;
536 }
537
538out:
539 bh_unlock_sock(sk);
540 sock_put(sk);
541}
542
Daniel Borkmann28850dc2013-06-07 05:11:46 +0000543void __tcp_v4_send_check(struct sk_buff *skb, __be32 saddr, __be32 daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700545 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546
Patrick McHardy84fa7932006-08-29 16:44:56 -0700547 if (skb->ip_summed == CHECKSUM_PARTIAL) {
Herbert Xu419f9f82010-04-11 02:15:53 +0000548 th->check = ~tcp_v4_check(skb->len, saddr, daddr, 0);
Herbert Xu663ead32007-04-09 11:59:07 -0700549 skb->csum_start = skb_transport_header(skb) - skb->head;
Al Viroff1dcad2006-11-20 18:07:29 -0800550 skb->csum_offset = offsetof(struct tcphdr, check);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 } else {
Herbert Xu419f9f82010-04-11 02:15:53 +0000552 th->check = tcp_v4_check(skb->len, saddr, daddr,
Joe Perches07f07572008-11-19 15:44:53 -0800553 csum_partial(th,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 th->doff << 2,
555 skb->csum));
556 }
557}
558
Herbert Xu419f9f82010-04-11 02:15:53 +0000559/* This routine computes an IPv4 TCP checksum. */
Herbert Xubb296242010-04-11 02:15:55 +0000560void tcp_v4_send_check(struct sock *sk, struct sk_buff *skb)
Herbert Xu419f9f82010-04-11 02:15:53 +0000561{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400562 const struct inet_sock *inet = inet_sk(sk);
Herbert Xu419f9f82010-04-11 02:15:53 +0000563
564 __tcp_v4_send_check(skb, inet->inet_saddr, inet->inet_daddr);
565}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000566EXPORT_SYMBOL(tcp_v4_send_check);
Herbert Xu419f9f82010-04-11 02:15:53 +0000567
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568/*
569 * This routine will send an RST to the other tcp.
570 *
571 * Someone asks: why I NEVER use socket parameters (TOS, TTL etc.)
572 * for reset.
573 * Answer: if a packet caused RST, it is not for a socket
574 * existing in our system, if it is matched to a socket,
575 * it is just duplicate segment or bug in other side's TCP.
576 * So that we build reply only basing on parameters
577 * arrived with segment.
578 * Exception: precedence violation. We do not implement it in any case.
579 */
580
Eric Dumazeta00e7442015-09-29 07:42:39 -0700581static void tcp_v4_send_reset(const struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400583 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800584 struct {
585 struct tcphdr th;
586#ifdef CONFIG_TCP_MD5SIG
Al Viro714e85b2006-11-14 20:51:49 -0800587 __be32 opt[(TCPOLEN_MD5SIG_ALIGNED >> 2)];
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800588#endif
589 } rep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 struct ip_reply_arg arg;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800591#ifdef CONFIG_TCP_MD5SIG
Florian Westphale46787f2015-12-21 21:29:25 +0100592 struct tcp_md5sig_key *key = NULL;
Shawn Lu658ddaa2012-01-31 22:35:48 +0000593 const __u8 *hash_location = NULL;
594 unsigned char newhash[16];
595 int genhash;
596 struct sock *sk1 = NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800597#endif
Pavel Emelyanova86b1e32008-07-16 20:20:58 -0700598 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599
600 /* Never send a reset in response to a reset. */
601 if (th->rst)
602 return;
603
Eric Dumazetc3658e82014-11-25 07:40:04 -0800604 /* If sk not NULL, it means we did a successful lookup and incoming
605 * route had to be correct. prequeue might have dropped our dst.
606 */
607 if (!sk && skb_rtable(skb)->rt_type != RTN_LOCAL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 return;
609
610 /* Swap the send and the receive. */
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800611 memset(&rep, 0, sizeof(rep));
612 rep.th.dest = th->source;
613 rep.th.source = th->dest;
614 rep.th.doff = sizeof(struct tcphdr) / 4;
615 rep.th.rst = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
617 if (th->ack) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800618 rep.th.seq = th->ack_seq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800620 rep.th.ack = 1;
621 rep.th.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
622 skb->len - (th->doff << 2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 }
624
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200625 memset(&arg, 0, sizeof(arg));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800626 arg.iov[0].iov_base = (unsigned char *)&rep;
627 arg.iov[0].iov_len = sizeof(rep.th);
628
Eric Dumazet0f85fea2014-12-09 09:56:08 -0800629 net = sk ? sock_net(sk) : dev_net(skb_dst(skb)->dev);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800630#ifdef CONFIG_TCP_MD5SIG
Eric Dumazet3b24d852016-04-01 08:52:17 -0700631 rcu_read_lock();
Shawn Lu658ddaa2012-01-31 22:35:48 +0000632 hash_location = tcp_parse_md5sig_option(th);
Florian Westphal271c3b92015-12-21 21:29:26 +0100633 if (sk && sk_fullsock(sk)) {
Florian Westphale46787f2015-12-21 21:29:25 +0100634 key = tcp_md5_do_lookup(sk, (union tcp_md5_addr *)
635 &ip_hdr(skb)->saddr, AF_INET);
636 } else if (hash_location) {
Shawn Lu658ddaa2012-01-31 22:35:48 +0000637 /*
638 * active side is lost. Try to find listening socket through
639 * source port, and then find md5 key through listening socket.
640 * we are not loose security here:
641 * Incoming packet is checked with md5 hash with finding key,
642 * no RST generated if md5 hash doesn't match.
643 */
Craig Galleka5836362016-02-10 11:50:38 -0500644 sk1 = __inet_lookup_listener(net, &tcp_hashinfo, NULL, 0,
645 ip_hdr(skb)->saddr,
Tom Herbertda5e3632013-01-22 09:50:24 +0000646 th->source, ip_hdr(skb)->daddr,
Shawn Lu658ddaa2012-01-31 22:35:48 +0000647 ntohs(th->source), inet_iif(skb));
648 /* don't send rst if it can't find key */
649 if (!sk1)
Eric Dumazet3b24d852016-04-01 08:52:17 -0700650 goto out;
651
Shawn Lu658ddaa2012-01-31 22:35:48 +0000652 key = tcp_md5_do_lookup(sk1, (union tcp_md5_addr *)
653 &ip_hdr(skb)->saddr, AF_INET);
654 if (!key)
Eric Dumazet3b24d852016-04-01 08:52:17 -0700655 goto out;
656
Shawn Lu658ddaa2012-01-31 22:35:48 +0000657
Eric Dumazet39f8e582015-03-24 15:58:55 -0700658 genhash = tcp_v4_md5_hash_skb(newhash, key, NULL, skb);
Shawn Lu658ddaa2012-01-31 22:35:48 +0000659 if (genhash || memcmp(hash_location, newhash, 16) != 0)
Eric Dumazet3b24d852016-04-01 08:52:17 -0700660 goto out;
661
Shawn Lu658ddaa2012-01-31 22:35:48 +0000662 }
663
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800664 if (key) {
665 rep.opt[0] = htonl((TCPOPT_NOP << 24) |
666 (TCPOPT_NOP << 16) |
667 (TCPOPT_MD5SIG << 8) |
668 TCPOLEN_MD5SIG);
669 /* Update length and the length the header thinks exists */
670 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
671 rep.th.doff = arg.iov[0].iov_len / 4;
672
Adam Langley49a72df2008-07-19 00:01:42 -0700673 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[1],
Ilpo Järvinen78e645cb2008-10-09 14:37:47 -0700674 key, ip_hdr(skb)->saddr,
675 ip_hdr(skb)->daddr, &rep.th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800676 }
677#endif
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700678 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
679 ip_hdr(skb)->saddr, /* XXX */
Ilpo Järvinen52cd5752008-10-08 11:34:06 -0700680 arg.iov[0].iov_len, IPPROTO_TCP, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
Florian Westphal271c3b92015-12-21 21:29:26 +0100682 arg.flags = (sk && inet_sk_transparent(sk)) ? IP_REPLY_ARG_NOSRCCHECK : 0;
683
Shawn Lue2446ea2012-02-04 12:38:09 +0000684 /* When socket is gone, all binding information is lost.
Alexey Kuznetsov4c675252012-10-12 04:34:17 +0000685 * routing might fail in this case. No choice here, if we choose to force
686 * input interface, we will misroute in case of asymmetric route.
Shawn Lue2446ea2012-02-04 12:38:09 +0000687 */
Alexey Kuznetsov4c675252012-10-12 04:34:17 +0000688 if (sk)
689 arg.bound_dev_if = sk->sk_bound_dev_if;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690
Florian Westphal271c3b92015-12-21 21:29:26 +0100691 BUILD_BUG_ON(offsetof(struct sock, sk_bound_dev_if) !=
692 offsetof(struct inet_timewait_sock, tw_bound_dev_if));
693
Eric Dumazet66b13d92011-10-24 03:06:21 -0400694 arg.tos = ip_hdr(skb)->tos;
Eric Dumazet47dcc202016-05-06 09:46:18 -0700695 local_bh_disable();
Eric Dumazetbdbbb852015-01-29 21:35:05 -0800696 ip_send_unicast_reply(*this_cpu_ptr(net->ipv4.tcp_sk),
697 skb, &TCP_SKB_CB(skb)->header.h4.opt,
Eric Dumazet24a2d432014-09-27 09:50:55 -0700698 ip_hdr(skb)->saddr, ip_hdr(skb)->daddr,
699 &arg, arg.iov[0].iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700
Eric Dumazet90bbcc62016-04-27 16:44:32 -0700701 __TCP_INC_STATS(net, TCP_MIB_OUTSEGS);
702 __TCP_INC_STATS(net, TCP_MIB_OUTRSTS);
Eric Dumazet47dcc202016-05-06 09:46:18 -0700703 local_bh_enable();
Shawn Lu658ddaa2012-01-31 22:35:48 +0000704
705#ifdef CONFIG_TCP_MD5SIG
Eric Dumazet3b24d852016-04-01 08:52:17 -0700706out:
707 rcu_read_unlock();
Shawn Lu658ddaa2012-01-31 22:35:48 +0000708#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709}
710
711/* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
712 outside socket context is ugly, certainly. What can I do?
713 */
714
Eric Dumazete62a1232016-01-21 08:02:54 -0800715static void tcp_v4_send_ack(struct net *net,
716 struct sk_buff *skb, u32 seq, u32 ack,
Andrey Vaginee684b62013-02-11 05:50:19 +0000717 u32 win, u32 tsval, u32 tsecr, int oif,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700718 struct tcp_md5sig_key *key,
Eric Dumazet66b13d92011-10-24 03:06:21 -0400719 int reply_flags, u8 tos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400721 const struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 struct {
723 struct tcphdr th;
Al Viro714e85b2006-11-14 20:51:49 -0800724 __be32 opt[(TCPOLEN_TSTAMP_ALIGNED >> 2)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800725#ifdef CONFIG_TCP_MD5SIG
Al Viro714e85b2006-11-14 20:51:49 -0800726 + (TCPOLEN_MD5SIG_ALIGNED >> 2)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800727#endif
728 ];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 } rep;
730 struct ip_reply_arg arg;
731
732 memset(&rep.th, 0, sizeof(struct tcphdr));
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200733 memset(&arg, 0, sizeof(arg));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734
735 arg.iov[0].iov_base = (unsigned char *)&rep;
736 arg.iov[0].iov_len = sizeof(rep.th);
Andrey Vaginee684b62013-02-11 05:50:19 +0000737 if (tsecr) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800738 rep.opt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
739 (TCPOPT_TIMESTAMP << 8) |
740 TCPOLEN_TIMESTAMP);
Andrey Vaginee684b62013-02-11 05:50:19 +0000741 rep.opt[1] = htonl(tsval);
742 rep.opt[2] = htonl(tsecr);
Craig Schlentercb48cfe2007-01-09 00:11:15 -0800743 arg.iov[0].iov_len += TCPOLEN_TSTAMP_ALIGNED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 }
745
746 /* Swap the send and the receive. */
747 rep.th.dest = th->source;
748 rep.th.source = th->dest;
749 rep.th.doff = arg.iov[0].iov_len / 4;
750 rep.th.seq = htonl(seq);
751 rep.th.ack_seq = htonl(ack);
752 rep.th.ack = 1;
753 rep.th.window = htons(win);
754
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800755#ifdef CONFIG_TCP_MD5SIG
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800756 if (key) {
Andrey Vaginee684b62013-02-11 05:50:19 +0000757 int offset = (tsecr) ? 3 : 0;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800758
759 rep.opt[offset++] = htonl((TCPOPT_NOP << 24) |
760 (TCPOPT_NOP << 16) |
761 (TCPOPT_MD5SIG << 8) |
762 TCPOLEN_MD5SIG);
763 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
764 rep.th.doff = arg.iov[0].iov_len/4;
765
Adam Langley49a72df2008-07-19 00:01:42 -0700766 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[offset],
Adam Langley90b7e112008-07-31 20:49:48 -0700767 key, ip_hdr(skb)->saddr,
768 ip_hdr(skb)->daddr, &rep.th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800769 }
770#endif
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700771 arg.flags = reply_flags;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700772 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
773 ip_hdr(skb)->saddr, /* XXX */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 arg.iov[0].iov_len, IPPROTO_TCP, 0);
775 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900776 if (oif)
777 arg.bound_dev_if = oif;
Eric Dumazet66b13d92011-10-24 03:06:21 -0400778 arg.tos = tos;
Eric Dumazet47dcc202016-05-06 09:46:18 -0700779 local_bh_disable();
Eric Dumazetbdbbb852015-01-29 21:35:05 -0800780 ip_send_unicast_reply(*this_cpu_ptr(net->ipv4.tcp_sk),
781 skb, &TCP_SKB_CB(skb)->header.h4.opt,
Eric Dumazet24a2d432014-09-27 09:50:55 -0700782 ip_hdr(skb)->saddr, ip_hdr(skb)->daddr,
783 &arg, arg.iov[0].iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784
Eric Dumazet90bbcc62016-04-27 16:44:32 -0700785 __TCP_INC_STATS(net, TCP_MIB_OUTSEGS);
Eric Dumazet47dcc202016-05-06 09:46:18 -0700786 local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787}
788
789static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
790{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700791 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800792 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793
Eric Dumazete62a1232016-01-21 08:02:54 -0800794 tcp_v4_send_ack(sock_net(sk), skb,
795 tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200796 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
Andrey Vaginee684b62013-02-11 05:50:19 +0000797 tcp_time_stamp + tcptw->tw_ts_offset,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900798 tcptw->tw_ts_recent,
799 tw->tw_bound_dev_if,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700800 tcp_twsk_md5_key(tcptw),
Eric Dumazet66b13d92011-10-24 03:06:21 -0400801 tw->tw_transparent ? IP_REPLY_ARG_NOSRCCHECK : 0,
802 tw->tw_tos
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900803 );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700805 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806}
807
Eric Dumazeta00e7442015-09-29 07:42:39 -0700808static void tcp_v4_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200809 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810{
Jerry Chu168a8f52012-08-31 12:29:13 +0000811 /* sk->sk_state == TCP_LISTEN -> for regular TCP_SYN_RECV
812 * sk->sk_state == TCP_SYN_RECV -> for Fast Open.
813 */
Eric Dumazete62a1232016-01-21 08:02:54 -0800814 u32 seq = (sk->sk_state == TCP_LISTEN) ? tcp_rsk(req)->snt_isn + 1 :
815 tcp_sk(sk)->snd_nxt;
816
817 tcp_v4_send_ack(sock_net(sk), skb, seq,
Eric Dumazeted53d0a2015-10-08 19:33:23 -0700818 tcp_rsk(req)->rcv_nxt, req->rsk_rcv_wnd,
Andrey Vaginee684b62013-02-11 05:50:19 +0000819 tcp_time_stamp,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900820 req->ts_recent,
821 0,
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000822 tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&ip_hdr(skb)->daddr,
823 AF_INET),
Eric Dumazet66b13d92011-10-24 03:06:21 -0400824 inet_rsk(req)->no_srccheck ? IP_REPLY_ARG_NOSRCCHECK : 0,
825 ip_hdr(skb)->tos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826}
827
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828/*
Kris Katterjohn9bf1d832008-02-17 22:29:19 -0800829 * Send a SYN-ACK after having received a SYN.
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700830 * This still operates on a request_sock only, not on a big
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 * socket.
832 */
Eric Dumazet0f935dbe2015-09-25 07:39:21 -0700833static int tcp_v4_send_synack(const struct sock *sk, struct dst_entry *dst,
Octavian Purdilad6274bd2014-06-25 17:09:58 +0300834 struct flowi *fl,
Octavian Purdila72659ec2010-01-17 19:09:39 -0800835 struct request_sock *req,
Eric Dumazetca6fb062015-10-02 11:43:35 -0700836 struct tcp_fastopen_cookie *foc,
Eric Dumazetb3d05142016-04-13 22:05:39 -0700837 enum tcp_synack_type synack_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700839 const struct inet_request_sock *ireq = inet_rsk(req);
David S. Miller6bd023f2011-05-18 18:32:03 -0400840 struct flowi4 fl4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 int err = -1;
Weilong Chend41db5a2013-12-23 14:37:28 +0800842 struct sk_buff *skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843
844 /* First, grab a route. */
David S. Millerba3f7f02012-07-17 14:02:46 -0700845 if (!dst && (dst = inet_csk_route_req(sk, &fl4, req)) == NULL)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800846 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847
Eric Dumazetb3d05142016-04-13 22:05:39 -0700848 skb = tcp_make_synack(sk, dst, req, foc, synack_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849
850 if (skb) {
Eric Dumazet634fb9792013-10-09 15:21:29 -0700851 __tcp_v4_send_check(skb, ireq->ir_loc_addr, ireq->ir_rmt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852
Eric Dumazet634fb9792013-10-09 15:21:29 -0700853 err = ip_build_and_send_pkt(skb, sk, ireq->ir_loc_addr,
854 ireq->ir_rmt_addr,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700855 ireq->opt);
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200856 err = net_xmit_eval(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 }
858
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 return err;
860}
861
862/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700863 * IPv4 request_sock destructor.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 */
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700865static void tcp_v4_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866{
Jesper Juhla51482b2005-11-08 09:41:34 -0800867 kfree(inet_rsk(req)->opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868}
869
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800870#ifdef CONFIG_TCP_MD5SIG
871/*
872 * RFC2385 MD5 checksumming requires a mapping of
873 * IP address->MD5 Key.
874 * We need to maintain these in the sk structure.
875 */
876
877/* Find the Key structure for an address. */
Eric Dumazetb83e3de2015-09-25 07:39:15 -0700878struct tcp_md5sig_key *tcp_md5_do_lookup(const struct sock *sk,
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000879 const union tcp_md5_addr *addr,
880 int family)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800881{
Eric Dumazetfd3a1542015-03-24 15:58:56 -0700882 const struct tcp_sock *tp = tcp_sk(sk);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000883 struct tcp_md5sig_key *key;
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000884 unsigned int size = sizeof(struct in_addr);
Eric Dumazetfd3a1542015-03-24 15:58:56 -0700885 const struct tcp_md5sig_info *md5sig;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800886
Eric Dumazeta8afca02012-01-31 18:45:40 +0000887 /* caller either holds rcu_read_lock() or socket lock */
888 md5sig = rcu_dereference_check(tp->md5sig_info,
Hannes Frederic Sowa1e1d04e2016-04-05 17:10:15 +0200889 lockdep_sock_is_held(sk));
Eric Dumazeta8afca02012-01-31 18:45:40 +0000890 if (!md5sig)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800891 return NULL;
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000892#if IS_ENABLED(CONFIG_IPV6)
893 if (family == AF_INET6)
894 size = sizeof(struct in6_addr);
895#endif
Sasha Levinb67bfe02013-02-27 17:06:00 -0800896 hlist_for_each_entry_rcu(key, &md5sig->head, node) {
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000897 if (key->family != family)
898 continue;
899 if (!memcmp(&key->addr, addr, size))
900 return key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800901 }
902 return NULL;
903}
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000904EXPORT_SYMBOL(tcp_md5_do_lookup);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800905
Eric Dumazetb83e3de2015-09-25 07:39:15 -0700906struct tcp_md5sig_key *tcp_v4_md5_lookup(const struct sock *sk,
Eric Dumazetfd3a1542015-03-24 15:58:56 -0700907 const struct sock *addr_sk)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800908{
Eric Dumazetb52e6922015-04-09 14:36:42 -0700909 const union tcp_md5_addr *addr;
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000910
Eric Dumazetb52e6922015-04-09 14:36:42 -0700911 addr = (const union tcp_md5_addr *)&addr_sk->sk_daddr;
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000912 return tcp_md5_do_lookup(sk, addr, AF_INET);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800913}
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800914EXPORT_SYMBOL(tcp_v4_md5_lookup);
915
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800916/* This can be called on a newly created socket, from other files */
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000917int tcp_md5_do_add(struct sock *sk, const union tcp_md5_addr *addr,
918 int family, const u8 *newkey, u8 newkeylen, gfp_t gfp)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800919{
920 /* Add Key to the list */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700921 struct tcp_md5sig_key *key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800922 struct tcp_sock *tp = tcp_sk(sk);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000923 struct tcp_md5sig_info *md5sig;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800924
Aydin Arikc0353c72013-06-14 18:56:31 +1200925 key = tcp_md5_do_lookup(sk, addr, family);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800926 if (key) {
927 /* Pre-existing entry - just update that one. */
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000928 memcpy(key->key, newkey, newkeylen);
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700929 key->keylen = newkeylen;
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000930 return 0;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800931 }
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000932
Eric Dumazeta8afca02012-01-31 18:45:40 +0000933 md5sig = rcu_dereference_protected(tp->md5sig_info,
Hannes Frederic Sowa1e1d04e2016-04-05 17:10:15 +0200934 lockdep_sock_is_held(sk));
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000935 if (!md5sig) {
936 md5sig = kmalloc(sizeof(*md5sig), gfp);
937 if (!md5sig)
938 return -ENOMEM;
939
940 sk_nocaps_add(sk, NETIF_F_GSO_MASK);
941 INIT_HLIST_HEAD(&md5sig->head);
Eric Dumazeta8afca02012-01-31 18:45:40 +0000942 rcu_assign_pointer(tp->md5sig_info, md5sig);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000943 }
944
Eric Dumazet5f3d9cb2012-01-31 10:56:48 +0000945 key = sock_kmalloc(sk, sizeof(*key), gfp);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000946 if (!key)
947 return -ENOMEM;
Eric Dumazet71cea172013-05-20 06:52:26 +0000948 if (!tcp_alloc_md5sig_pool()) {
Eric Dumazet5f3d9cb2012-01-31 10:56:48 +0000949 sock_kfree_s(sk, key, sizeof(*key));
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000950 return -ENOMEM;
951 }
952
953 memcpy(key->key, newkey, newkeylen);
954 key->keylen = newkeylen;
955 key->family = family;
956 memcpy(&key->addr, addr,
957 (family == AF_INET6) ? sizeof(struct in6_addr) :
958 sizeof(struct in_addr));
959 hlist_add_head_rcu(&key->node, &md5sig->head);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800960 return 0;
961}
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000962EXPORT_SYMBOL(tcp_md5_do_add);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800963
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000964int tcp_md5_do_del(struct sock *sk, const union tcp_md5_addr *addr, int family)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800965{
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000966 struct tcp_md5sig_key *key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800967
Aydin Arikc0353c72013-06-14 18:56:31 +1200968 key = tcp_md5_do_lookup(sk, addr, family);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000969 if (!key)
970 return -ENOENT;
971 hlist_del_rcu(&key->node);
Eric Dumazet5f3d9cb2012-01-31 10:56:48 +0000972 atomic_sub(sizeof(*key), &sk->sk_omem_alloc);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000973 kfree_rcu(key, rcu);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000974 return 0;
975}
976EXPORT_SYMBOL(tcp_md5_do_del);
977
stephen hemmingere0683e702012-10-26 14:31:40 +0000978static void tcp_clear_md5_list(struct sock *sk)
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000979{
980 struct tcp_sock *tp = tcp_sk(sk);
981 struct tcp_md5sig_key *key;
Sasha Levinb67bfe02013-02-27 17:06:00 -0800982 struct hlist_node *n;
Eric Dumazeta8afca02012-01-31 18:45:40 +0000983 struct tcp_md5sig_info *md5sig;
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000984
Eric Dumazeta8afca02012-01-31 18:45:40 +0000985 md5sig = rcu_dereference_protected(tp->md5sig_info, 1);
986
Sasha Levinb67bfe02013-02-27 17:06:00 -0800987 hlist_for_each_entry_safe(key, n, &md5sig->head, node) {
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000988 hlist_del_rcu(&key->node);
Eric Dumazet5f3d9cb2012-01-31 10:56:48 +0000989 atomic_sub(sizeof(*key), &sk->sk_omem_alloc);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000990 kfree_rcu(key, rcu);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800991 }
992}
993
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200994static int tcp_v4_parse_md5_keys(struct sock *sk, char __user *optval,
995 int optlen)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800996{
997 struct tcp_md5sig cmd;
998 struct sockaddr_in *sin = (struct sockaddr_in *)&cmd.tcpm_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800999
1000 if (optlen < sizeof(cmd))
1001 return -EINVAL;
1002
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001003 if (copy_from_user(&cmd, optval, sizeof(cmd)))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001004 return -EFAULT;
1005
1006 if (sin->sin_family != AF_INET)
1007 return -EINVAL;
1008
Dmitry Popov64a124e2014-08-03 22:45:19 +04001009 if (!cmd.tcpm_keylen)
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001010 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin->sin_addr.s_addr,
1011 AF_INET);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001012
1013 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
1014 return -EINVAL;
1015
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001016 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin->sin_addr.s_addr,
1017 AF_INET, cmd.tcpm_key, cmd.tcpm_keylen,
1018 GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001019}
1020
Eric Dumazet19689e32016-06-27 18:51:53 +02001021static int tcp_v4_md5_hash_headers(struct tcp_md5sig_pool *hp,
1022 __be32 daddr, __be32 saddr,
1023 const struct tcphdr *th, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001024{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001025 struct tcp4_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -07001026 struct scatterlist sg;
Eric Dumazet19689e32016-06-27 18:51:53 +02001027 struct tcphdr *_th;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001028
Eric Dumazet19689e32016-06-27 18:51:53 +02001029 bp = hp->scratch;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001030 bp->saddr = saddr;
1031 bp->daddr = daddr;
1032 bp->pad = 0;
YOSHIFUJI Hideaki076fb722008-04-17 12:48:12 +09001033 bp->protocol = IPPROTO_TCP;
Adam Langley49a72df2008-07-19 00:01:42 -07001034 bp->len = cpu_to_be16(nbytes);
David S. Millerc7da57a2007-10-26 00:41:21 -07001035
Eric Dumazet19689e32016-06-27 18:51:53 +02001036 _th = (struct tcphdr *)(bp + 1);
1037 memcpy(_th, th, sizeof(*th));
1038 _th->check = 0;
1039
1040 sg_init_one(&sg, bp, sizeof(*bp) + sizeof(*th));
1041 ahash_request_set_crypt(hp->md5_req, &sg, NULL,
1042 sizeof(*bp) + sizeof(*th));
Herbert Xucf80e0e2016-01-24 21:20:23 +08001043 return crypto_ahash_update(hp->md5_req);
Adam Langley49a72df2008-07-19 00:01:42 -07001044}
1045
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001046static int tcp_v4_md5_hash_hdr(char *md5_hash, const struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -04001047 __be32 daddr, __be32 saddr, const struct tcphdr *th)
Adam Langley49a72df2008-07-19 00:01:42 -07001048{
1049 struct tcp_md5sig_pool *hp;
Herbert Xucf80e0e2016-01-24 21:20:23 +08001050 struct ahash_request *req;
Adam Langley49a72df2008-07-19 00:01:42 -07001051
1052 hp = tcp_get_md5sig_pool();
1053 if (!hp)
1054 goto clear_hash_noput;
Herbert Xucf80e0e2016-01-24 21:20:23 +08001055 req = hp->md5_req;
Adam Langley49a72df2008-07-19 00:01:42 -07001056
Herbert Xucf80e0e2016-01-24 21:20:23 +08001057 if (crypto_ahash_init(req))
Adam Langley49a72df2008-07-19 00:01:42 -07001058 goto clear_hash;
Eric Dumazet19689e32016-06-27 18:51:53 +02001059 if (tcp_v4_md5_hash_headers(hp, daddr, saddr, th, th->doff << 2))
Adam Langley49a72df2008-07-19 00:01:42 -07001060 goto clear_hash;
1061 if (tcp_md5_hash_key(hp, key))
1062 goto clear_hash;
Herbert Xucf80e0e2016-01-24 21:20:23 +08001063 ahash_request_set_crypt(req, NULL, md5_hash, 0);
1064 if (crypto_ahash_final(req))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001065 goto clear_hash;
1066
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001067 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001068 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -07001069
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001070clear_hash:
1071 tcp_put_md5sig_pool();
1072clear_hash_noput:
1073 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -07001074 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001075}
1076
Eric Dumazet39f8e582015-03-24 15:58:55 -07001077int tcp_v4_md5_hash_skb(char *md5_hash, const struct tcp_md5sig_key *key,
1078 const struct sock *sk,
Eric Dumazet318cf7a2011-10-24 02:46:04 -04001079 const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001080{
Adam Langley49a72df2008-07-19 00:01:42 -07001081 struct tcp_md5sig_pool *hp;
Herbert Xucf80e0e2016-01-24 21:20:23 +08001082 struct ahash_request *req;
Eric Dumazet318cf7a2011-10-24 02:46:04 -04001083 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001084 __be32 saddr, daddr;
1085
Eric Dumazet39f8e582015-03-24 15:58:55 -07001086 if (sk) { /* valid for establish/request sockets */
1087 saddr = sk->sk_rcv_saddr;
1088 daddr = sk->sk_daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001089 } else {
Adam Langley49a72df2008-07-19 00:01:42 -07001090 const struct iphdr *iph = ip_hdr(skb);
1091 saddr = iph->saddr;
1092 daddr = iph->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001093 }
Adam Langley49a72df2008-07-19 00:01:42 -07001094
1095 hp = tcp_get_md5sig_pool();
1096 if (!hp)
1097 goto clear_hash_noput;
Herbert Xucf80e0e2016-01-24 21:20:23 +08001098 req = hp->md5_req;
Adam Langley49a72df2008-07-19 00:01:42 -07001099
Herbert Xucf80e0e2016-01-24 21:20:23 +08001100 if (crypto_ahash_init(req))
Adam Langley49a72df2008-07-19 00:01:42 -07001101 goto clear_hash;
1102
Eric Dumazet19689e32016-06-27 18:51:53 +02001103 if (tcp_v4_md5_hash_headers(hp, daddr, saddr, th, skb->len))
Adam Langley49a72df2008-07-19 00:01:42 -07001104 goto clear_hash;
1105 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
1106 goto clear_hash;
1107 if (tcp_md5_hash_key(hp, key))
1108 goto clear_hash;
Herbert Xucf80e0e2016-01-24 21:20:23 +08001109 ahash_request_set_crypt(req, NULL, md5_hash, 0);
1110 if (crypto_ahash_final(req))
Adam Langley49a72df2008-07-19 00:01:42 -07001111 goto clear_hash;
1112
1113 tcp_put_md5sig_pool();
1114 return 0;
1115
1116clear_hash:
1117 tcp_put_md5sig_pool();
1118clear_hash_noput:
1119 memset(md5_hash, 0, 16);
1120 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001121}
Adam Langley49a72df2008-07-19 00:01:42 -07001122EXPORT_SYMBOL(tcp_v4_md5_hash_skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001123
Eric Dumazetba8e2752015-10-02 11:43:28 -07001124#endif
1125
Eric Dumazetff74e232015-03-24 15:58:54 -07001126/* Called with rcu_read_lock() */
Eric Dumazetba8e2752015-10-02 11:43:28 -07001127static bool tcp_v4_inbound_md5_hash(const struct sock *sk,
Eric Dumazetff74e232015-03-24 15:58:54 -07001128 const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001129{
Eric Dumazetba8e2752015-10-02 11:43:28 -07001130#ifdef CONFIG_TCP_MD5SIG
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001131 /*
1132 * This gets called for each TCP segment that arrives
1133 * so we want to be efficient.
1134 * We have 3 drop cases:
1135 * o No MD5 hash and one expected.
1136 * o MD5 hash and we're not expecting one.
1137 * o MD5 hash and its wrong.
1138 */
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001139 const __u8 *hash_location = NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001140 struct tcp_md5sig_key *hash_expected;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001141 const struct iphdr *iph = ip_hdr(skb);
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001142 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001143 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001144 unsigned char newhash[16];
1145
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001146 hash_expected = tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&iph->saddr,
1147 AF_INET);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +09001148 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001149
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001150 /* We've parsed the options - do we have a hash? */
1151 if (!hash_expected && !hash_location)
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001152 return false;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001153
1154 if (hash_expected && !hash_location) {
Eric Dumazetc10d9312016-04-29 14:16:47 -07001155 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001156 return true;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001157 }
1158
1159 if (!hash_expected && hash_location) {
Eric Dumazetc10d9312016-04-29 14:16:47 -07001160 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001161 return true;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001162 }
1163
1164 /* Okay, so this is hash_expected and hash_location -
1165 * so we need to calculate the checksum.
1166 */
Adam Langley49a72df2008-07-19 00:01:42 -07001167 genhash = tcp_v4_md5_hash_skb(newhash,
1168 hash_expected,
Eric Dumazet39f8e582015-03-24 15:58:55 -07001169 NULL, skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001170
1171 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
Joe Perchese87cc472012-05-13 21:56:26 +00001172 net_info_ratelimited("MD5 Hash failed for (%pI4, %d)->(%pI4, %d)%s\n",
1173 &iph->saddr, ntohs(th->source),
1174 &iph->daddr, ntohs(th->dest),
1175 genhash ? " tcp_v4_calc_md5_hash failed"
1176 : "");
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001177 return true;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001178 }
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001179 return false;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001180#endif
Eric Dumazetba8e2752015-10-02 11:43:28 -07001181 return false;
1182}
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001183
Eric Dumazetb40cf182015-09-25 07:39:08 -07001184static void tcp_v4_init_req(struct request_sock *req,
1185 const struct sock *sk_listener,
Octavian Purdila16bea702014-06-25 17:09:53 +03001186 struct sk_buff *skb)
1187{
1188 struct inet_request_sock *ireq = inet_rsk(req);
1189
Eric Dumazet08d2cc3b2015-03-18 14:05:38 -07001190 sk_rcv_saddr_set(req_to_sk(req), ip_hdr(skb)->daddr);
1191 sk_daddr_set(req_to_sk(req), ip_hdr(skb)->saddr);
1192 ireq->no_srccheck = inet_sk(sk_listener)->transparent;
Octavian Purdila16bea702014-06-25 17:09:53 +03001193 ireq->opt = tcp_v4_save_options(skb);
1194}
1195
Eric Dumazetf9646292015-09-29 07:42:50 -07001196static struct dst_entry *tcp_v4_route_req(const struct sock *sk,
1197 struct flowi *fl,
Octavian Purdilad94e0412014-06-25 17:09:55 +03001198 const struct request_sock *req,
1199 bool *strict)
1200{
1201 struct dst_entry *dst = inet_csk_route_req(sk, &fl->u.ip4, req);
1202
1203 if (strict) {
1204 if (fl->u.ip4.daddr == inet_rsk(req)->ir_rmt_addr)
1205 *strict = true;
1206 else
1207 *strict = false;
1208 }
1209
1210 return dst;
1211}
1212
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001213struct request_sock_ops tcp_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214 .family = PF_INET,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001215 .obj_size = sizeof(struct tcp_request_sock),
Octavian Purdila5db92c92014-06-25 17:09:59 +03001216 .rtx_syn_ack = tcp_rtx_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001217 .send_ack = tcp_v4_reqsk_send_ack,
1218 .destructor = tcp_v4_reqsk_destructor,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 .send_reset = tcp_v4_send_reset,
stephen hemminger688d1942014-08-29 23:32:05 -07001220 .syn_ack_timeout = tcp_syn_ack_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221};
1222
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001223static const struct tcp_request_sock_ops tcp_request_sock_ipv4_ops = {
Octavian Purdila2aec4a22014-06-25 17:10:00 +03001224 .mss_clamp = TCP_MSS_DEFAULT,
Octavian Purdila16bea702014-06-25 17:09:53 +03001225#ifdef CONFIG_TCP_MD5SIG
Eric Dumazetfd3a1542015-03-24 15:58:56 -07001226 .req_md5_lookup = tcp_v4_md5_lookup,
John Dykstrae3afe7b2009-07-16 05:04:51 +00001227 .calc_md5_hash = tcp_v4_md5_hash_skb,
Andrew Mortonb6332e62006-11-30 19:16:28 -08001228#endif
Octavian Purdila16bea702014-06-25 17:09:53 +03001229 .init_req = tcp_v4_init_req,
Octavian Purdilafb7b37a2014-06-25 17:09:54 +03001230#ifdef CONFIG_SYN_COOKIES
1231 .cookie_init_seq = cookie_v4_init_sequence,
1232#endif
Octavian Purdilad94e0412014-06-25 17:09:55 +03001233 .route_req = tcp_v4_route_req,
Octavian Purdila936b8bd2014-06-25 17:09:57 +03001234 .init_seq = tcp_v4_init_sequence,
Octavian Purdilad6274bd2014-06-25 17:09:58 +03001235 .send_synack = tcp_v4_send_synack,
Octavian Purdila16bea702014-06-25 17:09:53 +03001236};
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001237
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1239{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240 /* Never answer to SYNs send to broadcast or multicast */
Eric Dumazet511c3f92009-06-02 05:14:27 +00001241 if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242 goto drop;
1243
Octavian Purdila1fb6f152014-06-25 17:10:02 +03001244 return tcp_conn_request(&tcp_request_sock_ops,
1245 &tcp_request_sock_ipv4_ops, sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247drop:
Eric Dumazet9caad862016-04-01 08:52:20 -07001248 tcp_listendrop(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249 return 0;
1250}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001251EXPORT_SYMBOL(tcp_v4_conn_request);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252
1253
1254/*
1255 * The three way handshake has completed - we got a valid synack -
1256 * now create the new socket.
1257 */
Eric Dumazet0c271712015-09-29 07:42:48 -07001258struct sock *tcp_v4_syn_recv_sock(const struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001259 struct request_sock *req,
Eric Dumazet5e0724d2015-10-22 08:20:46 -07001260 struct dst_entry *dst,
1261 struct request_sock *req_unhash,
1262 bool *own_req)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001264 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 struct inet_sock *newinet;
1266 struct tcp_sock *newtp;
1267 struct sock *newsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001268#ifdef CONFIG_TCP_MD5SIG
1269 struct tcp_md5sig_key *key;
1270#endif
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001271 struct ip_options_rcu *inet_opt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272
1273 if (sk_acceptq_is_full(sk))
1274 goto exit_overflow;
1275
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 newsk = tcp_create_openreq_child(sk, req, skb);
1277 if (!newsk)
Balazs Scheidler093d2822010-10-21 13:06:43 +02001278 goto exit_nonewsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279
Herbert Xubcd76112006-06-30 13:36:35 -07001280 newsk->sk_gso_type = SKB_GSO_TCPV4;
Neal Cardwellfae6ef82012-08-19 03:30:38 +00001281 inet_sk_rx_dst_set(newsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282
1283 newtp = tcp_sk(newsk);
1284 newinet = inet_sk(newsk);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001285 ireq = inet_rsk(req);
Eric Dumazetd1e559d2015-03-18 14:05:35 -07001286 sk_daddr_set(newsk, ireq->ir_rmt_addr);
1287 sk_rcv_saddr_set(newsk, ireq->ir_loc_addr);
David Ahern6dd9a142015-12-16 13:20:44 -08001288 newsk->sk_bound_dev_if = ireq->ir_iif;
Eric Dumazet634fb9792013-10-09 15:21:29 -07001289 newinet->inet_saddr = ireq->ir_loc_addr;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001290 inet_opt = ireq->opt;
1291 rcu_assign_pointer(newinet->inet_opt, inet_opt);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001292 ireq->opt = NULL;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001293 newinet->mc_index = inet_iif(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001294 newinet->mc_ttl = ip_hdr(skb)->ttl;
Jiri Benc4c507d22012-02-09 09:35:49 +00001295 newinet->rcv_tos = ip_hdr(skb)->tos;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001296 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001297 if (inet_opt)
1298 inet_csk(newsk)->icsk_ext_hdr_len = inet_opt->opt.optlen;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001299 newinet->inet_id = newtp->write_seq ^ jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300
Eric Dumazetdfd25ff2012-03-10 09:20:21 +00001301 if (!dst) {
1302 dst = inet_csk_route_child_sock(sk, newsk, req);
1303 if (!dst)
1304 goto put_and_exit;
1305 } else {
1306 /* syncookie case : see end of cookie_v4_check() */
1307 }
David S. Miller0e734412011-05-08 15:28:03 -07001308 sk_setup_caps(newsk, dst);
1309
Daniel Borkmann81164412015-01-05 23:57:48 +01001310 tcp_ca_openreq_child(newsk, dst);
1311
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 tcp_sync_mss(newsk, dst_mtu(dst));
David S. Miller0dbaee32010-12-13 12:52:14 -08001313 newtp->advmss = dst_metric_advmss(dst);
Tom Quetchenbachf5fff5d2008-09-21 00:21:51 -07001314 if (tcp_sk(sk)->rx_opt.user_mss &&
1315 tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1316 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1317
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 tcp_initialize_rcv_mss(newsk);
1319
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001320#ifdef CONFIG_TCP_MD5SIG
1321 /* Copy over the MD5 key from the original socket */
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001322 key = tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&newinet->inet_daddr,
1323 AF_INET);
Ian Morris00db4122015-04-03 09:17:27 +01001324 if (key) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001325 /*
1326 * We're using one, so create a matching key
1327 * on the newsk structure. If we fail to get
1328 * memory, then we end up not copying the key
1329 * across. Shucks.
1330 */
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001331 tcp_md5_do_add(newsk, (union tcp_md5_addr *)&newinet->inet_daddr,
1332 AF_INET, key->key, key->keylen, GFP_ATOMIC);
Eric Dumazeta4654192010-05-16 00:36:33 -07001333 sk_nocaps_add(newsk, NETIF_F_GSO_MASK);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001334 }
1335#endif
1336
David S. Miller0e734412011-05-08 15:28:03 -07001337 if (__inet_inherit_port(sk, newsk) < 0)
1338 goto put_and_exit;
Eric Dumazet5e0724d2015-10-22 08:20:46 -07001339 *own_req = inet_ehash_nolisten(newsk, req_to_sk(req_unhash));
Eric Dumazet805c4bc2015-11-05 11:07:13 -08001340 if (*own_req)
Eric Dumazet49a496c2015-11-05 12:50:19 -08001341 tcp_move_syn(newtp, req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342
1343 return newsk;
1344
1345exit_overflow:
Eric Dumazetc10d9312016-04-29 14:16:47 -07001346 NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001347exit_nonewsk:
1348 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349exit:
Eric Dumazet9caad862016-04-01 08:52:20 -07001350 tcp_listendrop(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 return NULL;
David S. Miller0e734412011-05-08 15:28:03 -07001352put_and_exit:
Christoph Paasche337e242012-12-14 04:07:58 +00001353 inet_csk_prepare_forced_close(newsk);
1354 tcp_done(newsk);
David S. Miller0e734412011-05-08 15:28:03 -07001355 goto exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001357EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358
Eric Dumazet079096f2015-10-02 11:43:32 -07001359static struct sock *tcp_v4_cookie_check(struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361#ifdef CONFIG_SYN_COOKIES
Eric Dumazet079096f2015-10-02 11:43:32 -07001362 const struct tcphdr *th = tcp_hdr(skb);
1363
Florian Westphalaf9b4732010-06-03 00:43:44 +00001364 if (!th->syn)
Cong Wang461b74c2014-10-15 14:33:22 -07001365 sk = cookie_v4_check(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366#endif
1367 return sk;
1368}
1369
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370/* The socket must have it's spinlock held when we get
Eric Dumazete994b2f2015-10-02 11:43:39 -07001371 * here, unless it is a TCP_LISTEN socket.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 *
1373 * We have a potential double-lock case here, so even when
1374 * doing backlog processing we use the BH locking scheme.
1375 * This is because we cannot sleep with the original spinlock
1376 * held.
1377 */
1378int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1379{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001380 struct sock *rsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001381
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
Eric Dumazet404e0a82012-07-29 23:20:37 +00001383 struct dst_entry *dst = sk->sk_rx_dst;
1384
Tom Herbertbdeab992011-08-14 19:45:55 +00001385 sock_rps_save_rxhash(sk, skb);
Eric Dumazet3d973792014-11-11 05:54:27 -08001386 sk_mark_napi_id(sk, skb);
Eric Dumazet404e0a82012-07-29 23:20:37 +00001387 if (dst) {
Eric Dumazet505fbcf2012-07-27 06:23:40 +00001388 if (inet_sk(sk)->rx_dst_ifindex != skb->skb_iif ||
Ian Morris51456b22015-04-03 09:17:26 +01001389 !dst->ops->check(dst, 0)) {
David S. Miller92101b32012-07-23 16:29:00 -07001390 dst_release(dst);
1391 sk->sk_rx_dst = NULL;
1392 }
1393 }
Vijay Subramanianc995ae22013-09-03 12:23:22 -07001394 tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 return 0;
1396 }
1397
Eric Dumazet12e25e12015-06-03 23:49:21 -07001398 if (tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 goto csum_err;
1400
1401 if (sk->sk_state == TCP_LISTEN) {
Eric Dumazet079096f2015-10-02 11:43:32 -07001402 struct sock *nsk = tcp_v4_cookie_check(sk, skb);
1403
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 if (!nsk)
1405 goto discard;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 if (nsk != sk) {
Tom Herbertbdeab992011-08-14 19:45:55 +00001407 sock_rps_save_rxhash(nsk, skb);
Eric Dumazet38cb5242015-10-02 11:43:26 -07001408 sk_mark_napi_id(nsk, skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001409 if (tcp_child_process(sk, nsk, skb)) {
1410 rsk = nsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001412 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 return 0;
1414 }
Eric Dumazetca551582010-06-03 09:03:58 +00001415 } else
Tom Herbertbdeab992011-08-14 19:45:55 +00001416 sock_rps_save_rxhash(sk, skb);
Eric Dumazetca551582010-06-03 09:03:58 +00001417
Eric Dumazet72ab4a82015-09-29 07:42:41 -07001418 if (tcp_rcv_state_process(sk, skb)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001419 rsk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001421 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 return 0;
1423
1424reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001425 tcp_v4_send_reset(rsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426discard:
1427 kfree_skb(skb);
1428 /* Be careful here. If this function gets more complicated and
1429 * gcc suffers from register pressure on the x86, sk (in %ebx)
1430 * might be destroyed here. This current version compiles correctly,
1431 * but you have been warned.
1432 */
1433 return 0;
1434
1435csum_err:
Eric Dumazetc10d9312016-04-29 14:16:47 -07001436 TCP_INC_STATS(sock_net(sk), TCP_MIB_CSUMERRORS);
1437 TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 goto discard;
1439}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001440EXPORT_SYMBOL(tcp_v4_do_rcv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441
David S. Miller160eb5a2012-06-27 22:01:22 -07001442void tcp_v4_early_demux(struct sk_buff *skb)
David S. Miller41063e92012-06-19 21:22:05 -07001443{
David S. Miller41063e92012-06-19 21:22:05 -07001444 const struct iphdr *iph;
1445 const struct tcphdr *th;
1446 struct sock *sk;
David S. Miller41063e92012-06-19 21:22:05 -07001447
David S. Miller41063e92012-06-19 21:22:05 -07001448 if (skb->pkt_type != PACKET_HOST)
David S. Miller160eb5a2012-06-27 22:01:22 -07001449 return;
David S. Miller41063e92012-06-19 21:22:05 -07001450
Eric Dumazet45f00f92012-10-22 21:42:47 +00001451 if (!pskb_may_pull(skb, skb_transport_offset(skb) + sizeof(struct tcphdr)))
David S. Miller160eb5a2012-06-27 22:01:22 -07001452 return;
David S. Miller41063e92012-06-19 21:22:05 -07001453
1454 iph = ip_hdr(skb);
Eric Dumazet45f00f92012-10-22 21:42:47 +00001455 th = tcp_hdr(skb);
David S. Miller41063e92012-06-19 21:22:05 -07001456
1457 if (th->doff < sizeof(struct tcphdr) / 4)
David S. Miller160eb5a2012-06-27 22:01:22 -07001458 return;
David S. Miller41063e92012-06-19 21:22:05 -07001459
Eric Dumazet45f00f92012-10-22 21:42:47 +00001460 sk = __inet_lookup_established(dev_net(skb->dev), &tcp_hashinfo,
David S. Miller41063e92012-06-19 21:22:05 -07001461 iph->saddr, th->source,
Vijay Subramanian7011d082012-06-23 17:38:10 +00001462 iph->daddr, ntohs(th->dest),
Eric Dumazet9cb429d2012-07-24 01:19:31 +00001463 skb->skb_iif);
David S. Miller41063e92012-06-19 21:22:05 -07001464 if (sk) {
1465 skb->sk = sk;
1466 skb->destructor = sock_edemux;
Eric Dumazetf7e4eb02015-03-15 21:12:13 -07001467 if (sk_fullsock(sk)) {
Michal Kubečekd0c294c2015-03-23 15:14:00 +01001468 struct dst_entry *dst = READ_ONCE(sk->sk_rx_dst);
Eric Dumazet505fbcf2012-07-27 06:23:40 +00001469
David S. Miller41063e92012-06-19 21:22:05 -07001470 if (dst)
1471 dst = dst_check(dst, 0);
David S. Miller92101b32012-07-23 16:29:00 -07001472 if (dst &&
Eric Dumazet505fbcf2012-07-27 06:23:40 +00001473 inet_sk(sk)->rx_dst_ifindex == skb->skb_iif)
David S. Miller92101b32012-07-23 16:29:00 -07001474 skb_dst_set_noref(skb, dst);
David S. Miller41063e92012-06-19 21:22:05 -07001475 }
1476 }
David S. Miller41063e92012-06-19 21:22:05 -07001477}
1478
Eric Dumazetb2fb4f52013-03-06 12:58:01 +00001479/* Packet is added to VJ-style prequeue for processing in process
1480 * context, if a reader task is waiting. Apparently, this exciting
1481 * idea (VJ's mail "Re: query about TCP header on tcp-ip" of 07 Sep 93)
1482 * failed somewhere. Latency? Burstiness? Well, at least now we will
1483 * see, why it failed. 8)8) --ANK
1484 *
1485 */
1486bool tcp_prequeue(struct sock *sk, struct sk_buff *skb)
1487{
1488 struct tcp_sock *tp = tcp_sk(sk);
1489
1490 if (sysctl_tcp_low_latency || !tp->ucopy.task)
1491 return false;
1492
1493 if (skb->len <= tcp_hdrlen(skb) &&
1494 skb_queue_len(&tp->ucopy.prequeue) == 0)
1495 return false;
1496
Eric Dumazetca777ef2014-09-08 08:06:07 -07001497 /* Before escaping RCU protected region, we need to take care of skb
1498 * dst. Prequeue is only enabled for established sockets.
1499 * For such sockets, we might need the skb dst only to set sk->sk_rx_dst
1500 * Instead of doing full sk_rx_dst validity here, let's perform
1501 * an optimistic check.
1502 */
1503 if (likely(sk->sk_rx_dst))
1504 skb_dst_drop(skb);
1505 else
Eric Dumazet5037e9e2015-12-14 14:08:53 -08001506 skb_dst_force_safe(skb);
Eric Dumazetca777ef2014-09-08 08:06:07 -07001507
Eric Dumazetb2fb4f52013-03-06 12:58:01 +00001508 __skb_queue_tail(&tp->ucopy.prequeue, skb);
1509 tp->ucopy.memory += skb->truesize;
Eric Dumazet0cef6a42016-04-27 10:12:25 -07001510 if (skb_queue_len(&tp->ucopy.prequeue) >= 32 ||
1511 tp->ucopy.memory + atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf) {
Eric Dumazetb2fb4f52013-03-06 12:58:01 +00001512 struct sk_buff *skb1;
1513
1514 BUG_ON(sock_owned_by_user(sk));
Eric Dumazet0cef6a42016-04-27 10:12:25 -07001515 __NET_ADD_STATS(sock_net(sk), LINUX_MIB_TCPPREQUEUEDROPPED,
1516 skb_queue_len(&tp->ucopy.prequeue));
Eric Dumazetb2fb4f52013-03-06 12:58:01 +00001517
Eric Dumazet0cef6a42016-04-27 10:12:25 -07001518 while ((skb1 = __skb_dequeue(&tp->ucopy.prequeue)) != NULL)
Eric Dumazetb2fb4f52013-03-06 12:58:01 +00001519 sk_backlog_rcv(sk, skb1);
Eric Dumazetb2fb4f52013-03-06 12:58:01 +00001520
1521 tp->ucopy.memory = 0;
1522 } else if (skb_queue_len(&tp->ucopy.prequeue) == 1) {
1523 wake_up_interruptible_sync_poll(sk_sleep(sk),
1524 POLLIN | POLLRDNORM | POLLRDBAND);
1525 if (!inet_csk_ack_scheduled(sk))
1526 inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
1527 (3 * tcp_rto_min(sk)) / 4,
1528 TCP_RTO_MAX);
1529 }
1530 return true;
1531}
1532EXPORT_SYMBOL(tcp_prequeue);
1533
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534/*
1535 * From tcp_input.c
1536 */
1537
1538int tcp_v4_rcv(struct sk_buff *skb)
1539{
Eric Dumazet3b24d852016-04-01 08:52:17 -07001540 struct net *net = dev_net(skb->dev);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001541 const struct iphdr *iph;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001542 const struct tcphdr *th;
Eric Dumazet3b24d852016-04-01 08:52:17 -07001543 bool refcounted;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 struct sock *sk;
1545 int ret;
1546
1547 if (skb->pkt_type != PACKET_HOST)
1548 goto discard_it;
1549
1550 /* Count it even if it's bad */
Eric Dumazet90bbcc62016-04-27 16:44:32 -07001551 __TCP_INC_STATS(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552
1553 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1554 goto discard_it;
1555
Eric Dumazetea1627c2016-05-13 09:16:40 -07001556 th = (const struct tcphdr *)skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557
Eric Dumazetea1627c2016-05-13 09:16:40 -07001558 if (unlikely(th->doff < sizeof(struct tcphdr) / 4))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 goto bad_packet;
1560 if (!pskb_may_pull(skb, th->doff * 4))
1561 goto discard_it;
1562
1563 /* An explanation is required here, I think.
1564 * Packet length and doff are validated by header prediction,
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -08001565 * provided case of th->doff==0 is eliminated.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 * So, we defer the checks. */
Tom Herberted70fcf2014-05-02 16:29:38 -07001567
1568 if (skb_checksum_init(skb, IPPROTO_TCP, inet_compute_pseudo))
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001569 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570
Eric Dumazetea1627c2016-05-13 09:16:40 -07001571 th = (const struct tcphdr *)skb->data;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001572 iph = ip_hdr(skb);
Eric Dumazet971f10e2014-09-27 09:50:57 -07001573 /* This is tricky : We move IPCB at its correct location into TCP_SKB_CB()
1574 * barrier() makes sure compiler wont play fool^Waliasing games.
1575 */
1576 memmove(&TCP_SKB_CB(skb)->header.h4, IPCB(skb),
1577 sizeof(struct inet_skb_parm));
1578 barrier();
1579
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1581 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1582 skb->len - th->doff * 4);
1583 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
Eric Dumazete11ecdd2014-09-15 04:19:51 -07001584 TCP_SKB_CB(skb)->tcp_flags = tcp_flag_byte(th);
Eric Dumazet04317da2014-09-05 15:33:32 -07001585 TCP_SKB_CB(skb)->tcp_tw_isn = 0;
Eric Dumazetb82d1bb2011-09-27 02:20:08 -04001586 TCP_SKB_CB(skb)->ip_dsfield = ipv4_get_dsfield(iph);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 TCP_SKB_CB(skb)->sacked = 0;
1588
Eric Dumazet4bdc3d62015-10-13 17:12:54 -07001589lookup:
Craig Galleka5836362016-02-10 11:50:38 -05001590 sk = __inet_lookup_skb(&tcp_hashinfo, skb, __tcp_hdrlen(th), th->source,
Eric Dumazet3b24d852016-04-01 08:52:17 -07001591 th->dest, &refcounted);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592 if (!sk)
1593 goto no_tcp_socket;
1594
Eric Dumazetbb134d52010-03-09 05:55:56 +00001595process:
1596 if (sk->sk_state == TCP_TIME_WAIT)
1597 goto do_time_wait;
1598
Eric Dumazet079096f2015-10-02 11:43:32 -07001599 if (sk->sk_state == TCP_NEW_SYN_RECV) {
1600 struct request_sock *req = inet_reqsk(sk);
Eric Dumazet77166822016-02-18 05:39:18 -08001601 struct sock *nsk;
Eric Dumazet079096f2015-10-02 11:43:32 -07001602
1603 sk = req->rsk_listener;
Eric Dumazet72923552016-02-11 22:50:29 -08001604 if (unlikely(tcp_v4_inbound_md5_hash(sk, skb))) {
1605 reqsk_put(req);
1606 goto discard_it;
1607 }
Eric Dumazet77166822016-02-18 05:39:18 -08001608 if (unlikely(sk->sk_state != TCP_LISTEN)) {
Eric Dumazetf03f2e12015-10-14 11:16:27 -07001609 inet_csk_reqsk_queue_drop_and_put(sk, req);
Eric Dumazet4bdc3d62015-10-13 17:12:54 -07001610 goto lookup;
1611 }
Eric Dumazet3b24d852016-04-01 08:52:17 -07001612 /* We own a reference on the listener, increase it again
1613 * as we might lose it too soon.
1614 */
Eric Dumazet77166822016-02-18 05:39:18 -08001615 sock_hold(sk);
Eric Dumazet3b24d852016-04-01 08:52:17 -07001616 refcounted = true;
Eric Dumazet77166822016-02-18 05:39:18 -08001617 nsk = tcp_check_req(sk, skb, req, false);
Eric Dumazet079096f2015-10-02 11:43:32 -07001618 if (!nsk) {
1619 reqsk_put(req);
Eric Dumazet77166822016-02-18 05:39:18 -08001620 goto discard_and_relse;
Eric Dumazet079096f2015-10-02 11:43:32 -07001621 }
1622 if (nsk == sk) {
Eric Dumazet079096f2015-10-02 11:43:32 -07001623 reqsk_put(req);
1624 } else if (tcp_child_process(sk, nsk, skb)) {
1625 tcp_v4_send_reset(nsk, skb);
Eric Dumazet77166822016-02-18 05:39:18 -08001626 goto discard_and_relse;
Eric Dumazet079096f2015-10-02 11:43:32 -07001627 } else {
Eric Dumazet77166822016-02-18 05:39:18 -08001628 sock_put(sk);
Eric Dumazet079096f2015-10-02 11:43:32 -07001629 return 0;
1630 }
1631 }
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001632 if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
Eric Dumazet02a1d6e2016-04-27 16:44:39 -07001633 __NET_INC_STATS(net, LINUX_MIB_TCPMINTTLDROP);
Stephen Hemmingerd218d112010-01-11 16:28:01 -08001634 goto discard_and_relse;
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001635 }
Stephen Hemmingerd218d112010-01-11 16:28:01 -08001636
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1638 goto discard_and_relse;
Dmitry Popov9ea88a12014-08-07 02:38:22 +04001639
Dmitry Popov9ea88a12014-08-07 02:38:22 +04001640 if (tcp_v4_inbound_md5_hash(sk, skb))
1641 goto discard_and_relse;
Dmitry Popov9ea88a12014-08-07 02:38:22 +04001642
Patrick McHardyb59c2702006-01-06 23:06:10 -08001643 nf_reset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001645 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646 goto discard_and_relse;
1647
1648 skb->dev = NULL;
1649
Eric Dumazete994b2f2015-10-02 11:43:39 -07001650 if (sk->sk_state == TCP_LISTEN) {
1651 ret = tcp_v4_do_rcv(sk, skb);
1652 goto put_and_return;
1653 }
1654
1655 sk_incoming_cpu_update(sk);
1656
Ingo Molnarc6366182006-07-03 00:25:13 -07001657 bh_lock_sock_nested(sk);
Martin KaFai Laua44d6ea2016-03-14 10:52:15 -07001658 tcp_segs_in(tcp_sk(sk), skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659 ret = 0;
1660 if (!sock_owned_by_user(sk)) {
Dan Williams7bced392013-12-30 12:37:29 -08001661 if (!tcp_prequeue(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662 ret = tcp_v4_do_rcv(sk, skb);
Eric Dumazetda882c12012-04-22 23:38:54 +00001663 } else if (unlikely(sk_add_backlog(sk, skb,
1664 sk->sk_rcvbuf + sk->sk_sndbuf))) {
Zhu Yi6b03a532010-03-04 18:01:41 +00001665 bh_unlock_sock(sk);
Eric Dumazet02a1d6e2016-04-27 16:44:39 -07001666 __NET_INC_STATS(net, LINUX_MIB_TCPBACKLOGDROP);
Zhu Yi6b03a532010-03-04 18:01:41 +00001667 goto discard_and_relse;
1668 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669 bh_unlock_sock(sk);
1670
Eric Dumazete994b2f2015-10-02 11:43:39 -07001671put_and_return:
Eric Dumazet3b24d852016-04-01 08:52:17 -07001672 if (refcounted)
1673 sock_put(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674
1675 return ret;
1676
1677no_tcp_socket:
1678 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1679 goto discard_it;
1680
Eric Dumazet12e25e12015-06-03 23:49:21 -07001681 if (tcp_checksum_complete(skb)) {
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001682csum_error:
Eric Dumazet90bbcc62016-04-27 16:44:32 -07001683 __TCP_INC_STATS(net, TCP_MIB_CSUMERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684bad_packet:
Eric Dumazet90bbcc62016-04-27 16:44:32 -07001685 __TCP_INC_STATS(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001687 tcp_v4_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688 }
1689
1690discard_it:
1691 /* Discard frame. */
1692 kfree_skb(skb);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001693 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694
1695discard_and_relse:
Eric Dumazet532182c2016-04-01 08:52:19 -07001696 sk_drops_add(sk, skb);
Eric Dumazet3b24d852016-04-01 08:52:17 -07001697 if (refcounted)
1698 sock_put(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 goto discard_it;
1700
1701do_time_wait:
1702 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001703 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 goto discard_it;
1705 }
1706
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001707 if (tcp_checksum_complete(skb)) {
1708 inet_twsk_put(inet_twsk(sk));
1709 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001711 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 case TCP_TW_SYN: {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001713 struct sock *sk2 = inet_lookup_listener(dev_net(skb->dev),
Craig Galleka5836362016-02-10 11:50:38 -05001714 &tcp_hashinfo, skb,
1715 __tcp_hdrlen(th),
Tom Herbertda5e3632013-01-22 09:50:24 +00001716 iph->saddr, th->source,
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001717 iph->daddr, th->dest,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001718 inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719 if (sk2) {
Eric Dumazetdbe7faa2015-07-08 14:28:30 -07001720 inet_twsk_deschedule_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721 sk = sk2;
Eric Dumazet3b24d852016-04-01 08:52:17 -07001722 refcounted = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723 goto process;
1724 }
1725 /* Fall through to ACK */
1726 }
1727 case TCP_TW_ACK:
1728 tcp_v4_timewait_ack(sk, skb);
1729 break;
1730 case TCP_TW_RST:
Florian Westphal271c3b92015-12-21 21:29:26 +01001731 tcp_v4_send_reset(sk, skb);
1732 inet_twsk_deschedule_put(inet_twsk(sk));
1733 goto discard_it;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734 case TCP_TW_SUCCESS:;
1735 }
1736 goto discard_it;
1737}
1738
David S. Millerccb7c412010-12-01 18:09:13 -08001739static struct timewait_sock_ops tcp_timewait_sock_ops = {
1740 .twsk_obj_size = sizeof(struct tcp_timewait_sock),
1741 .twsk_unique = tcp_twsk_unique,
1742 .twsk_destructor= tcp_twsk_destructor,
David S. Millerccb7c412010-12-01 18:09:13 -08001743};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744
Eric Dumazet63d02d12012-08-09 14:11:00 +00001745void inet_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb)
Eric Dumazet5d299f32012-08-06 05:09:33 +00001746{
1747 struct dst_entry *dst = skb_dst(skb);
1748
Eric Dumazet5037e9e2015-12-14 14:08:53 -08001749 if (dst && dst_hold_safe(dst)) {
Eric Dumazetca777ef2014-09-08 08:06:07 -07001750 sk->sk_rx_dst = dst;
1751 inet_sk(sk)->rx_dst_ifindex = skb->skb_iif;
1752 }
Eric Dumazet5d299f32012-08-06 05:09:33 +00001753}
Eric Dumazet63d02d12012-08-09 14:11:00 +00001754EXPORT_SYMBOL(inet_sk_rx_dst_set);
Eric Dumazet5d299f32012-08-06 05:09:33 +00001755
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001756const struct inet_connection_sock_af_ops ipv4_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001757 .queue_xmit = ip_queue_xmit,
1758 .send_check = tcp_v4_send_check,
1759 .rebuild_header = inet_sk_rebuild_header,
Eric Dumazet5d299f32012-08-06 05:09:33 +00001760 .sk_rx_dst_set = inet_sk_rx_dst_set,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001761 .conn_request = tcp_v4_conn_request,
1762 .syn_recv_sock = tcp_v4_syn_recv_sock,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001763 .net_header_len = sizeof(struct iphdr),
1764 .setsockopt = ip_setsockopt,
1765 .getsockopt = ip_getsockopt,
1766 .addr2sockaddr = inet_csk_addr2sockaddr,
1767 .sockaddr_len = sizeof(struct sockaddr_in),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001768 .bind_conflict = inet_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001769#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001770 .compat_setsockopt = compat_ip_setsockopt,
1771 .compat_getsockopt = compat_ip_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001772#endif
Neal Cardwell4fab9072014-08-14 12:40:05 -04001773 .mtu_reduced = tcp_v4_mtu_reduced,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774};
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001775EXPORT_SYMBOL(ipv4_specific);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001777#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001778static const struct tcp_sock_af_ops tcp_sock_ipv4_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001779 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001780 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001781 .md5_parse = tcp_v4_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001782};
Andrew Mortonb6332e62006-11-30 19:16:28 -08001783#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001784
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785/* NOTE: A lot of things set to zero explicitly by call to
1786 * sk_alloc() so need not be done here.
1787 */
1788static int tcp_v4_init_sock(struct sock *sk)
1789{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001790 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791
Neal Cardwell900f65d2012-04-19 09:55:21 +00001792 tcp_init_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001794 icsk->icsk_af_ops = &ipv4_specific;
Neal Cardwell900f65d2012-04-19 09:55:21 +00001795
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001796#ifdef CONFIG_TCP_MD5SIG
David S. Millerac807fa2012-04-23 03:21:58 -04001797 tcp_sk(sk)->af_specific = &tcp_sock_ipv4_specific;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001798#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800 return 0;
1801}
1802
Brian Haley7d06b2e2008-06-14 17:04:49 -07001803void tcp_v4_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804{
1805 struct tcp_sock *tp = tcp_sk(sk);
1806
1807 tcp_clear_xmit_timers(sk);
1808
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001809 tcp_cleanup_congestion_control(sk);
Stephen Hemminger317a76f2005-06-23 12:19:55 -07001810
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811 /* Cleanup up the write buffer. */
David S. Millerfe067e82007-03-07 12:12:44 -08001812 tcp_write_queue_purge(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813
1814 /* Cleans up our, hopefully empty, out_of_order_queue. */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001815 __skb_queue_purge(&tp->out_of_order_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001817#ifdef CONFIG_TCP_MD5SIG
1818 /* Clean up the MD5 key list, if any */
1819 if (tp->md5sig_info) {
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001820 tcp_clear_md5_list(sk);
Eric Dumazeta8afca02012-01-31 18:45:40 +00001821 kfree_rcu(tp->md5sig_info, rcu);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001822 tp->md5sig_info = NULL;
1823 }
1824#endif
1825
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 /* Clean prequeue, it must be empty really */
1827 __skb_queue_purge(&tp->ucopy.prequeue);
1828
1829 /* Clean up a referenced TCP bind bucket. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001830 if (inet_csk(sk)->icsk_bind_hash)
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001831 inet_put_port(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832
Ian Morris00db4122015-04-03 09:17:27 +01001833 BUG_ON(tp->fastopen_rsk);
William Allen Simpson435cf552009-12-02 18:17:05 +00001834
Yuchung Chengcf60af02012-07-19 06:43:09 +00001835 /* If socket is aborted during connect operation */
1836 tcp_free_fastopen_req(tp);
Eric Dumazetcd8ae852015-05-03 21:34:46 -07001837 tcp_saved_syn_free(tp);
Yuchung Chengcf60af02012-07-19 06:43:09 +00001838
Eric Dumazet777c6ae2016-05-04 15:27:29 -07001839 local_bh_disable();
Glauber Costa180d8cd2011-12-11 21:47:02 +00001840 sk_sockets_allocated_dec(sk);
Eric Dumazet777c6ae2016-05-04 15:27:29 -07001841 local_bh_enable();
Johannes Weiner3d596f72016-01-14 15:21:05 -08001842
Johannes Weinerbaac50b2016-01-14 15:21:17 -08001843 if (mem_cgroup_sockets_enabled && sk->sk_memcg)
Johannes Weiner3d596f72016-01-14 15:21:05 -08001844 sock_release_memcg(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846EXPORT_SYMBOL(tcp_v4_destroy_sock);
1847
1848#ifdef CONFIG_PROC_FS
1849/* Proc filesystem TCP sock list dumping. */
1850
Tom Herberta8b690f2010-06-07 00:43:42 -07001851/*
1852 * Get next listener socket follow cur. If cur is NULL, get first socket
1853 * starting from bucket given in st->bucket; when st->bucket is zero the
1854 * very first socket in the hash table is returned.
1855 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856static void *listening_get_next(struct seq_file *seq, void *cur)
1857{
Jianjun Kong5799de02008-11-03 02:49:10 -08001858 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07001859 struct net *net = seq_file_net(seq);
Eric Dumazet3b24d852016-04-01 08:52:17 -07001860 struct inet_listen_hashbucket *ilb;
1861 struct inet_connection_sock *icsk;
1862 struct sock *sk = cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001863
1864 if (!sk) {
Eric Dumazet3b24d852016-04-01 08:52:17 -07001865get_head:
Tom Herberta8b690f2010-06-07 00:43:42 -07001866 ilb = &tcp_hashinfo.listening_hash[st->bucket];
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001867 spin_lock_bh(&ilb->lock);
Eric Dumazet3b24d852016-04-01 08:52:17 -07001868 sk = sk_head(&ilb->head);
Tom Herberta8b690f2010-06-07 00:43:42 -07001869 st->offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 goto get_sk;
1871 }
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001872 ilb = &tcp_hashinfo.listening_hash[st->bucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873 ++st->num;
Tom Herberta8b690f2010-06-07 00:43:42 -07001874 ++st->offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875
Eric Dumazet3b24d852016-04-01 08:52:17 -07001876 sk = sk_next(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877get_sk:
Eric Dumazet3b24d852016-04-01 08:52:17 -07001878 sk_for_each_from(sk) {
Pavel Emelyanov8475ef92010-11-22 03:26:12 +00001879 if (!net_eq(sock_net(sk), net))
1880 continue;
Eric Dumazet3b24d852016-04-01 08:52:17 -07001881 if (sk->sk_family == st->family)
1882 return sk;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001883 icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884 }
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001885 spin_unlock_bh(&ilb->lock);
Tom Herberta8b690f2010-06-07 00:43:42 -07001886 st->offset = 0;
Eric Dumazet3b24d852016-04-01 08:52:17 -07001887 if (++st->bucket < INET_LHTABLE_SIZE)
1888 goto get_head;
1889 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890}
1891
1892static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
1893{
Tom Herberta8b690f2010-06-07 00:43:42 -07001894 struct tcp_iter_state *st = seq->private;
1895 void *rc;
1896
1897 st->bucket = 0;
1898 st->offset = 0;
1899 rc = listening_get_next(seq, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900
1901 while (rc && *pos) {
1902 rc = listening_get_next(seq, rc);
1903 --*pos;
1904 }
1905 return rc;
1906}
1907
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07001908static inline bool empty_bucket(const struct tcp_iter_state *st)
Andi Kleen6eac5602008-08-28 01:08:02 -07001909{
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07001910 return hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].chain);
Andi Kleen6eac5602008-08-28 01:08:02 -07001911}
1912
Tom Herberta8b690f2010-06-07 00:43:42 -07001913/*
1914 * Get first established socket starting from bucket given in st->bucket.
1915 * If st->bucket is zero, the very first socket in the hash is returned.
1916 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917static void *established_get_first(struct seq_file *seq)
1918{
Jianjun Kong5799de02008-11-03 02:49:10 -08001919 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07001920 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921 void *rc = NULL;
1922
Tom Herberta8b690f2010-06-07 00:43:42 -07001923 st->offset = 0;
1924 for (; st->bucket <= tcp_hashinfo.ehash_mask; ++st->bucket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 struct sock *sk;
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001926 struct hlist_nulls_node *node;
Eric Dumazet9db66bd2008-11-20 20:39:09 -08001927 spinlock_t *lock = inet_ehash_lockp(&tcp_hashinfo, st->bucket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928
Andi Kleen6eac5602008-08-28 01:08:02 -07001929 /* Lockless fast path for the common case of empty buckets */
1930 if (empty_bucket(st))
1931 continue;
1932
Eric Dumazet9db66bd2008-11-20 20:39:09 -08001933 spin_lock_bh(lock);
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001934 sk_nulls_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
Daniel Lezcanof40c8172008-03-21 04:13:54 -07001935 if (sk->sk_family != st->family ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09001936 !net_eq(sock_net(sk), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 continue;
1938 }
1939 rc = sk;
1940 goto out;
1941 }
Eric Dumazet9db66bd2008-11-20 20:39:09 -08001942 spin_unlock_bh(lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 }
1944out:
1945 return rc;
1946}
1947
1948static void *established_get_next(struct seq_file *seq, void *cur)
1949{
1950 struct sock *sk = cur;
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001951 struct hlist_nulls_node *node;
Jianjun Kong5799de02008-11-03 02:49:10 -08001952 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07001953 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954
1955 ++st->num;
Tom Herberta8b690f2010-06-07 00:43:42 -07001956 ++st->offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07001958 sk = sk_nulls_next(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001960 sk_nulls_for_each_from(sk, node) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09001961 if (sk->sk_family == st->family && net_eq(sock_net(sk), net))
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07001962 return sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963 }
1964
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07001965 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
1966 ++st->bucket;
1967 return established_get_first(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968}
1969
1970static void *established_get_idx(struct seq_file *seq, loff_t pos)
1971{
Tom Herberta8b690f2010-06-07 00:43:42 -07001972 struct tcp_iter_state *st = seq->private;
1973 void *rc;
1974
1975 st->bucket = 0;
1976 rc = established_get_first(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977
1978 while (rc && pos) {
1979 rc = established_get_next(seq, rc);
1980 --pos;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001981 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982 return rc;
1983}
1984
1985static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
1986{
1987 void *rc;
Jianjun Kong5799de02008-11-03 02:49:10 -08001988 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990 st->state = TCP_SEQ_STATE_LISTENING;
1991 rc = listening_get_idx(seq, &pos);
1992
1993 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994 st->state = TCP_SEQ_STATE_ESTABLISHED;
1995 rc = established_get_idx(seq, pos);
1996 }
1997
1998 return rc;
1999}
2000
Tom Herberta8b690f2010-06-07 00:43:42 -07002001static void *tcp_seek_last_pos(struct seq_file *seq)
2002{
2003 struct tcp_iter_state *st = seq->private;
2004 int offset = st->offset;
2005 int orig_num = st->num;
2006 void *rc = NULL;
2007
2008 switch (st->state) {
Tom Herberta8b690f2010-06-07 00:43:42 -07002009 case TCP_SEQ_STATE_LISTENING:
2010 if (st->bucket >= INET_LHTABLE_SIZE)
2011 break;
2012 st->state = TCP_SEQ_STATE_LISTENING;
2013 rc = listening_get_next(seq, NULL);
2014 while (offset-- && rc)
2015 rc = listening_get_next(seq, rc);
2016 if (rc)
2017 break;
2018 st->bucket = 0;
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002019 st->state = TCP_SEQ_STATE_ESTABLISHED;
Tom Herberta8b690f2010-06-07 00:43:42 -07002020 /* Fallthrough */
2021 case TCP_SEQ_STATE_ESTABLISHED:
Tom Herberta8b690f2010-06-07 00:43:42 -07002022 if (st->bucket > tcp_hashinfo.ehash_mask)
2023 break;
2024 rc = established_get_first(seq);
2025 while (offset-- && rc)
2026 rc = established_get_next(seq, rc);
2027 }
2028
2029 st->num = orig_num;
2030
2031 return rc;
2032}
2033
Linus Torvalds1da177e2005-04-16 15:20:36 -07002034static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
2035{
Jianjun Kong5799de02008-11-03 02:49:10 -08002036 struct tcp_iter_state *st = seq->private;
Tom Herberta8b690f2010-06-07 00:43:42 -07002037 void *rc;
2038
2039 if (*pos && *pos == st->last_pos) {
2040 rc = tcp_seek_last_pos(seq);
2041 if (rc)
2042 goto out;
2043 }
2044
Linus Torvalds1da177e2005-04-16 15:20:36 -07002045 st->state = TCP_SEQ_STATE_LISTENING;
2046 st->num = 0;
Tom Herberta8b690f2010-06-07 00:43:42 -07002047 st->bucket = 0;
2048 st->offset = 0;
2049 rc = *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2050
2051out:
2052 st->last_pos = *pos;
2053 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054}
2055
2056static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2057{
Tom Herberta8b690f2010-06-07 00:43:42 -07002058 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059 void *rc = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060
2061 if (v == SEQ_START_TOKEN) {
2062 rc = tcp_get_idx(seq, 0);
2063 goto out;
2064 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002065
2066 switch (st->state) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067 case TCP_SEQ_STATE_LISTENING:
2068 rc = listening_get_next(seq, v);
2069 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070 st->state = TCP_SEQ_STATE_ESTABLISHED;
Tom Herberta8b690f2010-06-07 00:43:42 -07002071 st->bucket = 0;
2072 st->offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073 rc = established_get_first(seq);
2074 }
2075 break;
2076 case TCP_SEQ_STATE_ESTABLISHED:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077 rc = established_get_next(seq, v);
2078 break;
2079 }
2080out:
2081 ++*pos;
Tom Herberta8b690f2010-06-07 00:43:42 -07002082 st->last_pos = *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083 return rc;
2084}
2085
2086static void tcp_seq_stop(struct seq_file *seq, void *v)
2087{
Jianjun Kong5799de02008-11-03 02:49:10 -08002088 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089
2090 switch (st->state) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091 case TCP_SEQ_STATE_LISTENING:
2092 if (v != SEQ_START_TOKEN)
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002093 spin_unlock_bh(&tcp_hashinfo.listening_hash[st->bucket].lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095 case TCP_SEQ_STATE_ESTABLISHED:
2096 if (v)
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002097 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002098 break;
2099 }
2100}
2101
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002102int tcp_seq_open(struct inode *inode, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103{
Al Virod9dda782013-03-31 18:16:14 -04002104 struct tcp_seq_afinfo *afinfo = PDE_DATA(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002105 struct tcp_iter_state *s;
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002106 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002108 err = seq_open_net(inode, file, &afinfo->seq_ops,
2109 sizeof(struct tcp_iter_state));
2110 if (err < 0)
2111 return err;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002112
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002113 s = ((struct seq_file *)file->private_data)->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114 s->family = afinfo->family;
stephen hemminger688d1942014-08-29 23:32:05 -07002115 s->last_pos = 0;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002116 return 0;
2117}
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002118EXPORT_SYMBOL(tcp_seq_open);
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002119
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002120int tcp_proc_register(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121{
2122 int rc = 0;
2123 struct proc_dir_entry *p;
2124
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002125 afinfo->seq_ops.start = tcp_seq_start;
2126 afinfo->seq_ops.next = tcp_seq_next;
2127 afinfo->seq_ops.stop = tcp_seq_stop;
2128
Denis V. Lunev84841c32008-05-02 04:10:08 -07002129 p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net,
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002130 afinfo->seq_fops, afinfo);
Denis V. Lunev84841c32008-05-02 04:10:08 -07002131 if (!p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132 rc = -ENOMEM;
2133 return rc;
2134}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002135EXPORT_SYMBOL(tcp_proc_register);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002136
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002137void tcp_proc_unregister(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138{
Gao fengece31ff2013-02-18 01:34:56 +00002139 remove_proc_entry(afinfo->name, net->proc_net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002141EXPORT_SYMBOL(tcp_proc_unregister);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002142
Eric Dumazetd4f06872015-03-12 16:44:09 -07002143static void get_openreq4(const struct request_sock *req,
Eric Dumazetaa3a0c82015-10-02 11:43:30 -07002144 struct seq_file *f, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002146 const struct inet_request_sock *ireq = inet_rsk(req);
Eric Dumazetfa76ce732015-03-19 19:04:20 -07002147 long delta = req->rsk_timer.expires - jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002149 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
Tetsuo Handa652586d2013-11-14 14:31:57 -08002150 " %02X %08X:%08X %02X:%08lX %08X %5u %8d %u %d %pK",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151 i,
Eric Dumazet634fb9792013-10-09 15:21:29 -07002152 ireq->ir_loc_addr,
Eric Dumazetd4f06872015-03-12 16:44:09 -07002153 ireq->ir_num,
Eric Dumazet634fb9792013-10-09 15:21:29 -07002154 ireq->ir_rmt_addr,
2155 ntohs(ireq->ir_rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156 TCP_SYN_RECV,
2157 0, 0, /* could print option size, but that is af dependent. */
2158 1, /* timers active (only the expire timer) */
Eric Dumazeta399a802012-08-08 21:13:53 +00002159 jiffies_delta_to_clock_t(delta),
Eric Dumazete6c022a2012-10-27 23:16:46 +00002160 req->num_timeout,
Eric Dumazetaa3a0c82015-10-02 11:43:30 -07002161 from_kuid_munged(seq_user_ns(f),
2162 sock_i_uid(req->rsk_listener)),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163 0, /* non standard timer */
2164 0, /* open_requests have no inode */
Eric Dumazetd4f06872015-03-12 16:44:09 -07002165 0,
Tetsuo Handa652586d2013-11-14 14:31:57 -08002166 req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002167}
2168
Tetsuo Handa652586d2013-11-14 14:31:57 -08002169static void get_tcp4_sock(struct sock *sk, struct seq_file *f, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002170{
2171 int timer_active;
2172 unsigned long timer_expires;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002173 const struct tcp_sock *tp = tcp_sk(sk);
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002174 const struct inet_connection_sock *icsk = inet_csk(sk);
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002175 const struct inet_sock *inet = inet_sk(sk);
Eric Dumazet0536fcc2015-09-29 07:42:52 -07002176 const struct fastopen_queue *fastopenq = &icsk->icsk_accept_queue.fastopenq;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00002177 __be32 dest = inet->inet_daddr;
2178 __be32 src = inet->inet_rcv_saddr;
2179 __u16 destp = ntohs(inet->inet_dport);
2180 __u16 srcp = ntohs(inet->inet_sport);
Eric Dumazet49d09002009-12-03 16:06:13 -08002181 int rx_queue;
Eric Dumazet00fd38d2015-11-12 08:43:18 -08002182 int state;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183
Nandita Dukkipati6ba8a3b2013-03-11 10:00:43 +00002184 if (icsk->icsk_pending == ICSK_TIME_RETRANS ||
2185 icsk->icsk_pending == ICSK_TIME_EARLY_RETRANS ||
2186 icsk->icsk_pending == ICSK_TIME_LOSS_PROBE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002188 timer_expires = icsk->icsk_timeout;
2189 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002190 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002191 timer_expires = icsk->icsk_timeout;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002192 } else if (timer_pending(&sk->sk_timer)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193 timer_active = 2;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002194 timer_expires = sk->sk_timer.expires;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195 } else {
2196 timer_active = 0;
2197 timer_expires = jiffies;
2198 }
2199
Eric Dumazet00fd38d2015-11-12 08:43:18 -08002200 state = sk_state_load(sk);
2201 if (state == TCP_LISTEN)
Eric Dumazet49d09002009-12-03 16:06:13 -08002202 rx_queue = sk->sk_ack_backlog;
2203 else
Eric Dumazet00fd38d2015-11-12 08:43:18 -08002204 /* Because we don't lock the socket,
2205 * we might find a transient negative value.
Eric Dumazet49d09002009-12-03 16:06:13 -08002206 */
2207 rx_queue = max_t(int, tp->rcv_nxt - tp->copied_seq, 0);
2208
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002209 seq_printf(f, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
Tetsuo Handa652586d2013-11-14 14:31:57 -08002210 "%08X %5u %8d %lu %d %pK %lu %lu %u %u %d",
Eric Dumazet00fd38d2015-11-12 08:43:18 -08002211 i, src, srcp, dest, destp, state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07002212 tp->write_seq - tp->snd_una,
Eric Dumazet49d09002009-12-03 16:06:13 -08002213 rx_queue,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002214 timer_active,
Eric Dumazeta399a802012-08-08 21:13:53 +00002215 jiffies_delta_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002216 icsk->icsk_retransmits,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06002217 from_kuid_munged(seq_user_ns(f), sock_i_uid(sk)),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03002218 icsk->icsk_probes_out,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002219 sock_i_ino(sk),
2220 atomic_read(&sk->sk_refcnt), sk,
Stephen Hemminger7be87352008-06-27 20:00:19 -07002221 jiffies_to_clock_t(icsk->icsk_rto),
2222 jiffies_to_clock_t(icsk->icsk_ack.ato),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002223 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002224 tp->snd_cwnd,
Eric Dumazet00fd38d2015-11-12 08:43:18 -08002225 state == TCP_LISTEN ?
2226 fastopenq->max_qlen :
Tetsuo Handa652586d2013-11-14 14:31:57 -08002227 (tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228}
2229
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002230static void get_timewait4_sock(const struct inet_timewait_sock *tw,
Tetsuo Handa652586d2013-11-14 14:31:57 -08002231 struct seq_file *f, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232{
Eric Dumazet789f5582015-04-12 18:51:09 -07002233 long delta = tw->tw_timer.expires - jiffies;
Al Viro23f33c22006-09-27 18:43:50 -07002234 __be32 dest, src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235 __u16 destp, srcp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236
2237 dest = tw->tw_daddr;
2238 src = tw->tw_rcv_saddr;
2239 destp = ntohs(tw->tw_dport);
2240 srcp = ntohs(tw->tw_sport);
2241
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002242 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
Tetsuo Handa652586d2013-11-14 14:31:57 -08002243 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
Eric Dumazeta399a802012-08-08 21:13:53 +00002245 3, jiffies_delta_to_clock_t(delta), 0, 0, 0, 0,
Tetsuo Handa652586d2013-11-14 14:31:57 -08002246 atomic_read(&tw->tw_refcnt), tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247}
2248
2249#define TMPSZ 150
2250
2251static int tcp4_seq_show(struct seq_file *seq, void *v)
2252{
Jianjun Kong5799de02008-11-03 02:49:10 -08002253 struct tcp_iter_state *st;
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002254 struct sock *sk = v;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002255
Tetsuo Handa652586d2013-11-14 14:31:57 -08002256 seq_setwidth(seq, TMPSZ - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002257 if (v == SEQ_START_TOKEN) {
Tetsuo Handa652586d2013-11-14 14:31:57 -08002258 seq_puts(seq, " sl local_address rem_address st tx_queue "
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259 "rx_queue tr tm->when retrnsmt uid timeout "
2260 "inode");
2261 goto out;
2262 }
2263 st = seq->private;
2264
Eric Dumazet079096f2015-10-02 11:43:32 -07002265 if (sk->sk_state == TCP_TIME_WAIT)
2266 get_timewait4_sock(v, seq, st->num);
2267 else if (sk->sk_state == TCP_NEW_SYN_RECV)
Eric Dumazetaa3a0c82015-10-02 11:43:30 -07002268 get_openreq4(v, seq, st->num);
Eric Dumazet079096f2015-10-02 11:43:32 -07002269 else
2270 get_tcp4_sock(v, seq, st->num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002271out:
Tetsuo Handa652586d2013-11-14 14:31:57 -08002272 seq_pad(seq, '\n');
Linus Torvalds1da177e2005-04-16 15:20:36 -07002273 return 0;
2274}
2275
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002276static const struct file_operations tcp_afinfo_seq_fops = {
2277 .owner = THIS_MODULE,
2278 .open = tcp_seq_open,
2279 .read = seq_read,
2280 .llseek = seq_lseek,
2281 .release = seq_release_net
2282};
2283
Linus Torvalds1da177e2005-04-16 15:20:36 -07002284static struct tcp_seq_afinfo tcp4_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002285 .name = "tcp",
2286 .family = AF_INET,
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002287 .seq_fops = &tcp_afinfo_seq_fops,
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002288 .seq_ops = {
2289 .show = tcp4_seq_show,
2290 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002291};
2292
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002293static int __net_init tcp4_proc_init_net(struct net *net)
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002294{
2295 return tcp_proc_register(net, &tcp4_seq_afinfo);
2296}
2297
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002298static void __net_exit tcp4_proc_exit_net(struct net *net)
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002299{
2300 tcp_proc_unregister(net, &tcp4_seq_afinfo);
2301}
2302
2303static struct pernet_operations tcp4_net_ops = {
2304 .init = tcp4_proc_init_net,
2305 .exit = tcp4_proc_exit_net,
2306};
2307
Linus Torvalds1da177e2005-04-16 15:20:36 -07002308int __init tcp4_proc_init(void)
2309{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002310 return register_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311}
2312
2313void tcp4_proc_exit(void)
2314{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002315 unregister_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316}
2317#endif /* CONFIG_PROC_FS */
2318
2319struct proto tcp_prot = {
2320 .name = "TCP",
2321 .owner = THIS_MODULE,
2322 .close = tcp_close,
2323 .connect = tcp_v4_connect,
2324 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002325 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326 .ioctl = tcp_ioctl,
2327 .init = tcp_v4_init_sock,
2328 .destroy = tcp_v4_destroy_sock,
2329 .shutdown = tcp_shutdown,
2330 .setsockopt = tcp_setsockopt,
2331 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002332 .recvmsg = tcp_recvmsg,
Changli Gao7ba42912010-07-10 20:41:55 +00002333 .sendmsg = tcp_sendmsg,
2334 .sendpage = tcp_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002335 .backlog_rcv = tcp_v4_do_rcv,
Eric Dumazet46d3cea2012-07-11 05:50:31 +00002336 .release_cb = tcp_release_cb,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08002337 .hash = inet_hash,
2338 .unhash = inet_unhash,
2339 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002340 .enter_memory_pressure = tcp_enter_memory_pressure,
Eric Dumazetc9bee3b72013-07-22 20:27:07 -07002341 .stream_memory_free = tcp_stream_memory_free,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002342 .sockets_allocated = &tcp_sockets_allocated,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07002343 .orphan_count = &tcp_orphan_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002344 .memory_allocated = &tcp_memory_allocated,
2345 .memory_pressure = &tcp_memory_pressure,
Eric W. Biedermana4fe34b2013-10-19 16:25:36 -07002346 .sysctl_mem = sysctl_tcp_mem,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002347 .sysctl_wmem = sysctl_tcp_wmem,
2348 .sysctl_rmem = sysctl_tcp_rmem,
2349 .max_header = MAX_TCP_HEADER,
2350 .obj_size = sizeof(struct tcp_sock),
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002351 .slab_flags = SLAB_DESTROY_BY_RCU,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002352 .twsk_prot = &tcp_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002353 .rsk_prot = &tcp_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07002354 .h.hashinfo = &tcp_hashinfo,
Changli Gao7ba42912010-07-10 20:41:55 +00002355 .no_autobind = true,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002356#ifdef CONFIG_COMPAT
2357 .compat_setsockopt = compat_tcp_setsockopt,
2358 .compat_getsockopt = compat_tcp_getsockopt,
2359#endif
Lorenzo Colittic1e64e22015-12-16 12:30:05 +09002360 .diag_destroy = tcp_abort,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002361};
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002362EXPORT_SYMBOL(tcp_prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002363
Denis V. Lunev046ee902008-04-03 14:31:33 -07002364static void __net_exit tcp_sk_exit(struct net *net)
2365{
Eric Dumazetbdbbb852015-01-29 21:35:05 -08002366 int cpu;
2367
2368 for_each_possible_cpu(cpu)
2369 inet_ctl_sock_destroy(*per_cpu_ptr(net->ipv4.tcp_sk, cpu));
2370 free_percpu(net->ipv4.tcp_sk);
2371}
2372
2373static int __net_init tcp_sk_init(struct net *net)
2374{
2375 int res, cpu;
2376
2377 net->ipv4.tcp_sk = alloc_percpu(struct sock *);
2378 if (!net->ipv4.tcp_sk)
2379 return -ENOMEM;
2380
2381 for_each_possible_cpu(cpu) {
2382 struct sock *sk;
2383
2384 res = inet_ctl_sock_create(&sk, PF_INET, SOCK_RAW,
2385 IPPROTO_TCP, net);
2386 if (res)
2387 goto fail;
Eric Dumazeta9d65322016-04-01 08:52:21 -07002388 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
Eric Dumazetbdbbb852015-01-29 21:35:05 -08002389 *per_cpu_ptr(net->ipv4.tcp_sk, cpu) = sk;
2390 }
Daniel Borkmann49213552015-05-19 21:04:22 +02002391
Eric Dumazetbdbbb852015-01-29 21:35:05 -08002392 net->ipv4.sysctl_tcp_ecn = 2;
Daniel Borkmann49213552015-05-19 21:04:22 +02002393 net->ipv4.sysctl_tcp_ecn_fallback = 1;
2394
Fan Dub0f9ca52015-02-10 09:53:16 +08002395 net->ipv4.sysctl_tcp_base_mss = TCP_BASE_MSS;
Fan Du6b58e0a2015-03-06 11:18:23 +08002396 net->ipv4.sysctl_tcp_probe_threshold = TCP_PROBE_THRESHOLD;
Fan Du05cbc0d2015-03-06 11:18:24 +08002397 net->ipv4.sysctl_tcp_probe_interval = TCP_PROBE_INTERVAL;
Eric Dumazetbdbbb852015-01-29 21:35:05 -08002398
Nikolay Borisov13b287e2016-01-07 16:38:43 +02002399 net->ipv4.sysctl_tcp_keepalive_time = TCP_KEEPALIVE_TIME;
Nikolay Borisov9bd68612016-01-07 16:38:44 +02002400 net->ipv4.sysctl_tcp_keepalive_probes = TCP_KEEPALIVE_PROBES;
Nikolay Borisovb840d152016-01-07 16:38:45 +02002401 net->ipv4.sysctl_tcp_keepalive_intvl = TCP_KEEPALIVE_INTVL;
Nikolay Borisov13b287e2016-01-07 16:38:43 +02002402
Nikolay Borisov6fa25162016-02-03 09:46:49 +02002403 net->ipv4.sysctl_tcp_syn_retries = TCP_SYN_RETRIES;
Nikolay Borisov7c083ec2016-02-03 09:46:50 +02002404 net->ipv4.sysctl_tcp_synack_retries = TCP_SYNACK_RETRIES;
David S. Miller0aca7372016-02-08 04:24:33 -05002405 net->ipv4.sysctl_tcp_syncookies = 1;
Nikolay Borisov1043e252016-02-03 09:46:52 +02002406 net->ipv4.sysctl_tcp_reordering = TCP_FASTRETRANS_THRESH;
Nikolay Borisovae5c3f42016-02-03 09:46:53 +02002407 net->ipv4.sysctl_tcp_retries1 = TCP_RETR1;
Nikolay Borisovc6214a92016-02-03 09:46:54 +02002408 net->ipv4.sysctl_tcp_retries2 = TCP_RETR2;
Nikolay Borisovc402d9b2016-02-03 09:46:55 +02002409 net->ipv4.sysctl_tcp_orphan_retries = 0;
Nikolay Borisov1e579ca2016-02-03 09:46:56 +02002410 net->ipv4.sysctl_tcp_fin_timeout = TCP_FIN_TIMEOUT;
Nikolay Borisov4979f2d2016-02-03 09:46:57 +02002411 net->ipv4.sysctl_tcp_notsent_lowat = UINT_MAX;
Nikolay Borisov12ed8242016-02-03 09:46:51 +02002412
Daniel Borkmann49213552015-05-19 21:04:22 +02002413 return 0;
Eric Dumazetbdbbb852015-01-29 21:35:05 -08002414fail:
2415 tcp_sk_exit(net);
2416
2417 return res;
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002418}
2419
2420static void __net_exit tcp_sk_exit_batch(struct list_head *net_exit_list)
2421{
2422 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET);
Denis V. Lunev046ee902008-04-03 14:31:33 -07002423}
2424
2425static struct pernet_operations __net_initdata tcp_sk_ops = {
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002426 .init = tcp_sk_init,
2427 .exit = tcp_sk_exit,
2428 .exit_batch = tcp_sk_exit_batch,
Denis V. Lunev046ee902008-04-03 14:31:33 -07002429};
2430
Denis V. Lunev9b0f9762008-02-29 11:13:15 -08002431void __init tcp_v4_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002432{
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002433 inet_hashinfo_init(&tcp_hashinfo);
Eric W. Biederman6a1b3052009-02-22 00:10:18 -08002434 if (register_pernet_subsys(&tcp_sk_ops))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002435 panic("Failed to create the TCP control socket.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002436}