blob: 02e6cd29ebf12d4e7b7ca270454cba99e118100c [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>
Chris Leech1a2449a2006-05-23 18:05:53 -070075#include <net/netdma.h>
David S. Miller6e5714e2011-08-03 20:50:44 -070076#include <net/secure_seq.h>
Glauber Costad1a4c0b2011-12-11 21:47:04 +000077#include <net/tcp_memcontrol.h>
Eliezer Tamir076bb0c2013-07-10 17:13:17 +030078#include <net/busy_poll.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
80#include <linux/inet.h>
81#include <linux/ipv6.h>
82#include <linux/stddef.h>
83#include <linux/proc_fs.h>
84#include <linux/seq_file.h>
85
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080086#include <linux/crypto.h>
87#include <linux/scatterlist.h>
88
Brian Haleyab32ea52006-09-22 14:15:41 -070089int sysctl_tcp_tw_reuse __read_mostly;
90int sysctl_tcp_low_latency __read_mostly;
Eric Dumazet4bc2f182010-07-09 21:22:10 +000091EXPORT_SYMBOL(sysctl_tcp_low_latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080093#ifdef CONFIG_TCP_MD5SIG
Eric Dumazeta915da9b2012-01-31 05:18:33 +000094static int tcp_v4_md5_hash_hdr(char *md5_hash, const struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -040095 __be32 daddr, __be32 saddr, const struct tcphdr *th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080096#endif
97
Eric Dumazet5caea4e2008-11-20 00:40:07 -080098struct inet_hashinfo tcp_hashinfo;
Eric Dumazet4bc2f182010-07-09 21:22:10 +000099EXPORT_SYMBOL(tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100
Octavian Purdila936b8bd2014-06-25 17:09:57 +0300101static __u32 tcp_v4_init_sequence(const struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700103 return secure_tcp_sequence_number(ip_hdr(skb)->daddr,
104 ip_hdr(skb)->saddr,
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700105 tcp_hdr(skb)->dest,
106 tcp_hdr(skb)->source);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107}
108
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800109int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp)
110{
111 const struct tcp_timewait_sock *tcptw = tcp_twsk(sktw);
112 struct tcp_sock *tp = tcp_sk(sk);
113
114 /* With PAWS, it is safe from the viewpoint
115 of data integrity. Even without PAWS it is safe provided sequence
116 spaces do not overlap i.e. at data rates <= 80Mbit/sec.
117
118 Actually, the idea is close to VJ's one, only timestamp cache is
119 held not per host, but per port pair and TW bucket is used as state
120 holder.
121
122 If TW bucket has been already destroyed we fall back to VJ's scheme
123 and use initial timestamp retrieved from peer table.
124 */
125 if (tcptw->tw_ts_recent_stamp &&
126 (twp == NULL || (sysctl_tcp_tw_reuse &&
James Morris9d729f72007-03-04 16:12:44 -0800127 get_seconds() - tcptw->tw_ts_recent_stamp > 1))) {
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800128 tp->write_seq = tcptw->tw_snd_nxt + 65535 + 2;
129 if (tp->write_seq == 0)
130 tp->write_seq = 1;
131 tp->rx_opt.ts_recent = tcptw->tw_ts_recent;
132 tp->rx_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp;
133 sock_hold(sktw);
134 return 1;
135 }
136
137 return 0;
138}
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800139EXPORT_SYMBOL_GPL(tcp_twsk_unique);
140
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141/* This will initiate an outgoing connection. */
142int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
143{
David S. Miller2d7192d2011-04-26 13:28:44 -0700144 struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 struct inet_sock *inet = inet_sk(sk);
146 struct tcp_sock *tp = tcp_sk(sk);
David S. Millerdca8b082011-02-24 13:38:12 -0800147 __be16 orig_sport, orig_dport;
Al Virobada8ad2006-09-26 21:27:15 -0700148 __be32 daddr, nexthop;
David S. Millerda905bd2011-05-06 16:11:19 -0700149 struct flowi4 *fl4;
David S. Miller2d7192d2011-04-26 13:28:44 -0700150 struct rtable *rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 int err;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000152 struct ip_options_rcu *inet_opt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
154 if (addr_len < sizeof(struct sockaddr_in))
155 return -EINVAL;
156
157 if (usin->sin_family != AF_INET)
158 return -EAFNOSUPPORT;
159
160 nexthop = daddr = usin->sin_addr.s_addr;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000161 inet_opt = rcu_dereference_protected(inet->inet_opt,
162 sock_owned_by_user(sk));
163 if (inet_opt && inet_opt->opt.srr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 if (!daddr)
165 return -EINVAL;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000166 nexthop = inet_opt->opt.faddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 }
168
David S. Millerdca8b082011-02-24 13:38:12 -0800169 orig_sport = inet->inet_sport;
170 orig_dport = usin->sin_port;
David S. Millerda905bd2011-05-06 16:11:19 -0700171 fl4 = &inet->cork.fl.u.ip4;
172 rt = ip_route_connect(fl4, nexthop, inet->inet_saddr,
David S. Millerb23dd4f2011-03-02 14:31:35 -0800173 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
174 IPPROTO_TCP,
Steffen Klassert0e0d44a2013-08-28 08:04:14 +0200175 orig_sport, orig_dport, sk);
David S. Millerb23dd4f2011-03-02 14:31:35 -0800176 if (IS_ERR(rt)) {
177 err = PTR_ERR(rt);
178 if (err == -ENETUNREACH)
Eric Dumazetf1d8cba2013-11-28 09:51:22 -0800179 IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTNOROUTES);
David S. Millerb23dd4f2011-03-02 14:31:35 -0800180 return err;
Wei Dong584bdf82007-05-31 22:49:28 -0700181 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182
183 if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
184 ip_rt_put(rt);
185 return -ENETUNREACH;
186 }
187
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000188 if (!inet_opt || !inet_opt->opt.srr)
David S. Millerda905bd2011-05-06 16:11:19 -0700189 daddr = fl4->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000191 if (!inet->inet_saddr)
David S. Millerda905bd2011-05-06 16:11:19 -0700192 inet->inet_saddr = fl4->saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000193 inet->inet_rcv_saddr = inet->inet_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000195 if (tp->rx_opt.ts_recent_stamp && inet->inet_daddr != daddr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 /* Reset inherited state */
197 tp->rx_opt.ts_recent = 0;
198 tp->rx_opt.ts_recent_stamp = 0;
Pavel Emelyanovee995282012-04-19 03:40:39 +0000199 if (likely(!tp->repair))
200 tp->write_seq = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 }
202
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -0700203 if (tcp_death_row.sysctl_tw_recycle &&
David S. Miller81166dd2012-07-10 03:14:24 -0700204 !tp->rx_opt.ts_recent_stamp && fl4->daddr == daddr)
205 tcp_fetch_timewait_stamp(sk, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000207 inet->inet_dport = usin->sin_port;
208 inet->inet_daddr = daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209
Tom Herbertb73c3d02014-07-01 21:32:17 -0700210 inet_set_txhash(sk);
211
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800212 inet_csk(sk)->icsk_ext_hdr_len = 0;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000213 if (inet_opt)
214 inet_csk(sk)->icsk_ext_hdr_len = inet_opt->opt.optlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
William Allen Simpsonbee7ca92009-11-10 09:51:18 +0000216 tp->rx_opt.mss_clamp = TCP_MSS_DEFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217
218 /* Socket identity is still unknown (sport may be zero).
219 * However we set state to SYN-SENT and not releasing socket
220 * lock select source port, enter ourselves into the hash tables and
221 * complete initialization after this.
222 */
223 tcp_set_state(sk, TCP_SYN_SENT);
Arnaldo Carvalho de Meloa7f5e7f2005-12-13 23:25:31 -0800224 err = inet_hash_connect(&tcp_death_row, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 if (err)
226 goto failure;
227
David S. Millerda905bd2011-05-06 16:11:19 -0700228 rt = ip_route_newports(fl4, rt, orig_sport, orig_dport,
David S. Millerb23dd4f2011-03-02 14:31:35 -0800229 inet->inet_sport, inet->inet_dport, sk);
230 if (IS_ERR(rt)) {
231 err = PTR_ERR(rt);
232 rt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 goto failure;
David S. Millerb23dd4f2011-03-02 14:31:35 -0800234 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 /* OK, now commit destination to socket. */
Herbert Xubcd76112006-06-30 13:36:35 -0700236 sk->sk_gso_type = SKB_GSO_TCPV4;
Changli Gaod8d1f302010-06-10 23:31:35 -0700237 sk_setup_caps(sk, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238
Pavel Emelyanovee995282012-04-19 03:40:39 +0000239 if (!tp->write_seq && likely(!tp->repair))
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000240 tp->write_seq = secure_tcp_sequence_number(inet->inet_saddr,
241 inet->inet_daddr,
242 inet->inet_sport,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 usin->sin_port);
244
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000245 inet->inet_id = tp->write_seq ^ jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246
Andrey Vagin2b916472012-11-22 01:13:58 +0000247 err = tcp_connect(sk);
Pavel Emelyanovee995282012-04-19 03:40:39 +0000248
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 rt = NULL;
250 if (err)
251 goto failure;
252
253 return 0;
254
255failure:
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200256 /*
257 * This unhashes the socket and releases the local port,
258 * if necessary.
259 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 tcp_set_state(sk, TCP_CLOSE);
261 ip_rt_put(rt);
262 sk->sk_route_caps = 0;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000263 inet->inet_dport = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 return err;
265}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000266EXPORT_SYMBOL(tcp_v4_connect);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268/*
Eric Dumazet563d34d2012-07-23 09:48:52 +0200269 * This routine reacts to ICMP_FRAG_NEEDED mtu indications as defined in RFC1191.
270 * It can be called through tcp_release_cb() if socket was owned by user
271 * at the time tcp_v4_err() was called to handle ICMP message.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 */
Neal Cardwell4fab9072014-08-14 12:40:05 -0400273void tcp_v4_mtu_reduced(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274{
275 struct dst_entry *dst;
276 struct inet_sock *inet = inet_sk(sk);
Eric Dumazet563d34d2012-07-23 09:48:52 +0200277 u32 mtu = tcp_sk(sk)->mtu_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278
David S. Miller80d0a692012-07-16 03:28:06 -0700279 dst = inet_csk_update_pmtu(sk, mtu);
280 if (!dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 return;
282
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 /* Something is about to be wrong... Remember soft error
284 * for the case, if this connection will not able to recover.
285 */
286 if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
287 sk->sk_err_soft = EMSGSIZE;
288
289 mtu = dst_mtu(dst);
290
291 if (inet->pmtudisc != IP_PMTUDISC_DONT &&
Hannes Frederic Sowa482fc602013-11-05 02:24:17 +0100292 ip_sk_accept_pmtu(sk) &&
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800293 inet_csk(sk)->icsk_pmtu_cookie > mtu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 tcp_sync_mss(sk, mtu);
295
296 /* Resend the TCP packet because it's
297 * clear that the old packet has been
298 * dropped. This is the new "fast" path mtu
299 * discovery.
300 */
301 tcp_simple_retransmit(sk);
302 } /* else let the usual retransmit timer handle it */
303}
Neal Cardwell4fab9072014-08-14 12:40:05 -0400304EXPORT_SYMBOL(tcp_v4_mtu_reduced);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305
David S. Miller55be7a92012-07-11 21:27:49 -0700306static void do_redirect(struct sk_buff *skb, struct sock *sk)
307{
308 struct dst_entry *dst = __sk_dst_check(sk, 0);
309
David S. Miller1ed5c482012-07-12 00:41:25 -0700310 if (dst)
David S. Miller6700c272012-07-17 03:29:28 -0700311 dst->ops->redirect(dst, sk, skb);
David S. Miller55be7a92012-07-11 21:27:49 -0700312}
313
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314/*
315 * This routine is called by the ICMP module when it gets some
316 * sort of error condition. If err < 0 then the socket should
317 * be closed and the error returned to the user. If err > 0
318 * it's just the icmp type << 8 | icmp code. After adjustment
319 * header points to the first 8 bytes of the tcp header. We need
320 * to find the appropriate port.
321 *
322 * The locking strategy used here is very "optimistic". When
323 * someone else accesses the socket the ICMP is just dropped
324 * and for some paths there is no check at all.
325 * A more general error queue to queue errors for later handling
326 * is probably better.
327 *
328 */
329
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000330void tcp_v4_err(struct sk_buff *icmp_skb, u32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000332 const struct iphdr *iph = (const struct iphdr *)icmp_skb->data;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000333 struct tcphdr *th = (struct tcphdr *)(icmp_skb->data + (iph->ihl << 2));
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000334 struct inet_connection_sock *icsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 struct tcp_sock *tp;
336 struct inet_sock *inet;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000337 const int type = icmp_hdr(icmp_skb)->type;
338 const int code = icmp_hdr(icmp_skb)->code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 struct sock *sk;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000340 struct sk_buff *skb;
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700341 struct request_sock *fastopen;
342 __u32 seq, snd_una;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000343 __u32 remaining;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 int err;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000345 struct net *net = dev_net(icmp_skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346
Pavel Emelyanovfd54d712008-07-14 23:01:40 -0700347 sk = inet_lookup(net, &tcp_hashinfo, iph->daddr, th->dest,
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000348 iph->saddr, th->source, inet_iif(icmp_skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 if (!sk) {
Pavel Emelyanovdcfc23c2008-07-14 23:03:00 -0700350 ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 return;
352 }
353 if (sk->sk_state == TCP_TIME_WAIT) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700354 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 return;
356 }
357
358 bh_lock_sock(sk);
359 /* If too many ICMPs get dropped on busy
360 * servers this needs to be solved differently.
Eric Dumazet563d34d2012-07-23 09:48:52 +0200361 * We do take care of PMTU discovery (RFC1191) special case :
362 * we can receive locally generated ICMP messages while socket is held.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 */
Eric Dumazetb74aa932013-01-19 16:10:37 +0000364 if (sock_owned_by_user(sk)) {
365 if (!(type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED))
366 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
367 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 if (sk->sk_state == TCP_CLOSE)
369 goto out;
370
stephen hemminger97e3ecd12010-03-18 11:27:32 +0000371 if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
372 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
373 goto out;
374 }
375
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000376 icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 tp = tcp_sk(sk);
378 seq = ntohl(th->seq);
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700379 /* XXX (TFO) - tp->snd_una should be ISN (tcp_create_openreq_child() */
380 fastopen = tp->fastopen_rsk;
381 snd_una = fastopen ? tcp_rsk(fastopen)->snt_isn : tp->snd_una;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 if (sk->sk_state != TCP_LISTEN &&
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700383 !between(seq, snd_una, tp->snd_nxt)) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700384 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 goto out;
386 }
387
388 switch (type) {
David S. Miller55be7a92012-07-11 21:27:49 -0700389 case ICMP_REDIRECT:
390 do_redirect(icmp_skb, sk);
391 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 case ICMP_SOURCE_QUENCH:
393 /* Just silently ignore these. */
394 goto out;
395 case ICMP_PARAMETERPROB:
396 err = EPROTO;
397 break;
398 case ICMP_DEST_UNREACH:
399 if (code > NR_ICMP_UNREACH)
400 goto out;
401
402 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
Eric Dumazet0d4f0602013-03-18 07:01:28 +0000403 /* We are not interested in TCP_LISTEN and open_requests
404 * (SYN-ACKs send out by Linux are always <576bytes so
405 * they should go through unfragmented).
406 */
407 if (sk->sk_state == TCP_LISTEN)
408 goto out;
409
Eric Dumazet563d34d2012-07-23 09:48:52 +0200410 tp->mtu_info = info;
Eric Dumazet144d56e2012-08-20 00:22:46 +0000411 if (!sock_owned_by_user(sk)) {
Eric Dumazet563d34d2012-07-23 09:48:52 +0200412 tcp_v4_mtu_reduced(sk);
Eric Dumazet144d56e2012-08-20 00:22:46 +0000413 } else {
414 if (!test_and_set_bit(TCP_MTU_REDUCED_DEFERRED, &tp->tsq_flags))
415 sock_hold(sk);
416 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 goto out;
418 }
419
420 err = icmp_err_convert[code].errno;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000421 /* check if icmp_skb allows revert of backoff
422 * (see draft-zimmermann-tcp-lcd) */
423 if (code != ICMP_NET_UNREACH && code != ICMP_HOST_UNREACH)
424 break;
425 if (seq != tp->snd_una || !icsk->icsk_retransmits ||
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700426 !icsk->icsk_backoff || fastopen)
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000427 break;
428
David S. Miller8f49c272010-11-12 13:35:00 -0800429 if (sock_owned_by_user(sk))
430 break;
431
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000432 icsk->icsk_backoff--;
Eric Dumazet740b0f12014-02-26 14:02:48 -0800433 inet_csk(sk)->icsk_rto = (tp->srtt_us ? __tcp_set_rto(tp) :
Jerry Chu9ad7c042011-06-08 11:08:38 +0000434 TCP_TIMEOUT_INIT) << icsk->icsk_backoff;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000435 tcp_bound_rto(sk);
436
437 skb = tcp_write_queue_head(sk);
438 BUG_ON(!skb);
439
440 remaining = icsk->icsk_rto - min(icsk->icsk_rto,
441 tcp_time_stamp - TCP_SKB_CB(skb)->when);
442
443 if (remaining) {
444 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
445 remaining, TCP_RTO_MAX);
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000446 } else {
447 /* RTO revert clocked out retransmission.
448 * Will retransmit now */
449 tcp_retransmit_timer(sk);
450 }
451
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 break;
453 case ICMP_TIME_EXCEEDED:
454 err = EHOSTUNREACH;
455 break;
456 default:
457 goto out;
458 }
459
460 switch (sk->sk_state) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700461 struct request_sock *req, **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 case TCP_LISTEN:
463 if (sock_owned_by_user(sk))
464 goto out;
465
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700466 req = inet_csk_search_req(sk, &prev, th->dest,
467 iph->daddr, iph->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 if (!req)
469 goto out;
470
471 /* ICMPs are not backlogged, hence we cannot get
472 an established socket here.
473 */
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700474 WARN_ON(req->sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700476 if (seq != tcp_rsk(req)->snt_isn) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700477 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 goto out;
479 }
480
481 /*
482 * Still in SYN_RECV, just remove it silently.
483 * There is no good way to pass the error to the newly
484 * created socket, and POSIX does not want network
485 * errors returned from accept().
486 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700487 inet_csk_reqsk_queue_drop(sk, req, prev);
Vijay Subramanian848bf152013-01-31 08:24:06 +0000488 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 goto out;
490
491 case TCP_SYN_SENT:
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700492 case TCP_SYN_RECV:
493 /* Only in fast or simultaneous open. If a fast open socket is
494 * is already accepted it is treated as a connected one below.
495 */
496 if (fastopen && fastopen->sk == NULL)
497 break;
498
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 if (!sock_owned_by_user(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 sk->sk_err = err;
501
502 sk->sk_error_report(sk);
503
504 tcp_done(sk);
505 } else {
506 sk->sk_err_soft = err;
507 }
508 goto out;
509 }
510
511 /* If we've already connected we will keep trying
512 * until we time out, or the user gives up.
513 *
514 * rfc1122 4.2.3.9 allows to consider as hard errors
515 * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
516 * but it is obsoleted by pmtu discovery).
517 *
518 * Note, that in modern internet, where routing is unreliable
519 * and in each dark corner broken firewalls sit, sending random
520 * errors ordered by their masters even this two messages finally lose
521 * their original sense (even Linux sends invalid PORT_UNREACHs)
522 *
523 * Now we are in compliance with RFCs.
524 * --ANK (980905)
525 */
526
527 inet = inet_sk(sk);
528 if (!sock_owned_by_user(sk) && inet->recverr) {
529 sk->sk_err = err;
530 sk->sk_error_report(sk);
531 } else { /* Only an error on timeout */
532 sk->sk_err_soft = err;
533 }
534
535out:
536 bh_unlock_sock(sk);
537 sock_put(sk);
538}
539
Daniel Borkmann28850dc2013-06-07 05:11:46 +0000540void __tcp_v4_send_check(struct sk_buff *skb, __be32 saddr, __be32 daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700542 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543
Patrick McHardy84fa7932006-08-29 16:44:56 -0700544 if (skb->ip_summed == CHECKSUM_PARTIAL) {
Herbert Xu419f9f82010-04-11 02:15:53 +0000545 th->check = ~tcp_v4_check(skb->len, saddr, daddr, 0);
Herbert Xu663ead32007-04-09 11:59:07 -0700546 skb->csum_start = skb_transport_header(skb) - skb->head;
Al Viroff1dcad2006-11-20 18:07:29 -0800547 skb->csum_offset = offsetof(struct tcphdr, check);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 } else {
Herbert Xu419f9f82010-04-11 02:15:53 +0000549 th->check = tcp_v4_check(skb->len, saddr, daddr,
Joe Perches07f07572008-11-19 15:44:53 -0800550 csum_partial(th,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 th->doff << 2,
552 skb->csum));
553 }
554}
555
Herbert Xu419f9f82010-04-11 02:15:53 +0000556/* This routine computes an IPv4 TCP checksum. */
Herbert Xubb296242010-04-11 02:15:55 +0000557void tcp_v4_send_check(struct sock *sk, struct sk_buff *skb)
Herbert Xu419f9f82010-04-11 02:15:53 +0000558{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400559 const struct inet_sock *inet = inet_sk(sk);
Herbert Xu419f9f82010-04-11 02:15:53 +0000560
561 __tcp_v4_send_check(skb, inet->inet_saddr, inet->inet_daddr);
562}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000563EXPORT_SYMBOL(tcp_v4_send_check);
Herbert Xu419f9f82010-04-11 02:15:53 +0000564
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565/*
566 * This routine will send an RST to the other tcp.
567 *
568 * Someone asks: why I NEVER use socket parameters (TOS, TTL etc.)
569 * for reset.
570 * Answer: if a packet caused RST, it is not for a socket
571 * existing in our system, if it is matched to a socket,
572 * it is just duplicate segment or bug in other side's TCP.
573 * So that we build reply only basing on parameters
574 * arrived with segment.
575 * Exception: precedence violation. We do not implement it in any case.
576 */
577
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800578static void tcp_v4_send_reset(struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400580 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800581 struct {
582 struct tcphdr th;
583#ifdef CONFIG_TCP_MD5SIG
Al Viro714e85b2006-11-14 20:51:49 -0800584 __be32 opt[(TCPOLEN_MD5SIG_ALIGNED >> 2)];
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800585#endif
586 } rep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 struct ip_reply_arg arg;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800588#ifdef CONFIG_TCP_MD5SIG
589 struct tcp_md5sig_key *key;
Shawn Lu658ddaa2012-01-31 22:35:48 +0000590 const __u8 *hash_location = NULL;
591 unsigned char newhash[16];
592 int genhash;
593 struct sock *sk1 = NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800594#endif
Pavel Emelyanova86b1e32008-07-16 20:20:58 -0700595 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596
597 /* Never send a reset in response to a reset. */
598 if (th->rst)
599 return;
600
Eric Dumazet511c3f92009-06-02 05:14:27 +0000601 if (skb_rtable(skb)->rt_type != RTN_LOCAL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 return;
603
604 /* Swap the send and the receive. */
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800605 memset(&rep, 0, sizeof(rep));
606 rep.th.dest = th->source;
607 rep.th.source = th->dest;
608 rep.th.doff = sizeof(struct tcphdr) / 4;
609 rep.th.rst = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610
611 if (th->ack) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800612 rep.th.seq = th->ack_seq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800614 rep.th.ack = 1;
615 rep.th.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
616 skb->len - (th->doff << 2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 }
618
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200619 memset(&arg, 0, sizeof(arg));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800620 arg.iov[0].iov_base = (unsigned char *)&rep;
621 arg.iov[0].iov_len = sizeof(rep.th);
622
623#ifdef CONFIG_TCP_MD5SIG
Shawn Lu658ddaa2012-01-31 22:35:48 +0000624 hash_location = tcp_parse_md5sig_option(th);
625 if (!sk && hash_location) {
626 /*
627 * active side is lost. Try to find listening socket through
628 * source port, and then find md5 key through listening socket.
629 * we are not loose security here:
630 * Incoming packet is checked with md5 hash with finding key,
631 * no RST generated if md5 hash doesn't match.
632 */
633 sk1 = __inet_lookup_listener(dev_net(skb_dst(skb)->dev),
Tom Herbertda5e3632013-01-22 09:50:24 +0000634 &tcp_hashinfo, ip_hdr(skb)->saddr,
635 th->source, ip_hdr(skb)->daddr,
Shawn Lu658ddaa2012-01-31 22:35:48 +0000636 ntohs(th->source), inet_iif(skb));
637 /* don't send rst if it can't find key */
638 if (!sk1)
639 return;
640 rcu_read_lock();
641 key = tcp_md5_do_lookup(sk1, (union tcp_md5_addr *)
642 &ip_hdr(skb)->saddr, AF_INET);
643 if (!key)
644 goto release_sk1;
645
646 genhash = tcp_v4_md5_hash_skb(newhash, key, NULL, NULL, skb);
647 if (genhash || memcmp(hash_location, newhash, 16) != 0)
648 goto release_sk1;
649 } else {
650 key = sk ? tcp_md5_do_lookup(sk, (union tcp_md5_addr *)
651 &ip_hdr(skb)->saddr,
652 AF_INET) : NULL;
653 }
654
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800655 if (key) {
656 rep.opt[0] = htonl((TCPOPT_NOP << 24) |
657 (TCPOPT_NOP << 16) |
658 (TCPOPT_MD5SIG << 8) |
659 TCPOLEN_MD5SIG);
660 /* Update length and the length the header thinks exists */
661 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
662 rep.th.doff = arg.iov[0].iov_len / 4;
663
Adam Langley49a72df2008-07-19 00:01:42 -0700664 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[1],
Ilpo Järvinen78e645cb2008-10-09 14:37:47 -0700665 key, ip_hdr(skb)->saddr,
666 ip_hdr(skb)->daddr, &rep.th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800667 }
668#endif
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700669 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
670 ip_hdr(skb)->saddr, /* XXX */
Ilpo Järvinen52cd5752008-10-08 11:34:06 -0700671 arg.iov[0].iov_len, IPPROTO_TCP, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700673 arg.flags = (sk && inet_sk(sk)->transparent) ? IP_REPLY_ARG_NOSRCCHECK : 0;
Shawn Lue2446ea2012-02-04 12:38:09 +0000674 /* When socket is gone, all binding information is lost.
Alexey Kuznetsov4c675252012-10-12 04:34:17 +0000675 * routing might fail in this case. No choice here, if we choose to force
676 * input interface, we will misroute in case of asymmetric route.
Shawn Lue2446ea2012-02-04 12:38:09 +0000677 */
Alexey Kuznetsov4c675252012-10-12 04:34:17 +0000678 if (sk)
679 arg.bound_dev_if = sk->sk_bound_dev_if;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680
Eric Dumazetadf30902009-06-02 05:19:30 +0000681 net = dev_net(skb_dst(skb)->dev);
Eric Dumazet66b13d92011-10-24 03:06:21 -0400682 arg.tos = ip_hdr(skb)->tos;
Eric Dumazetbe9f4a42012-07-19 07:34:03 +0000683 ip_send_unicast_reply(net, skb, ip_hdr(skb)->saddr,
David S. Miller70e73412012-06-28 03:21:41 -0700684 ip_hdr(skb)->daddr, &arg, arg.iov[0].iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685
Pavel Emelyanov63231bd2008-07-16 20:22:25 -0700686 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
687 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
Shawn Lu658ddaa2012-01-31 22:35:48 +0000688
689#ifdef CONFIG_TCP_MD5SIG
690release_sk1:
691 if (sk1) {
692 rcu_read_unlock();
693 sock_put(sk1);
694 }
695#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696}
697
698/* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
699 outside socket context is ugly, certainly. What can I do?
700 */
701
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900702static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
Andrey Vaginee684b62013-02-11 05:50:19 +0000703 u32 win, u32 tsval, u32 tsecr, int oif,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700704 struct tcp_md5sig_key *key,
Eric Dumazet66b13d92011-10-24 03:06:21 -0400705 int reply_flags, u8 tos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400707 const struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 struct {
709 struct tcphdr th;
Al Viro714e85b2006-11-14 20:51:49 -0800710 __be32 opt[(TCPOLEN_TSTAMP_ALIGNED >> 2)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800711#ifdef CONFIG_TCP_MD5SIG
Al Viro714e85b2006-11-14 20:51:49 -0800712 + (TCPOLEN_MD5SIG_ALIGNED >> 2)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800713#endif
714 ];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 } rep;
716 struct ip_reply_arg arg;
Eric Dumazetadf30902009-06-02 05:19:30 +0000717 struct net *net = dev_net(skb_dst(skb)->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718
719 memset(&rep.th, 0, sizeof(struct tcphdr));
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200720 memset(&arg, 0, sizeof(arg));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721
722 arg.iov[0].iov_base = (unsigned char *)&rep;
723 arg.iov[0].iov_len = sizeof(rep.th);
Andrey Vaginee684b62013-02-11 05:50:19 +0000724 if (tsecr) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800725 rep.opt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
726 (TCPOPT_TIMESTAMP << 8) |
727 TCPOLEN_TIMESTAMP);
Andrey Vaginee684b62013-02-11 05:50:19 +0000728 rep.opt[1] = htonl(tsval);
729 rep.opt[2] = htonl(tsecr);
Craig Schlentercb48cfe2007-01-09 00:11:15 -0800730 arg.iov[0].iov_len += TCPOLEN_TSTAMP_ALIGNED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 }
732
733 /* Swap the send and the receive. */
734 rep.th.dest = th->source;
735 rep.th.source = th->dest;
736 rep.th.doff = arg.iov[0].iov_len / 4;
737 rep.th.seq = htonl(seq);
738 rep.th.ack_seq = htonl(ack);
739 rep.th.ack = 1;
740 rep.th.window = htons(win);
741
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800742#ifdef CONFIG_TCP_MD5SIG
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800743 if (key) {
Andrey Vaginee684b62013-02-11 05:50:19 +0000744 int offset = (tsecr) ? 3 : 0;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800745
746 rep.opt[offset++] = htonl((TCPOPT_NOP << 24) |
747 (TCPOPT_NOP << 16) |
748 (TCPOPT_MD5SIG << 8) |
749 TCPOLEN_MD5SIG);
750 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
751 rep.th.doff = arg.iov[0].iov_len/4;
752
Adam Langley49a72df2008-07-19 00:01:42 -0700753 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[offset],
Adam Langley90b7e112008-07-31 20:49:48 -0700754 key, ip_hdr(skb)->saddr,
755 ip_hdr(skb)->daddr, &rep.th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800756 }
757#endif
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700758 arg.flags = reply_flags;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700759 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
760 ip_hdr(skb)->saddr, /* XXX */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 arg.iov[0].iov_len, IPPROTO_TCP, 0);
762 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900763 if (oif)
764 arg.bound_dev_if = oif;
Eric Dumazet66b13d92011-10-24 03:06:21 -0400765 arg.tos = tos;
Eric Dumazetbe9f4a42012-07-19 07:34:03 +0000766 ip_send_unicast_reply(net, skb, ip_hdr(skb)->saddr,
David S. Miller70e73412012-06-28 03:21:41 -0700767 ip_hdr(skb)->daddr, &arg, arg.iov[0].iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768
Pavel Emelyanov63231bd2008-07-16 20:22:25 -0700769 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770}
771
772static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
773{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700774 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800775 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900777 tcp_v4_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200778 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
Andrey Vaginee684b62013-02-11 05:50:19 +0000779 tcp_time_stamp + tcptw->tw_ts_offset,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900780 tcptw->tw_ts_recent,
781 tw->tw_bound_dev_if,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700782 tcp_twsk_md5_key(tcptw),
Eric Dumazet66b13d92011-10-24 03:06:21 -0400783 tw->tw_transparent ? IP_REPLY_ARG_NOSRCCHECK : 0,
784 tw->tw_tos
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900785 );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700787 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788}
789
Gui Jianfeng6edafaa2008-08-06 23:50:04 -0700790static void tcp_v4_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200791 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792{
Jerry Chu168a8f52012-08-31 12:29:13 +0000793 /* sk->sk_state == TCP_LISTEN -> for regular TCP_SYN_RECV
794 * sk->sk_state == TCP_SYN_RECV -> for Fast Open.
795 */
796 tcp_v4_send_ack(skb, (sk->sk_state == TCP_LISTEN) ?
797 tcp_rsk(req)->snt_isn + 1 : tcp_sk(sk)->snd_nxt,
798 tcp_rsk(req)->rcv_nxt, req->rcv_wnd,
Andrey Vaginee684b62013-02-11 05:50:19 +0000799 tcp_time_stamp,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900800 req->ts_recent,
801 0,
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000802 tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&ip_hdr(skb)->daddr,
803 AF_INET),
Eric Dumazet66b13d92011-10-24 03:06:21 -0400804 inet_rsk(req)->no_srccheck ? IP_REPLY_ARG_NOSRCCHECK : 0,
805 ip_hdr(skb)->tos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806}
807
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808/*
Kris Katterjohn9bf1d832008-02-17 22:29:19 -0800809 * Send a SYN-ACK after having received a SYN.
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700810 * This still operates on a request_sock only, not on a big
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 * socket.
812 */
Octavian Purdila72659ec2010-01-17 19:09:39 -0800813static int tcp_v4_send_synack(struct sock *sk, struct dst_entry *dst,
Octavian Purdilad6274bd2014-06-25 17:09:58 +0300814 struct flowi *fl,
Octavian Purdila72659ec2010-01-17 19:09:39 -0800815 struct request_sock *req,
Yuchung Cheng843f4a52014-05-11 20:22:11 -0700816 u16 queue_mapping,
817 struct tcp_fastopen_cookie *foc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700819 const struct inet_request_sock *ireq = inet_rsk(req);
David S. Miller6bd023f2011-05-18 18:32:03 -0400820 struct flowi4 fl4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 int err = -1;
Weilong Chend41db5a2013-12-23 14:37:28 +0800822 struct sk_buff *skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823
824 /* First, grab a route. */
David S. Millerba3f7f02012-07-17 14:02:46 -0700825 if (!dst && (dst = inet_csk_route_req(sk, &fl4, req)) == NULL)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800826 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827
Yuchung Cheng843f4a52014-05-11 20:22:11 -0700828 skb = tcp_make_synack(sk, dst, req, foc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829
830 if (skb) {
Eric Dumazet634fb9792013-10-09 15:21:29 -0700831 __tcp_v4_send_check(skb, ireq->ir_loc_addr, ireq->ir_rmt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832
Eric Dumazetfff32692012-06-01 01:47:50 +0000833 skb_set_queue_mapping(skb, queue_mapping);
Eric Dumazet634fb9792013-10-09 15:21:29 -0700834 err = ip_build_and_send_pkt(skb, sk, ireq->ir_loc_addr,
835 ireq->ir_rmt_addr,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700836 ireq->opt);
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200837 err = net_xmit_eval(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 }
839
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 return err;
841}
842
843/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700844 * IPv4 request_sock destructor.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 */
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700846static void tcp_v4_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847{
Jesper Juhla51482b2005-11-08 09:41:34 -0800848 kfree(inet_rsk(req)->opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849}
850
Eric Dumazet946cedc2011-08-30 03:21:44 +0000851/*
Eric Dumazeta2a385d2012-05-16 23:15:34 +0000852 * Return true if a syncookie should be sent
Eric Dumazet946cedc2011-08-30 03:21:44 +0000853 */
Eric Dumazeta2a385d2012-05-16 23:15:34 +0000854bool tcp_syn_flood_action(struct sock *sk,
Eric Dumazet946cedc2011-08-30 03:21:44 +0000855 const struct sk_buff *skb,
856 const char *proto)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857{
Eric Dumazet946cedc2011-08-30 03:21:44 +0000858 const char *msg = "Dropping request";
Eric Dumazeta2a385d2012-05-16 23:15:34 +0000859 bool want_cookie = false;
Eric Dumazet946cedc2011-08-30 03:21:44 +0000860 struct listen_sock *lopt;
861
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000862#ifdef CONFIG_SYN_COOKIES
Eric Dumazet946cedc2011-08-30 03:21:44 +0000863 if (sysctl_tcp_syncookies) {
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000864 msg = "Sending cookies";
Eric Dumazeta2a385d2012-05-16 23:15:34 +0000865 want_cookie = true;
Eric Dumazet946cedc2011-08-30 03:21:44 +0000866 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPREQQFULLDOCOOKIES);
867 } else
Arnaldo Carvalho de Melo80e40da2006-01-04 01:58:06 -0200868#endif
Eric Dumazet946cedc2011-08-30 03:21:44 +0000869 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPREQQFULLDROP);
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000870
Eric Dumazet946cedc2011-08-30 03:21:44 +0000871 lopt = inet_csk(sk)->icsk_accept_queue.listen_opt;
Hannes Frederic Sowa5ad37d52013-07-26 17:43:23 +0200872 if (!lopt->synflood_warned && sysctl_tcp_syncookies != 2) {
Eric Dumazet946cedc2011-08-30 03:21:44 +0000873 lopt->synflood_warned = 1;
Joe Perchesafd465032012-03-12 07:03:32 +0000874 pr_info("%s: Possible SYN flooding on port %d. %s. Check SNMP counters.\n",
Eric Dumazet946cedc2011-08-30 03:21:44 +0000875 proto, ntohs(tcp_hdr(skb)->dest), msg);
876 }
877 return want_cookie;
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000878}
Eric Dumazet946cedc2011-08-30 03:21:44 +0000879EXPORT_SYMBOL(tcp_syn_flood_action);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880
881/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700882 * Save and compile IPv4 options into the request_sock if needed.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 */
Christoph Paasch5dff7472012-09-26 11:59:09 +0000884static struct ip_options_rcu *tcp_v4_save_options(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885{
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000886 const struct ip_options *opt = &(IPCB(skb)->opt);
887 struct ip_options_rcu *dopt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888
889 if (opt && opt->optlen) {
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000890 int opt_size = sizeof(*dopt) + opt->optlen;
891
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 dopt = kmalloc(opt_size, GFP_ATOMIC);
893 if (dopt) {
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000894 if (ip_options_echo(&dopt->opt, skb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 kfree(dopt);
896 dopt = NULL;
897 }
898 }
899 }
900 return dopt;
901}
902
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800903#ifdef CONFIG_TCP_MD5SIG
904/*
905 * RFC2385 MD5 checksumming requires a mapping of
906 * IP address->MD5 Key.
907 * We need to maintain these in the sk structure.
908 */
909
910/* Find the Key structure for an address. */
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000911struct tcp_md5sig_key *tcp_md5_do_lookup(struct sock *sk,
912 const union tcp_md5_addr *addr,
913 int family)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800914{
915 struct tcp_sock *tp = tcp_sk(sk);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000916 struct tcp_md5sig_key *key;
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000917 unsigned int size = sizeof(struct in_addr);
Eric Dumazeta8afca02012-01-31 18:45:40 +0000918 struct tcp_md5sig_info *md5sig;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800919
Eric Dumazeta8afca02012-01-31 18:45:40 +0000920 /* caller either holds rcu_read_lock() or socket lock */
921 md5sig = rcu_dereference_check(tp->md5sig_info,
Eric Dumazetb4fb05e2012-03-07 04:45:43 +0000922 sock_owned_by_user(sk) ||
923 lockdep_is_held(&sk->sk_lock.slock));
Eric Dumazeta8afca02012-01-31 18:45:40 +0000924 if (!md5sig)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800925 return NULL;
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000926#if IS_ENABLED(CONFIG_IPV6)
927 if (family == AF_INET6)
928 size = sizeof(struct in6_addr);
929#endif
Sasha Levinb67bfe02013-02-27 17:06:00 -0800930 hlist_for_each_entry_rcu(key, &md5sig->head, node) {
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000931 if (key->family != family)
932 continue;
933 if (!memcmp(&key->addr, addr, size))
934 return key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800935 }
936 return NULL;
937}
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000938EXPORT_SYMBOL(tcp_md5_do_lookup);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800939
940struct tcp_md5sig_key *tcp_v4_md5_lookup(struct sock *sk,
941 struct sock *addr_sk)
942{
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000943 union tcp_md5_addr *addr;
944
945 addr = (union tcp_md5_addr *)&inet_sk(addr_sk)->inet_daddr;
946 return tcp_md5_do_lookup(sk, addr, AF_INET);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800947}
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800948EXPORT_SYMBOL(tcp_v4_md5_lookup);
949
Adrian Bunkf5b99bc2006-11-30 17:22:29 -0800950static struct tcp_md5sig_key *tcp_v4_reqsk_md5_lookup(struct sock *sk,
951 struct request_sock *req)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800952{
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000953 union tcp_md5_addr *addr;
954
Eric Dumazet634fb9792013-10-09 15:21:29 -0700955 addr = (union tcp_md5_addr *)&inet_rsk(req)->ir_rmt_addr;
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000956 return tcp_md5_do_lookup(sk, addr, AF_INET);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800957}
958
959/* This can be called on a newly created socket, from other files */
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000960int tcp_md5_do_add(struct sock *sk, const union tcp_md5_addr *addr,
961 int family, const u8 *newkey, u8 newkeylen, gfp_t gfp)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800962{
963 /* Add Key to the list */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700964 struct tcp_md5sig_key *key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800965 struct tcp_sock *tp = tcp_sk(sk);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000966 struct tcp_md5sig_info *md5sig;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800967
Aydin Arikc0353c72013-06-14 18:56:31 +1200968 key = tcp_md5_do_lookup(sk, addr, family);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800969 if (key) {
970 /* Pre-existing entry - just update that one. */
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000971 memcpy(key->key, newkey, newkeylen);
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700972 key->keylen = newkeylen;
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000973 return 0;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800974 }
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000975
Eric Dumazeta8afca02012-01-31 18:45:40 +0000976 md5sig = rcu_dereference_protected(tp->md5sig_info,
977 sock_owned_by_user(sk));
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000978 if (!md5sig) {
979 md5sig = kmalloc(sizeof(*md5sig), gfp);
980 if (!md5sig)
981 return -ENOMEM;
982
983 sk_nocaps_add(sk, NETIF_F_GSO_MASK);
984 INIT_HLIST_HEAD(&md5sig->head);
Eric Dumazeta8afca02012-01-31 18:45:40 +0000985 rcu_assign_pointer(tp->md5sig_info, md5sig);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000986 }
987
Eric Dumazet5f3d9cb2012-01-31 10:56:48 +0000988 key = sock_kmalloc(sk, sizeof(*key), gfp);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000989 if (!key)
990 return -ENOMEM;
Eric Dumazet71cea172013-05-20 06:52:26 +0000991 if (!tcp_alloc_md5sig_pool()) {
Eric Dumazet5f3d9cb2012-01-31 10:56:48 +0000992 sock_kfree_s(sk, key, sizeof(*key));
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000993 return -ENOMEM;
994 }
995
996 memcpy(key->key, newkey, newkeylen);
997 key->keylen = newkeylen;
998 key->family = family;
999 memcpy(&key->addr, addr,
1000 (family == AF_INET6) ? sizeof(struct in6_addr) :
1001 sizeof(struct in_addr));
1002 hlist_add_head_rcu(&key->node, &md5sig->head);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001003 return 0;
1004}
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001005EXPORT_SYMBOL(tcp_md5_do_add);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001006
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001007int tcp_md5_do_del(struct sock *sk, const union tcp_md5_addr *addr, int family)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001008{
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001009 struct tcp_md5sig_key *key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001010
Aydin Arikc0353c72013-06-14 18:56:31 +12001011 key = tcp_md5_do_lookup(sk, addr, family);
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001012 if (!key)
1013 return -ENOENT;
1014 hlist_del_rcu(&key->node);
Eric Dumazet5f3d9cb2012-01-31 10:56:48 +00001015 atomic_sub(sizeof(*key), &sk->sk_omem_alloc);
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001016 kfree_rcu(key, rcu);
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001017 return 0;
1018}
1019EXPORT_SYMBOL(tcp_md5_do_del);
1020
stephen hemmingere0683e702012-10-26 14:31:40 +00001021static void tcp_clear_md5_list(struct sock *sk)
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001022{
1023 struct tcp_sock *tp = tcp_sk(sk);
1024 struct tcp_md5sig_key *key;
Sasha Levinb67bfe02013-02-27 17:06:00 -08001025 struct hlist_node *n;
Eric Dumazeta8afca02012-01-31 18:45:40 +00001026 struct tcp_md5sig_info *md5sig;
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001027
Eric Dumazeta8afca02012-01-31 18:45:40 +00001028 md5sig = rcu_dereference_protected(tp->md5sig_info, 1);
1029
Sasha Levinb67bfe02013-02-27 17:06:00 -08001030 hlist_for_each_entry_safe(key, n, &md5sig->head, node) {
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001031 hlist_del_rcu(&key->node);
Eric Dumazet5f3d9cb2012-01-31 10:56:48 +00001032 atomic_sub(sizeof(*key), &sk->sk_omem_alloc);
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001033 kfree_rcu(key, rcu);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001034 }
1035}
1036
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001037static int tcp_v4_parse_md5_keys(struct sock *sk, char __user *optval,
1038 int optlen)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001039{
1040 struct tcp_md5sig cmd;
1041 struct sockaddr_in *sin = (struct sockaddr_in *)&cmd.tcpm_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001042
1043 if (optlen < sizeof(cmd))
1044 return -EINVAL;
1045
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001046 if (copy_from_user(&cmd, optval, sizeof(cmd)))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001047 return -EFAULT;
1048
1049 if (sin->sin_family != AF_INET)
1050 return -EINVAL;
1051
Dmitry Popov64a124e2014-08-03 22:45:19 +04001052 if (!cmd.tcpm_keylen)
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001053 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin->sin_addr.s_addr,
1054 AF_INET);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001055
1056 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
1057 return -EINVAL;
1058
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001059 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin->sin_addr.s_addr,
1060 AF_INET, cmd.tcpm_key, cmd.tcpm_keylen,
1061 GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001062}
1063
Adam Langley49a72df2008-07-19 00:01:42 -07001064static int tcp_v4_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
1065 __be32 daddr, __be32 saddr, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001066{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001067 struct tcp4_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -07001068 struct scatterlist sg;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001069
1070 bp = &hp->md5_blk.ip4;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001071
1072 /*
Adam Langley49a72df2008-07-19 00:01:42 -07001073 * 1. the TCP pseudo-header (in the order: source IP address,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001074 * destination IP address, zero-padded protocol number, and
1075 * segment length)
1076 */
1077 bp->saddr = saddr;
1078 bp->daddr = daddr;
1079 bp->pad = 0;
YOSHIFUJI Hideaki076fb722008-04-17 12:48:12 +09001080 bp->protocol = IPPROTO_TCP;
Adam Langley49a72df2008-07-19 00:01:42 -07001081 bp->len = cpu_to_be16(nbytes);
David S. Millerc7da57a2007-10-26 00:41:21 -07001082
Adam Langley49a72df2008-07-19 00:01:42 -07001083 sg_init_one(&sg, bp, sizeof(*bp));
1084 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
1085}
1086
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001087static int tcp_v4_md5_hash_hdr(char *md5_hash, const struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -04001088 __be32 daddr, __be32 saddr, const struct tcphdr *th)
Adam Langley49a72df2008-07-19 00:01:42 -07001089{
1090 struct tcp_md5sig_pool *hp;
1091 struct hash_desc *desc;
1092
1093 hp = tcp_get_md5sig_pool();
1094 if (!hp)
1095 goto clear_hash_noput;
1096 desc = &hp->md5_desc;
1097
1098 if (crypto_hash_init(desc))
1099 goto clear_hash;
1100 if (tcp_v4_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
1101 goto clear_hash;
1102 if (tcp_md5_hash_header(hp, th))
1103 goto clear_hash;
1104 if (tcp_md5_hash_key(hp, key))
1105 goto clear_hash;
1106 if (crypto_hash_final(desc, md5_hash))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001107 goto clear_hash;
1108
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001109 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001110 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -07001111
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001112clear_hash:
1113 tcp_put_md5sig_pool();
1114clear_hash_noput:
1115 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -07001116 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001117}
1118
Adam Langley49a72df2008-07-19 00:01:42 -07001119int tcp_v4_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -04001120 const struct sock *sk, const struct request_sock *req,
1121 const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001122{
Adam Langley49a72df2008-07-19 00:01:42 -07001123 struct tcp_md5sig_pool *hp;
1124 struct hash_desc *desc;
Eric Dumazet318cf7a2011-10-24 02:46:04 -04001125 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001126 __be32 saddr, daddr;
1127
1128 if (sk) {
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001129 saddr = inet_sk(sk)->inet_saddr;
1130 daddr = inet_sk(sk)->inet_daddr;
Adam Langley49a72df2008-07-19 00:01:42 -07001131 } else if (req) {
Eric Dumazet634fb9792013-10-09 15:21:29 -07001132 saddr = inet_rsk(req)->ir_loc_addr;
1133 daddr = inet_rsk(req)->ir_rmt_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001134 } else {
Adam Langley49a72df2008-07-19 00:01:42 -07001135 const struct iphdr *iph = ip_hdr(skb);
1136 saddr = iph->saddr;
1137 daddr = iph->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001138 }
Adam Langley49a72df2008-07-19 00:01:42 -07001139
1140 hp = tcp_get_md5sig_pool();
1141 if (!hp)
1142 goto clear_hash_noput;
1143 desc = &hp->md5_desc;
1144
1145 if (crypto_hash_init(desc))
1146 goto clear_hash;
1147
1148 if (tcp_v4_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
1149 goto clear_hash;
1150 if (tcp_md5_hash_header(hp, th))
1151 goto clear_hash;
1152 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
1153 goto clear_hash;
1154 if (tcp_md5_hash_key(hp, key))
1155 goto clear_hash;
1156 if (crypto_hash_final(desc, md5_hash))
1157 goto clear_hash;
1158
1159 tcp_put_md5sig_pool();
1160 return 0;
1161
1162clear_hash:
1163 tcp_put_md5sig_pool();
1164clear_hash_noput:
1165 memset(md5_hash, 0, 16);
1166 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001167}
Adam Langley49a72df2008-07-19 00:01:42 -07001168EXPORT_SYMBOL(tcp_v4_md5_hash_skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001169
Dmitry Popov9ea88a12014-08-07 02:38:22 +04001170static bool __tcp_v4_inbound_md5_hash(struct sock *sk,
1171 const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001172{
1173 /*
1174 * This gets called for each TCP segment that arrives
1175 * so we want to be efficient.
1176 * We have 3 drop cases:
1177 * o No MD5 hash and one expected.
1178 * o MD5 hash and we're not expecting one.
1179 * o MD5 hash and its wrong.
1180 */
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001181 const __u8 *hash_location = NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001182 struct tcp_md5sig_key *hash_expected;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001183 const struct iphdr *iph = ip_hdr(skb);
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001184 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001185 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001186 unsigned char newhash[16];
1187
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001188 hash_expected = tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&iph->saddr,
1189 AF_INET);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +09001190 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001191
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001192 /* We've parsed the options - do we have a hash? */
1193 if (!hash_expected && !hash_location)
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001194 return false;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001195
1196 if (hash_expected && !hash_location) {
David S. Miller785957d2008-07-30 03:03:15 -07001197 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001198 return true;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001199 }
1200
1201 if (!hash_expected && hash_location) {
David S. Miller785957d2008-07-30 03:03:15 -07001202 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001203 return true;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001204 }
1205
1206 /* Okay, so this is hash_expected and hash_location -
1207 * so we need to calculate the checksum.
1208 */
Adam Langley49a72df2008-07-19 00:01:42 -07001209 genhash = tcp_v4_md5_hash_skb(newhash,
1210 hash_expected,
1211 NULL, NULL, skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001212
1213 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
Joe Perchese87cc472012-05-13 21:56:26 +00001214 net_info_ratelimited("MD5 Hash failed for (%pI4, %d)->(%pI4, %d)%s\n",
1215 &iph->saddr, ntohs(th->source),
1216 &iph->daddr, ntohs(th->dest),
1217 genhash ? " tcp_v4_calc_md5_hash failed"
1218 : "");
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001219 return true;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001220 }
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001221 return false;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001222}
1223
Dmitry Popov9ea88a12014-08-07 02:38:22 +04001224static bool tcp_v4_inbound_md5_hash(struct sock *sk, const struct sk_buff *skb)
1225{
1226 bool ret;
1227
1228 rcu_read_lock();
1229 ret = __tcp_v4_inbound_md5_hash(sk, skb);
1230 rcu_read_unlock();
1231
1232 return ret;
1233}
1234
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001235#endif
1236
Octavian Purdila16bea702014-06-25 17:09:53 +03001237static void tcp_v4_init_req(struct request_sock *req, struct sock *sk,
1238 struct sk_buff *skb)
1239{
1240 struct inet_request_sock *ireq = inet_rsk(req);
1241
1242 ireq->ir_loc_addr = ip_hdr(skb)->daddr;
1243 ireq->ir_rmt_addr = ip_hdr(skb)->saddr;
1244 ireq->no_srccheck = inet_sk(sk)->transparent;
1245 ireq->opt = tcp_v4_save_options(skb);
1246}
1247
Octavian Purdilad94e0412014-06-25 17:09:55 +03001248static struct dst_entry *tcp_v4_route_req(struct sock *sk, struct flowi *fl,
1249 const struct request_sock *req,
1250 bool *strict)
1251{
1252 struct dst_entry *dst = inet_csk_route_req(sk, &fl->u.ip4, req);
1253
1254 if (strict) {
1255 if (fl->u.ip4.daddr == inet_rsk(req)->ir_rmt_addr)
1256 *strict = true;
1257 else
1258 *strict = false;
1259 }
1260
1261 return dst;
1262}
1263
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001264struct request_sock_ops tcp_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 .family = PF_INET,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001266 .obj_size = sizeof(struct tcp_request_sock),
Octavian Purdila5db92c92014-06-25 17:09:59 +03001267 .rtx_syn_ack = tcp_rtx_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001268 .send_ack = tcp_v4_reqsk_send_ack,
1269 .destructor = tcp_v4_reqsk_destructor,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270 .send_reset = tcp_v4_send_reset,
stephen hemminger688d1942014-08-29 23:32:05 -07001271 .syn_ack_timeout = tcp_syn_ack_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272};
1273
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001274static const struct tcp_request_sock_ops tcp_request_sock_ipv4_ops = {
Octavian Purdila2aec4a22014-06-25 17:10:00 +03001275 .mss_clamp = TCP_MSS_DEFAULT,
Octavian Purdila16bea702014-06-25 17:09:53 +03001276#ifdef CONFIG_TCP_MD5SIG
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001277 .md5_lookup = tcp_v4_reqsk_md5_lookup,
John Dykstrae3afe7b2009-07-16 05:04:51 +00001278 .calc_md5_hash = tcp_v4_md5_hash_skb,
Andrew Mortonb6332e62006-11-30 19:16:28 -08001279#endif
Octavian Purdila16bea702014-06-25 17:09:53 +03001280 .init_req = tcp_v4_init_req,
Octavian Purdilafb7b37a2014-06-25 17:09:54 +03001281#ifdef CONFIG_SYN_COOKIES
1282 .cookie_init_seq = cookie_v4_init_sequence,
1283#endif
Octavian Purdilad94e0412014-06-25 17:09:55 +03001284 .route_req = tcp_v4_route_req,
Octavian Purdila936b8bd2014-06-25 17:09:57 +03001285 .init_seq = tcp_v4_init_sequence,
Octavian Purdilad6274bd2014-06-25 17:09:58 +03001286 .send_synack = tcp_v4_send_synack,
Octavian Purdila695da142014-06-25 17:10:01 +03001287 .queue_hash_add = inet_csk_reqsk_queue_hash_add,
Octavian Purdila16bea702014-06-25 17:09:53 +03001288};
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001289
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1291{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 /* Never answer to SYNs send to broadcast or multicast */
Eric Dumazet511c3f92009-06-02 05:14:27 +00001293 if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 goto drop;
1295
Octavian Purdila1fb6f152014-06-25 17:10:02 +03001296 return tcp_conn_request(&tcp_request_sock_ops,
1297 &tcp_request_sock_ipv4_ops, sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299drop:
Vijay Subramanian848bf152013-01-31 08:24:06 +00001300 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301 return 0;
1302}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001303EXPORT_SYMBOL(tcp_v4_conn_request);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304
1305
1306/*
1307 * The three way handshake has completed - we got a valid synack -
1308 * now create the new socket.
1309 */
1310struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001311 struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 struct dst_entry *dst)
1313{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001314 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 struct inet_sock *newinet;
1316 struct tcp_sock *newtp;
1317 struct sock *newsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001318#ifdef CONFIG_TCP_MD5SIG
1319 struct tcp_md5sig_key *key;
1320#endif
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001321 struct ip_options_rcu *inet_opt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322
1323 if (sk_acceptq_is_full(sk))
1324 goto exit_overflow;
1325
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 newsk = tcp_create_openreq_child(sk, req, skb);
1327 if (!newsk)
Balazs Scheidler093d2822010-10-21 13:06:43 +02001328 goto exit_nonewsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329
Herbert Xubcd76112006-06-30 13:36:35 -07001330 newsk->sk_gso_type = SKB_GSO_TCPV4;
Neal Cardwellfae6ef82012-08-19 03:30:38 +00001331 inet_sk_rx_dst_set(newsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332
1333 newtp = tcp_sk(newsk);
1334 newinet = inet_sk(newsk);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001335 ireq = inet_rsk(req);
Eric Dumazet634fb9792013-10-09 15:21:29 -07001336 newinet->inet_daddr = ireq->ir_rmt_addr;
1337 newinet->inet_rcv_saddr = ireq->ir_loc_addr;
1338 newinet->inet_saddr = ireq->ir_loc_addr;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001339 inet_opt = ireq->opt;
1340 rcu_assign_pointer(newinet->inet_opt, inet_opt);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001341 ireq->opt = NULL;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001342 newinet->mc_index = inet_iif(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001343 newinet->mc_ttl = ip_hdr(skb)->ttl;
Jiri Benc4c507d22012-02-09 09:35:49 +00001344 newinet->rcv_tos = ip_hdr(skb)->tos;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001345 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Tom Herbertb73c3d02014-07-01 21:32:17 -07001346 inet_set_txhash(newsk);
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001347 if (inet_opt)
1348 inet_csk(newsk)->icsk_ext_hdr_len = inet_opt->opt.optlen;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001349 newinet->inet_id = newtp->write_seq ^ jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350
Eric Dumazetdfd25ff2012-03-10 09:20:21 +00001351 if (!dst) {
1352 dst = inet_csk_route_child_sock(sk, newsk, req);
1353 if (!dst)
1354 goto put_and_exit;
1355 } else {
1356 /* syncookie case : see end of cookie_v4_check() */
1357 }
David S. Miller0e734412011-05-08 15:28:03 -07001358 sk_setup_caps(newsk, dst);
1359
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 tcp_sync_mss(newsk, dst_mtu(dst));
David S. Miller0dbaee32010-12-13 12:52:14 -08001361 newtp->advmss = dst_metric_advmss(dst);
Tom Quetchenbachf5fff5d2008-09-21 00:21:51 -07001362 if (tcp_sk(sk)->rx_opt.user_mss &&
1363 tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1364 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1365
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 tcp_initialize_rcv_mss(newsk);
1367
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001368#ifdef CONFIG_TCP_MD5SIG
1369 /* Copy over the MD5 key from the original socket */
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001370 key = tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&newinet->inet_daddr,
1371 AF_INET);
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001372 if (key != NULL) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001373 /*
1374 * We're using one, so create a matching key
1375 * on the newsk structure. If we fail to get
1376 * memory, then we end up not copying the key
1377 * across. Shucks.
1378 */
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001379 tcp_md5_do_add(newsk, (union tcp_md5_addr *)&newinet->inet_daddr,
1380 AF_INET, key->key, key->keylen, GFP_ATOMIC);
Eric Dumazeta4654192010-05-16 00:36:33 -07001381 sk_nocaps_add(newsk, NETIF_F_GSO_MASK);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001382 }
1383#endif
1384
David S. Miller0e734412011-05-08 15:28:03 -07001385 if (__inet_inherit_port(sk, newsk) < 0)
1386 goto put_and_exit;
Eric Dumazet9327f702009-12-04 03:46:54 +00001387 __inet_hash_nolisten(newsk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388
1389 return newsk;
1390
1391exit_overflow:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001392 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001393exit_nonewsk:
1394 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395exit:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001396 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 return NULL;
David S. Miller0e734412011-05-08 15:28:03 -07001398put_and_exit:
Christoph Paasche337e242012-12-14 04:07:58 +00001399 inet_csk_prepare_forced_close(newsk);
1400 tcp_done(newsk);
David S. Miller0e734412011-05-08 15:28:03 -07001401 goto exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001403EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404
1405static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
1406{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001407 struct tcphdr *th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001408 const struct iphdr *iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 struct sock *nsk;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001410 struct request_sock **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 /* Find possible connection requests. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001412 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
1413 iph->saddr, iph->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 if (req)
Jerry Chu83368862012-08-31 12:29:12 +00001415 return tcp_check_req(sk, skb, req, prev, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001417 nsk = inet_lookup_established(sock_net(sk), &tcp_hashinfo, iph->saddr,
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001418 th->source, iph->daddr, th->dest, inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419
1420 if (nsk) {
1421 if (nsk->sk_state != TCP_TIME_WAIT) {
1422 bh_lock_sock(nsk);
1423 return nsk;
1424 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001425 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 return NULL;
1427 }
1428
1429#ifdef CONFIG_SYN_COOKIES
Florian Westphalaf9b4732010-06-03 00:43:44 +00001430 if (!th->syn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
1432#endif
1433 return sk;
1434}
1435
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436/* The socket must have it's spinlock held when we get
1437 * here.
1438 *
1439 * We have a potential double-lock case here, so even when
1440 * doing backlog processing we use the BH locking scheme.
1441 * This is because we cannot sleep with the original spinlock
1442 * held.
1443 */
1444int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1445{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001446 struct sock *rsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001447
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
Eric Dumazet404e0a82012-07-29 23:20:37 +00001449 struct dst_entry *dst = sk->sk_rx_dst;
1450
Tom Herbertbdeab992011-08-14 19:45:55 +00001451 sock_rps_save_rxhash(sk, skb);
Eric Dumazet404e0a82012-07-29 23:20:37 +00001452 if (dst) {
Eric Dumazet505fbcf2012-07-27 06:23:40 +00001453 if (inet_sk(sk)->rx_dst_ifindex != skb->skb_iif ||
1454 dst->ops->check(dst, 0) == NULL) {
David S. Miller92101b32012-07-23 16:29:00 -07001455 dst_release(dst);
1456 sk->sk_rx_dst = NULL;
1457 }
1458 }
Vijay Subramanianc995ae22013-09-03 12:23:22 -07001459 tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 return 0;
1461 }
1462
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07001463 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464 goto csum_err;
1465
1466 if (sk->sk_state == TCP_LISTEN) {
1467 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
1468 if (!nsk)
1469 goto discard;
1470
1471 if (nsk != sk) {
Tom Herbertbdeab992011-08-14 19:45:55 +00001472 sock_rps_save_rxhash(nsk, skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001473 if (tcp_child_process(sk, nsk, skb)) {
1474 rsk = nsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001476 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477 return 0;
1478 }
Eric Dumazetca551582010-06-03 09:03:58 +00001479 } else
Tom Herbertbdeab992011-08-14 19:45:55 +00001480 sock_rps_save_rxhash(sk, skb);
Eric Dumazetca551582010-06-03 09:03:58 +00001481
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001482 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001483 rsk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001485 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 return 0;
1487
1488reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001489 tcp_v4_send_reset(rsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490discard:
1491 kfree_skb(skb);
1492 /* Be careful here. If this function gets more complicated and
1493 * gcc suffers from register pressure on the x86, sk (in %ebx)
1494 * might be destroyed here. This current version compiles correctly,
1495 * but you have been warned.
1496 */
1497 return 0;
1498
1499csum_err:
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001500 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_CSUMERRORS);
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001501 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502 goto discard;
1503}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001504EXPORT_SYMBOL(tcp_v4_do_rcv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505
David S. Miller160eb5a2012-06-27 22:01:22 -07001506void tcp_v4_early_demux(struct sk_buff *skb)
David S. Miller41063e92012-06-19 21:22:05 -07001507{
David S. Miller41063e92012-06-19 21:22:05 -07001508 const struct iphdr *iph;
1509 const struct tcphdr *th;
1510 struct sock *sk;
David S. Miller41063e92012-06-19 21:22:05 -07001511
David S. Miller41063e92012-06-19 21:22:05 -07001512 if (skb->pkt_type != PACKET_HOST)
David S. Miller160eb5a2012-06-27 22:01:22 -07001513 return;
David S. Miller41063e92012-06-19 21:22:05 -07001514
Eric Dumazet45f00f92012-10-22 21:42:47 +00001515 if (!pskb_may_pull(skb, skb_transport_offset(skb) + sizeof(struct tcphdr)))
David S. Miller160eb5a2012-06-27 22:01:22 -07001516 return;
David S. Miller41063e92012-06-19 21:22:05 -07001517
1518 iph = ip_hdr(skb);
Eric Dumazet45f00f92012-10-22 21:42:47 +00001519 th = tcp_hdr(skb);
David S. Miller41063e92012-06-19 21:22:05 -07001520
1521 if (th->doff < sizeof(struct tcphdr) / 4)
David S. Miller160eb5a2012-06-27 22:01:22 -07001522 return;
David S. Miller41063e92012-06-19 21:22:05 -07001523
Eric Dumazet45f00f92012-10-22 21:42:47 +00001524 sk = __inet_lookup_established(dev_net(skb->dev), &tcp_hashinfo,
David S. Miller41063e92012-06-19 21:22:05 -07001525 iph->saddr, th->source,
Vijay Subramanian7011d082012-06-23 17:38:10 +00001526 iph->daddr, ntohs(th->dest),
Eric Dumazet9cb429d2012-07-24 01:19:31 +00001527 skb->skb_iif);
David S. Miller41063e92012-06-19 21:22:05 -07001528 if (sk) {
1529 skb->sk = sk;
1530 skb->destructor = sock_edemux;
1531 if (sk->sk_state != TCP_TIME_WAIT) {
1532 struct dst_entry *dst = sk->sk_rx_dst;
Eric Dumazet505fbcf2012-07-27 06:23:40 +00001533
David S. Miller41063e92012-06-19 21:22:05 -07001534 if (dst)
1535 dst = dst_check(dst, 0);
David S. Miller92101b32012-07-23 16:29:00 -07001536 if (dst &&
Eric Dumazet505fbcf2012-07-27 06:23:40 +00001537 inet_sk(sk)->rx_dst_ifindex == skb->skb_iif)
David S. Miller92101b32012-07-23 16:29:00 -07001538 skb_dst_set_noref(skb, dst);
David S. Miller41063e92012-06-19 21:22:05 -07001539 }
1540 }
David S. Miller41063e92012-06-19 21:22:05 -07001541}
1542
Eric Dumazetb2fb4f52013-03-06 12:58:01 +00001543/* Packet is added to VJ-style prequeue for processing in process
1544 * context, if a reader task is waiting. Apparently, this exciting
1545 * idea (VJ's mail "Re: query about TCP header on tcp-ip" of 07 Sep 93)
1546 * failed somewhere. Latency? Burstiness? Well, at least now we will
1547 * see, why it failed. 8)8) --ANK
1548 *
1549 */
1550bool tcp_prequeue(struct sock *sk, struct sk_buff *skb)
1551{
1552 struct tcp_sock *tp = tcp_sk(sk);
1553
1554 if (sysctl_tcp_low_latency || !tp->ucopy.task)
1555 return false;
1556
1557 if (skb->len <= tcp_hdrlen(skb) &&
1558 skb_queue_len(&tp->ucopy.prequeue) == 0)
1559 return false;
1560
David S. Miller58717682013-04-30 03:50:54 -04001561 skb_dst_force(skb);
Eric Dumazetb2fb4f52013-03-06 12:58:01 +00001562 __skb_queue_tail(&tp->ucopy.prequeue, skb);
1563 tp->ucopy.memory += skb->truesize;
1564 if (tp->ucopy.memory > sk->sk_rcvbuf) {
1565 struct sk_buff *skb1;
1566
1567 BUG_ON(sock_owned_by_user(sk));
1568
1569 while ((skb1 = __skb_dequeue(&tp->ucopy.prequeue)) != NULL) {
1570 sk_backlog_rcv(sk, skb1);
1571 NET_INC_STATS_BH(sock_net(sk),
1572 LINUX_MIB_TCPPREQUEUEDROPPED);
1573 }
1574
1575 tp->ucopy.memory = 0;
1576 } else if (skb_queue_len(&tp->ucopy.prequeue) == 1) {
1577 wake_up_interruptible_sync_poll(sk_sleep(sk),
1578 POLLIN | POLLRDNORM | POLLRDBAND);
1579 if (!inet_csk_ack_scheduled(sk))
1580 inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
1581 (3 * tcp_rto_min(sk)) / 4,
1582 TCP_RTO_MAX);
1583 }
1584 return true;
1585}
1586EXPORT_SYMBOL(tcp_prequeue);
1587
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588/*
1589 * From tcp_input.c
1590 */
1591
1592int tcp_v4_rcv(struct sk_buff *skb)
1593{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001594 const struct iphdr *iph;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001595 const struct tcphdr *th;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596 struct sock *sk;
1597 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001598 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599
1600 if (skb->pkt_type != PACKET_HOST)
1601 goto discard_it;
1602
1603 /* Count it even if it's bad */
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001604 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605
1606 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1607 goto discard_it;
1608
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001609 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610
1611 if (th->doff < sizeof(struct tcphdr) / 4)
1612 goto bad_packet;
1613 if (!pskb_may_pull(skb, th->doff * 4))
1614 goto discard_it;
1615
1616 /* An explanation is required here, I think.
1617 * Packet length and doff are validated by header prediction,
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -08001618 * provided case of th->doff==0 is eliminated.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619 * So, we defer the checks. */
Tom Herberted70fcf2014-05-02 16:29:38 -07001620
1621 if (skb_checksum_init(skb, IPPROTO_TCP, inet_compute_pseudo))
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001622 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001624 th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001625 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1627 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1628 skb->len - th->doff * 4);
1629 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
Eric Dumazet04317da2014-09-05 15:33:32 -07001630 TCP_SKB_CB(skb)->tcp_tw_isn = 0;
Eric Dumazetb82d1bb2011-09-27 02:20:08 -04001631 TCP_SKB_CB(skb)->ip_dsfield = ipv4_get_dsfield(iph);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 TCP_SKB_CB(skb)->sacked = 0;
1633
Arnaldo Carvalho de Melo9a1f27c2008-10-07 11:41:57 -07001634 sk = __inet_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635 if (!sk)
1636 goto no_tcp_socket;
1637
Eric Dumazetbb134d52010-03-09 05:55:56 +00001638process:
1639 if (sk->sk_state == TCP_TIME_WAIT)
1640 goto do_time_wait;
1641
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001642 if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
1643 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
Stephen Hemmingerd218d112010-01-11 16:28:01 -08001644 goto discard_and_relse;
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001645 }
Stephen Hemmingerd218d112010-01-11 16:28:01 -08001646
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1648 goto discard_and_relse;
Dmitry Popov9ea88a12014-08-07 02:38:22 +04001649
1650#ifdef CONFIG_TCP_MD5SIG
1651 /*
1652 * We really want to reject the packet as early as possible
1653 * if:
1654 * o We're expecting an MD5'd packet and this is no MD5 tcp option
1655 * o There is an MD5 option and we're not expecting one
1656 */
1657 if (tcp_v4_inbound_md5_hash(sk, skb))
1658 goto discard_and_relse;
1659#endif
1660
Patrick McHardyb59c2702006-01-06 23:06:10 -08001661 nf_reset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001663 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664 goto discard_and_relse;
1665
Eliezer Tamir8b80cda2013-07-10 17:13:26 +03001666 sk_mark_napi_id(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 skb->dev = NULL;
1668
Ingo Molnarc6366182006-07-03 00:25:13 -07001669 bh_lock_sock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 ret = 0;
1671 if (!sock_owned_by_user(sk)) {
Chris Leech1a2449a2006-05-23 18:05:53 -07001672#ifdef CONFIG_NET_DMA
1673 struct tcp_sock *tp = tcp_sk(sk);
1674 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
Dave Jianga2bd1142012-04-04 16:10:46 -07001675 tp->ucopy.dma_chan = net_dma_find_channel();
Chris Leech1a2449a2006-05-23 18:05:53 -07001676 if (tp->ucopy.dma_chan)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677 ret = tcp_v4_do_rcv(sk, skb);
Chris Leech1a2449a2006-05-23 18:05:53 -07001678 else
1679#endif
1680 {
1681 if (!tcp_prequeue(sk, skb))
Shan Weiae8d7f82009-05-05 01:01:29 +00001682 ret = tcp_v4_do_rcv(sk, skb);
Chris Leech1a2449a2006-05-23 18:05:53 -07001683 }
Eric Dumazetda882c12012-04-22 23:38:54 +00001684 } else if (unlikely(sk_add_backlog(sk, skb,
1685 sk->sk_rcvbuf + sk->sk_sndbuf))) {
Zhu Yi6b03a532010-03-04 18:01:41 +00001686 bh_unlock_sock(sk);
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001687 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
Zhu Yi6b03a532010-03-04 18:01:41 +00001688 goto discard_and_relse;
1689 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690 bh_unlock_sock(sk);
1691
1692 sock_put(sk);
1693
1694 return ret;
1695
1696no_tcp_socket:
1697 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1698 goto discard_it;
1699
1700 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001701csum_error:
1702 TCP_INC_STATS_BH(net, TCP_MIB_CSUMERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703bad_packet:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001704 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001706 tcp_v4_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 }
1708
1709discard_it:
1710 /* Discard frame. */
1711 kfree_skb(skb);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001712 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713
1714discard_and_relse:
1715 sock_put(sk);
1716 goto discard_it;
1717
1718do_time_wait:
1719 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001720 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721 goto discard_it;
1722 }
1723
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001724 if (skb->len < (th->doff << 2)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001725 inet_twsk_put(inet_twsk(sk));
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001726 goto bad_packet;
1727 }
1728 if (tcp_checksum_complete(skb)) {
1729 inet_twsk_put(inet_twsk(sk));
1730 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001732 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733 case TCP_TW_SYN: {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001734 struct sock *sk2 = inet_lookup_listener(dev_net(skb->dev),
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001735 &tcp_hashinfo,
Tom Herbertda5e3632013-01-22 09:50:24 +00001736 iph->saddr, th->source,
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001737 iph->daddr, th->dest,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001738 inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739 if (sk2) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001740 inet_twsk_deschedule(inet_twsk(sk), &tcp_death_row);
1741 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742 sk = sk2;
1743 goto process;
1744 }
1745 /* Fall through to ACK */
1746 }
1747 case TCP_TW_ACK:
1748 tcp_v4_timewait_ack(sk, skb);
1749 break;
1750 case TCP_TW_RST:
1751 goto no_tcp_socket;
1752 case TCP_TW_SUCCESS:;
1753 }
1754 goto discard_it;
1755}
1756
David S. Millerccb7c412010-12-01 18:09:13 -08001757static struct timewait_sock_ops tcp_timewait_sock_ops = {
1758 .twsk_obj_size = sizeof(struct tcp_timewait_sock),
1759 .twsk_unique = tcp_twsk_unique,
1760 .twsk_destructor= tcp_twsk_destructor,
David S. Millerccb7c412010-12-01 18:09:13 -08001761};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762
Eric Dumazet63d02d12012-08-09 14:11:00 +00001763void inet_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb)
Eric Dumazet5d299f32012-08-06 05:09:33 +00001764{
1765 struct dst_entry *dst = skb_dst(skb);
1766
1767 dst_hold(dst);
1768 sk->sk_rx_dst = dst;
1769 inet_sk(sk)->rx_dst_ifindex = skb->skb_iif;
1770}
Eric Dumazet63d02d12012-08-09 14:11:00 +00001771EXPORT_SYMBOL(inet_sk_rx_dst_set);
Eric Dumazet5d299f32012-08-06 05:09:33 +00001772
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001773const struct inet_connection_sock_af_ops ipv4_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001774 .queue_xmit = ip_queue_xmit,
1775 .send_check = tcp_v4_send_check,
1776 .rebuild_header = inet_sk_rebuild_header,
Eric Dumazet5d299f32012-08-06 05:09:33 +00001777 .sk_rx_dst_set = inet_sk_rx_dst_set,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001778 .conn_request = tcp_v4_conn_request,
1779 .syn_recv_sock = tcp_v4_syn_recv_sock,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001780 .net_header_len = sizeof(struct iphdr),
1781 .setsockopt = ip_setsockopt,
1782 .getsockopt = ip_getsockopt,
1783 .addr2sockaddr = inet_csk_addr2sockaddr,
1784 .sockaddr_len = sizeof(struct sockaddr_in),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001785 .bind_conflict = inet_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001786#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001787 .compat_setsockopt = compat_ip_setsockopt,
1788 .compat_getsockopt = compat_ip_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001789#endif
Neal Cardwell4fab9072014-08-14 12:40:05 -04001790 .mtu_reduced = tcp_v4_mtu_reduced,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791};
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001792EXPORT_SYMBOL(ipv4_specific);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001794#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001795static const struct tcp_sock_af_ops tcp_sock_ipv4_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001796 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001797 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001798 .md5_parse = tcp_v4_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001799};
Andrew Mortonb6332e62006-11-30 19:16:28 -08001800#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001801
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802/* NOTE: A lot of things set to zero explicitly by call to
1803 * sk_alloc() so need not be done here.
1804 */
1805static int tcp_v4_init_sock(struct sock *sk)
1806{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001807 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808
Neal Cardwell900f65d2012-04-19 09:55:21 +00001809 tcp_init_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001811 icsk->icsk_af_ops = &ipv4_specific;
Neal Cardwell900f65d2012-04-19 09:55:21 +00001812
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001813#ifdef CONFIG_TCP_MD5SIG
David S. Millerac807fa2012-04-23 03:21:58 -04001814 tcp_sk(sk)->af_specific = &tcp_sock_ipv4_specific;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001815#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 return 0;
1818}
1819
Brian Haley7d06b2e2008-06-14 17:04:49 -07001820void tcp_v4_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821{
1822 struct tcp_sock *tp = tcp_sk(sk);
1823
1824 tcp_clear_xmit_timers(sk);
1825
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001826 tcp_cleanup_congestion_control(sk);
Stephen Hemminger317a76f2005-06-23 12:19:55 -07001827
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828 /* Cleanup up the write buffer. */
David S. Millerfe067e82007-03-07 12:12:44 -08001829 tcp_write_queue_purge(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830
1831 /* Cleans up our, hopefully empty, out_of_order_queue. */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001832 __skb_queue_purge(&tp->out_of_order_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001834#ifdef CONFIG_TCP_MD5SIG
1835 /* Clean up the MD5 key list, if any */
1836 if (tp->md5sig_info) {
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001837 tcp_clear_md5_list(sk);
Eric Dumazeta8afca02012-01-31 18:45:40 +00001838 kfree_rcu(tp->md5sig_info, rcu);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001839 tp->md5sig_info = NULL;
1840 }
1841#endif
1842
Chris Leech1a2449a2006-05-23 18:05:53 -07001843#ifdef CONFIG_NET_DMA
1844 /* Cleans up our sk_async_wait_queue */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001845 __skb_queue_purge(&sk->sk_async_wait_queue);
Chris Leech1a2449a2006-05-23 18:05:53 -07001846#endif
1847
Linus Torvalds1da177e2005-04-16 15:20:36 -07001848 /* Clean prequeue, it must be empty really */
1849 __skb_queue_purge(&tp->ucopy.prequeue);
1850
1851 /* Clean up a referenced TCP bind bucket. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001852 if (inet_csk(sk)->icsk_bind_hash)
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001853 inet_put_port(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854
Jerry Chu168a8f52012-08-31 12:29:13 +00001855 BUG_ON(tp->fastopen_rsk != NULL);
William Allen Simpson435cf552009-12-02 18:17:05 +00001856
Yuchung Chengcf60af02012-07-19 06:43:09 +00001857 /* If socket is aborted during connect operation */
1858 tcp_free_fastopen_req(tp);
1859
Glauber Costa180d8cd2011-12-11 21:47:02 +00001860 sk_sockets_allocated_dec(sk);
Glauber Costad1a4c0b2011-12-11 21:47:04 +00001861 sock_release_memcg(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001863EXPORT_SYMBOL(tcp_v4_destroy_sock);
1864
1865#ifdef CONFIG_PROC_FS
1866/* Proc filesystem TCP sock list dumping. */
1867
Tom Herberta8b690f2010-06-07 00:43:42 -07001868/*
1869 * Get next listener socket follow cur. If cur is NULL, get first socket
1870 * starting from bucket given in st->bucket; when st->bucket is zero the
1871 * very first socket in the hash table is returned.
1872 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873static void *listening_get_next(struct seq_file *seq, void *cur)
1874{
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001875 struct inet_connection_sock *icsk;
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08001876 struct hlist_nulls_node *node;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877 struct sock *sk = cur;
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001878 struct inet_listen_hashbucket *ilb;
Jianjun Kong5799de02008-11-03 02:49:10 -08001879 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07001880 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881
1882 if (!sk) {
Tom Herberta8b690f2010-06-07 00:43:42 -07001883 ilb = &tcp_hashinfo.listening_hash[st->bucket];
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001884 spin_lock_bh(&ilb->lock);
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08001885 sk = sk_nulls_head(&ilb->head);
Tom Herberta8b690f2010-06-07 00:43:42 -07001886 st->offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887 goto get_sk;
1888 }
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001889 ilb = &tcp_hashinfo.listening_hash[st->bucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 ++st->num;
Tom Herberta8b690f2010-06-07 00:43:42 -07001891 ++st->offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892
1893 if (st->state == TCP_SEQ_STATE_OPENREQ) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001894 struct request_sock *req = cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001896 icsk = inet_csk(st->syn_wait_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897 req = req->dl_next;
1898 while (1) {
1899 while (req) {
Daniel Lezcanobdccc4c2008-07-19 00:15:13 -07001900 if (req->rsk_ops->family == st->family) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001901 cur = req;
1902 goto out;
1903 }
1904 req = req->dl_next;
1905 }
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001906 if (++st->sbucket >= icsk->icsk_accept_queue.listen_opt->nr_table_entries)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907 break;
1908get_req:
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001909 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 }
Eric Dumazet1bde5ac2010-12-23 09:32:46 -08001911 sk = sk_nulls_next(st->syn_wait_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 st->state = TCP_SEQ_STATE_LISTENING;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001913 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914 } else {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001915 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001916 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1917 if (reqsk_queue_len(&icsk->icsk_accept_queue))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 goto start_req;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001919 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Eric Dumazet1bde5ac2010-12-23 09:32:46 -08001920 sk = sk_nulls_next(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921 }
1922get_sk:
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08001923 sk_nulls_for_each_from(sk, node) {
Pavel Emelyanov8475ef92010-11-22 03:26:12 +00001924 if (!net_eq(sock_net(sk), net))
1925 continue;
1926 if (sk->sk_family == st->family) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927 cur = sk;
1928 goto out;
1929 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001930 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001931 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1932 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933start_req:
1934 st->uid = sock_i_uid(sk);
1935 st->syn_wait_sk = sk;
1936 st->state = TCP_SEQ_STATE_OPENREQ;
1937 st->sbucket = 0;
1938 goto get_req;
1939 }
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001940 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941 }
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001942 spin_unlock_bh(&ilb->lock);
Tom Herberta8b690f2010-06-07 00:43:42 -07001943 st->offset = 0;
Arnaldo Carvalho de Melo0f7ff922005-08-09 19:59:44 -07001944 if (++st->bucket < INET_LHTABLE_SIZE) {
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001945 ilb = &tcp_hashinfo.listening_hash[st->bucket];
1946 spin_lock_bh(&ilb->lock);
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08001947 sk = sk_nulls_head(&ilb->head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 goto get_sk;
1949 }
1950 cur = NULL;
1951out:
1952 return cur;
1953}
1954
1955static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
1956{
Tom Herberta8b690f2010-06-07 00:43:42 -07001957 struct tcp_iter_state *st = seq->private;
1958 void *rc;
1959
1960 st->bucket = 0;
1961 st->offset = 0;
1962 rc = listening_get_next(seq, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963
1964 while (rc && *pos) {
1965 rc = listening_get_next(seq, rc);
1966 --*pos;
1967 }
1968 return rc;
1969}
1970
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07001971static inline bool empty_bucket(const struct tcp_iter_state *st)
Andi Kleen6eac5602008-08-28 01:08:02 -07001972{
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07001973 return hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].chain);
Andi Kleen6eac5602008-08-28 01:08:02 -07001974}
1975
Tom Herberta8b690f2010-06-07 00:43:42 -07001976/*
1977 * Get first established socket starting from bucket given in st->bucket.
1978 * If st->bucket is zero, the very first socket in the hash is returned.
1979 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001980static void *established_get_first(struct seq_file *seq)
1981{
Jianjun Kong5799de02008-11-03 02:49:10 -08001982 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07001983 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984 void *rc = NULL;
1985
Tom Herberta8b690f2010-06-07 00:43:42 -07001986 st->offset = 0;
1987 for (; st->bucket <= tcp_hashinfo.ehash_mask; ++st->bucket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988 struct sock *sk;
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001989 struct hlist_nulls_node *node;
Eric Dumazet9db66bd2008-11-20 20:39:09 -08001990 spinlock_t *lock = inet_ehash_lockp(&tcp_hashinfo, st->bucket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991
Andi Kleen6eac5602008-08-28 01:08:02 -07001992 /* Lockless fast path for the common case of empty buckets */
1993 if (empty_bucket(st))
1994 continue;
1995
Eric Dumazet9db66bd2008-11-20 20:39:09 -08001996 spin_lock_bh(lock);
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001997 sk_nulls_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
Daniel Lezcanof40c8172008-03-21 04:13:54 -07001998 if (sk->sk_family != st->family ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09001999 !net_eq(sock_net(sk), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000 continue;
2001 }
2002 rc = sk;
2003 goto out;
2004 }
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002005 spin_unlock_bh(lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006 }
2007out:
2008 return rc;
2009}
2010
2011static void *established_get_next(struct seq_file *seq, void *cur)
2012{
2013 struct sock *sk = cur;
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002014 struct hlist_nulls_node *node;
Jianjun Kong5799de02008-11-03 02:49:10 -08002015 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002016 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017
2018 ++st->num;
Tom Herberta8b690f2010-06-07 00:43:42 -07002019 ++st->offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002021 sk = sk_nulls_next(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002023 sk_nulls_for_each_from(sk, node) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002024 if (sk->sk_family == st->family && net_eq(sock_net(sk), net))
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002025 return sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026 }
2027
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002028 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
2029 ++st->bucket;
2030 return established_get_first(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031}
2032
2033static void *established_get_idx(struct seq_file *seq, loff_t pos)
2034{
Tom Herberta8b690f2010-06-07 00:43:42 -07002035 struct tcp_iter_state *st = seq->private;
2036 void *rc;
2037
2038 st->bucket = 0;
2039 rc = established_get_first(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040
2041 while (rc && pos) {
2042 rc = established_get_next(seq, rc);
2043 --pos;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002044 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002045 return rc;
2046}
2047
2048static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
2049{
2050 void *rc;
Jianjun Kong5799de02008-11-03 02:49:10 -08002051 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002052
Linus Torvalds1da177e2005-04-16 15:20:36 -07002053 st->state = TCP_SEQ_STATE_LISTENING;
2054 rc = listening_get_idx(seq, &pos);
2055
2056 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057 st->state = TCP_SEQ_STATE_ESTABLISHED;
2058 rc = established_get_idx(seq, pos);
2059 }
2060
2061 return rc;
2062}
2063
Tom Herberta8b690f2010-06-07 00:43:42 -07002064static void *tcp_seek_last_pos(struct seq_file *seq)
2065{
2066 struct tcp_iter_state *st = seq->private;
2067 int offset = st->offset;
2068 int orig_num = st->num;
2069 void *rc = NULL;
2070
2071 switch (st->state) {
2072 case TCP_SEQ_STATE_OPENREQ:
2073 case TCP_SEQ_STATE_LISTENING:
2074 if (st->bucket >= INET_LHTABLE_SIZE)
2075 break;
2076 st->state = TCP_SEQ_STATE_LISTENING;
2077 rc = listening_get_next(seq, NULL);
2078 while (offset-- && rc)
2079 rc = listening_get_next(seq, rc);
2080 if (rc)
2081 break;
2082 st->bucket = 0;
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002083 st->state = TCP_SEQ_STATE_ESTABLISHED;
Tom Herberta8b690f2010-06-07 00:43:42 -07002084 /* Fallthrough */
2085 case TCP_SEQ_STATE_ESTABLISHED:
Tom Herberta8b690f2010-06-07 00:43:42 -07002086 if (st->bucket > tcp_hashinfo.ehash_mask)
2087 break;
2088 rc = established_get_first(seq);
2089 while (offset-- && rc)
2090 rc = established_get_next(seq, rc);
2091 }
2092
2093 st->num = orig_num;
2094
2095 return rc;
2096}
2097
Linus Torvalds1da177e2005-04-16 15:20:36 -07002098static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
2099{
Jianjun Kong5799de02008-11-03 02:49:10 -08002100 struct tcp_iter_state *st = seq->private;
Tom Herberta8b690f2010-06-07 00:43:42 -07002101 void *rc;
2102
2103 if (*pos && *pos == st->last_pos) {
2104 rc = tcp_seek_last_pos(seq);
2105 if (rc)
2106 goto out;
2107 }
2108
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109 st->state = TCP_SEQ_STATE_LISTENING;
2110 st->num = 0;
Tom Herberta8b690f2010-06-07 00:43:42 -07002111 st->bucket = 0;
2112 st->offset = 0;
2113 rc = *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2114
2115out:
2116 st->last_pos = *pos;
2117 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118}
2119
2120static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2121{
Tom Herberta8b690f2010-06-07 00:43:42 -07002122 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123 void *rc = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002124
2125 if (v == SEQ_START_TOKEN) {
2126 rc = tcp_get_idx(seq, 0);
2127 goto out;
2128 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129
2130 switch (st->state) {
2131 case TCP_SEQ_STATE_OPENREQ:
2132 case TCP_SEQ_STATE_LISTENING:
2133 rc = listening_get_next(seq, v);
2134 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002135 st->state = TCP_SEQ_STATE_ESTABLISHED;
Tom Herberta8b690f2010-06-07 00:43:42 -07002136 st->bucket = 0;
2137 st->offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138 rc = established_get_first(seq);
2139 }
2140 break;
2141 case TCP_SEQ_STATE_ESTABLISHED:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002142 rc = established_get_next(seq, v);
2143 break;
2144 }
2145out:
2146 ++*pos;
Tom Herberta8b690f2010-06-07 00:43:42 -07002147 st->last_pos = *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148 return rc;
2149}
2150
2151static void tcp_seq_stop(struct seq_file *seq, void *v)
2152{
Jianjun Kong5799de02008-11-03 02:49:10 -08002153 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002154
2155 switch (st->state) {
2156 case TCP_SEQ_STATE_OPENREQ:
2157 if (v) {
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002158 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
2159 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002160 }
2161 case TCP_SEQ_STATE_LISTENING:
2162 if (v != SEQ_START_TOKEN)
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002163 spin_unlock_bh(&tcp_hashinfo.listening_hash[st->bucket].lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002165 case TCP_SEQ_STATE_ESTABLISHED:
2166 if (v)
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002167 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168 break;
2169 }
2170}
2171
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002172int tcp_seq_open(struct inode *inode, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173{
Al Virod9dda782013-03-31 18:16:14 -04002174 struct tcp_seq_afinfo *afinfo = PDE_DATA(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002175 struct tcp_iter_state *s;
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002176 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002178 err = seq_open_net(inode, file, &afinfo->seq_ops,
2179 sizeof(struct tcp_iter_state));
2180 if (err < 0)
2181 return err;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002182
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002183 s = ((struct seq_file *)file->private_data)->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184 s->family = afinfo->family;
stephen hemminger688d1942014-08-29 23:32:05 -07002185 s->last_pos = 0;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002186 return 0;
2187}
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002188EXPORT_SYMBOL(tcp_seq_open);
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002189
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002190int tcp_proc_register(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191{
2192 int rc = 0;
2193 struct proc_dir_entry *p;
2194
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002195 afinfo->seq_ops.start = tcp_seq_start;
2196 afinfo->seq_ops.next = tcp_seq_next;
2197 afinfo->seq_ops.stop = tcp_seq_stop;
2198
Denis V. Lunev84841c32008-05-02 04:10:08 -07002199 p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net,
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002200 afinfo->seq_fops, afinfo);
Denis V. Lunev84841c32008-05-02 04:10:08 -07002201 if (!p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202 rc = -ENOMEM;
2203 return rc;
2204}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002205EXPORT_SYMBOL(tcp_proc_register);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002206
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002207void tcp_proc_unregister(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208{
Gao fengece31ff2013-02-18 01:34:56 +00002209 remove_proc_entry(afinfo->name, net->proc_net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002211EXPORT_SYMBOL(tcp_proc_unregister);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002212
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002213static void get_openreq4(const struct sock *sk, const struct request_sock *req,
Tetsuo Handa652586d2013-11-14 14:31:57 -08002214 struct seq_file *f, int i, kuid_t uid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002215{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002216 const struct inet_request_sock *ireq = inet_rsk(req);
Eric Dumazeta399a802012-08-08 21:13:53 +00002217 long delta = req->expires - jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002218
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002219 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
Tetsuo Handa652586d2013-11-14 14:31:57 -08002220 " %02X %08X:%08X %02X:%08lX %08X %5u %8d %u %d %pK",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002221 i,
Eric Dumazet634fb9792013-10-09 15:21:29 -07002222 ireq->ir_loc_addr,
Eric Dumazetc720c7e2009-10-15 06:30:45 +00002223 ntohs(inet_sk(sk)->inet_sport),
Eric Dumazet634fb9792013-10-09 15:21:29 -07002224 ireq->ir_rmt_addr,
2225 ntohs(ireq->ir_rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226 TCP_SYN_RECV,
2227 0, 0, /* could print option size, but that is af dependent. */
2228 1, /* timers active (only the expire timer) */
Eric Dumazeta399a802012-08-08 21:13:53 +00002229 jiffies_delta_to_clock_t(delta),
Eric Dumazete6c022a2012-10-27 23:16:46 +00002230 req->num_timeout,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06002231 from_kuid_munged(seq_user_ns(f), uid),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232 0, /* non standard timer */
2233 0, /* open_requests have no inode */
2234 atomic_read(&sk->sk_refcnt),
Tetsuo Handa652586d2013-11-14 14:31:57 -08002235 req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236}
2237
Tetsuo Handa652586d2013-11-14 14:31:57 -08002238static void get_tcp4_sock(struct sock *sk, struct seq_file *f, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002239{
2240 int timer_active;
2241 unsigned long timer_expires;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002242 const struct tcp_sock *tp = tcp_sk(sk);
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002243 const struct inet_connection_sock *icsk = inet_csk(sk);
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002244 const struct inet_sock *inet = inet_sk(sk);
Jerry Chu168a8f52012-08-31 12:29:13 +00002245 struct fastopen_queue *fastopenq = icsk->icsk_accept_queue.fastopenq;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00002246 __be32 dest = inet->inet_daddr;
2247 __be32 src = inet->inet_rcv_saddr;
2248 __u16 destp = ntohs(inet->inet_dport);
2249 __u16 srcp = ntohs(inet->inet_sport);
Eric Dumazet49d09002009-12-03 16:06:13 -08002250 int rx_queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002251
Nandita Dukkipati6ba8a3b2013-03-11 10:00:43 +00002252 if (icsk->icsk_pending == ICSK_TIME_RETRANS ||
2253 icsk->icsk_pending == ICSK_TIME_EARLY_RETRANS ||
2254 icsk->icsk_pending == ICSK_TIME_LOSS_PROBE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002255 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002256 timer_expires = icsk->icsk_timeout;
2257 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002258 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002259 timer_expires = icsk->icsk_timeout;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002260 } else if (timer_pending(&sk->sk_timer)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002261 timer_active = 2;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002262 timer_expires = sk->sk_timer.expires;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002263 } else {
2264 timer_active = 0;
2265 timer_expires = jiffies;
2266 }
2267
Eric Dumazet49d09002009-12-03 16:06:13 -08002268 if (sk->sk_state == TCP_LISTEN)
2269 rx_queue = sk->sk_ack_backlog;
2270 else
2271 /*
2272 * because we dont lock socket, we might find a transient negative value
2273 */
2274 rx_queue = max_t(int, tp->rcv_nxt - tp->copied_seq, 0);
2275
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002276 seq_printf(f, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
Tetsuo Handa652586d2013-11-14 14:31:57 -08002277 "%08X %5u %8d %lu %d %pK %lu %lu %u %u %d",
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002278 i, src, srcp, dest, destp, sk->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07002279 tp->write_seq - tp->snd_una,
Eric Dumazet49d09002009-12-03 16:06:13 -08002280 rx_queue,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002281 timer_active,
Eric Dumazeta399a802012-08-08 21:13:53 +00002282 jiffies_delta_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002283 icsk->icsk_retransmits,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06002284 from_kuid_munged(seq_user_ns(f), sock_i_uid(sk)),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03002285 icsk->icsk_probes_out,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002286 sock_i_ino(sk),
2287 atomic_read(&sk->sk_refcnt), sk,
Stephen Hemminger7be87352008-06-27 20:00:19 -07002288 jiffies_to_clock_t(icsk->icsk_rto),
2289 jiffies_to_clock_t(icsk->icsk_ack.ato),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002290 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002291 tp->snd_cwnd,
Jerry Chu168a8f52012-08-31 12:29:13 +00002292 sk->sk_state == TCP_LISTEN ?
2293 (fastopenq ? fastopenq->max_qlen : 0) :
Tetsuo Handa652586d2013-11-14 14:31:57 -08002294 (tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295}
2296
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002297static void get_timewait4_sock(const struct inet_timewait_sock *tw,
Tetsuo Handa652586d2013-11-14 14:31:57 -08002298 struct seq_file *f, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002299{
Al Viro23f33c22006-09-27 18:43:50 -07002300 __be32 dest, src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002301 __u16 destp, srcp;
Eric Dumazete2a1d3e2014-03-27 07:19:19 -07002302 s32 delta = tw->tw_ttd - inet_tw_time_stamp();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002303
2304 dest = tw->tw_daddr;
2305 src = tw->tw_rcv_saddr;
2306 destp = ntohs(tw->tw_dport);
2307 srcp = ntohs(tw->tw_sport);
2308
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002309 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
Tetsuo Handa652586d2013-11-14 14:31:57 -08002310 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
Eric Dumazeta399a802012-08-08 21:13:53 +00002312 3, jiffies_delta_to_clock_t(delta), 0, 0, 0, 0,
Tetsuo Handa652586d2013-11-14 14:31:57 -08002313 atomic_read(&tw->tw_refcnt), tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314}
2315
2316#define TMPSZ 150
2317
2318static int tcp4_seq_show(struct seq_file *seq, void *v)
2319{
Jianjun Kong5799de02008-11-03 02:49:10 -08002320 struct tcp_iter_state *st;
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002321 struct sock *sk = v;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322
Tetsuo Handa652586d2013-11-14 14:31:57 -08002323 seq_setwidth(seq, TMPSZ - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002324 if (v == SEQ_START_TOKEN) {
Tetsuo Handa652586d2013-11-14 14:31:57 -08002325 seq_puts(seq, " sl local_address rem_address st tx_queue "
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326 "rx_queue tr tm->when retrnsmt uid timeout "
2327 "inode");
2328 goto out;
2329 }
2330 st = seq->private;
2331
2332 switch (st->state) {
2333 case TCP_SEQ_STATE_LISTENING:
2334 case TCP_SEQ_STATE_ESTABLISHED:
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002335 if (sk->sk_state == TCP_TIME_WAIT)
Tetsuo Handa652586d2013-11-14 14:31:57 -08002336 get_timewait4_sock(v, seq, st->num);
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002337 else
Tetsuo Handa652586d2013-11-14 14:31:57 -08002338 get_tcp4_sock(v, seq, st->num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002339 break;
2340 case TCP_SEQ_STATE_OPENREQ:
Tetsuo Handa652586d2013-11-14 14:31:57 -08002341 get_openreq4(st->syn_wait_sk, v, seq, st->num, st->uid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002342 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002343 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002344out:
Tetsuo Handa652586d2013-11-14 14:31:57 -08002345 seq_pad(seq, '\n');
Linus Torvalds1da177e2005-04-16 15:20:36 -07002346 return 0;
2347}
2348
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002349static const struct file_operations tcp_afinfo_seq_fops = {
2350 .owner = THIS_MODULE,
2351 .open = tcp_seq_open,
2352 .read = seq_read,
2353 .llseek = seq_lseek,
2354 .release = seq_release_net
2355};
2356
Linus Torvalds1da177e2005-04-16 15:20:36 -07002357static struct tcp_seq_afinfo tcp4_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002358 .name = "tcp",
2359 .family = AF_INET,
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002360 .seq_fops = &tcp_afinfo_seq_fops,
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002361 .seq_ops = {
2362 .show = tcp4_seq_show,
2363 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002364};
2365
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002366static int __net_init tcp4_proc_init_net(struct net *net)
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002367{
2368 return tcp_proc_register(net, &tcp4_seq_afinfo);
2369}
2370
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002371static void __net_exit tcp4_proc_exit_net(struct net *net)
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002372{
2373 tcp_proc_unregister(net, &tcp4_seq_afinfo);
2374}
2375
2376static struct pernet_operations tcp4_net_ops = {
2377 .init = tcp4_proc_init_net,
2378 .exit = tcp4_proc_exit_net,
2379};
2380
Linus Torvalds1da177e2005-04-16 15:20:36 -07002381int __init tcp4_proc_init(void)
2382{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002383 return register_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002384}
2385
2386void tcp4_proc_exit(void)
2387{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002388 unregister_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002389}
2390#endif /* CONFIG_PROC_FS */
2391
2392struct proto tcp_prot = {
2393 .name = "TCP",
2394 .owner = THIS_MODULE,
2395 .close = tcp_close,
2396 .connect = tcp_v4_connect,
2397 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002398 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002399 .ioctl = tcp_ioctl,
2400 .init = tcp_v4_init_sock,
2401 .destroy = tcp_v4_destroy_sock,
2402 .shutdown = tcp_shutdown,
2403 .setsockopt = tcp_setsockopt,
2404 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002405 .recvmsg = tcp_recvmsg,
Changli Gao7ba42912010-07-10 20:41:55 +00002406 .sendmsg = tcp_sendmsg,
2407 .sendpage = tcp_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002408 .backlog_rcv = tcp_v4_do_rcv,
Eric Dumazet46d3cea2012-07-11 05:50:31 +00002409 .release_cb = tcp_release_cb,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08002410 .hash = inet_hash,
2411 .unhash = inet_unhash,
2412 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002413 .enter_memory_pressure = tcp_enter_memory_pressure,
Eric Dumazetc9bee3b72013-07-22 20:27:07 -07002414 .stream_memory_free = tcp_stream_memory_free,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002415 .sockets_allocated = &tcp_sockets_allocated,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07002416 .orphan_count = &tcp_orphan_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002417 .memory_allocated = &tcp_memory_allocated,
2418 .memory_pressure = &tcp_memory_pressure,
Eric W. Biedermana4fe34b2013-10-19 16:25:36 -07002419 .sysctl_mem = sysctl_tcp_mem,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002420 .sysctl_wmem = sysctl_tcp_wmem,
2421 .sysctl_rmem = sysctl_tcp_rmem,
2422 .max_header = MAX_TCP_HEADER,
2423 .obj_size = sizeof(struct tcp_sock),
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002424 .slab_flags = SLAB_DESTROY_BY_RCU,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002425 .twsk_prot = &tcp_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002426 .rsk_prot = &tcp_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07002427 .h.hashinfo = &tcp_hashinfo,
Changli Gao7ba42912010-07-10 20:41:55 +00002428 .no_autobind = true,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002429#ifdef CONFIG_COMPAT
2430 .compat_setsockopt = compat_tcp_setsockopt,
2431 .compat_getsockopt = compat_tcp_getsockopt,
2432#endif
Andrew Mortonc255a452012-07-31 16:43:02 -07002433#ifdef CONFIG_MEMCG_KMEM
Glauber Costad1a4c0b2011-12-11 21:47:04 +00002434 .init_cgroup = tcp_init_cgroup,
2435 .destroy_cgroup = tcp_destroy_cgroup,
2436 .proto_cgroup = tcp_proto_cgroup,
2437#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002438};
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002439EXPORT_SYMBOL(tcp_prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002440
Denis V. Lunev046ee902008-04-03 14:31:33 -07002441static int __net_init tcp_sk_init(struct net *net)
2442{
Hannes Frederic Sowa5d134f12013-01-05 16:10:48 +00002443 net->ipv4.sysctl_tcp_ecn = 2;
Eric Dumazetbe9f4a42012-07-19 07:34:03 +00002444 return 0;
Denis V. Lunev046ee902008-04-03 14:31:33 -07002445}
2446
2447static void __net_exit tcp_sk_exit(struct net *net)
2448{
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002449}
2450
2451static void __net_exit tcp_sk_exit_batch(struct list_head *net_exit_list)
2452{
2453 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET);
Denis V. Lunev046ee902008-04-03 14:31:33 -07002454}
2455
2456static struct pernet_operations __net_initdata tcp_sk_ops = {
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002457 .init = tcp_sk_init,
2458 .exit = tcp_sk_exit,
2459 .exit_batch = tcp_sk_exit_batch,
Denis V. Lunev046ee902008-04-03 14:31:33 -07002460};
2461
Denis V. Lunev9b0f9762008-02-29 11:13:15 -08002462void __init tcp_v4_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002463{
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002464 inet_hashinfo_init(&tcp_hashinfo);
Eric W. Biederman6a1b3052009-02-22 00:10:18 -08002465 if (register_pernet_subsys(&tcp_sk_ops))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002466 panic("Failed to create the TCP control socket.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002467}