blob: 94d1a7757ff7462edf6c32406df7187b4839bf4f [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * Implementation of the Transmission Control Protocol(TCP).
7 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 * IPv4 specific functions
9 *
10 *
11 * code split from:
12 * linux/ipv4/tcp.c
13 * linux/ipv4/tcp_input.c
14 * linux/ipv4/tcp_output.c
15 *
16 * See tcp.c for author information
17 *
18 * This program is free software; you can redistribute it and/or
19 * modify it under the terms of the GNU General Public License
20 * as published by the Free Software Foundation; either version
21 * 2 of the License, or (at your option) any later version.
22 */
23
24/*
25 * Changes:
26 * David S. Miller : New socket lookup architecture.
27 * This code is dedicated to John Dyson.
28 * David S. Miller : Change semantics of established hash,
29 * half is devoted to TIME_WAIT sockets
30 * and the rest go in the other half.
31 * Andi Kleen : Add support for syncookies and fixed
32 * some bugs: ip options weren't passed to
33 * the TCP layer, missed a check for an
34 * ACK bit.
35 * Andi Kleen : Implemented fast path mtu discovery.
36 * Fixed many serious bugs in the
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -070037 * request_sock handling and moved
Linus Torvalds1da177e2005-04-16 15:20:36 -070038 * most of it into the af independent code.
39 * Added tail drop and some other bugfixes.
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -080040 * Added new listen semantics.
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 * Mike McLagan : Routing by source
42 * Juan Jose Ciarlante: ip_dynaddr bits
43 * Andi Kleen: various fixes.
44 * Vitaly E. Lavrov : Transparent proxy revived after year
45 * coma.
46 * Andi Kleen : Fix new listen.
47 * Andi Kleen : Fix accept error reporting.
48 * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which
49 * Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind
50 * a single port at the same time.
51 */
52
Joe Perchesafd465032012-03-12 07:03:32 +000053#define pr_fmt(fmt) "TCP: " fmt
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
Herbert Xueb4dea52008-12-29 23:04:08 -080055#include <linux/bottom_half.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070056#include <linux/types.h>
57#include <linux/fcntl.h>
58#include <linux/module.h>
59#include <linux/random.h>
60#include <linux/cache.h>
61#include <linux/jhash.h>
62#include <linux/init.h>
63#include <linux/times.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090064#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020066#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070067#include <net/icmp.h>
Arnaldo Carvalho de Melo304a1612005-08-09 19:59:20 -070068#include <net/inet_hashtables.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070069#include <net/tcp.h>
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -030070#include <net/transp_v6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070071#include <net/ipv6.h>
72#include <net/inet_common.h>
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -080073#include <net/timewait_sock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070074#include <net/xfrm.h>
David S. Miller6e5714e2011-08-03 20:50:44 -070075#include <net/secure_seq.h>
Glauber Costad1a4c0b2011-12-11 21:47:04 +000076#include <net/tcp_memcontrol.h>
Eliezer Tamir076bb0c2013-07-10 17:13:17 +030077#include <net/busy_poll.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
79#include <linux/inet.h>
80#include <linux/ipv6.h>
81#include <linux/stddef.h>
82#include <linux/proc_fs.h>
83#include <linux/seq_file.h>
84
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080085#include <linux/crypto.h>
86#include <linux/scatterlist.h>
87
Brian Haleyab32ea52006-09-22 14:15:41 -070088int sysctl_tcp_tw_reuse __read_mostly;
89int sysctl_tcp_low_latency __read_mostly;
Eric Dumazet4bc2f182010-07-09 21:22:10 +000090EXPORT_SYMBOL(sysctl_tcp_low_latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080092#ifdef CONFIG_TCP_MD5SIG
Eric Dumazeta915da9b2012-01-31 05:18:33 +000093static int tcp_v4_md5_hash_hdr(char *md5_hash, const struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -040094 __be32 daddr, __be32 saddr, const struct tcphdr *th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080095#endif
96
Eric Dumazet5caea4e2008-11-20 00:40:07 -080097struct inet_hashinfo tcp_hashinfo;
Eric Dumazet4bc2f182010-07-09 21:22:10 +000098EXPORT_SYMBOL(tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
Octavian Purdila936b8bd2014-06-25 17:09:57 +0300100static __u32 tcp_v4_init_sequence(const struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700102 return secure_tcp_sequence_number(ip_hdr(skb)->daddr,
103 ip_hdr(skb)->saddr,
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700104 tcp_hdr(skb)->dest,
105 tcp_hdr(skb)->source);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106}
107
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800108int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp)
109{
110 const struct tcp_timewait_sock *tcptw = tcp_twsk(sktw);
111 struct tcp_sock *tp = tcp_sk(sk);
112
113 /* With PAWS, it is safe from the viewpoint
114 of data integrity. Even without PAWS it is safe provided sequence
115 spaces do not overlap i.e. at data rates <= 80Mbit/sec.
116
117 Actually, the idea is close to VJ's one, only timestamp cache is
118 held not per host, but per port pair and TW bucket is used as state
119 holder.
120
121 If TW bucket has been already destroyed we fall back to VJ's scheme
122 and use initial timestamp retrieved from peer table.
123 */
124 if (tcptw->tw_ts_recent_stamp &&
125 (twp == NULL || (sysctl_tcp_tw_reuse &&
James Morris9d729f72007-03-04 16:12:44 -0800126 get_seconds() - tcptw->tw_ts_recent_stamp > 1))) {
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800127 tp->write_seq = tcptw->tw_snd_nxt + 65535 + 2;
128 if (tp->write_seq == 0)
129 tp->write_seq = 1;
130 tp->rx_opt.ts_recent = tcptw->tw_ts_recent;
131 tp->rx_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp;
132 sock_hold(sktw);
133 return 1;
134 }
135
136 return 0;
137}
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800138EXPORT_SYMBOL_GPL(tcp_twsk_unique);
139
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140/* This will initiate an outgoing connection. */
141int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
142{
David S. Miller2d7192d2011-04-26 13:28:44 -0700143 struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 struct inet_sock *inet = inet_sk(sk);
145 struct tcp_sock *tp = tcp_sk(sk);
David S. Millerdca8b082011-02-24 13:38:12 -0800146 __be16 orig_sport, orig_dport;
Al Virobada8ad2006-09-26 21:27:15 -0700147 __be32 daddr, nexthop;
David S. Millerda905bd2011-05-06 16:11:19 -0700148 struct flowi4 *fl4;
David S. Miller2d7192d2011-04-26 13:28:44 -0700149 struct rtable *rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 int err;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000151 struct ip_options_rcu *inet_opt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152
153 if (addr_len < sizeof(struct sockaddr_in))
154 return -EINVAL;
155
156 if (usin->sin_family != AF_INET)
157 return -EAFNOSUPPORT;
158
159 nexthop = daddr = usin->sin_addr.s_addr;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000160 inet_opt = rcu_dereference_protected(inet->inet_opt,
161 sock_owned_by_user(sk));
162 if (inet_opt && inet_opt->opt.srr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 if (!daddr)
164 return -EINVAL;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000165 nexthop = inet_opt->opt.faddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 }
167
David S. Millerdca8b082011-02-24 13:38:12 -0800168 orig_sport = inet->inet_sport;
169 orig_dport = usin->sin_port;
David S. Millerda905bd2011-05-06 16:11:19 -0700170 fl4 = &inet->cork.fl.u.ip4;
171 rt = ip_route_connect(fl4, nexthop, inet->inet_saddr,
David S. Millerb23dd4f2011-03-02 14:31:35 -0800172 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
173 IPPROTO_TCP,
Steffen Klassert0e0d44a2013-08-28 08:04:14 +0200174 orig_sport, orig_dport, sk);
David S. Millerb23dd4f2011-03-02 14:31:35 -0800175 if (IS_ERR(rt)) {
176 err = PTR_ERR(rt);
177 if (err == -ENETUNREACH)
Eric Dumazetf1d8cba2013-11-28 09:51:22 -0800178 IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTNOROUTES);
David S. Millerb23dd4f2011-03-02 14:31:35 -0800179 return err;
Wei Dong584bdf82007-05-31 22:49:28 -0700180 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181
182 if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
183 ip_rt_put(rt);
184 return -ENETUNREACH;
185 }
186
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000187 if (!inet_opt || !inet_opt->opt.srr)
David S. Millerda905bd2011-05-06 16:11:19 -0700188 daddr = fl4->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000190 if (!inet->inet_saddr)
David S. Millerda905bd2011-05-06 16:11:19 -0700191 inet->inet_saddr = fl4->saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000192 inet->inet_rcv_saddr = inet->inet_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000194 if (tp->rx_opt.ts_recent_stamp && inet->inet_daddr != daddr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 /* Reset inherited state */
196 tp->rx_opt.ts_recent = 0;
197 tp->rx_opt.ts_recent_stamp = 0;
Pavel Emelyanovee995282012-04-19 03:40:39 +0000198 if (likely(!tp->repair))
199 tp->write_seq = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 }
201
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -0700202 if (tcp_death_row.sysctl_tw_recycle &&
David S. Miller81166dd2012-07-10 03:14:24 -0700203 !tp->rx_opt.ts_recent_stamp && fl4->daddr == daddr)
204 tcp_fetch_timewait_stamp(sk, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000206 inet->inet_dport = usin->sin_port;
207 inet->inet_daddr = daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208
Tom Herbertb73c3d02014-07-01 21:32:17 -0700209 inet_set_txhash(sk);
210
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800211 inet_csk(sk)->icsk_ext_hdr_len = 0;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000212 if (inet_opt)
213 inet_csk(sk)->icsk_ext_hdr_len = inet_opt->opt.optlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214
William Allen Simpsonbee7ca92009-11-10 09:51:18 +0000215 tp->rx_opt.mss_clamp = TCP_MSS_DEFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216
217 /* Socket identity is still unknown (sport may be zero).
218 * However we set state to SYN-SENT and not releasing socket
219 * lock select source port, enter ourselves into the hash tables and
220 * complete initialization after this.
221 */
222 tcp_set_state(sk, TCP_SYN_SENT);
Arnaldo Carvalho de Meloa7f5e7f2005-12-13 23:25:31 -0800223 err = inet_hash_connect(&tcp_death_row, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 if (err)
225 goto failure;
226
David S. Millerda905bd2011-05-06 16:11:19 -0700227 rt = ip_route_newports(fl4, rt, orig_sport, orig_dport,
David S. Millerb23dd4f2011-03-02 14:31:35 -0800228 inet->inet_sport, inet->inet_dport, sk);
229 if (IS_ERR(rt)) {
230 err = PTR_ERR(rt);
231 rt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 goto failure;
David S. Millerb23dd4f2011-03-02 14:31:35 -0800233 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 /* OK, now commit destination to socket. */
Herbert Xubcd76112006-06-30 13:36:35 -0700235 sk->sk_gso_type = SKB_GSO_TCPV4;
Changli Gaod8d1f302010-06-10 23:31:35 -0700236 sk_setup_caps(sk, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237
Pavel Emelyanovee995282012-04-19 03:40:39 +0000238 if (!tp->write_seq && likely(!tp->repair))
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000239 tp->write_seq = secure_tcp_sequence_number(inet->inet_saddr,
240 inet->inet_daddr,
241 inet->inet_sport,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 usin->sin_port);
243
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000244 inet->inet_id = tp->write_seq ^ jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245
Andrey Vagin2b916472012-11-22 01:13:58 +0000246 err = tcp_connect(sk);
Pavel Emelyanovee995282012-04-19 03:40:39 +0000247
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 rt = NULL;
249 if (err)
250 goto failure;
251
252 return 0;
253
254failure:
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200255 /*
256 * This unhashes the socket and releases the local port,
257 * if necessary.
258 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 tcp_set_state(sk, TCP_CLOSE);
260 ip_rt_put(rt);
261 sk->sk_route_caps = 0;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000262 inet->inet_dport = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 return err;
264}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000265EXPORT_SYMBOL(tcp_v4_connect);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267/*
Eric Dumazet563d34d2012-07-23 09:48:52 +0200268 * This routine reacts to ICMP_FRAG_NEEDED mtu indications as defined in RFC1191.
269 * It can be called through tcp_release_cb() if socket was owned by user
270 * at the time tcp_v4_err() was called to handle ICMP message.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 */
Neal Cardwell4fab9072014-08-14 12:40:05 -0400272void tcp_v4_mtu_reduced(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273{
274 struct dst_entry *dst;
275 struct inet_sock *inet = inet_sk(sk);
Eric Dumazet563d34d2012-07-23 09:48:52 +0200276 u32 mtu = tcp_sk(sk)->mtu_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277
David S. Miller80d0a692012-07-16 03:28:06 -0700278 dst = inet_csk_update_pmtu(sk, mtu);
279 if (!dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 return;
281
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 /* Something is about to be wrong... Remember soft error
283 * for the case, if this connection will not able to recover.
284 */
285 if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
286 sk->sk_err_soft = EMSGSIZE;
287
288 mtu = dst_mtu(dst);
289
290 if (inet->pmtudisc != IP_PMTUDISC_DONT &&
Hannes Frederic Sowa482fc602013-11-05 02:24:17 +0100291 ip_sk_accept_pmtu(sk) &&
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800292 inet_csk(sk)->icsk_pmtu_cookie > mtu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 tcp_sync_mss(sk, mtu);
294
295 /* Resend the TCP packet because it's
296 * clear that the old packet has been
297 * dropped. This is the new "fast" path mtu
298 * discovery.
299 */
300 tcp_simple_retransmit(sk);
301 } /* else let the usual retransmit timer handle it */
302}
Neal Cardwell4fab9072014-08-14 12:40:05 -0400303EXPORT_SYMBOL(tcp_v4_mtu_reduced);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304
David S. Miller55be7a92012-07-11 21:27:49 -0700305static void do_redirect(struct sk_buff *skb, struct sock *sk)
306{
307 struct dst_entry *dst = __sk_dst_check(sk, 0);
308
David S. Miller1ed5c482012-07-12 00:41:25 -0700309 if (dst)
David S. Miller6700c272012-07-17 03:29:28 -0700310 dst->ops->redirect(dst, sk, skb);
David S. Miller55be7a92012-07-11 21:27:49 -0700311}
312
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313/*
314 * This routine is called by the ICMP module when it gets some
315 * sort of error condition. If err < 0 then the socket should
316 * be closed and the error returned to the user. If err > 0
317 * it's just the icmp type << 8 | icmp code. After adjustment
318 * header points to the first 8 bytes of the tcp header. We need
319 * to find the appropriate port.
320 *
321 * The locking strategy used here is very "optimistic". When
322 * someone else accesses the socket the ICMP is just dropped
323 * and for some paths there is no check at all.
324 * A more general error queue to queue errors for later handling
325 * is probably better.
326 *
327 */
328
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000329void tcp_v4_err(struct sk_buff *icmp_skb, u32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000331 const struct iphdr *iph = (const struct iphdr *)icmp_skb->data;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000332 struct tcphdr *th = (struct tcphdr *)(icmp_skb->data + (iph->ihl << 2));
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000333 struct inet_connection_sock *icsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 struct tcp_sock *tp;
335 struct inet_sock *inet;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000336 const int type = icmp_hdr(icmp_skb)->type;
337 const int code = icmp_hdr(icmp_skb)->code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 struct sock *sk;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000339 struct sk_buff *skb;
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700340 struct request_sock *fastopen;
341 __u32 seq, snd_una;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000342 __u32 remaining;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 int err;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000344 struct net *net = dev_net(icmp_skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345
Pavel Emelyanovfd54d712008-07-14 23:01:40 -0700346 sk = inet_lookup(net, &tcp_hashinfo, iph->daddr, th->dest,
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000347 iph->saddr, th->source, inet_iif(icmp_skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 if (!sk) {
Pavel Emelyanovdcfc23c2008-07-14 23:03:00 -0700349 ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 return;
351 }
352 if (sk->sk_state == TCP_TIME_WAIT) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700353 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 return;
355 }
356
357 bh_lock_sock(sk);
358 /* If too many ICMPs get dropped on busy
359 * servers this needs to be solved differently.
Eric Dumazet563d34d2012-07-23 09:48:52 +0200360 * We do take care of PMTU discovery (RFC1191) special case :
361 * we can receive locally generated ICMP messages while socket is held.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 */
Eric Dumazetb74aa932013-01-19 16:10:37 +0000363 if (sock_owned_by_user(sk)) {
364 if (!(type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED))
365 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
366 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 if (sk->sk_state == TCP_CLOSE)
368 goto out;
369
stephen hemminger97e3ecd12010-03-18 11:27:32 +0000370 if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
371 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
372 goto out;
373 }
374
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000375 icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 tp = tcp_sk(sk);
377 seq = ntohl(th->seq);
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700378 /* XXX (TFO) - tp->snd_una should be ISN (tcp_create_openreq_child() */
379 fastopen = tp->fastopen_rsk;
380 snd_una = fastopen ? tcp_rsk(fastopen)->snt_isn : tp->snd_una;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 if (sk->sk_state != TCP_LISTEN &&
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700382 !between(seq, snd_una, tp->snd_nxt)) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700383 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 goto out;
385 }
386
387 switch (type) {
David S. Miller55be7a92012-07-11 21:27:49 -0700388 case ICMP_REDIRECT:
389 do_redirect(icmp_skb, sk);
390 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 case ICMP_SOURCE_QUENCH:
392 /* Just silently ignore these. */
393 goto out;
394 case ICMP_PARAMETERPROB:
395 err = EPROTO;
396 break;
397 case ICMP_DEST_UNREACH:
398 if (code > NR_ICMP_UNREACH)
399 goto out;
400
401 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
Eric Dumazet0d4f0602013-03-18 07:01:28 +0000402 /* We are not interested in TCP_LISTEN and open_requests
403 * (SYN-ACKs send out by Linux are always <576bytes so
404 * they should go through unfragmented).
405 */
406 if (sk->sk_state == TCP_LISTEN)
407 goto out;
408
Eric Dumazet563d34d2012-07-23 09:48:52 +0200409 tp->mtu_info = info;
Eric Dumazet144d56e2012-08-20 00:22:46 +0000410 if (!sock_owned_by_user(sk)) {
Eric Dumazet563d34d2012-07-23 09:48:52 +0200411 tcp_v4_mtu_reduced(sk);
Eric Dumazet144d56e2012-08-20 00:22:46 +0000412 } else {
413 if (!test_and_set_bit(TCP_MTU_REDUCED_DEFERRED, &tp->tsq_flags))
414 sock_hold(sk);
415 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 goto out;
417 }
418
419 err = icmp_err_convert[code].errno;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000420 /* check if icmp_skb allows revert of backoff
421 * (see draft-zimmermann-tcp-lcd) */
422 if (code != ICMP_NET_UNREACH && code != ICMP_HOST_UNREACH)
423 break;
424 if (seq != tp->snd_una || !icsk->icsk_retransmits ||
Yuchung Cheng0a672f72014-05-11 20:22:12 -0700425 !icsk->icsk_backoff || fastopen)
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000426 break;
427
David S. Miller8f49c272010-11-12 13:35:00 -0800428 if (sock_owned_by_user(sk))
429 break;
430
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000431 icsk->icsk_backoff--;
Eric Dumazetfcdd1cf2014-09-22 13:19:44 -0700432 icsk->icsk_rto = tp->srtt_us ? __tcp_set_rto(tp) :
433 TCP_TIMEOUT_INIT;
434 icsk->icsk_rto = inet_csk_rto_backoff(icsk, TCP_RTO_MAX);
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000435
436 skb = tcp_write_queue_head(sk);
437 BUG_ON(!skb);
438
Eric Dumazet7faee5c2014-09-05 15:33:33 -0700439 remaining = icsk->icsk_rto -
440 min(icsk->icsk_rto,
441 tcp_time_stamp - tcp_skb_timestamp(skb));
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000442
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 Dumazet24a2d432014-09-27 09:50:55 -0700683 ip_send_unicast_reply(net, skb, &TCP_SKB_CB(skb)->header.h4.opt,
684 ip_hdr(skb)->saddr, ip_hdr(skb)->daddr,
685 &arg, arg.iov[0].iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686
Pavel Emelyanov63231bd2008-07-16 20:22:25 -0700687 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
688 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
Shawn Lu658ddaa2012-01-31 22:35:48 +0000689
690#ifdef CONFIG_TCP_MD5SIG
691release_sk1:
692 if (sk1) {
693 rcu_read_unlock();
694 sock_put(sk1);
695 }
696#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697}
698
699/* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
700 outside socket context is ugly, certainly. What can I do?
701 */
702
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900703static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
Andrey Vaginee684b62013-02-11 05:50:19 +0000704 u32 win, u32 tsval, u32 tsecr, int oif,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700705 struct tcp_md5sig_key *key,
Eric Dumazet66b13d92011-10-24 03:06:21 -0400706 int reply_flags, u8 tos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400708 const struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 struct {
710 struct tcphdr th;
Al Viro714e85b2006-11-14 20:51:49 -0800711 __be32 opt[(TCPOLEN_TSTAMP_ALIGNED >> 2)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800712#ifdef CONFIG_TCP_MD5SIG
Al Viro714e85b2006-11-14 20:51:49 -0800713 + (TCPOLEN_MD5SIG_ALIGNED >> 2)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800714#endif
715 ];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 } rep;
717 struct ip_reply_arg arg;
Eric Dumazetadf30902009-06-02 05:19:30 +0000718 struct net *net = dev_net(skb_dst(skb)->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719
720 memset(&rep.th, 0, sizeof(struct tcphdr));
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200721 memset(&arg, 0, sizeof(arg));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722
723 arg.iov[0].iov_base = (unsigned char *)&rep;
724 arg.iov[0].iov_len = sizeof(rep.th);
Andrey Vaginee684b62013-02-11 05:50:19 +0000725 if (tsecr) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800726 rep.opt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
727 (TCPOPT_TIMESTAMP << 8) |
728 TCPOLEN_TIMESTAMP);
Andrey Vaginee684b62013-02-11 05:50:19 +0000729 rep.opt[1] = htonl(tsval);
730 rep.opt[2] = htonl(tsecr);
Craig Schlentercb48cfe2007-01-09 00:11:15 -0800731 arg.iov[0].iov_len += TCPOLEN_TSTAMP_ALIGNED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 }
733
734 /* Swap the send and the receive. */
735 rep.th.dest = th->source;
736 rep.th.source = th->dest;
737 rep.th.doff = arg.iov[0].iov_len / 4;
738 rep.th.seq = htonl(seq);
739 rep.th.ack_seq = htonl(ack);
740 rep.th.ack = 1;
741 rep.th.window = htons(win);
742
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800743#ifdef CONFIG_TCP_MD5SIG
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800744 if (key) {
Andrey Vaginee684b62013-02-11 05:50:19 +0000745 int offset = (tsecr) ? 3 : 0;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800746
747 rep.opt[offset++] = htonl((TCPOPT_NOP << 24) |
748 (TCPOPT_NOP << 16) |
749 (TCPOPT_MD5SIG << 8) |
750 TCPOLEN_MD5SIG);
751 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
752 rep.th.doff = arg.iov[0].iov_len/4;
753
Adam Langley49a72df2008-07-19 00:01:42 -0700754 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[offset],
Adam Langley90b7e112008-07-31 20:49:48 -0700755 key, ip_hdr(skb)->saddr,
756 ip_hdr(skb)->daddr, &rep.th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800757 }
758#endif
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700759 arg.flags = reply_flags;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700760 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
761 ip_hdr(skb)->saddr, /* XXX */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 arg.iov[0].iov_len, IPPROTO_TCP, 0);
763 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900764 if (oif)
765 arg.bound_dev_if = oif;
Eric Dumazet66b13d92011-10-24 03:06:21 -0400766 arg.tos = tos;
Eric Dumazet24a2d432014-09-27 09:50:55 -0700767 ip_send_unicast_reply(net, skb, &TCP_SKB_CB(skb)->header.h4.opt,
768 ip_hdr(skb)->saddr, ip_hdr(skb)->daddr,
769 &arg, arg.iov[0].iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770
Pavel Emelyanov63231bd2008-07-16 20:22:25 -0700771 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772}
773
774static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
775{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700776 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800777 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900779 tcp_v4_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200780 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
Andrey Vaginee684b62013-02-11 05:50:19 +0000781 tcp_time_stamp + tcptw->tw_ts_offset,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900782 tcptw->tw_ts_recent,
783 tw->tw_bound_dev_if,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700784 tcp_twsk_md5_key(tcptw),
Eric Dumazet66b13d92011-10-24 03:06:21 -0400785 tw->tw_transparent ? IP_REPLY_ARG_NOSRCCHECK : 0,
786 tw->tw_tos
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900787 );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700789 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790}
791
Gui Jianfeng6edafaa2008-08-06 23:50:04 -0700792static void tcp_v4_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200793 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794{
Jerry Chu168a8f52012-08-31 12:29:13 +0000795 /* sk->sk_state == TCP_LISTEN -> for regular TCP_SYN_RECV
796 * sk->sk_state == TCP_SYN_RECV -> for Fast Open.
797 */
798 tcp_v4_send_ack(skb, (sk->sk_state == TCP_LISTEN) ?
799 tcp_rsk(req)->snt_isn + 1 : tcp_sk(sk)->snd_nxt,
800 tcp_rsk(req)->rcv_nxt, req->rcv_wnd,
Andrey Vaginee684b62013-02-11 05:50:19 +0000801 tcp_time_stamp,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900802 req->ts_recent,
803 0,
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000804 tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&ip_hdr(skb)->daddr,
805 AF_INET),
Eric Dumazet66b13d92011-10-24 03:06:21 -0400806 inet_rsk(req)->no_srccheck ? IP_REPLY_ARG_NOSRCCHECK : 0,
807 ip_hdr(skb)->tos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808}
809
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810/*
Kris Katterjohn9bf1d832008-02-17 22:29:19 -0800811 * Send a SYN-ACK after having received a SYN.
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700812 * This still operates on a request_sock only, not on a big
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 * socket.
814 */
Octavian Purdila72659ec2010-01-17 19:09:39 -0800815static int tcp_v4_send_synack(struct sock *sk, struct dst_entry *dst,
Octavian Purdilad6274bd2014-06-25 17:09:58 +0300816 struct flowi *fl,
Octavian Purdila72659ec2010-01-17 19:09:39 -0800817 struct request_sock *req,
Yuchung Cheng843f4a52014-05-11 20:22:11 -0700818 u16 queue_mapping,
819 struct tcp_fastopen_cookie *foc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700821 const struct inet_request_sock *ireq = inet_rsk(req);
David S. Miller6bd023f2011-05-18 18:32:03 -0400822 struct flowi4 fl4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 int err = -1;
Weilong Chend41db5a2013-12-23 14:37:28 +0800824 struct sk_buff *skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825
826 /* First, grab a route. */
David S. Millerba3f7f02012-07-17 14:02:46 -0700827 if (!dst && (dst = inet_csk_route_req(sk, &fl4, req)) == NULL)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800828 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829
Yuchung Cheng843f4a52014-05-11 20:22:11 -0700830 skb = tcp_make_synack(sk, dst, req, foc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831
832 if (skb) {
Eric Dumazet634fb9792013-10-09 15:21:29 -0700833 __tcp_v4_send_check(skb, ireq->ir_loc_addr, ireq->ir_rmt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834
Eric Dumazetfff32692012-06-01 01:47:50 +0000835 skb_set_queue_mapping(skb, queue_mapping);
Eric Dumazet634fb9792013-10-09 15:21:29 -0700836 err = ip_build_and_send_pkt(skb, sk, ireq->ir_loc_addr,
837 ireq->ir_rmt_addr,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700838 ireq->opt);
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200839 err = net_xmit_eval(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 }
841
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 return err;
843}
844
845/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700846 * IPv4 request_sock destructor.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 */
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700848static void tcp_v4_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849{
Jesper Juhla51482b2005-11-08 09:41:34 -0800850 kfree(inet_rsk(req)->opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851}
852
Eric Dumazet946cedc2011-08-30 03:21:44 +0000853/*
Eric Dumazeta2a385d2012-05-16 23:15:34 +0000854 * Return true if a syncookie should be sent
Eric Dumazet946cedc2011-08-30 03:21:44 +0000855 */
Eric Dumazeta2a385d2012-05-16 23:15:34 +0000856bool tcp_syn_flood_action(struct sock *sk,
Eric Dumazet946cedc2011-08-30 03:21:44 +0000857 const struct sk_buff *skb,
858 const char *proto)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859{
Eric Dumazet946cedc2011-08-30 03:21:44 +0000860 const char *msg = "Dropping request";
Eric Dumazeta2a385d2012-05-16 23:15:34 +0000861 bool want_cookie = false;
Eric Dumazet946cedc2011-08-30 03:21:44 +0000862 struct listen_sock *lopt;
863
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000864#ifdef CONFIG_SYN_COOKIES
Eric Dumazet946cedc2011-08-30 03:21:44 +0000865 if (sysctl_tcp_syncookies) {
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000866 msg = "Sending cookies";
Eric Dumazeta2a385d2012-05-16 23:15:34 +0000867 want_cookie = true;
Eric Dumazet946cedc2011-08-30 03:21:44 +0000868 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPREQQFULLDOCOOKIES);
869 } else
Arnaldo Carvalho de Melo80e40da2006-01-04 01:58:06 -0200870#endif
Eric Dumazet946cedc2011-08-30 03:21:44 +0000871 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPREQQFULLDROP);
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000872
Eric Dumazet946cedc2011-08-30 03:21:44 +0000873 lopt = inet_csk(sk)->icsk_accept_queue.listen_opt;
Hannes Frederic Sowa5ad37d52013-07-26 17:43:23 +0200874 if (!lopt->synflood_warned && sysctl_tcp_syncookies != 2) {
Eric Dumazet946cedc2011-08-30 03:21:44 +0000875 lopt->synflood_warned = 1;
Joe Perchesafd465032012-03-12 07:03:32 +0000876 pr_info("%s: Possible SYN flooding on port %d. %s. Check SNMP counters.\n",
Eric Dumazet946cedc2011-08-30 03:21:44 +0000877 proto, ntohs(tcp_hdr(skb)->dest), msg);
878 }
879 return want_cookie;
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000880}
Eric Dumazet946cedc2011-08-30 03:21:44 +0000881EXPORT_SYMBOL(tcp_syn_flood_action);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800883#ifdef CONFIG_TCP_MD5SIG
884/*
885 * RFC2385 MD5 checksumming requires a mapping of
886 * IP address->MD5 Key.
887 * We need to maintain these in the sk structure.
888 */
889
890/* Find the Key structure for an address. */
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000891struct tcp_md5sig_key *tcp_md5_do_lookup(struct sock *sk,
892 const union tcp_md5_addr *addr,
893 int family)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800894{
895 struct tcp_sock *tp = tcp_sk(sk);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000896 struct tcp_md5sig_key *key;
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000897 unsigned int size = sizeof(struct in_addr);
Eric Dumazeta8afca02012-01-31 18:45:40 +0000898 struct tcp_md5sig_info *md5sig;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800899
Eric Dumazeta8afca02012-01-31 18:45:40 +0000900 /* caller either holds rcu_read_lock() or socket lock */
901 md5sig = rcu_dereference_check(tp->md5sig_info,
Eric Dumazetb4fb05e2012-03-07 04:45:43 +0000902 sock_owned_by_user(sk) ||
903 lockdep_is_held(&sk->sk_lock.slock));
Eric Dumazeta8afca02012-01-31 18:45:40 +0000904 if (!md5sig)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800905 return NULL;
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000906#if IS_ENABLED(CONFIG_IPV6)
907 if (family == AF_INET6)
908 size = sizeof(struct in6_addr);
909#endif
Sasha Levinb67bfe02013-02-27 17:06:00 -0800910 hlist_for_each_entry_rcu(key, &md5sig->head, node) {
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000911 if (key->family != family)
912 continue;
913 if (!memcmp(&key->addr, addr, size))
914 return key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800915 }
916 return NULL;
917}
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000918EXPORT_SYMBOL(tcp_md5_do_lookup);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800919
920struct tcp_md5sig_key *tcp_v4_md5_lookup(struct sock *sk,
921 struct sock *addr_sk)
922{
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000923 union tcp_md5_addr *addr;
924
925 addr = (union tcp_md5_addr *)&inet_sk(addr_sk)->inet_daddr;
926 return tcp_md5_do_lookup(sk, addr, AF_INET);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800927}
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800928EXPORT_SYMBOL(tcp_v4_md5_lookup);
929
Adrian Bunkf5b99bc2006-11-30 17:22:29 -0800930static struct tcp_md5sig_key *tcp_v4_reqsk_md5_lookup(struct sock *sk,
931 struct request_sock *req)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800932{
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000933 union tcp_md5_addr *addr;
934
Eric Dumazet634fb9792013-10-09 15:21:29 -0700935 addr = (union tcp_md5_addr *)&inet_rsk(req)->ir_rmt_addr;
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000936 return tcp_md5_do_lookup(sk, addr, AF_INET);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800937}
938
939/* This can be called on a newly created socket, from other files */
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000940int tcp_md5_do_add(struct sock *sk, const union tcp_md5_addr *addr,
941 int family, const u8 *newkey, u8 newkeylen, gfp_t gfp)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800942{
943 /* Add Key to the list */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700944 struct tcp_md5sig_key *key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800945 struct tcp_sock *tp = tcp_sk(sk);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000946 struct tcp_md5sig_info *md5sig;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800947
Aydin Arikc0353c72013-06-14 18:56:31 +1200948 key = tcp_md5_do_lookup(sk, addr, family);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800949 if (key) {
950 /* Pre-existing entry - just update that one. */
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000951 memcpy(key->key, newkey, newkeylen);
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700952 key->keylen = newkeylen;
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000953 return 0;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800954 }
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000955
Eric Dumazeta8afca02012-01-31 18:45:40 +0000956 md5sig = rcu_dereference_protected(tp->md5sig_info,
957 sock_owned_by_user(sk));
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000958 if (!md5sig) {
959 md5sig = kmalloc(sizeof(*md5sig), gfp);
960 if (!md5sig)
961 return -ENOMEM;
962
963 sk_nocaps_add(sk, NETIF_F_GSO_MASK);
964 INIT_HLIST_HEAD(&md5sig->head);
Eric Dumazeta8afca02012-01-31 18:45:40 +0000965 rcu_assign_pointer(tp->md5sig_info, md5sig);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000966 }
967
Eric Dumazet5f3d9cb2012-01-31 10:56:48 +0000968 key = sock_kmalloc(sk, sizeof(*key), gfp);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000969 if (!key)
970 return -ENOMEM;
Eric Dumazet71cea172013-05-20 06:52:26 +0000971 if (!tcp_alloc_md5sig_pool()) {
Eric Dumazet5f3d9cb2012-01-31 10:56:48 +0000972 sock_kfree_s(sk, key, sizeof(*key));
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000973 return -ENOMEM;
974 }
975
976 memcpy(key->key, newkey, newkeylen);
977 key->keylen = newkeylen;
978 key->family = family;
979 memcpy(&key->addr, addr,
980 (family == AF_INET6) ? sizeof(struct in6_addr) :
981 sizeof(struct in_addr));
982 hlist_add_head_rcu(&key->node, &md5sig->head);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800983 return 0;
984}
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000985EXPORT_SYMBOL(tcp_md5_do_add);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800986
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000987int tcp_md5_do_del(struct sock *sk, const union tcp_md5_addr *addr, int family)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800988{
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000989 struct tcp_md5sig_key *key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800990
Aydin Arikc0353c72013-06-14 18:56:31 +1200991 key = tcp_md5_do_lookup(sk, addr, family);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000992 if (!key)
993 return -ENOENT;
994 hlist_del_rcu(&key->node);
Eric Dumazet5f3d9cb2012-01-31 10:56:48 +0000995 atomic_sub(sizeof(*key), &sk->sk_omem_alloc);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000996 kfree_rcu(key, rcu);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000997 return 0;
998}
999EXPORT_SYMBOL(tcp_md5_do_del);
1000
stephen hemmingere0683e702012-10-26 14:31:40 +00001001static void tcp_clear_md5_list(struct sock *sk)
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001002{
1003 struct tcp_sock *tp = tcp_sk(sk);
1004 struct tcp_md5sig_key *key;
Sasha Levinb67bfe02013-02-27 17:06:00 -08001005 struct hlist_node *n;
Eric Dumazeta8afca02012-01-31 18:45:40 +00001006 struct tcp_md5sig_info *md5sig;
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001007
Eric Dumazeta8afca02012-01-31 18:45:40 +00001008 md5sig = rcu_dereference_protected(tp->md5sig_info, 1);
1009
Sasha Levinb67bfe02013-02-27 17:06:00 -08001010 hlist_for_each_entry_safe(key, n, &md5sig->head, node) {
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001011 hlist_del_rcu(&key->node);
Eric Dumazet5f3d9cb2012-01-31 10:56:48 +00001012 atomic_sub(sizeof(*key), &sk->sk_omem_alloc);
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001013 kfree_rcu(key, rcu);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001014 }
1015}
1016
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001017static int tcp_v4_parse_md5_keys(struct sock *sk, char __user *optval,
1018 int optlen)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001019{
1020 struct tcp_md5sig cmd;
1021 struct sockaddr_in *sin = (struct sockaddr_in *)&cmd.tcpm_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001022
1023 if (optlen < sizeof(cmd))
1024 return -EINVAL;
1025
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001026 if (copy_from_user(&cmd, optval, sizeof(cmd)))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001027 return -EFAULT;
1028
1029 if (sin->sin_family != AF_INET)
1030 return -EINVAL;
1031
Dmitry Popov64a124e2014-08-03 22:45:19 +04001032 if (!cmd.tcpm_keylen)
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001033 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin->sin_addr.s_addr,
1034 AF_INET);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001035
1036 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
1037 return -EINVAL;
1038
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001039 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin->sin_addr.s_addr,
1040 AF_INET, cmd.tcpm_key, cmd.tcpm_keylen,
1041 GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001042}
1043
Adam Langley49a72df2008-07-19 00:01:42 -07001044static int tcp_v4_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
1045 __be32 daddr, __be32 saddr, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001046{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001047 struct tcp4_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -07001048 struct scatterlist sg;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001049
1050 bp = &hp->md5_blk.ip4;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001051
1052 /*
Adam Langley49a72df2008-07-19 00:01:42 -07001053 * 1. the TCP pseudo-header (in the order: source IP address,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001054 * destination IP address, zero-padded protocol number, and
1055 * segment length)
1056 */
1057 bp->saddr = saddr;
1058 bp->daddr = daddr;
1059 bp->pad = 0;
YOSHIFUJI Hideaki076fb722008-04-17 12:48:12 +09001060 bp->protocol = IPPROTO_TCP;
Adam Langley49a72df2008-07-19 00:01:42 -07001061 bp->len = cpu_to_be16(nbytes);
David S. Millerc7da57a2007-10-26 00:41:21 -07001062
Adam Langley49a72df2008-07-19 00:01:42 -07001063 sg_init_one(&sg, bp, sizeof(*bp));
1064 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
1065}
1066
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001067static int tcp_v4_md5_hash_hdr(char *md5_hash, const struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -04001068 __be32 daddr, __be32 saddr, const struct tcphdr *th)
Adam Langley49a72df2008-07-19 00:01:42 -07001069{
1070 struct tcp_md5sig_pool *hp;
1071 struct hash_desc *desc;
1072
1073 hp = tcp_get_md5sig_pool();
1074 if (!hp)
1075 goto clear_hash_noput;
1076 desc = &hp->md5_desc;
1077
1078 if (crypto_hash_init(desc))
1079 goto clear_hash;
1080 if (tcp_v4_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
1081 goto clear_hash;
1082 if (tcp_md5_hash_header(hp, th))
1083 goto clear_hash;
1084 if (tcp_md5_hash_key(hp, key))
1085 goto clear_hash;
1086 if (crypto_hash_final(desc, md5_hash))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001087 goto clear_hash;
1088
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001089 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001090 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -07001091
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001092clear_hash:
1093 tcp_put_md5sig_pool();
1094clear_hash_noput:
1095 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -07001096 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001097}
1098
Adam Langley49a72df2008-07-19 00:01:42 -07001099int tcp_v4_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -04001100 const struct sock *sk, const struct request_sock *req,
1101 const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001102{
Adam Langley49a72df2008-07-19 00:01:42 -07001103 struct tcp_md5sig_pool *hp;
1104 struct hash_desc *desc;
Eric Dumazet318cf7a2011-10-24 02:46:04 -04001105 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001106 __be32 saddr, daddr;
1107
1108 if (sk) {
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001109 saddr = inet_sk(sk)->inet_saddr;
1110 daddr = inet_sk(sk)->inet_daddr;
Adam Langley49a72df2008-07-19 00:01:42 -07001111 } else if (req) {
Eric Dumazet634fb9792013-10-09 15:21:29 -07001112 saddr = inet_rsk(req)->ir_loc_addr;
1113 daddr = inet_rsk(req)->ir_rmt_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001114 } else {
Adam Langley49a72df2008-07-19 00:01:42 -07001115 const struct iphdr *iph = ip_hdr(skb);
1116 saddr = iph->saddr;
1117 daddr = iph->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001118 }
Adam Langley49a72df2008-07-19 00:01:42 -07001119
1120 hp = tcp_get_md5sig_pool();
1121 if (!hp)
1122 goto clear_hash_noput;
1123 desc = &hp->md5_desc;
1124
1125 if (crypto_hash_init(desc))
1126 goto clear_hash;
1127
1128 if (tcp_v4_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
1129 goto clear_hash;
1130 if (tcp_md5_hash_header(hp, th))
1131 goto clear_hash;
1132 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
1133 goto clear_hash;
1134 if (tcp_md5_hash_key(hp, key))
1135 goto clear_hash;
1136 if (crypto_hash_final(desc, md5_hash))
1137 goto clear_hash;
1138
1139 tcp_put_md5sig_pool();
1140 return 0;
1141
1142clear_hash:
1143 tcp_put_md5sig_pool();
1144clear_hash_noput:
1145 memset(md5_hash, 0, 16);
1146 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001147}
Adam Langley49a72df2008-07-19 00:01:42 -07001148EXPORT_SYMBOL(tcp_v4_md5_hash_skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001149
Dmitry Popov9ea88a12014-08-07 02:38:22 +04001150static bool __tcp_v4_inbound_md5_hash(struct sock *sk,
1151 const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001152{
1153 /*
1154 * This gets called for each TCP segment that arrives
1155 * so we want to be efficient.
1156 * We have 3 drop cases:
1157 * o No MD5 hash and one expected.
1158 * o MD5 hash and we're not expecting one.
1159 * o MD5 hash and its wrong.
1160 */
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001161 const __u8 *hash_location = NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001162 struct tcp_md5sig_key *hash_expected;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001163 const struct iphdr *iph = ip_hdr(skb);
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001164 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001165 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001166 unsigned char newhash[16];
1167
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001168 hash_expected = tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&iph->saddr,
1169 AF_INET);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +09001170 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001171
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001172 /* We've parsed the options - do we have a hash? */
1173 if (!hash_expected && !hash_location)
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001174 return false;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001175
1176 if (hash_expected && !hash_location) {
David S. Miller785957d2008-07-30 03:03:15 -07001177 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001178 return true;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001179 }
1180
1181 if (!hash_expected && hash_location) {
David S. Miller785957d2008-07-30 03:03:15 -07001182 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001183 return true;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001184 }
1185
1186 /* Okay, so this is hash_expected and hash_location -
1187 * so we need to calculate the checksum.
1188 */
Adam Langley49a72df2008-07-19 00:01:42 -07001189 genhash = tcp_v4_md5_hash_skb(newhash,
1190 hash_expected,
1191 NULL, NULL, skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001192
1193 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
Joe Perchese87cc472012-05-13 21:56:26 +00001194 net_info_ratelimited("MD5 Hash failed for (%pI4, %d)->(%pI4, %d)%s\n",
1195 &iph->saddr, ntohs(th->source),
1196 &iph->daddr, ntohs(th->dest),
1197 genhash ? " tcp_v4_calc_md5_hash failed"
1198 : "");
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001199 return true;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001200 }
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001201 return false;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001202}
1203
Dmitry Popov9ea88a12014-08-07 02:38:22 +04001204static bool tcp_v4_inbound_md5_hash(struct sock *sk, const struct sk_buff *skb)
1205{
1206 bool ret;
1207
1208 rcu_read_lock();
1209 ret = __tcp_v4_inbound_md5_hash(sk, skb);
1210 rcu_read_unlock();
1211
1212 return ret;
1213}
1214
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001215#endif
1216
Octavian Purdila16bea702014-06-25 17:09:53 +03001217static void tcp_v4_init_req(struct request_sock *req, struct sock *sk,
1218 struct sk_buff *skb)
1219{
1220 struct inet_request_sock *ireq = inet_rsk(req);
1221
1222 ireq->ir_loc_addr = ip_hdr(skb)->daddr;
1223 ireq->ir_rmt_addr = ip_hdr(skb)->saddr;
1224 ireq->no_srccheck = inet_sk(sk)->transparent;
1225 ireq->opt = tcp_v4_save_options(skb);
1226}
1227
Octavian Purdilad94e0412014-06-25 17:09:55 +03001228static struct dst_entry *tcp_v4_route_req(struct sock *sk, struct flowi *fl,
1229 const struct request_sock *req,
1230 bool *strict)
1231{
1232 struct dst_entry *dst = inet_csk_route_req(sk, &fl->u.ip4, req);
1233
1234 if (strict) {
1235 if (fl->u.ip4.daddr == inet_rsk(req)->ir_rmt_addr)
1236 *strict = true;
1237 else
1238 *strict = false;
1239 }
1240
1241 return dst;
1242}
1243
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001244struct request_sock_ops tcp_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 .family = PF_INET,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001246 .obj_size = sizeof(struct tcp_request_sock),
Octavian Purdila5db92c92014-06-25 17:09:59 +03001247 .rtx_syn_ack = tcp_rtx_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001248 .send_ack = tcp_v4_reqsk_send_ack,
1249 .destructor = tcp_v4_reqsk_destructor,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 .send_reset = tcp_v4_send_reset,
stephen hemminger688d1942014-08-29 23:32:05 -07001251 .syn_ack_timeout = tcp_syn_ack_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252};
1253
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001254static const struct tcp_request_sock_ops tcp_request_sock_ipv4_ops = {
Octavian Purdila2aec4a22014-06-25 17:10:00 +03001255 .mss_clamp = TCP_MSS_DEFAULT,
Octavian Purdila16bea702014-06-25 17:09:53 +03001256#ifdef CONFIG_TCP_MD5SIG
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001257 .md5_lookup = tcp_v4_reqsk_md5_lookup,
John Dykstrae3afe7b2009-07-16 05:04:51 +00001258 .calc_md5_hash = tcp_v4_md5_hash_skb,
Andrew Mortonb6332e62006-11-30 19:16:28 -08001259#endif
Octavian Purdila16bea702014-06-25 17:09:53 +03001260 .init_req = tcp_v4_init_req,
Octavian Purdilafb7b37a2014-06-25 17:09:54 +03001261#ifdef CONFIG_SYN_COOKIES
1262 .cookie_init_seq = cookie_v4_init_sequence,
1263#endif
Octavian Purdilad94e0412014-06-25 17:09:55 +03001264 .route_req = tcp_v4_route_req,
Octavian Purdila936b8bd2014-06-25 17:09:57 +03001265 .init_seq = tcp_v4_init_sequence,
Octavian Purdilad6274bd2014-06-25 17:09:58 +03001266 .send_synack = tcp_v4_send_synack,
Octavian Purdila695da142014-06-25 17:10:01 +03001267 .queue_hash_add = inet_csk_reqsk_queue_hash_add,
Octavian Purdila16bea702014-06-25 17:09:53 +03001268};
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001269
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1271{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 /* Never answer to SYNs send to broadcast or multicast */
Eric Dumazet511c3f92009-06-02 05:14:27 +00001273 if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274 goto drop;
1275
Octavian Purdila1fb6f152014-06-25 17:10:02 +03001276 return tcp_conn_request(&tcp_request_sock_ops,
1277 &tcp_request_sock_ipv4_ops, sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279drop:
Vijay Subramanian848bf152013-01-31 08:24:06 +00001280 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 return 0;
1282}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001283EXPORT_SYMBOL(tcp_v4_conn_request);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284
1285
1286/*
1287 * The three way handshake has completed - we got a valid synack -
1288 * now create the new socket.
1289 */
1290struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001291 struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 struct dst_entry *dst)
1293{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001294 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 struct inet_sock *newinet;
1296 struct tcp_sock *newtp;
1297 struct sock *newsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001298#ifdef CONFIG_TCP_MD5SIG
1299 struct tcp_md5sig_key *key;
1300#endif
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001301 struct ip_options_rcu *inet_opt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302
1303 if (sk_acceptq_is_full(sk))
1304 goto exit_overflow;
1305
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 newsk = tcp_create_openreq_child(sk, req, skb);
1307 if (!newsk)
Balazs Scheidler093d2822010-10-21 13:06:43 +02001308 goto exit_nonewsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309
Herbert Xubcd76112006-06-30 13:36:35 -07001310 newsk->sk_gso_type = SKB_GSO_TCPV4;
Neal Cardwellfae6ef82012-08-19 03:30:38 +00001311 inet_sk_rx_dst_set(newsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312
1313 newtp = tcp_sk(newsk);
1314 newinet = inet_sk(newsk);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001315 ireq = inet_rsk(req);
Eric Dumazet634fb9792013-10-09 15:21:29 -07001316 newinet->inet_daddr = ireq->ir_rmt_addr;
1317 newinet->inet_rcv_saddr = ireq->ir_loc_addr;
1318 newinet->inet_saddr = ireq->ir_loc_addr;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001319 inet_opt = ireq->opt;
1320 rcu_assign_pointer(newinet->inet_opt, inet_opt);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001321 ireq->opt = NULL;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001322 newinet->mc_index = inet_iif(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001323 newinet->mc_ttl = ip_hdr(skb)->ttl;
Jiri Benc4c507d22012-02-09 09:35:49 +00001324 newinet->rcv_tos = ip_hdr(skb)->tos;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001325 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Tom Herbertb73c3d02014-07-01 21:32:17 -07001326 inet_set_txhash(newsk);
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001327 if (inet_opt)
1328 inet_csk(newsk)->icsk_ext_hdr_len = inet_opt->opt.optlen;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001329 newinet->inet_id = newtp->write_seq ^ jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330
Eric Dumazetdfd25ff2012-03-10 09:20:21 +00001331 if (!dst) {
1332 dst = inet_csk_route_child_sock(sk, newsk, req);
1333 if (!dst)
1334 goto put_and_exit;
1335 } else {
1336 /* syncookie case : see end of cookie_v4_check() */
1337 }
David S. Miller0e734412011-05-08 15:28:03 -07001338 sk_setup_caps(newsk, dst);
1339
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340 tcp_sync_mss(newsk, dst_mtu(dst));
David S. Miller0dbaee32010-12-13 12:52:14 -08001341 newtp->advmss = dst_metric_advmss(dst);
Tom Quetchenbachf5fff5d2008-09-21 00:21:51 -07001342 if (tcp_sk(sk)->rx_opt.user_mss &&
1343 tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1344 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1345
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 tcp_initialize_rcv_mss(newsk);
1347
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001348#ifdef CONFIG_TCP_MD5SIG
1349 /* Copy over the MD5 key from the original socket */
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001350 key = tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&newinet->inet_daddr,
1351 AF_INET);
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001352 if (key != NULL) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001353 /*
1354 * We're using one, so create a matching key
1355 * on the newsk structure. If we fail to get
1356 * memory, then we end up not copying the key
1357 * across. Shucks.
1358 */
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001359 tcp_md5_do_add(newsk, (union tcp_md5_addr *)&newinet->inet_daddr,
1360 AF_INET, key->key, key->keylen, GFP_ATOMIC);
Eric Dumazeta4654192010-05-16 00:36:33 -07001361 sk_nocaps_add(newsk, NETIF_F_GSO_MASK);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001362 }
1363#endif
1364
David S. Miller0e734412011-05-08 15:28:03 -07001365 if (__inet_inherit_port(sk, newsk) < 0)
1366 goto put_and_exit;
Eric Dumazet9327f702009-12-04 03:46:54 +00001367 __inet_hash_nolisten(newsk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368
1369 return newsk;
1370
1371exit_overflow:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001372 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001373exit_nonewsk:
1374 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375exit:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001376 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 return NULL;
David S. Miller0e734412011-05-08 15:28:03 -07001378put_and_exit:
Christoph Paasche337e242012-12-14 04:07:58 +00001379 inet_csk_prepare_forced_close(newsk);
1380 tcp_done(newsk);
David S. Miller0e734412011-05-08 15:28:03 -07001381 goto exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001383EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384
1385static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
1386{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001387 struct tcphdr *th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001388 const struct iphdr *iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 struct sock *nsk;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001390 struct request_sock **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391 /* Find possible connection requests. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001392 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
1393 iph->saddr, iph->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 if (req)
Jerry Chu83368862012-08-31 12:29:12 +00001395 return tcp_check_req(sk, skb, req, prev, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001397 nsk = inet_lookup_established(sock_net(sk), &tcp_hashinfo, iph->saddr,
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001398 th->source, iph->daddr, th->dest, inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399
1400 if (nsk) {
1401 if (nsk->sk_state != TCP_TIME_WAIT) {
1402 bh_lock_sock(nsk);
1403 return nsk;
1404 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001405 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 return NULL;
1407 }
1408
1409#ifdef CONFIG_SYN_COOKIES
Florian Westphalaf9b4732010-06-03 00:43:44 +00001410 if (!th->syn)
Cong Wang461b74c2014-10-15 14:33:22 -07001411 sk = cookie_v4_check(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412#endif
1413 return sk;
1414}
1415
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416/* The socket must have it's spinlock held when we get
1417 * here.
1418 *
1419 * We have a potential double-lock case here, so even when
1420 * doing backlog processing we use the BH locking scheme.
1421 * This is because we cannot sleep with the original spinlock
1422 * held.
1423 */
1424int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1425{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001426 struct sock *rsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001427
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
Eric Dumazet404e0a82012-07-29 23:20:37 +00001429 struct dst_entry *dst = sk->sk_rx_dst;
1430
Tom Herbertbdeab992011-08-14 19:45:55 +00001431 sock_rps_save_rxhash(sk, skb);
Eric Dumazet404e0a82012-07-29 23:20:37 +00001432 if (dst) {
Eric Dumazet505fbcf2012-07-27 06:23:40 +00001433 if (inet_sk(sk)->rx_dst_ifindex != skb->skb_iif ||
1434 dst->ops->check(dst, 0) == NULL) {
David S. Miller92101b32012-07-23 16:29:00 -07001435 dst_release(dst);
1436 sk->sk_rx_dst = NULL;
1437 }
1438 }
Vijay Subramanianc995ae22013-09-03 12:23:22 -07001439 tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440 return 0;
1441 }
1442
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07001443 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 goto csum_err;
1445
1446 if (sk->sk_state == TCP_LISTEN) {
1447 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
1448 if (!nsk)
1449 goto discard;
1450
1451 if (nsk != sk) {
Tom Herbertbdeab992011-08-14 19:45:55 +00001452 sock_rps_save_rxhash(nsk, skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001453 if (tcp_child_process(sk, nsk, skb)) {
1454 rsk = nsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001456 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 return 0;
1458 }
Eric Dumazetca551582010-06-03 09:03:58 +00001459 } else
Tom Herbertbdeab992011-08-14 19:45:55 +00001460 sock_rps_save_rxhash(sk, skb);
Eric Dumazetca551582010-06-03 09:03:58 +00001461
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001462 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001463 rsk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001465 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466 return 0;
1467
1468reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001469 tcp_v4_send_reset(rsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470discard:
1471 kfree_skb(skb);
1472 /* Be careful here. If this function gets more complicated and
1473 * gcc suffers from register pressure on the x86, sk (in %ebx)
1474 * might be destroyed here. This current version compiles correctly,
1475 * but you have been warned.
1476 */
1477 return 0;
1478
1479csum_err:
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001480 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_CSUMERRORS);
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001481 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482 goto discard;
1483}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001484EXPORT_SYMBOL(tcp_v4_do_rcv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485
David S. Miller160eb5a2012-06-27 22:01:22 -07001486void tcp_v4_early_demux(struct sk_buff *skb)
David S. Miller41063e92012-06-19 21:22:05 -07001487{
David S. Miller41063e92012-06-19 21:22:05 -07001488 const struct iphdr *iph;
1489 const struct tcphdr *th;
1490 struct sock *sk;
David S. Miller41063e92012-06-19 21:22:05 -07001491
David S. Miller41063e92012-06-19 21:22:05 -07001492 if (skb->pkt_type != PACKET_HOST)
David S. Miller160eb5a2012-06-27 22:01:22 -07001493 return;
David S. Miller41063e92012-06-19 21:22:05 -07001494
Eric Dumazet45f00f92012-10-22 21:42:47 +00001495 if (!pskb_may_pull(skb, skb_transport_offset(skb) + sizeof(struct tcphdr)))
David S. Miller160eb5a2012-06-27 22:01:22 -07001496 return;
David S. Miller41063e92012-06-19 21:22:05 -07001497
1498 iph = ip_hdr(skb);
Eric Dumazet45f00f92012-10-22 21:42:47 +00001499 th = tcp_hdr(skb);
David S. Miller41063e92012-06-19 21:22:05 -07001500
1501 if (th->doff < sizeof(struct tcphdr) / 4)
David S. Miller160eb5a2012-06-27 22:01:22 -07001502 return;
David S. Miller41063e92012-06-19 21:22:05 -07001503
Eric Dumazet45f00f92012-10-22 21:42:47 +00001504 sk = __inet_lookup_established(dev_net(skb->dev), &tcp_hashinfo,
David S. Miller41063e92012-06-19 21:22:05 -07001505 iph->saddr, th->source,
Vijay Subramanian7011d082012-06-23 17:38:10 +00001506 iph->daddr, ntohs(th->dest),
Eric Dumazet9cb429d2012-07-24 01:19:31 +00001507 skb->skb_iif);
David S. Miller41063e92012-06-19 21:22:05 -07001508 if (sk) {
1509 skb->sk = sk;
1510 skb->destructor = sock_edemux;
1511 if (sk->sk_state != TCP_TIME_WAIT) {
1512 struct dst_entry *dst = sk->sk_rx_dst;
Eric Dumazet505fbcf2012-07-27 06:23:40 +00001513
David S. Miller41063e92012-06-19 21:22:05 -07001514 if (dst)
1515 dst = dst_check(dst, 0);
David S. Miller92101b32012-07-23 16:29:00 -07001516 if (dst &&
Eric Dumazet505fbcf2012-07-27 06:23:40 +00001517 inet_sk(sk)->rx_dst_ifindex == skb->skb_iif)
David S. Miller92101b32012-07-23 16:29:00 -07001518 skb_dst_set_noref(skb, dst);
David S. Miller41063e92012-06-19 21:22:05 -07001519 }
1520 }
David S. Miller41063e92012-06-19 21:22:05 -07001521}
1522
Eric Dumazetb2fb4f52013-03-06 12:58:01 +00001523/* Packet is added to VJ-style prequeue for processing in process
1524 * context, if a reader task is waiting. Apparently, this exciting
1525 * idea (VJ's mail "Re: query about TCP header on tcp-ip" of 07 Sep 93)
1526 * failed somewhere. Latency? Burstiness? Well, at least now we will
1527 * see, why it failed. 8)8) --ANK
1528 *
1529 */
1530bool tcp_prequeue(struct sock *sk, struct sk_buff *skb)
1531{
1532 struct tcp_sock *tp = tcp_sk(sk);
1533
1534 if (sysctl_tcp_low_latency || !tp->ucopy.task)
1535 return false;
1536
1537 if (skb->len <= tcp_hdrlen(skb) &&
1538 skb_queue_len(&tp->ucopy.prequeue) == 0)
1539 return false;
1540
Eric Dumazetca777ef2014-09-08 08:06:07 -07001541 /* Before escaping RCU protected region, we need to take care of skb
1542 * dst. Prequeue is only enabled for established sockets.
1543 * For such sockets, we might need the skb dst only to set sk->sk_rx_dst
1544 * Instead of doing full sk_rx_dst validity here, let's perform
1545 * an optimistic check.
1546 */
1547 if (likely(sk->sk_rx_dst))
1548 skb_dst_drop(skb);
1549 else
1550 skb_dst_force(skb);
1551
Eric Dumazetb2fb4f52013-03-06 12:58:01 +00001552 __skb_queue_tail(&tp->ucopy.prequeue, skb);
1553 tp->ucopy.memory += skb->truesize;
1554 if (tp->ucopy.memory > sk->sk_rcvbuf) {
1555 struct sk_buff *skb1;
1556
1557 BUG_ON(sock_owned_by_user(sk));
1558
1559 while ((skb1 = __skb_dequeue(&tp->ucopy.prequeue)) != NULL) {
1560 sk_backlog_rcv(sk, skb1);
1561 NET_INC_STATS_BH(sock_net(sk),
1562 LINUX_MIB_TCPPREQUEUEDROPPED);
1563 }
1564
1565 tp->ucopy.memory = 0;
1566 } else if (skb_queue_len(&tp->ucopy.prequeue) == 1) {
1567 wake_up_interruptible_sync_poll(sk_sleep(sk),
1568 POLLIN | POLLRDNORM | POLLRDBAND);
1569 if (!inet_csk_ack_scheduled(sk))
1570 inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
1571 (3 * tcp_rto_min(sk)) / 4,
1572 TCP_RTO_MAX);
1573 }
1574 return true;
1575}
1576EXPORT_SYMBOL(tcp_prequeue);
1577
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578/*
1579 * From tcp_input.c
1580 */
1581
1582int tcp_v4_rcv(struct sk_buff *skb)
1583{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001584 const struct iphdr *iph;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001585 const struct tcphdr *th;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 struct sock *sk;
1587 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001588 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589
1590 if (skb->pkt_type != PACKET_HOST)
1591 goto discard_it;
1592
1593 /* Count it even if it's bad */
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001594 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595
1596 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1597 goto discard_it;
1598
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001599 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600
1601 if (th->doff < sizeof(struct tcphdr) / 4)
1602 goto bad_packet;
1603 if (!pskb_may_pull(skb, th->doff * 4))
1604 goto discard_it;
1605
1606 /* An explanation is required here, I think.
1607 * Packet length and doff are validated by header prediction,
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -08001608 * provided case of th->doff==0 is eliminated.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609 * So, we defer the checks. */
Tom Herberted70fcf2014-05-02 16:29:38 -07001610
1611 if (skb_checksum_init(skb, IPPROTO_TCP, inet_compute_pseudo))
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001612 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001614 th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001615 iph = ip_hdr(skb);
Eric Dumazet971f10e2014-09-27 09:50:57 -07001616 /* This is tricky : We move IPCB at its correct location into TCP_SKB_CB()
1617 * barrier() makes sure compiler wont play fool^Waliasing games.
1618 */
1619 memmove(&TCP_SKB_CB(skb)->header.h4, IPCB(skb),
1620 sizeof(struct inet_skb_parm));
1621 barrier();
1622
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1624 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1625 skb->len - th->doff * 4);
1626 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
Eric Dumazete11ecdd2014-09-15 04:19:51 -07001627 TCP_SKB_CB(skb)->tcp_flags = tcp_flag_byte(th);
Eric Dumazet04317da2014-09-05 15:33:32 -07001628 TCP_SKB_CB(skb)->tcp_tw_isn = 0;
Eric Dumazetb82d1bb2011-09-27 02:20:08 -04001629 TCP_SKB_CB(skb)->ip_dsfield = ipv4_get_dsfield(iph);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630 TCP_SKB_CB(skb)->sacked = 0;
1631
Arnaldo Carvalho de Melo9a1f27c2008-10-07 11:41:57 -07001632 sk = __inet_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 if (!sk)
1634 goto no_tcp_socket;
1635
Eric Dumazetbb134d52010-03-09 05:55:56 +00001636process:
1637 if (sk->sk_state == TCP_TIME_WAIT)
1638 goto do_time_wait;
1639
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001640 if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
1641 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
Stephen Hemmingerd218d112010-01-11 16:28:01 -08001642 goto discard_and_relse;
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001643 }
Stephen Hemmingerd218d112010-01-11 16:28:01 -08001644
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1646 goto discard_and_relse;
Dmitry Popov9ea88a12014-08-07 02:38:22 +04001647
1648#ifdef CONFIG_TCP_MD5SIG
1649 /*
1650 * We really want to reject the packet as early as possible
1651 * if:
1652 * o We're expecting an MD5'd packet and this is no MD5 tcp option
1653 * o There is an MD5 option and we're not expecting one
1654 */
1655 if (tcp_v4_inbound_md5_hash(sk, skb))
1656 goto discard_and_relse;
1657#endif
1658
Patrick McHardyb59c2702006-01-06 23:06:10 -08001659 nf_reset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001661 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662 goto discard_and_relse;
1663
Eliezer Tamir8b80cda2013-07-10 17:13:26 +03001664 sk_mark_napi_id(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665 skb->dev = NULL;
1666
Ingo Molnarc6366182006-07-03 00:25:13 -07001667 bh_lock_sock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 ret = 0;
1669 if (!sock_owned_by_user(sk)) {
Dan Williams7bced392013-12-30 12:37:29 -08001670 if (!tcp_prequeue(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671 ret = tcp_v4_do_rcv(sk, skb);
Eric Dumazetda882c12012-04-22 23:38:54 +00001672 } else if (unlikely(sk_add_backlog(sk, skb,
1673 sk->sk_rcvbuf + sk->sk_sndbuf))) {
Zhu Yi6b03a532010-03-04 18:01:41 +00001674 bh_unlock_sock(sk);
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001675 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
Zhu Yi6b03a532010-03-04 18:01:41 +00001676 goto discard_and_relse;
1677 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678 bh_unlock_sock(sk);
1679
1680 sock_put(sk);
1681
1682 return ret;
1683
1684no_tcp_socket:
1685 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1686 goto discard_it;
1687
1688 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001689csum_error:
1690 TCP_INC_STATS_BH(net, TCP_MIB_CSUMERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691bad_packet:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001692 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001694 tcp_v4_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 }
1696
1697discard_it:
1698 /* Discard frame. */
1699 kfree_skb(skb);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001700 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701
1702discard_and_relse:
1703 sock_put(sk);
1704 goto discard_it;
1705
1706do_time_wait:
1707 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001708 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709 goto discard_it;
1710 }
1711
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001712 if (skb->len < (th->doff << 2)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001713 inet_twsk_put(inet_twsk(sk));
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001714 goto bad_packet;
1715 }
1716 if (tcp_checksum_complete(skb)) {
1717 inet_twsk_put(inet_twsk(sk));
1718 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001720 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721 case TCP_TW_SYN: {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001722 struct sock *sk2 = inet_lookup_listener(dev_net(skb->dev),
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001723 &tcp_hashinfo,
Tom Herbertda5e3632013-01-22 09:50:24 +00001724 iph->saddr, th->source,
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001725 iph->daddr, th->dest,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001726 inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727 if (sk2) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001728 inet_twsk_deschedule(inet_twsk(sk), &tcp_death_row);
1729 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730 sk = sk2;
1731 goto process;
1732 }
1733 /* Fall through to ACK */
1734 }
1735 case TCP_TW_ACK:
1736 tcp_v4_timewait_ack(sk, skb);
1737 break;
1738 case TCP_TW_RST:
1739 goto no_tcp_socket;
1740 case TCP_TW_SUCCESS:;
1741 }
1742 goto discard_it;
1743}
1744
David S. Millerccb7c412010-12-01 18:09:13 -08001745static struct timewait_sock_ops tcp_timewait_sock_ops = {
1746 .twsk_obj_size = sizeof(struct tcp_timewait_sock),
1747 .twsk_unique = tcp_twsk_unique,
1748 .twsk_destructor= tcp_twsk_destructor,
David S. Millerccb7c412010-12-01 18:09:13 -08001749};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750
Eric Dumazet63d02d12012-08-09 14:11:00 +00001751void inet_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb)
Eric Dumazet5d299f32012-08-06 05:09:33 +00001752{
1753 struct dst_entry *dst = skb_dst(skb);
1754
Eric Dumazetca777ef2014-09-08 08:06:07 -07001755 if (dst) {
1756 dst_hold(dst);
1757 sk->sk_rx_dst = dst;
1758 inet_sk(sk)->rx_dst_ifindex = skb->skb_iif;
1759 }
Eric Dumazet5d299f32012-08-06 05:09:33 +00001760}
Eric Dumazet63d02d12012-08-09 14:11:00 +00001761EXPORT_SYMBOL(inet_sk_rx_dst_set);
Eric Dumazet5d299f32012-08-06 05:09:33 +00001762
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001763const struct inet_connection_sock_af_ops ipv4_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001764 .queue_xmit = ip_queue_xmit,
1765 .send_check = tcp_v4_send_check,
1766 .rebuild_header = inet_sk_rebuild_header,
Eric Dumazet5d299f32012-08-06 05:09:33 +00001767 .sk_rx_dst_set = inet_sk_rx_dst_set,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001768 .conn_request = tcp_v4_conn_request,
1769 .syn_recv_sock = tcp_v4_syn_recv_sock,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001770 .net_header_len = sizeof(struct iphdr),
1771 .setsockopt = ip_setsockopt,
1772 .getsockopt = ip_getsockopt,
1773 .addr2sockaddr = inet_csk_addr2sockaddr,
1774 .sockaddr_len = sizeof(struct sockaddr_in),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001775 .bind_conflict = inet_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001776#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001777 .compat_setsockopt = compat_ip_setsockopt,
1778 .compat_getsockopt = compat_ip_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001779#endif
Neal Cardwell4fab9072014-08-14 12:40:05 -04001780 .mtu_reduced = tcp_v4_mtu_reduced,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781};
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001782EXPORT_SYMBOL(ipv4_specific);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001784#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001785static const struct tcp_sock_af_ops tcp_sock_ipv4_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001786 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001787 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001788 .md5_parse = tcp_v4_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001789};
Andrew Mortonb6332e62006-11-30 19:16:28 -08001790#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001791
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792/* NOTE: A lot of things set to zero explicitly by call to
1793 * sk_alloc() so need not be done here.
1794 */
1795static int tcp_v4_init_sock(struct sock *sk)
1796{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001797 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798
Neal Cardwell900f65d2012-04-19 09:55:21 +00001799 tcp_init_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001801 icsk->icsk_af_ops = &ipv4_specific;
Neal Cardwell900f65d2012-04-19 09:55:21 +00001802
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001803#ifdef CONFIG_TCP_MD5SIG
David S. Millerac807fa2012-04-23 03:21:58 -04001804 tcp_sk(sk)->af_specific = &tcp_sock_ipv4_specific;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001805#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807 return 0;
1808}
1809
Brian Haley7d06b2e2008-06-14 17:04:49 -07001810void tcp_v4_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811{
1812 struct tcp_sock *tp = tcp_sk(sk);
1813
1814 tcp_clear_xmit_timers(sk);
1815
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001816 tcp_cleanup_congestion_control(sk);
Stephen Hemminger317a76f2005-06-23 12:19:55 -07001817
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818 /* Cleanup up the write buffer. */
David S. Millerfe067e82007-03-07 12:12:44 -08001819 tcp_write_queue_purge(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820
1821 /* Cleans up our, hopefully empty, out_of_order_queue. */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001822 __skb_queue_purge(&tp->out_of_order_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001824#ifdef CONFIG_TCP_MD5SIG
1825 /* Clean up the MD5 key list, if any */
1826 if (tp->md5sig_info) {
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001827 tcp_clear_md5_list(sk);
Eric Dumazeta8afca02012-01-31 18:45:40 +00001828 kfree_rcu(tp->md5sig_info, rcu);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001829 tp->md5sig_info = NULL;
1830 }
1831#endif
1832
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833 /* Clean prequeue, it must be empty really */
1834 __skb_queue_purge(&tp->ucopy.prequeue);
1835
1836 /* Clean up a referenced TCP bind bucket. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001837 if (inet_csk(sk)->icsk_bind_hash)
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001838 inet_put_port(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839
Jerry Chu168a8f52012-08-31 12:29:13 +00001840 BUG_ON(tp->fastopen_rsk != NULL);
William Allen Simpson435cf552009-12-02 18:17:05 +00001841
Yuchung Chengcf60af02012-07-19 06:43:09 +00001842 /* If socket is aborted during connect operation */
1843 tcp_free_fastopen_req(tp);
1844
Glauber Costa180d8cd2011-12-11 21:47:02 +00001845 sk_sockets_allocated_dec(sk);
Glauber Costad1a4c0b2011-12-11 21:47:04 +00001846 sock_release_memcg(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001848EXPORT_SYMBOL(tcp_v4_destroy_sock);
1849
1850#ifdef CONFIG_PROC_FS
1851/* Proc filesystem TCP sock list dumping. */
1852
Tom Herberta8b690f2010-06-07 00:43:42 -07001853/*
1854 * Get next listener socket follow cur. If cur is NULL, get first socket
1855 * starting from bucket given in st->bucket; when st->bucket is zero the
1856 * very first socket in the hash table is returned.
1857 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858static void *listening_get_next(struct seq_file *seq, void *cur)
1859{
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001860 struct inet_connection_sock *icsk;
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08001861 struct hlist_nulls_node *node;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 struct sock *sk = cur;
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001863 struct inet_listen_hashbucket *ilb;
Jianjun Kong5799de02008-11-03 02:49:10 -08001864 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07001865 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866
1867 if (!sk) {
Tom Herberta8b690f2010-06-07 00:43:42 -07001868 ilb = &tcp_hashinfo.listening_hash[st->bucket];
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001869 spin_lock_bh(&ilb->lock);
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08001870 sk = sk_nulls_head(&ilb->head);
Tom Herberta8b690f2010-06-07 00:43:42 -07001871 st->offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872 goto get_sk;
1873 }
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001874 ilb = &tcp_hashinfo.listening_hash[st->bucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875 ++st->num;
Tom Herberta8b690f2010-06-07 00:43:42 -07001876 ++st->offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877
1878 if (st->state == TCP_SEQ_STATE_OPENREQ) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001879 struct request_sock *req = cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001881 icsk = inet_csk(st->syn_wait_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882 req = req->dl_next;
1883 while (1) {
1884 while (req) {
Daniel Lezcanobdccc4c2008-07-19 00:15:13 -07001885 if (req->rsk_ops->family == st->family) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001886 cur = req;
1887 goto out;
1888 }
1889 req = req->dl_next;
1890 }
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001891 if (++st->sbucket >= icsk->icsk_accept_queue.listen_opt->nr_table_entries)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892 break;
1893get_req:
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001894 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895 }
Eric Dumazet1bde5ac2010-12-23 09:32:46 -08001896 sk = sk_nulls_next(st->syn_wait_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897 st->state = TCP_SEQ_STATE_LISTENING;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001898 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899 } else {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001900 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001901 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1902 if (reqsk_queue_len(&icsk->icsk_accept_queue))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903 goto start_req;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001904 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Eric Dumazet1bde5ac2010-12-23 09:32:46 -08001905 sk = sk_nulls_next(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906 }
1907get_sk:
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08001908 sk_nulls_for_each_from(sk, node) {
Pavel Emelyanov8475ef92010-11-22 03:26:12 +00001909 if (!net_eq(sock_net(sk), net))
1910 continue;
1911 if (sk->sk_family == st->family) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 cur = sk;
1913 goto out;
1914 }
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 -07001918start_req:
1919 st->uid = sock_i_uid(sk);
1920 st->syn_wait_sk = sk;
1921 st->state = TCP_SEQ_STATE_OPENREQ;
1922 st->sbucket = 0;
1923 goto get_req;
1924 }
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001925 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 }
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001927 spin_unlock_bh(&ilb->lock);
Tom Herberta8b690f2010-06-07 00:43:42 -07001928 st->offset = 0;
Arnaldo Carvalho de Melo0f7ff922005-08-09 19:59:44 -07001929 if (++st->bucket < INET_LHTABLE_SIZE) {
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001930 ilb = &tcp_hashinfo.listening_hash[st->bucket];
1931 spin_lock_bh(&ilb->lock);
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08001932 sk = sk_nulls_head(&ilb->head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933 goto get_sk;
1934 }
1935 cur = NULL;
1936out:
1937 return cur;
1938}
1939
1940static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
1941{
Tom Herberta8b690f2010-06-07 00:43:42 -07001942 struct tcp_iter_state *st = seq->private;
1943 void *rc;
1944
1945 st->bucket = 0;
1946 st->offset = 0;
1947 rc = listening_get_next(seq, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948
1949 while (rc && *pos) {
1950 rc = listening_get_next(seq, rc);
1951 --*pos;
1952 }
1953 return rc;
1954}
1955
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07001956static inline bool empty_bucket(const struct tcp_iter_state *st)
Andi Kleen6eac5602008-08-28 01:08:02 -07001957{
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07001958 return hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].chain);
Andi Kleen6eac5602008-08-28 01:08:02 -07001959}
1960
Tom Herberta8b690f2010-06-07 00:43:42 -07001961/*
1962 * Get first established socket starting from bucket given in st->bucket.
1963 * If st->bucket is zero, the very first socket in the hash is returned.
1964 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965static void *established_get_first(struct seq_file *seq)
1966{
Jianjun Kong5799de02008-11-03 02:49:10 -08001967 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07001968 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969 void *rc = NULL;
1970
Tom Herberta8b690f2010-06-07 00:43:42 -07001971 st->offset = 0;
1972 for (; st->bucket <= tcp_hashinfo.ehash_mask; ++st->bucket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973 struct sock *sk;
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001974 struct hlist_nulls_node *node;
Eric Dumazet9db66bd2008-11-20 20:39:09 -08001975 spinlock_t *lock = inet_ehash_lockp(&tcp_hashinfo, st->bucket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976
Andi Kleen6eac5602008-08-28 01:08:02 -07001977 /* Lockless fast path for the common case of empty buckets */
1978 if (empty_bucket(st))
1979 continue;
1980
Eric Dumazet9db66bd2008-11-20 20:39:09 -08001981 spin_lock_bh(lock);
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001982 sk_nulls_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
Daniel Lezcanof40c8172008-03-21 04:13:54 -07001983 if (sk->sk_family != st->family ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09001984 !net_eq(sock_net(sk), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985 continue;
1986 }
1987 rc = sk;
1988 goto out;
1989 }
Eric Dumazet9db66bd2008-11-20 20:39:09 -08001990 spin_unlock_bh(lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991 }
1992out:
1993 return rc;
1994}
1995
1996static void *established_get_next(struct seq_file *seq, void *cur)
1997{
1998 struct sock *sk = cur;
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001999 struct hlist_nulls_node *node;
Jianjun Kong5799de02008-11-03 02:49:10 -08002000 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002001 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002
2003 ++st->num;
Tom Herberta8b690f2010-06-07 00:43:42 -07002004 ++st->offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002006 sk = sk_nulls_next(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002007
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002008 sk_nulls_for_each_from(sk, node) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002009 if (sk->sk_family == st->family && net_eq(sock_net(sk), net))
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002010 return sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011 }
2012
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002013 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
2014 ++st->bucket;
2015 return established_get_first(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016}
2017
2018static void *established_get_idx(struct seq_file *seq, loff_t pos)
2019{
Tom Herberta8b690f2010-06-07 00:43:42 -07002020 struct tcp_iter_state *st = seq->private;
2021 void *rc;
2022
2023 st->bucket = 0;
2024 rc = established_get_first(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002025
2026 while (rc && pos) {
2027 rc = established_get_next(seq, rc);
2028 --pos;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002029 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030 return rc;
2031}
2032
2033static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
2034{
2035 void *rc;
Jianjun Kong5799de02008-11-03 02:49:10 -08002036 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002037
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038 st->state = TCP_SEQ_STATE_LISTENING;
2039 rc = listening_get_idx(seq, &pos);
2040
2041 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042 st->state = TCP_SEQ_STATE_ESTABLISHED;
2043 rc = established_get_idx(seq, pos);
2044 }
2045
2046 return rc;
2047}
2048
Tom Herberta8b690f2010-06-07 00:43:42 -07002049static void *tcp_seek_last_pos(struct seq_file *seq)
2050{
2051 struct tcp_iter_state *st = seq->private;
2052 int offset = st->offset;
2053 int orig_num = st->num;
2054 void *rc = NULL;
2055
2056 switch (st->state) {
2057 case TCP_SEQ_STATE_OPENREQ:
2058 case TCP_SEQ_STATE_LISTENING:
2059 if (st->bucket >= INET_LHTABLE_SIZE)
2060 break;
2061 st->state = TCP_SEQ_STATE_LISTENING;
2062 rc = listening_get_next(seq, NULL);
2063 while (offset-- && rc)
2064 rc = listening_get_next(seq, rc);
2065 if (rc)
2066 break;
2067 st->bucket = 0;
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002068 st->state = TCP_SEQ_STATE_ESTABLISHED;
Tom Herberta8b690f2010-06-07 00:43:42 -07002069 /* Fallthrough */
2070 case TCP_SEQ_STATE_ESTABLISHED:
Tom Herberta8b690f2010-06-07 00:43:42 -07002071 if (st->bucket > tcp_hashinfo.ehash_mask)
2072 break;
2073 rc = established_get_first(seq);
2074 while (offset-- && rc)
2075 rc = established_get_next(seq, rc);
2076 }
2077
2078 st->num = orig_num;
2079
2080 return rc;
2081}
2082
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
2084{
Jianjun Kong5799de02008-11-03 02:49:10 -08002085 struct tcp_iter_state *st = seq->private;
Tom Herberta8b690f2010-06-07 00:43:42 -07002086 void *rc;
2087
2088 if (*pos && *pos == st->last_pos) {
2089 rc = tcp_seek_last_pos(seq);
2090 if (rc)
2091 goto out;
2092 }
2093
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094 st->state = TCP_SEQ_STATE_LISTENING;
2095 st->num = 0;
Tom Herberta8b690f2010-06-07 00:43:42 -07002096 st->bucket = 0;
2097 st->offset = 0;
2098 rc = *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2099
2100out:
2101 st->last_pos = *pos;
2102 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103}
2104
2105static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2106{
Tom Herberta8b690f2010-06-07 00:43:42 -07002107 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002108 void *rc = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109
2110 if (v == SEQ_START_TOKEN) {
2111 rc = tcp_get_idx(seq, 0);
2112 goto out;
2113 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114
2115 switch (st->state) {
2116 case TCP_SEQ_STATE_OPENREQ:
2117 case TCP_SEQ_STATE_LISTENING:
2118 rc = listening_get_next(seq, v);
2119 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120 st->state = TCP_SEQ_STATE_ESTABLISHED;
Tom Herberta8b690f2010-06-07 00:43:42 -07002121 st->bucket = 0;
2122 st->offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123 rc = established_get_first(seq);
2124 }
2125 break;
2126 case TCP_SEQ_STATE_ESTABLISHED:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002127 rc = established_get_next(seq, v);
2128 break;
2129 }
2130out:
2131 ++*pos;
Tom Herberta8b690f2010-06-07 00:43:42 -07002132 st->last_pos = *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002133 return rc;
2134}
2135
2136static void tcp_seq_stop(struct seq_file *seq, void *v)
2137{
Jianjun Kong5799de02008-11-03 02:49:10 -08002138 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139
2140 switch (st->state) {
2141 case TCP_SEQ_STATE_OPENREQ:
2142 if (v) {
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002143 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
2144 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145 }
2146 case TCP_SEQ_STATE_LISTENING:
2147 if (v != SEQ_START_TOKEN)
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002148 spin_unlock_bh(&tcp_hashinfo.listening_hash[st->bucket].lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002150 case TCP_SEQ_STATE_ESTABLISHED:
2151 if (v)
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002152 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153 break;
2154 }
2155}
2156
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002157int tcp_seq_open(struct inode *inode, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158{
Al Virod9dda782013-03-31 18:16:14 -04002159 struct tcp_seq_afinfo *afinfo = PDE_DATA(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002160 struct tcp_iter_state *s;
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002161 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002163 err = seq_open_net(inode, file, &afinfo->seq_ops,
2164 sizeof(struct tcp_iter_state));
2165 if (err < 0)
2166 return err;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002167
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002168 s = ((struct seq_file *)file->private_data)->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002169 s->family = afinfo->family;
stephen hemminger688d1942014-08-29 23:32:05 -07002170 s->last_pos = 0;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002171 return 0;
2172}
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002173EXPORT_SYMBOL(tcp_seq_open);
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002174
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002175int tcp_proc_register(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002176{
2177 int rc = 0;
2178 struct proc_dir_entry *p;
2179
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002180 afinfo->seq_ops.start = tcp_seq_start;
2181 afinfo->seq_ops.next = tcp_seq_next;
2182 afinfo->seq_ops.stop = tcp_seq_stop;
2183
Denis V. Lunev84841c32008-05-02 04:10:08 -07002184 p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net,
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002185 afinfo->seq_fops, afinfo);
Denis V. Lunev84841c32008-05-02 04:10:08 -07002186 if (!p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187 rc = -ENOMEM;
2188 return rc;
2189}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002190EXPORT_SYMBOL(tcp_proc_register);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002192void tcp_proc_unregister(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193{
Gao fengece31ff2013-02-18 01:34:56 +00002194 remove_proc_entry(afinfo->name, net->proc_net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002196EXPORT_SYMBOL(tcp_proc_unregister);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002198static void get_openreq4(const struct sock *sk, const struct request_sock *req,
Tetsuo Handa652586d2013-11-14 14:31:57 -08002199 struct seq_file *f, int i, kuid_t uid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002201 const struct inet_request_sock *ireq = inet_rsk(req);
Eric Dumazeta399a802012-08-08 21:13:53 +00002202 long delta = req->expires - jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002203
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002204 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
Tetsuo Handa652586d2013-11-14 14:31:57 -08002205 " %02X %08X:%08X %02X:%08lX %08X %5u %8d %u %d %pK",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002206 i,
Eric Dumazet634fb9792013-10-09 15:21:29 -07002207 ireq->ir_loc_addr,
Eric Dumazetc720c7e2009-10-15 06:30:45 +00002208 ntohs(inet_sk(sk)->inet_sport),
Eric Dumazet634fb9792013-10-09 15:21:29 -07002209 ireq->ir_rmt_addr,
2210 ntohs(ireq->ir_rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002211 TCP_SYN_RECV,
2212 0, 0, /* could print option size, but that is af dependent. */
2213 1, /* timers active (only the expire timer) */
Eric Dumazeta399a802012-08-08 21:13:53 +00002214 jiffies_delta_to_clock_t(delta),
Eric Dumazete6c022a2012-10-27 23:16:46 +00002215 req->num_timeout,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06002216 from_kuid_munged(seq_user_ns(f), uid),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217 0, /* non standard timer */
2218 0, /* open_requests have no inode */
2219 atomic_read(&sk->sk_refcnt),
Tetsuo Handa652586d2013-11-14 14:31:57 -08002220 req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002221}
2222
Tetsuo Handa652586d2013-11-14 14:31:57 -08002223static void get_tcp4_sock(struct sock *sk, struct seq_file *f, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002224{
2225 int timer_active;
2226 unsigned long timer_expires;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002227 const struct tcp_sock *tp = tcp_sk(sk);
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002228 const struct inet_connection_sock *icsk = inet_csk(sk);
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002229 const struct inet_sock *inet = inet_sk(sk);
Jerry Chu168a8f52012-08-31 12:29:13 +00002230 struct fastopen_queue *fastopenq = icsk->icsk_accept_queue.fastopenq;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00002231 __be32 dest = inet->inet_daddr;
2232 __be32 src = inet->inet_rcv_saddr;
2233 __u16 destp = ntohs(inet->inet_dport);
2234 __u16 srcp = ntohs(inet->inet_sport);
Eric Dumazet49d09002009-12-03 16:06:13 -08002235 int rx_queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236
Nandita Dukkipati6ba8a3b2013-03-11 10:00:43 +00002237 if (icsk->icsk_pending == ICSK_TIME_RETRANS ||
2238 icsk->icsk_pending == ICSK_TIME_EARLY_RETRANS ||
2239 icsk->icsk_pending == ICSK_TIME_LOSS_PROBE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002241 timer_expires = icsk->icsk_timeout;
2242 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002244 timer_expires = icsk->icsk_timeout;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002245 } else if (timer_pending(&sk->sk_timer)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002246 timer_active = 2;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002247 timer_expires = sk->sk_timer.expires;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002248 } else {
2249 timer_active = 0;
2250 timer_expires = jiffies;
2251 }
2252
Eric Dumazet49d09002009-12-03 16:06:13 -08002253 if (sk->sk_state == TCP_LISTEN)
2254 rx_queue = sk->sk_ack_backlog;
2255 else
2256 /*
2257 * because we dont lock socket, we might find a transient negative value
2258 */
2259 rx_queue = max_t(int, tp->rcv_nxt - tp->copied_seq, 0);
2260
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002261 seq_printf(f, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
Tetsuo Handa652586d2013-11-14 14:31:57 -08002262 "%08X %5u %8d %lu %d %pK %lu %lu %u %u %d",
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002263 i, src, srcp, dest, destp, sk->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07002264 tp->write_seq - tp->snd_una,
Eric Dumazet49d09002009-12-03 16:06:13 -08002265 rx_queue,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266 timer_active,
Eric Dumazeta399a802012-08-08 21:13:53 +00002267 jiffies_delta_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002268 icsk->icsk_retransmits,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06002269 from_kuid_munged(seq_user_ns(f), sock_i_uid(sk)),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03002270 icsk->icsk_probes_out,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002271 sock_i_ino(sk),
2272 atomic_read(&sk->sk_refcnt), sk,
Stephen Hemminger7be87352008-06-27 20:00:19 -07002273 jiffies_to_clock_t(icsk->icsk_rto),
2274 jiffies_to_clock_t(icsk->icsk_ack.ato),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002275 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002276 tp->snd_cwnd,
Jerry Chu168a8f52012-08-31 12:29:13 +00002277 sk->sk_state == TCP_LISTEN ?
2278 (fastopenq ? fastopenq->max_qlen : 0) :
Tetsuo Handa652586d2013-11-14 14:31:57 -08002279 (tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002280}
2281
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002282static void get_timewait4_sock(const struct inet_timewait_sock *tw,
Tetsuo Handa652586d2013-11-14 14:31:57 -08002283 struct seq_file *f, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002284{
Al Viro23f33c22006-09-27 18:43:50 -07002285 __be32 dest, src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002286 __u16 destp, srcp;
Eric Dumazete2a1d3e2014-03-27 07:19:19 -07002287 s32 delta = tw->tw_ttd - inet_tw_time_stamp();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002288
2289 dest = tw->tw_daddr;
2290 src = tw->tw_rcv_saddr;
2291 destp = ntohs(tw->tw_dport);
2292 srcp = ntohs(tw->tw_sport);
2293
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002294 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
Tetsuo Handa652586d2013-11-14 14:31:57 -08002295 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002296 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
Eric Dumazeta399a802012-08-08 21:13:53 +00002297 3, jiffies_delta_to_clock_t(delta), 0, 0, 0, 0,
Tetsuo Handa652586d2013-11-14 14:31:57 -08002298 atomic_read(&tw->tw_refcnt), tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002299}
2300
2301#define TMPSZ 150
2302
2303static int tcp4_seq_show(struct seq_file *seq, void *v)
2304{
Jianjun Kong5799de02008-11-03 02:49:10 -08002305 struct tcp_iter_state *st;
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002306 struct sock *sk = v;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307
Tetsuo Handa652586d2013-11-14 14:31:57 -08002308 seq_setwidth(seq, TMPSZ - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309 if (v == SEQ_START_TOKEN) {
Tetsuo Handa652586d2013-11-14 14:31:57 -08002310 seq_puts(seq, " sl local_address rem_address st tx_queue "
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311 "rx_queue tr tm->when retrnsmt uid timeout "
2312 "inode");
2313 goto out;
2314 }
2315 st = seq->private;
2316
2317 switch (st->state) {
2318 case TCP_SEQ_STATE_LISTENING:
2319 case TCP_SEQ_STATE_ESTABLISHED:
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002320 if (sk->sk_state == TCP_TIME_WAIT)
Tetsuo Handa652586d2013-11-14 14:31:57 -08002321 get_timewait4_sock(v, seq, st->num);
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002322 else
Tetsuo Handa652586d2013-11-14 14:31:57 -08002323 get_tcp4_sock(v, seq, st->num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002324 break;
2325 case TCP_SEQ_STATE_OPENREQ:
Tetsuo Handa652586d2013-11-14 14:31:57 -08002326 get_openreq4(st->syn_wait_sk, v, seq, st->num, st->uid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002327 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002328 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329out:
Tetsuo Handa652586d2013-11-14 14:31:57 -08002330 seq_pad(seq, '\n');
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331 return 0;
2332}
2333
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002334static const struct file_operations tcp_afinfo_seq_fops = {
2335 .owner = THIS_MODULE,
2336 .open = tcp_seq_open,
2337 .read = seq_read,
2338 .llseek = seq_lseek,
2339 .release = seq_release_net
2340};
2341
Linus Torvalds1da177e2005-04-16 15:20:36 -07002342static struct tcp_seq_afinfo tcp4_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002343 .name = "tcp",
2344 .family = AF_INET,
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002345 .seq_fops = &tcp_afinfo_seq_fops,
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002346 .seq_ops = {
2347 .show = tcp4_seq_show,
2348 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002349};
2350
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002351static int __net_init tcp4_proc_init_net(struct net *net)
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002352{
2353 return tcp_proc_register(net, &tcp4_seq_afinfo);
2354}
2355
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002356static void __net_exit tcp4_proc_exit_net(struct net *net)
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002357{
2358 tcp_proc_unregister(net, &tcp4_seq_afinfo);
2359}
2360
2361static struct pernet_operations tcp4_net_ops = {
2362 .init = tcp4_proc_init_net,
2363 .exit = tcp4_proc_exit_net,
2364};
2365
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366int __init tcp4_proc_init(void)
2367{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002368 return register_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002369}
2370
2371void tcp4_proc_exit(void)
2372{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002373 unregister_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002374}
2375#endif /* CONFIG_PROC_FS */
2376
2377struct proto tcp_prot = {
2378 .name = "TCP",
2379 .owner = THIS_MODULE,
2380 .close = tcp_close,
2381 .connect = tcp_v4_connect,
2382 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002383 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002384 .ioctl = tcp_ioctl,
2385 .init = tcp_v4_init_sock,
2386 .destroy = tcp_v4_destroy_sock,
2387 .shutdown = tcp_shutdown,
2388 .setsockopt = tcp_setsockopt,
2389 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002390 .recvmsg = tcp_recvmsg,
Changli Gao7ba42912010-07-10 20:41:55 +00002391 .sendmsg = tcp_sendmsg,
2392 .sendpage = tcp_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002393 .backlog_rcv = tcp_v4_do_rcv,
Eric Dumazet46d3cea2012-07-11 05:50:31 +00002394 .release_cb = tcp_release_cb,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08002395 .hash = inet_hash,
2396 .unhash = inet_unhash,
2397 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002398 .enter_memory_pressure = tcp_enter_memory_pressure,
Eric Dumazetc9bee3b72013-07-22 20:27:07 -07002399 .stream_memory_free = tcp_stream_memory_free,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002400 .sockets_allocated = &tcp_sockets_allocated,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07002401 .orphan_count = &tcp_orphan_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002402 .memory_allocated = &tcp_memory_allocated,
2403 .memory_pressure = &tcp_memory_pressure,
Eric W. Biedermana4fe34b2013-10-19 16:25:36 -07002404 .sysctl_mem = sysctl_tcp_mem,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002405 .sysctl_wmem = sysctl_tcp_wmem,
2406 .sysctl_rmem = sysctl_tcp_rmem,
2407 .max_header = MAX_TCP_HEADER,
2408 .obj_size = sizeof(struct tcp_sock),
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002409 .slab_flags = SLAB_DESTROY_BY_RCU,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002410 .twsk_prot = &tcp_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002411 .rsk_prot = &tcp_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07002412 .h.hashinfo = &tcp_hashinfo,
Changli Gao7ba42912010-07-10 20:41:55 +00002413 .no_autobind = true,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002414#ifdef CONFIG_COMPAT
2415 .compat_setsockopt = compat_tcp_setsockopt,
2416 .compat_getsockopt = compat_tcp_getsockopt,
2417#endif
Andrew Mortonc255a452012-07-31 16:43:02 -07002418#ifdef CONFIG_MEMCG_KMEM
Glauber Costad1a4c0b2011-12-11 21:47:04 +00002419 .init_cgroup = tcp_init_cgroup,
2420 .destroy_cgroup = tcp_destroy_cgroup,
2421 .proto_cgroup = tcp_proto_cgroup,
2422#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002423};
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002424EXPORT_SYMBOL(tcp_prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002425
Denis V. Lunev046ee902008-04-03 14:31:33 -07002426static int __net_init tcp_sk_init(struct net *net)
2427{
Hannes Frederic Sowa5d134f12013-01-05 16:10:48 +00002428 net->ipv4.sysctl_tcp_ecn = 2;
Eric Dumazetbe9f4a42012-07-19 07:34:03 +00002429 return 0;
Denis V. Lunev046ee902008-04-03 14:31:33 -07002430}
2431
2432static void __net_exit tcp_sk_exit(struct net *net)
2433{
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002434}
2435
2436static void __net_exit tcp_sk_exit_batch(struct list_head *net_exit_list)
2437{
2438 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET);
Denis V. Lunev046ee902008-04-03 14:31:33 -07002439}
2440
2441static struct pernet_operations __net_initdata tcp_sk_ops = {
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002442 .init = tcp_sk_init,
2443 .exit = tcp_sk_exit,
2444 .exit_batch = tcp_sk_exit_batch,
Denis V. Lunev046ee902008-04-03 14:31:33 -07002445};
2446
Denis V. Lunev9b0f9762008-02-29 11:13:15 -08002447void __init tcp_v4_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002448{
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002449 inet_hashinfo_init(&tcp_hashinfo);
Eric W. Biederman6a1b3052009-02-22 00:10:18 -08002450 if (register_pernet_subsys(&tcp_sk_ops))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002451 panic("Failed to create the TCP control socket.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002452}