blob: c4f1d9a76c443a8f0beca90317f088769502960f [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * Implementation of the Transmission Control Protocol(TCP).
7 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 * IPv4 specific functions
9 *
10 *
11 * code split from:
12 * linux/ipv4/tcp.c
13 * linux/ipv4/tcp_input.c
14 * linux/ipv4/tcp_output.c
15 *
16 * See tcp.c for author information
17 *
18 * This program is free software; you can redistribute it and/or
19 * modify it under the terms of the GNU General Public License
20 * as published by the Free Software Foundation; either version
21 * 2 of the License, or (at your option) any later version.
22 */
23
24/*
25 * Changes:
26 * David S. Miller : New socket lookup architecture.
27 * This code is dedicated to John Dyson.
28 * David S. Miller : Change semantics of established hash,
29 * half is devoted to TIME_WAIT sockets
30 * and the rest go in the other half.
31 * Andi Kleen : Add support for syncookies and fixed
32 * some bugs: ip options weren't passed to
33 * the TCP layer, missed a check for an
34 * ACK bit.
35 * Andi Kleen : Implemented fast path mtu discovery.
36 * Fixed many serious bugs in the
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -070037 * request_sock handling and moved
Linus Torvalds1da177e2005-04-16 15:20:36 -070038 * most of it into the af independent code.
39 * Added tail drop and some other bugfixes.
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -080040 * Added new listen semantics.
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 * Mike McLagan : Routing by source
42 * Juan Jose Ciarlante: ip_dynaddr bits
43 * Andi Kleen: various fixes.
44 * Vitaly E. Lavrov : Transparent proxy revived after year
45 * coma.
46 * Andi Kleen : Fix new listen.
47 * Andi Kleen : Fix accept error reporting.
48 * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which
49 * Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind
50 * a single port at the same time.
51 */
52
Joe Perchesafd465032012-03-12 07:03:32 +000053#define pr_fmt(fmt) "TCP: " fmt
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
Herbert Xueb4dea52008-12-29 23:04:08 -080055#include <linux/bottom_half.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070056#include <linux/types.h>
57#include <linux/fcntl.h>
58#include <linux/module.h>
59#include <linux/random.h>
60#include <linux/cache.h>
61#include <linux/jhash.h>
62#include <linux/init.h>
63#include <linux/times.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090064#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020066#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070067#include <net/icmp.h>
Arnaldo Carvalho de Melo304a1612005-08-09 19:59:20 -070068#include <net/inet_hashtables.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070069#include <net/tcp.h>
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -030070#include <net/transp_v6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070071#include <net/ipv6.h>
72#include <net/inet_common.h>
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -080073#include <net/timewait_sock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070074#include <net/xfrm.h>
Chris Leech1a2449a2006-05-23 18:05:53 -070075#include <net/netdma.h>
David S. Miller6e5714e2011-08-03 20:50:44 -070076#include <net/secure_seq.h>
Glauber Costad1a4c0b2011-12-11 21:47:04 +000077#include <net/tcp_memcontrol.h>
Eliezer Tamir076bb0c2013-07-10 17:13:17 +030078#include <net/busy_poll.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
80#include <linux/inet.h>
81#include <linux/ipv6.h>
82#include <linux/stddef.h>
83#include <linux/proc_fs.h>
84#include <linux/seq_file.h>
85
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080086#include <linux/crypto.h>
87#include <linux/scatterlist.h>
88
Brian Haleyab32ea52006-09-22 14:15:41 -070089int sysctl_tcp_tw_reuse __read_mostly;
90int sysctl_tcp_low_latency __read_mostly;
Eric Dumazet4bc2f182010-07-09 21:22:10 +000091EXPORT_SYMBOL(sysctl_tcp_low_latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080094#ifdef CONFIG_TCP_MD5SIG
Eric Dumazeta915da9b2012-01-31 05:18:33 +000095static int tcp_v4_md5_hash_hdr(char *md5_hash, const struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -040096 __be32 daddr, __be32 saddr, const struct tcphdr *th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080097#endif
98
Eric Dumazet5caea4e2008-11-20 00:40:07 -080099struct inet_hashinfo tcp_hashinfo;
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000100EXPORT_SYMBOL(tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400102static inline __u32 tcp_v4_init_sequence(const struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700104 return secure_tcp_sequence_number(ip_hdr(skb)->daddr,
105 ip_hdr(skb)->saddr,
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700106 tcp_hdr(skb)->dest,
107 tcp_hdr(skb)->source);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108}
109
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800110int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp)
111{
112 const struct tcp_timewait_sock *tcptw = tcp_twsk(sktw);
113 struct tcp_sock *tp = tcp_sk(sk);
114
115 /* With PAWS, it is safe from the viewpoint
116 of data integrity. Even without PAWS it is safe provided sequence
117 spaces do not overlap i.e. at data rates <= 80Mbit/sec.
118
119 Actually, the idea is close to VJ's one, only timestamp cache is
120 held not per host, but per port pair and TW bucket is used as state
121 holder.
122
123 If TW bucket has been already destroyed we fall back to VJ's scheme
124 and use initial timestamp retrieved from peer table.
125 */
126 if (tcptw->tw_ts_recent_stamp &&
127 (twp == NULL || (sysctl_tcp_tw_reuse &&
James Morris9d729f72007-03-04 16:12:44 -0800128 get_seconds() - tcptw->tw_ts_recent_stamp > 1))) {
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800129 tp->write_seq = tcptw->tw_snd_nxt + 65535 + 2;
130 if (tp->write_seq == 0)
131 tp->write_seq = 1;
132 tp->rx_opt.ts_recent = tcptw->tw_ts_recent;
133 tp->rx_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp;
134 sock_hold(sktw);
135 return 1;
136 }
137
138 return 0;
139}
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800140EXPORT_SYMBOL_GPL(tcp_twsk_unique);
141
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142/* This will initiate an outgoing connection. */
143int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
144{
David S. Miller2d7192d2011-04-26 13:28:44 -0700145 struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 struct inet_sock *inet = inet_sk(sk);
147 struct tcp_sock *tp = tcp_sk(sk);
David S. Millerdca8b082011-02-24 13:38:12 -0800148 __be16 orig_sport, orig_dport;
Al Virobada8ad2006-09-26 21:27:15 -0700149 __be32 daddr, nexthop;
David S. Millerda905bd2011-05-06 16:11:19 -0700150 struct flowi4 *fl4;
David S. Miller2d7192d2011-04-26 13:28:44 -0700151 struct rtable *rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 int err;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000153 struct ip_options_rcu *inet_opt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
155 if (addr_len < sizeof(struct sockaddr_in))
156 return -EINVAL;
157
158 if (usin->sin_family != AF_INET)
159 return -EAFNOSUPPORT;
160
161 nexthop = daddr = usin->sin_addr.s_addr;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000162 inet_opt = rcu_dereference_protected(inet->inet_opt,
163 sock_owned_by_user(sk));
164 if (inet_opt && inet_opt->opt.srr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 if (!daddr)
166 return -EINVAL;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000167 nexthop = inet_opt->opt.faddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 }
169
David S. Millerdca8b082011-02-24 13:38:12 -0800170 orig_sport = inet->inet_sport;
171 orig_dport = usin->sin_port;
David S. Millerda905bd2011-05-06 16:11:19 -0700172 fl4 = &inet->cork.fl.u.ip4;
173 rt = ip_route_connect(fl4, nexthop, inet->inet_saddr,
David S. Millerb23dd4f2011-03-02 14:31:35 -0800174 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
175 IPPROTO_TCP,
Steffen Klassert0e0d44a2013-08-28 08:04:14 +0200176 orig_sport, orig_dport, sk);
David S. Millerb23dd4f2011-03-02 14:31:35 -0800177 if (IS_ERR(rt)) {
178 err = PTR_ERR(rt);
179 if (err == -ENETUNREACH)
Eric Dumazetf1d8cba2013-11-28 09:51:22 -0800180 IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTNOROUTES);
David S. Millerb23dd4f2011-03-02 14:31:35 -0800181 return err;
Wei Dong584bdf82007-05-31 22:49:28 -0700182 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183
184 if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
185 ip_rt_put(rt);
186 return -ENETUNREACH;
187 }
188
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000189 if (!inet_opt || !inet_opt->opt.srr)
David S. Millerda905bd2011-05-06 16:11:19 -0700190 daddr = fl4->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000192 if (!inet->inet_saddr)
David S. Millerda905bd2011-05-06 16:11:19 -0700193 inet->inet_saddr = fl4->saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000194 inet->inet_rcv_saddr = inet->inet_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000196 if (tp->rx_opt.ts_recent_stamp && inet->inet_daddr != daddr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 /* Reset inherited state */
198 tp->rx_opt.ts_recent = 0;
199 tp->rx_opt.ts_recent_stamp = 0;
Pavel Emelyanovee995282012-04-19 03:40:39 +0000200 if (likely(!tp->repair))
201 tp->write_seq = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 }
203
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -0700204 if (tcp_death_row.sysctl_tw_recycle &&
David S. Miller81166dd2012-07-10 03:14:24 -0700205 !tp->rx_opt.ts_recent_stamp && fl4->daddr == daddr)
206 tcp_fetch_timewait_stamp(sk, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000208 inet->inet_dport = usin->sin_port;
209 inet->inet_daddr = daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210
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 */
Eric Dumazet563d34d2012-07-23 09:48:52 +0200272static void 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}
303
David S. Miller55be7a92012-07-11 21:27:49 -0700304static void do_redirect(struct sk_buff *skb, struct sock *sk)
305{
306 struct dst_entry *dst = __sk_dst_check(sk, 0);
307
David S. Miller1ed5c482012-07-12 00:41:25 -0700308 if (dst)
David S. Miller6700c272012-07-17 03:29:28 -0700309 dst->ops->redirect(dst, sk, skb);
David S. Miller55be7a92012-07-11 21:27:49 -0700310}
311
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312/*
313 * This routine is called by the ICMP module when it gets some
314 * sort of error condition. If err < 0 then the socket should
315 * be closed and the error returned to the user. If err > 0
316 * it's just the icmp type << 8 | icmp code. After adjustment
317 * header points to the first 8 bytes of the tcp header. We need
318 * to find the appropriate port.
319 *
320 * The locking strategy used here is very "optimistic". When
321 * someone else accesses the socket the ICMP is just dropped
322 * and for some paths there is no check at all.
323 * A more general error queue to queue errors for later handling
324 * is probably better.
325 *
326 */
327
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000328void tcp_v4_err(struct sk_buff *icmp_skb, u32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000330 const struct iphdr *iph = (const struct iphdr *)icmp_skb->data;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000331 struct tcphdr *th = (struct tcphdr *)(icmp_skb->data + (iph->ihl << 2));
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000332 struct inet_connection_sock *icsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 struct tcp_sock *tp;
334 struct inet_sock *inet;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000335 const int type = icmp_hdr(icmp_skb)->type;
336 const int code = icmp_hdr(icmp_skb)->code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 struct sock *sk;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000338 struct sk_buff *skb;
Jerry Chu168a8f52012-08-31 12:29:13 +0000339 struct request_sock *req;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 __u32 seq;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000341 __u32 remaining;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 int err;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000343 struct net *net = dev_net(icmp_skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000345 if (icmp_skb->len < (iph->ihl << 2) + 8) {
Pavel Emelyanovdcfc23c2008-07-14 23:03:00 -0700346 ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 return;
348 }
349
Pavel Emelyanovfd54d712008-07-14 23:01:40 -0700350 sk = inet_lookup(net, &tcp_hashinfo, iph->daddr, th->dest,
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000351 iph->saddr, th->source, inet_iif(icmp_skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 if (!sk) {
Pavel Emelyanovdcfc23c2008-07-14 23:03:00 -0700353 ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 return;
355 }
356 if (sk->sk_state == TCP_TIME_WAIT) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700357 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 return;
359 }
360
361 bh_lock_sock(sk);
362 /* If too many ICMPs get dropped on busy
363 * servers this needs to be solved differently.
Eric Dumazet563d34d2012-07-23 09:48:52 +0200364 * We do take care of PMTU discovery (RFC1191) special case :
365 * we can receive locally generated ICMP messages while socket is held.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 */
Eric Dumazetb74aa932013-01-19 16:10:37 +0000367 if (sock_owned_by_user(sk)) {
368 if (!(type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED))
369 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
370 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 if (sk->sk_state == TCP_CLOSE)
372 goto out;
373
stephen hemminger97e3ecd12010-03-18 11:27:32 +0000374 if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
375 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
376 goto out;
377 }
378
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000379 icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 tp = tcp_sk(sk);
Jerry Chu168a8f52012-08-31 12:29:13 +0000381 req = tp->fastopen_rsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 seq = ntohl(th->seq);
383 if (sk->sk_state != TCP_LISTEN &&
Jerry Chu168a8f52012-08-31 12:29:13 +0000384 !between(seq, tp->snd_una, tp->snd_nxt) &&
385 (req == NULL || seq != tcp_rsk(req)->snt_isn)) {
386 /* For a Fast Open socket, allow seq to be snt_isn. */
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700387 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 goto out;
389 }
390
391 switch (type) {
David S. Miller55be7a92012-07-11 21:27:49 -0700392 case ICMP_REDIRECT:
393 do_redirect(icmp_skb, sk);
394 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 case ICMP_SOURCE_QUENCH:
396 /* Just silently ignore these. */
397 goto out;
398 case ICMP_PARAMETERPROB:
399 err = EPROTO;
400 break;
401 case ICMP_DEST_UNREACH:
402 if (code > NR_ICMP_UNREACH)
403 goto out;
404
405 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
Eric Dumazet0d4f0602013-03-18 07:01:28 +0000406 /* We are not interested in TCP_LISTEN and open_requests
407 * (SYN-ACKs send out by Linux are always <576bytes so
408 * they should go through unfragmented).
409 */
410 if (sk->sk_state == TCP_LISTEN)
411 goto out;
412
Eric Dumazet563d34d2012-07-23 09:48:52 +0200413 tp->mtu_info = info;
Eric Dumazet144d56e2012-08-20 00:22:46 +0000414 if (!sock_owned_by_user(sk)) {
Eric Dumazet563d34d2012-07-23 09:48:52 +0200415 tcp_v4_mtu_reduced(sk);
Eric Dumazet144d56e2012-08-20 00:22:46 +0000416 } else {
417 if (!test_and_set_bit(TCP_MTU_REDUCED_DEFERRED, &tp->tsq_flags))
418 sock_hold(sk);
419 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 goto out;
421 }
422
423 err = icmp_err_convert[code].errno;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000424 /* check if icmp_skb allows revert of backoff
425 * (see draft-zimmermann-tcp-lcd) */
426 if (code != ICMP_NET_UNREACH && code != ICMP_HOST_UNREACH)
427 break;
428 if (seq != tp->snd_una || !icsk->icsk_retransmits ||
429 !icsk->icsk_backoff)
430 break;
431
Jerry Chu168a8f52012-08-31 12:29:13 +0000432 /* XXX (TFO) - revisit the following logic for TFO */
433
David S. Miller8f49c272010-11-12 13:35:00 -0800434 if (sock_owned_by_user(sk))
435 break;
436
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000437 icsk->icsk_backoff--;
Eric Dumazet740b0f12014-02-26 14:02:48 -0800438 inet_csk(sk)->icsk_rto = (tp->srtt_us ? __tcp_set_rto(tp) :
Jerry Chu9ad7c042011-06-08 11:08:38 +0000439 TCP_TIMEOUT_INIT) << icsk->icsk_backoff;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000440 tcp_bound_rto(sk);
441
442 skb = tcp_write_queue_head(sk);
443 BUG_ON(!skb);
444
445 remaining = icsk->icsk_rto - min(icsk->icsk_rto,
446 tcp_time_stamp - TCP_SKB_CB(skb)->when);
447
448 if (remaining) {
449 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
450 remaining, TCP_RTO_MAX);
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000451 } else {
452 /* RTO revert clocked out retransmission.
453 * Will retransmit now */
454 tcp_retransmit_timer(sk);
455 }
456
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 break;
458 case ICMP_TIME_EXCEEDED:
459 err = EHOSTUNREACH;
460 break;
461 default:
462 goto out;
463 }
464
Jerry Chu168a8f52012-08-31 12:29:13 +0000465 /* XXX (TFO) - if it's a TFO socket and has been accepted, rather
466 * than following the TCP_SYN_RECV case and closing the socket,
467 * we ignore the ICMP error and keep trying like a fully established
468 * socket. Is this the right thing to do?
469 */
470 if (req && req->sk == NULL)
471 goto out;
472
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 switch (sk->sk_state) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700474 struct request_sock *req, **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 case TCP_LISTEN:
476 if (sock_owned_by_user(sk))
477 goto out;
478
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700479 req = inet_csk_search_req(sk, &prev, th->dest,
480 iph->daddr, iph->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 if (!req)
482 goto out;
483
484 /* ICMPs are not backlogged, hence we cannot get
485 an established socket here.
486 */
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700487 WARN_ON(req->sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700489 if (seq != tcp_rsk(req)->snt_isn) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700490 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 goto out;
492 }
493
494 /*
495 * Still in SYN_RECV, just remove it silently.
496 * There is no good way to pass the error to the newly
497 * created socket, and POSIX does not want network
498 * errors returned from accept().
499 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700500 inet_csk_reqsk_queue_drop(sk, req, prev);
Vijay Subramanian848bf152013-01-31 08:24:06 +0000501 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 goto out;
503
504 case TCP_SYN_SENT:
505 case TCP_SYN_RECV: /* Cannot happen.
Jerry Chu168a8f52012-08-31 12:29:13 +0000506 It can f.e. if SYNs crossed,
507 or Fast Open.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 */
509 if (!sock_owned_by_user(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 sk->sk_err = err;
511
512 sk->sk_error_report(sk);
513
514 tcp_done(sk);
515 } else {
516 sk->sk_err_soft = err;
517 }
518 goto out;
519 }
520
521 /* If we've already connected we will keep trying
522 * until we time out, or the user gives up.
523 *
524 * rfc1122 4.2.3.9 allows to consider as hard errors
525 * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
526 * but it is obsoleted by pmtu discovery).
527 *
528 * Note, that in modern internet, where routing is unreliable
529 * and in each dark corner broken firewalls sit, sending random
530 * errors ordered by their masters even this two messages finally lose
531 * their original sense (even Linux sends invalid PORT_UNREACHs)
532 *
533 * Now we are in compliance with RFCs.
534 * --ANK (980905)
535 */
536
537 inet = inet_sk(sk);
538 if (!sock_owned_by_user(sk) && inet->recverr) {
539 sk->sk_err = err;
540 sk->sk_error_report(sk);
541 } else { /* Only an error on timeout */
542 sk->sk_err_soft = err;
543 }
544
545out:
546 bh_unlock_sock(sk);
547 sock_put(sk);
548}
549
Daniel Borkmann28850dc2013-06-07 05:11:46 +0000550void __tcp_v4_send_check(struct sk_buff *skb, __be32 saddr, __be32 daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700552 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553
Patrick McHardy84fa7932006-08-29 16:44:56 -0700554 if (skb->ip_summed == CHECKSUM_PARTIAL) {
Herbert Xu419f9f82010-04-11 02:15:53 +0000555 th->check = ~tcp_v4_check(skb->len, saddr, daddr, 0);
Herbert Xu663ead32007-04-09 11:59:07 -0700556 skb->csum_start = skb_transport_header(skb) - skb->head;
Al Viroff1dcad2006-11-20 18:07:29 -0800557 skb->csum_offset = offsetof(struct tcphdr, check);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 } else {
Herbert Xu419f9f82010-04-11 02:15:53 +0000559 th->check = tcp_v4_check(skb->len, saddr, daddr,
Joe Perches07f07572008-11-19 15:44:53 -0800560 csum_partial(th,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 th->doff << 2,
562 skb->csum));
563 }
564}
565
Herbert Xu419f9f82010-04-11 02:15:53 +0000566/* This routine computes an IPv4 TCP checksum. */
Herbert Xubb296242010-04-11 02:15:55 +0000567void tcp_v4_send_check(struct sock *sk, struct sk_buff *skb)
Herbert Xu419f9f82010-04-11 02:15:53 +0000568{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400569 const struct inet_sock *inet = inet_sk(sk);
Herbert Xu419f9f82010-04-11 02:15:53 +0000570
571 __tcp_v4_send_check(skb, inet->inet_saddr, inet->inet_daddr);
572}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000573EXPORT_SYMBOL(tcp_v4_send_check);
Herbert Xu419f9f82010-04-11 02:15:53 +0000574
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575/*
576 * This routine will send an RST to the other tcp.
577 *
578 * Someone asks: why I NEVER use socket parameters (TOS, TTL etc.)
579 * for reset.
580 * Answer: if a packet caused RST, it is not for a socket
581 * existing in our system, if it is matched to a socket,
582 * it is just duplicate segment or bug in other side's TCP.
583 * So that we build reply only basing on parameters
584 * arrived with segment.
585 * Exception: precedence violation. We do not implement it in any case.
586 */
587
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800588static void tcp_v4_send_reset(struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400590 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800591 struct {
592 struct tcphdr th;
593#ifdef CONFIG_TCP_MD5SIG
Al Viro714e85b2006-11-14 20:51:49 -0800594 __be32 opt[(TCPOLEN_MD5SIG_ALIGNED >> 2)];
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800595#endif
596 } rep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 struct ip_reply_arg arg;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800598#ifdef CONFIG_TCP_MD5SIG
599 struct tcp_md5sig_key *key;
Shawn Lu658ddaa2012-01-31 22:35:48 +0000600 const __u8 *hash_location = NULL;
601 unsigned char newhash[16];
602 int genhash;
603 struct sock *sk1 = NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800604#endif
Pavel Emelyanova86b1e32008-07-16 20:20:58 -0700605 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606
607 /* Never send a reset in response to a reset. */
608 if (th->rst)
609 return;
610
Eric Dumazet511c3f92009-06-02 05:14:27 +0000611 if (skb_rtable(skb)->rt_type != RTN_LOCAL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 return;
613
614 /* Swap the send and the receive. */
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800615 memset(&rep, 0, sizeof(rep));
616 rep.th.dest = th->source;
617 rep.th.source = th->dest;
618 rep.th.doff = sizeof(struct tcphdr) / 4;
619 rep.th.rst = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620
621 if (th->ack) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800622 rep.th.seq = th->ack_seq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800624 rep.th.ack = 1;
625 rep.th.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
626 skb->len - (th->doff << 2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 }
628
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200629 memset(&arg, 0, sizeof(arg));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800630 arg.iov[0].iov_base = (unsigned char *)&rep;
631 arg.iov[0].iov_len = sizeof(rep.th);
632
633#ifdef CONFIG_TCP_MD5SIG
Shawn Lu658ddaa2012-01-31 22:35:48 +0000634 hash_location = tcp_parse_md5sig_option(th);
635 if (!sk && hash_location) {
636 /*
637 * active side is lost. Try to find listening socket through
638 * source port, and then find md5 key through listening socket.
639 * we are not loose security here:
640 * Incoming packet is checked with md5 hash with finding key,
641 * no RST generated if md5 hash doesn't match.
642 */
643 sk1 = __inet_lookup_listener(dev_net(skb_dst(skb)->dev),
Tom Herbertda5e3632013-01-22 09:50:24 +0000644 &tcp_hashinfo, ip_hdr(skb)->saddr,
645 th->source, ip_hdr(skb)->daddr,
Shawn Lu658ddaa2012-01-31 22:35:48 +0000646 ntohs(th->source), inet_iif(skb));
647 /* don't send rst if it can't find key */
648 if (!sk1)
649 return;
650 rcu_read_lock();
651 key = tcp_md5_do_lookup(sk1, (union tcp_md5_addr *)
652 &ip_hdr(skb)->saddr, AF_INET);
653 if (!key)
654 goto release_sk1;
655
656 genhash = tcp_v4_md5_hash_skb(newhash, key, NULL, NULL, skb);
657 if (genhash || memcmp(hash_location, newhash, 16) != 0)
658 goto release_sk1;
659 } else {
660 key = sk ? tcp_md5_do_lookup(sk, (union tcp_md5_addr *)
661 &ip_hdr(skb)->saddr,
662 AF_INET) : NULL;
663 }
664
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800665 if (key) {
666 rep.opt[0] = htonl((TCPOPT_NOP << 24) |
667 (TCPOPT_NOP << 16) |
668 (TCPOPT_MD5SIG << 8) |
669 TCPOLEN_MD5SIG);
670 /* Update length and the length the header thinks exists */
671 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
672 rep.th.doff = arg.iov[0].iov_len / 4;
673
Adam Langley49a72df2008-07-19 00:01:42 -0700674 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[1],
Ilpo Järvinen78e645cb2008-10-09 14:37:47 -0700675 key, ip_hdr(skb)->saddr,
676 ip_hdr(skb)->daddr, &rep.th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800677 }
678#endif
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700679 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
680 ip_hdr(skb)->saddr, /* XXX */
Ilpo Järvinen52cd5752008-10-08 11:34:06 -0700681 arg.iov[0].iov_len, IPPROTO_TCP, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700683 arg.flags = (sk && inet_sk(sk)->transparent) ? IP_REPLY_ARG_NOSRCCHECK : 0;
Shawn Lue2446ea2012-02-04 12:38:09 +0000684 /* When socket is gone, all binding information is lost.
Alexey Kuznetsov4c675252012-10-12 04:34:17 +0000685 * routing might fail in this case. No choice here, if we choose to force
686 * input interface, we will misroute in case of asymmetric route.
Shawn Lue2446ea2012-02-04 12:38:09 +0000687 */
Alexey Kuznetsov4c675252012-10-12 04:34:17 +0000688 if (sk)
689 arg.bound_dev_if = sk->sk_bound_dev_if;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690
Eric Dumazetadf30902009-06-02 05:19:30 +0000691 net = dev_net(skb_dst(skb)->dev);
Eric Dumazet66b13d92011-10-24 03:06:21 -0400692 arg.tos = ip_hdr(skb)->tos;
Eric Dumazetbe9f4a42012-07-19 07:34:03 +0000693 ip_send_unicast_reply(net, skb, ip_hdr(skb)->saddr,
David S. Miller70e73412012-06-28 03:21:41 -0700694 ip_hdr(skb)->daddr, &arg, arg.iov[0].iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695
Pavel Emelyanov63231bddf2008-07-16 20:22:25 -0700696 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
697 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
Shawn Lu658ddaa2012-01-31 22:35:48 +0000698
699#ifdef CONFIG_TCP_MD5SIG
700release_sk1:
701 if (sk1) {
702 rcu_read_unlock();
703 sock_put(sk1);
704 }
705#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706}
707
708/* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
709 outside socket context is ugly, certainly. What can I do?
710 */
711
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900712static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
Andrey Vaginee684b62013-02-11 05:50:19 +0000713 u32 win, u32 tsval, u32 tsecr, int oif,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700714 struct tcp_md5sig_key *key,
Eric Dumazet66b13d92011-10-24 03:06:21 -0400715 int reply_flags, u8 tos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400717 const struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 struct {
719 struct tcphdr th;
Al Viro714e85b2006-11-14 20:51:49 -0800720 __be32 opt[(TCPOLEN_TSTAMP_ALIGNED >> 2)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800721#ifdef CONFIG_TCP_MD5SIG
Al Viro714e85b2006-11-14 20:51:49 -0800722 + (TCPOLEN_MD5SIG_ALIGNED >> 2)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800723#endif
724 ];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 } rep;
726 struct ip_reply_arg arg;
Eric Dumazetadf30902009-06-02 05:19:30 +0000727 struct net *net = dev_net(skb_dst(skb)->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728
729 memset(&rep.th, 0, sizeof(struct tcphdr));
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200730 memset(&arg, 0, sizeof(arg));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731
732 arg.iov[0].iov_base = (unsigned char *)&rep;
733 arg.iov[0].iov_len = sizeof(rep.th);
Andrey Vaginee684b62013-02-11 05:50:19 +0000734 if (tsecr) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800735 rep.opt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
736 (TCPOPT_TIMESTAMP << 8) |
737 TCPOLEN_TIMESTAMP);
Andrey Vaginee684b62013-02-11 05:50:19 +0000738 rep.opt[1] = htonl(tsval);
739 rep.opt[2] = htonl(tsecr);
Craig Schlentercb48cfe2007-01-09 00:11:15 -0800740 arg.iov[0].iov_len += TCPOLEN_TSTAMP_ALIGNED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 }
742
743 /* Swap the send and the receive. */
744 rep.th.dest = th->source;
745 rep.th.source = th->dest;
746 rep.th.doff = arg.iov[0].iov_len / 4;
747 rep.th.seq = htonl(seq);
748 rep.th.ack_seq = htonl(ack);
749 rep.th.ack = 1;
750 rep.th.window = htons(win);
751
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800752#ifdef CONFIG_TCP_MD5SIG
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800753 if (key) {
Andrey Vaginee684b62013-02-11 05:50:19 +0000754 int offset = (tsecr) ? 3 : 0;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800755
756 rep.opt[offset++] = htonl((TCPOPT_NOP << 24) |
757 (TCPOPT_NOP << 16) |
758 (TCPOPT_MD5SIG << 8) |
759 TCPOLEN_MD5SIG);
760 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
761 rep.th.doff = arg.iov[0].iov_len/4;
762
Adam Langley49a72df2008-07-19 00:01:42 -0700763 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[offset],
Adam Langley90b7e112008-07-31 20:49:48 -0700764 key, ip_hdr(skb)->saddr,
765 ip_hdr(skb)->daddr, &rep.th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800766 }
767#endif
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700768 arg.flags = reply_flags;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700769 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
770 ip_hdr(skb)->saddr, /* XXX */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 arg.iov[0].iov_len, IPPROTO_TCP, 0);
772 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900773 if (oif)
774 arg.bound_dev_if = oif;
Eric Dumazet66b13d92011-10-24 03:06:21 -0400775 arg.tos = tos;
Eric Dumazetbe9f4a42012-07-19 07:34:03 +0000776 ip_send_unicast_reply(net, skb, ip_hdr(skb)->saddr,
David S. Miller70e73412012-06-28 03:21:41 -0700777 ip_hdr(skb)->daddr, &arg, arg.iov[0].iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778
Pavel Emelyanov63231bddf2008-07-16 20:22:25 -0700779 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780}
781
782static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
783{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700784 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800785 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900787 tcp_v4_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200788 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
Andrey Vaginee684b62013-02-11 05:50:19 +0000789 tcp_time_stamp + tcptw->tw_ts_offset,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900790 tcptw->tw_ts_recent,
791 tw->tw_bound_dev_if,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700792 tcp_twsk_md5_key(tcptw),
Eric Dumazet66b13d92011-10-24 03:06:21 -0400793 tw->tw_transparent ? IP_REPLY_ARG_NOSRCCHECK : 0,
794 tw->tw_tos
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900795 );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700797 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798}
799
Gui Jianfeng6edafaa2008-08-06 23:50:04 -0700800static void tcp_v4_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200801 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802{
Jerry Chu168a8f52012-08-31 12:29:13 +0000803 /* sk->sk_state == TCP_LISTEN -> for regular TCP_SYN_RECV
804 * sk->sk_state == TCP_SYN_RECV -> for Fast Open.
805 */
806 tcp_v4_send_ack(skb, (sk->sk_state == TCP_LISTEN) ?
807 tcp_rsk(req)->snt_isn + 1 : tcp_sk(sk)->snd_nxt,
808 tcp_rsk(req)->rcv_nxt, req->rcv_wnd,
Andrey Vaginee684b62013-02-11 05:50:19 +0000809 tcp_time_stamp,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900810 req->ts_recent,
811 0,
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000812 tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&ip_hdr(skb)->daddr,
813 AF_INET),
Eric Dumazet66b13d92011-10-24 03:06:21 -0400814 inet_rsk(req)->no_srccheck ? IP_REPLY_ARG_NOSRCCHECK : 0,
815 ip_hdr(skb)->tos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816}
817
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818/*
Kris Katterjohn9bf1d832008-02-17 22:29:19 -0800819 * Send a SYN-ACK after having received a SYN.
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700820 * This still operates on a request_sock only, not on a big
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 * socket.
822 */
Octavian Purdila72659ec2010-01-17 19:09:39 -0800823static int tcp_v4_send_synack(struct sock *sk, struct dst_entry *dst,
824 struct request_sock *req,
Christoph Paasch397b4172013-08-18 17:34:38 +0200825 u16 queue_mapping)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700827 const struct inet_request_sock *ireq = inet_rsk(req);
David S. Miller6bd023f2011-05-18 18:32:03 -0400828 struct flowi4 fl4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 int err = -1;
Weilong Chend41db5a2013-12-23 14:37:28 +0800830 struct sk_buff *skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831
832 /* First, grab a route. */
David S. Millerba3f7f02012-07-17 14:02:46 -0700833 if (!dst && (dst = inet_csk_route_req(sk, &fl4, req)) == NULL)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800834 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835
Christoph Paasch1a2c6182013-03-17 08:23:34 +0000836 skb = tcp_make_synack(sk, dst, req, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837
838 if (skb) {
Eric Dumazet634fb9792013-10-09 15:21:29 -0700839 __tcp_v4_send_check(skb, ireq->ir_loc_addr, ireq->ir_rmt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840
Eric Dumazetfff32692012-06-01 01:47:50 +0000841 skb_set_queue_mapping(skb, queue_mapping);
Eric Dumazet634fb9792013-10-09 15:21:29 -0700842 err = ip_build_and_send_pkt(skb, sk, ireq->ir_loc_addr,
843 ireq->ir_rmt_addr,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700844 ireq->opt);
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200845 err = net_xmit_eval(err);
Neal Cardwell016818d2012-09-22 04:18:55 +0000846 if (!tcp_rsk(req)->snt_synack && !err)
847 tcp_rsk(req)->snt_synack = tcp_time_stamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 }
849
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 return err;
851}
852
Christoph Paasch1a2c6182013-03-17 08:23:34 +0000853static int tcp_v4_rtx_synack(struct sock *sk, struct request_sock *req)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800854{
Christoph Paasch397b4172013-08-18 17:34:38 +0200855 int res = tcp_v4_send_synack(sk, NULL, req, 0);
Eric Dumazete6c022a2012-10-27 23:16:46 +0000856
Yuchung Chengf19c29e2014-03-03 12:31:36 -0800857 if (!res) {
Eric Dumazete6c022a2012-10-27 23:16:46 +0000858 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_RETRANSSEGS);
Yuchung Chengf19c29e2014-03-03 12:31:36 -0800859 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPSYNRETRANS);
860 }
Eric Dumazete6c022a2012-10-27 23:16:46 +0000861 return res;
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800862}
863
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700865 * IPv4 request_sock destructor.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 */
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700867static void tcp_v4_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868{
Jesper Juhla51482b2005-11-08 09:41:34 -0800869 kfree(inet_rsk(req)->opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870}
871
Eric Dumazet946cedc2011-08-30 03:21:44 +0000872/*
Eric Dumazeta2a385d2012-05-16 23:15:34 +0000873 * Return true if a syncookie should be sent
Eric Dumazet946cedc2011-08-30 03:21:44 +0000874 */
Eric Dumazeta2a385d2012-05-16 23:15:34 +0000875bool tcp_syn_flood_action(struct sock *sk,
Eric Dumazet946cedc2011-08-30 03:21:44 +0000876 const struct sk_buff *skb,
877 const char *proto)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878{
Eric Dumazet946cedc2011-08-30 03:21:44 +0000879 const char *msg = "Dropping request";
Eric Dumazeta2a385d2012-05-16 23:15:34 +0000880 bool want_cookie = false;
Eric Dumazet946cedc2011-08-30 03:21:44 +0000881 struct listen_sock *lopt;
882
883
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000885#ifdef CONFIG_SYN_COOKIES
Eric Dumazet946cedc2011-08-30 03:21:44 +0000886 if (sysctl_tcp_syncookies) {
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000887 msg = "Sending cookies";
Eric Dumazeta2a385d2012-05-16 23:15:34 +0000888 want_cookie = true;
Eric Dumazet946cedc2011-08-30 03:21:44 +0000889 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPREQQFULLDOCOOKIES);
890 } else
Arnaldo Carvalho de Melo80e40da2006-01-04 01:58:06 -0200891#endif
Eric Dumazet946cedc2011-08-30 03:21:44 +0000892 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPREQQFULLDROP);
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000893
Eric Dumazet946cedc2011-08-30 03:21:44 +0000894 lopt = inet_csk(sk)->icsk_accept_queue.listen_opt;
Hannes Frederic Sowa5ad37d52013-07-26 17:43:23 +0200895 if (!lopt->synflood_warned && sysctl_tcp_syncookies != 2) {
Eric Dumazet946cedc2011-08-30 03:21:44 +0000896 lopt->synflood_warned = 1;
Joe Perchesafd465032012-03-12 07:03:32 +0000897 pr_info("%s: Possible SYN flooding on port %d. %s. Check SNMP counters.\n",
Eric Dumazet946cedc2011-08-30 03:21:44 +0000898 proto, ntohs(tcp_hdr(skb)->dest), msg);
899 }
900 return want_cookie;
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000901}
Eric Dumazet946cedc2011-08-30 03:21:44 +0000902EXPORT_SYMBOL(tcp_syn_flood_action);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903
904/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700905 * Save and compile IPv4 options into the request_sock if needed.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 */
Christoph Paasch5dff7472012-09-26 11:59:09 +0000907static struct ip_options_rcu *tcp_v4_save_options(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908{
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000909 const struct ip_options *opt = &(IPCB(skb)->opt);
910 struct ip_options_rcu *dopt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911
912 if (opt && opt->optlen) {
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000913 int opt_size = sizeof(*dopt) + opt->optlen;
914
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 dopt = kmalloc(opt_size, GFP_ATOMIC);
916 if (dopt) {
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000917 if (ip_options_echo(&dopt->opt, skb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 kfree(dopt);
919 dopt = NULL;
920 }
921 }
922 }
923 return dopt;
924}
925
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800926#ifdef CONFIG_TCP_MD5SIG
927/*
928 * RFC2385 MD5 checksumming requires a mapping of
929 * IP address->MD5 Key.
930 * We need to maintain these in the sk structure.
931 */
932
933/* Find the Key structure for an address. */
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000934struct tcp_md5sig_key *tcp_md5_do_lookup(struct sock *sk,
935 const union tcp_md5_addr *addr,
936 int family)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800937{
938 struct tcp_sock *tp = tcp_sk(sk);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000939 struct tcp_md5sig_key *key;
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000940 unsigned int size = sizeof(struct in_addr);
Eric Dumazeta8afca02012-01-31 18:45:40 +0000941 struct tcp_md5sig_info *md5sig;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800942
Eric Dumazeta8afca02012-01-31 18:45:40 +0000943 /* caller either holds rcu_read_lock() or socket lock */
944 md5sig = rcu_dereference_check(tp->md5sig_info,
Eric Dumazetb4fb05e2012-03-07 04:45:43 +0000945 sock_owned_by_user(sk) ||
946 lockdep_is_held(&sk->sk_lock.slock));
Eric Dumazeta8afca02012-01-31 18:45:40 +0000947 if (!md5sig)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800948 return NULL;
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000949#if IS_ENABLED(CONFIG_IPV6)
950 if (family == AF_INET6)
951 size = sizeof(struct in6_addr);
952#endif
Sasha Levinb67bfe02013-02-27 17:06:00 -0800953 hlist_for_each_entry_rcu(key, &md5sig->head, node) {
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000954 if (key->family != family)
955 continue;
956 if (!memcmp(&key->addr, addr, size))
957 return key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800958 }
959 return NULL;
960}
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000961EXPORT_SYMBOL(tcp_md5_do_lookup);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800962
963struct tcp_md5sig_key *tcp_v4_md5_lookup(struct sock *sk,
964 struct sock *addr_sk)
965{
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000966 union tcp_md5_addr *addr;
967
968 addr = (union tcp_md5_addr *)&inet_sk(addr_sk)->inet_daddr;
969 return tcp_md5_do_lookup(sk, addr, AF_INET);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800970}
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800971EXPORT_SYMBOL(tcp_v4_md5_lookup);
972
Adrian Bunkf5b99bc2006-11-30 17:22:29 -0800973static struct tcp_md5sig_key *tcp_v4_reqsk_md5_lookup(struct sock *sk,
974 struct request_sock *req)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800975{
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000976 union tcp_md5_addr *addr;
977
Eric Dumazet634fb9792013-10-09 15:21:29 -0700978 addr = (union tcp_md5_addr *)&inet_rsk(req)->ir_rmt_addr;
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000979 return tcp_md5_do_lookup(sk, addr, AF_INET);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800980}
981
982/* This can be called on a newly created socket, from other files */
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000983int tcp_md5_do_add(struct sock *sk, const union tcp_md5_addr *addr,
984 int family, const u8 *newkey, u8 newkeylen, gfp_t gfp)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800985{
986 /* Add Key to the list */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700987 struct tcp_md5sig_key *key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800988 struct tcp_sock *tp = tcp_sk(sk);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000989 struct tcp_md5sig_info *md5sig;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800990
Aydin Arikc0353c72013-06-14 18:56:31 +1200991 key = tcp_md5_do_lookup(sk, addr, family);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800992 if (key) {
993 /* Pre-existing entry - just update that one. */
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000994 memcpy(key->key, newkey, newkeylen);
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700995 key->keylen = newkeylen;
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000996 return 0;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800997 }
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000998
Eric Dumazeta8afca02012-01-31 18:45:40 +0000999 md5sig = rcu_dereference_protected(tp->md5sig_info,
1000 sock_owned_by_user(sk));
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001001 if (!md5sig) {
1002 md5sig = kmalloc(sizeof(*md5sig), gfp);
1003 if (!md5sig)
1004 return -ENOMEM;
1005
1006 sk_nocaps_add(sk, NETIF_F_GSO_MASK);
1007 INIT_HLIST_HEAD(&md5sig->head);
Eric Dumazeta8afca02012-01-31 18:45:40 +00001008 rcu_assign_pointer(tp->md5sig_info, md5sig);
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001009 }
1010
Eric Dumazet5f3d9cb2012-01-31 10:56:48 +00001011 key = sock_kmalloc(sk, sizeof(*key), gfp);
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001012 if (!key)
1013 return -ENOMEM;
Eric Dumazet71cea172013-05-20 06:52:26 +00001014 if (!tcp_alloc_md5sig_pool()) {
Eric Dumazet5f3d9cb2012-01-31 10:56:48 +00001015 sock_kfree_s(sk, key, sizeof(*key));
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001016 return -ENOMEM;
1017 }
1018
1019 memcpy(key->key, newkey, newkeylen);
1020 key->keylen = newkeylen;
1021 key->family = family;
1022 memcpy(&key->addr, addr,
1023 (family == AF_INET6) ? sizeof(struct in6_addr) :
1024 sizeof(struct in_addr));
1025 hlist_add_head_rcu(&key->node, &md5sig->head);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001026 return 0;
1027}
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001028EXPORT_SYMBOL(tcp_md5_do_add);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001029
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001030int tcp_md5_do_del(struct sock *sk, const union tcp_md5_addr *addr, int family)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001031{
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001032 struct tcp_md5sig_key *key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001033
Aydin Arikc0353c72013-06-14 18:56:31 +12001034 key = tcp_md5_do_lookup(sk, addr, family);
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001035 if (!key)
1036 return -ENOENT;
1037 hlist_del_rcu(&key->node);
Eric Dumazet5f3d9cb2012-01-31 10:56:48 +00001038 atomic_sub(sizeof(*key), &sk->sk_omem_alloc);
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001039 kfree_rcu(key, rcu);
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001040 return 0;
1041}
1042EXPORT_SYMBOL(tcp_md5_do_del);
1043
stephen hemmingere0683e702012-10-26 14:31:40 +00001044static void tcp_clear_md5_list(struct sock *sk)
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001045{
1046 struct tcp_sock *tp = tcp_sk(sk);
1047 struct tcp_md5sig_key *key;
Sasha Levinb67bfe02013-02-27 17:06:00 -08001048 struct hlist_node *n;
Eric Dumazeta8afca02012-01-31 18:45:40 +00001049 struct tcp_md5sig_info *md5sig;
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001050
Eric Dumazeta8afca02012-01-31 18:45:40 +00001051 md5sig = rcu_dereference_protected(tp->md5sig_info, 1);
1052
Sasha Levinb67bfe02013-02-27 17:06:00 -08001053 hlist_for_each_entry_safe(key, n, &md5sig->head, node) {
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001054 hlist_del_rcu(&key->node);
Eric Dumazet5f3d9cb2012-01-31 10:56:48 +00001055 atomic_sub(sizeof(*key), &sk->sk_omem_alloc);
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001056 kfree_rcu(key, rcu);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001057 }
1058}
1059
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001060static int tcp_v4_parse_md5_keys(struct sock *sk, char __user *optval,
1061 int optlen)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001062{
1063 struct tcp_md5sig cmd;
1064 struct sockaddr_in *sin = (struct sockaddr_in *)&cmd.tcpm_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001065
1066 if (optlen < sizeof(cmd))
1067 return -EINVAL;
1068
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001069 if (copy_from_user(&cmd, optval, sizeof(cmd)))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001070 return -EFAULT;
1071
1072 if (sin->sin_family != AF_INET)
1073 return -EINVAL;
1074
Eric Dumazeta8afca02012-01-31 18:45:40 +00001075 if (!cmd.tcpm_key || !cmd.tcpm_keylen)
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001076 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin->sin_addr.s_addr,
1077 AF_INET);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001078
1079 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
1080 return -EINVAL;
1081
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001082 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin->sin_addr.s_addr,
1083 AF_INET, cmd.tcpm_key, cmd.tcpm_keylen,
1084 GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001085}
1086
Adam Langley49a72df2008-07-19 00:01:42 -07001087static int tcp_v4_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
1088 __be32 daddr, __be32 saddr, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001089{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001090 struct tcp4_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -07001091 struct scatterlist sg;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001092
1093 bp = &hp->md5_blk.ip4;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001094
1095 /*
Adam Langley49a72df2008-07-19 00:01:42 -07001096 * 1. the TCP pseudo-header (in the order: source IP address,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001097 * destination IP address, zero-padded protocol number, and
1098 * segment length)
1099 */
1100 bp->saddr = saddr;
1101 bp->daddr = daddr;
1102 bp->pad = 0;
YOSHIFUJI Hideaki076fb722008-04-17 12:48:12 +09001103 bp->protocol = IPPROTO_TCP;
Adam Langley49a72df2008-07-19 00:01:42 -07001104 bp->len = cpu_to_be16(nbytes);
David S. Millerc7da57a2007-10-26 00:41:21 -07001105
Adam Langley49a72df2008-07-19 00:01:42 -07001106 sg_init_one(&sg, bp, sizeof(*bp));
1107 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
1108}
1109
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001110static int tcp_v4_md5_hash_hdr(char *md5_hash, const struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -04001111 __be32 daddr, __be32 saddr, const struct tcphdr *th)
Adam Langley49a72df2008-07-19 00:01:42 -07001112{
1113 struct tcp_md5sig_pool *hp;
1114 struct hash_desc *desc;
1115
1116 hp = tcp_get_md5sig_pool();
1117 if (!hp)
1118 goto clear_hash_noput;
1119 desc = &hp->md5_desc;
1120
1121 if (crypto_hash_init(desc))
1122 goto clear_hash;
1123 if (tcp_v4_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
1124 goto clear_hash;
1125 if (tcp_md5_hash_header(hp, th))
1126 goto clear_hash;
1127 if (tcp_md5_hash_key(hp, key))
1128 goto clear_hash;
1129 if (crypto_hash_final(desc, md5_hash))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001130 goto clear_hash;
1131
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001132 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001133 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -07001134
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001135clear_hash:
1136 tcp_put_md5sig_pool();
1137clear_hash_noput:
1138 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -07001139 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001140}
1141
Adam Langley49a72df2008-07-19 00:01:42 -07001142int tcp_v4_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -04001143 const struct sock *sk, const struct request_sock *req,
1144 const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001145{
Adam Langley49a72df2008-07-19 00:01:42 -07001146 struct tcp_md5sig_pool *hp;
1147 struct hash_desc *desc;
Eric Dumazet318cf7a2011-10-24 02:46:04 -04001148 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001149 __be32 saddr, daddr;
1150
1151 if (sk) {
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001152 saddr = inet_sk(sk)->inet_saddr;
1153 daddr = inet_sk(sk)->inet_daddr;
Adam Langley49a72df2008-07-19 00:01:42 -07001154 } else if (req) {
Eric Dumazet634fb9792013-10-09 15:21:29 -07001155 saddr = inet_rsk(req)->ir_loc_addr;
1156 daddr = inet_rsk(req)->ir_rmt_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001157 } else {
Adam Langley49a72df2008-07-19 00:01:42 -07001158 const struct iphdr *iph = ip_hdr(skb);
1159 saddr = iph->saddr;
1160 daddr = iph->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001161 }
Adam Langley49a72df2008-07-19 00:01:42 -07001162
1163 hp = tcp_get_md5sig_pool();
1164 if (!hp)
1165 goto clear_hash_noput;
1166 desc = &hp->md5_desc;
1167
1168 if (crypto_hash_init(desc))
1169 goto clear_hash;
1170
1171 if (tcp_v4_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
1172 goto clear_hash;
1173 if (tcp_md5_hash_header(hp, th))
1174 goto clear_hash;
1175 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
1176 goto clear_hash;
1177 if (tcp_md5_hash_key(hp, key))
1178 goto clear_hash;
1179 if (crypto_hash_final(desc, md5_hash))
1180 goto clear_hash;
1181
1182 tcp_put_md5sig_pool();
1183 return 0;
1184
1185clear_hash:
1186 tcp_put_md5sig_pool();
1187clear_hash_noput:
1188 memset(md5_hash, 0, 16);
1189 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001190}
Adam Langley49a72df2008-07-19 00:01:42 -07001191EXPORT_SYMBOL(tcp_v4_md5_hash_skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001192
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001193static bool tcp_v4_inbound_md5_hash(struct sock *sk, const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001194{
1195 /*
1196 * This gets called for each TCP segment that arrives
1197 * so we want to be efficient.
1198 * We have 3 drop cases:
1199 * o No MD5 hash and one expected.
1200 * o MD5 hash and we're not expecting one.
1201 * o MD5 hash and its wrong.
1202 */
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001203 const __u8 *hash_location = NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001204 struct tcp_md5sig_key *hash_expected;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001205 const struct iphdr *iph = ip_hdr(skb);
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001206 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001207 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001208 unsigned char newhash[16];
1209
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001210 hash_expected = tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&iph->saddr,
1211 AF_INET);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +09001212 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001213
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001214 /* We've parsed the options - do we have a hash? */
1215 if (!hash_expected && !hash_location)
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001216 return false;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001217
1218 if (hash_expected && !hash_location) {
David S. Miller785957d2008-07-30 03:03:15 -07001219 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001220 return true;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001221 }
1222
1223 if (!hash_expected && hash_location) {
David S. Miller785957d2008-07-30 03:03:15 -07001224 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001225 return true;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001226 }
1227
1228 /* Okay, so this is hash_expected and hash_location -
1229 * so we need to calculate the checksum.
1230 */
Adam Langley49a72df2008-07-19 00:01:42 -07001231 genhash = tcp_v4_md5_hash_skb(newhash,
1232 hash_expected,
1233 NULL, NULL, skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001234
1235 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
Joe Perchese87cc472012-05-13 21:56:26 +00001236 net_info_ratelimited("MD5 Hash failed for (%pI4, %d)->(%pI4, %d)%s\n",
1237 &iph->saddr, ntohs(th->source),
1238 &iph->daddr, ntohs(th->dest),
1239 genhash ? " tcp_v4_calc_md5_hash failed"
1240 : "");
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001241 return true;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001242 }
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001243 return false;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001244}
1245
1246#endif
1247
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001248struct request_sock_ops tcp_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249 .family = PF_INET,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001250 .obj_size = sizeof(struct tcp_request_sock),
Octavian Purdila72659ec2010-01-17 19:09:39 -08001251 .rtx_syn_ack = tcp_v4_rtx_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001252 .send_ack = tcp_v4_reqsk_send_ack,
1253 .destructor = tcp_v4_reqsk_destructor,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 .send_reset = tcp_v4_send_reset,
Octavian Purdila72659ec2010-01-17 19:09:39 -08001255 .syn_ack_timeout = tcp_syn_ack_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256};
1257
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001258#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001259static const struct tcp_request_sock_ops tcp_request_sock_ipv4_ops = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001260 .md5_lookup = tcp_v4_reqsk_md5_lookup,
John Dykstrae3afe7b2009-07-16 05:04:51 +00001261 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001262};
Andrew Mortonb6332e62006-11-30 19:16:28 -08001263#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001264
Jerry Chu168a8f52012-08-31 12:29:13 +00001265static bool tcp_fastopen_check(struct sock *sk, struct sk_buff *skb,
1266 struct request_sock *req,
1267 struct tcp_fastopen_cookie *foc,
1268 struct tcp_fastopen_cookie *valid_foc)
1269{
1270 bool skip_cookie = false;
1271 struct fastopen_queue *fastopenq;
1272
1273 if (likely(!fastopen_cookie_present(foc))) {
1274 /* See include/net/tcp.h for the meaning of these knobs */
1275 if ((sysctl_tcp_fastopen & TFO_SERVER_ALWAYS) ||
1276 ((sysctl_tcp_fastopen & TFO_SERVER_COOKIE_NOT_REQD) &&
1277 (TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(skb)->seq + 1)))
1278 skip_cookie = true; /* no cookie to validate */
1279 else
1280 return false;
1281 }
1282 fastopenq = inet_csk(sk)->icsk_accept_queue.fastopenq;
1283 /* A FO option is present; bump the counter. */
1284 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPFASTOPENPASSIVE);
1285
1286 /* Make sure the listener has enabled fastopen, and we don't
1287 * exceed the max # of pending TFO requests allowed before trying
1288 * to validating the cookie in order to avoid burning CPU cycles
1289 * unnecessarily.
1290 *
1291 * XXX (TFO) - The implication of checking the max_qlen before
1292 * processing a cookie request is that clients can't differentiate
1293 * between qlen overflow causing Fast Open to be disabled
1294 * temporarily vs a server not supporting Fast Open at all.
1295 */
1296 if ((sysctl_tcp_fastopen & TFO_SERVER_ENABLE) == 0 ||
1297 fastopenq == NULL || fastopenq->max_qlen == 0)
1298 return false;
1299
1300 if (fastopenq->qlen >= fastopenq->max_qlen) {
1301 struct request_sock *req1;
1302 spin_lock(&fastopenq->lock);
1303 req1 = fastopenq->rskq_rst_head;
1304 if ((req1 == NULL) || time_after(req1->expires, jiffies)) {
1305 spin_unlock(&fastopenq->lock);
1306 NET_INC_STATS_BH(sock_net(sk),
1307 LINUX_MIB_TCPFASTOPENLISTENOVERFLOW);
1308 /* Avoid bumping LINUX_MIB_TCPFASTOPENPASSIVEFAIL*/
1309 foc->len = -1;
1310 return false;
1311 }
1312 fastopenq->rskq_rst_head = req1->dl_next;
1313 fastopenq->qlen--;
1314 spin_unlock(&fastopenq->lock);
1315 reqsk_free(req1);
1316 }
1317 if (skip_cookie) {
1318 tcp_rsk(req)->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
1319 return true;
1320 }
Yuchung Cheng149479d2013-08-08 14:06:22 -07001321
Jerry Chu168a8f52012-08-31 12:29:13 +00001322 if (foc->len == TCP_FASTOPEN_COOKIE_SIZE) {
1323 if ((sysctl_tcp_fastopen & TFO_SERVER_COOKIE_NOT_CHKED) == 0) {
Yuchung Cheng149479d2013-08-08 14:06:22 -07001324 tcp_fastopen_cookie_gen(ip_hdr(skb)->saddr,
1325 ip_hdr(skb)->daddr, valid_foc);
Jerry Chu168a8f52012-08-31 12:29:13 +00001326 if ((valid_foc->len != TCP_FASTOPEN_COOKIE_SIZE) ||
1327 memcmp(&foc->val[0], &valid_foc->val[0],
1328 TCP_FASTOPEN_COOKIE_SIZE) != 0)
1329 return false;
1330 valid_foc->len = -1;
1331 }
1332 /* Acknowledge the data received from the peer. */
1333 tcp_rsk(req)->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
1334 return true;
1335 } else if (foc->len == 0) { /* Client requesting a cookie */
Yuchung Cheng149479d2013-08-08 14:06:22 -07001336 tcp_fastopen_cookie_gen(ip_hdr(skb)->saddr,
1337 ip_hdr(skb)->daddr, valid_foc);
Jerry Chu168a8f52012-08-31 12:29:13 +00001338 NET_INC_STATS_BH(sock_net(sk),
1339 LINUX_MIB_TCPFASTOPENCOOKIEREQD);
1340 } else {
1341 /* Client sent a cookie with wrong size. Treat it
1342 * the same as invalid and return a valid one.
1343 */
Yuchung Cheng149479d2013-08-08 14:06:22 -07001344 tcp_fastopen_cookie_gen(ip_hdr(skb)->saddr,
1345 ip_hdr(skb)->daddr, valid_foc);
Jerry Chu168a8f52012-08-31 12:29:13 +00001346 }
1347 return false;
1348}
1349
1350static int tcp_v4_conn_req_fastopen(struct sock *sk,
1351 struct sk_buff *skb,
1352 struct sk_buff *skb_synack,
Christoph Paasch1a2c6182013-03-17 08:23:34 +00001353 struct request_sock *req)
Jerry Chu168a8f52012-08-31 12:29:13 +00001354{
1355 struct tcp_sock *tp = tcp_sk(sk);
1356 struct request_sock_queue *queue = &inet_csk(sk)->icsk_accept_queue;
1357 const struct inet_request_sock *ireq = inet_rsk(req);
1358 struct sock *child;
Neal Cardwell016818d2012-09-22 04:18:55 +00001359 int err;
Jerry Chu168a8f52012-08-31 12:29:13 +00001360
Eric Dumazete6c022a2012-10-27 23:16:46 +00001361 req->num_retrans = 0;
1362 req->num_timeout = 0;
Jerry Chu168a8f52012-08-31 12:29:13 +00001363 req->sk = NULL;
1364
1365 child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, req, NULL);
1366 if (child == NULL) {
1367 NET_INC_STATS_BH(sock_net(sk),
1368 LINUX_MIB_TCPFASTOPENPASSIVEFAIL);
1369 kfree_skb(skb_synack);
1370 return -1;
1371 }
Eric Dumazet634fb9792013-10-09 15:21:29 -07001372 err = ip_build_and_send_pkt(skb_synack, sk, ireq->ir_loc_addr,
1373 ireq->ir_rmt_addr, ireq->opt);
Neal Cardwell016818d2012-09-22 04:18:55 +00001374 err = net_xmit_eval(err);
1375 if (!err)
1376 tcp_rsk(req)->snt_synack = tcp_time_stamp;
Jerry Chu168a8f52012-08-31 12:29:13 +00001377 /* XXX (TFO) - is it ok to ignore error and continue? */
1378
1379 spin_lock(&queue->fastopenq->lock);
1380 queue->fastopenq->qlen++;
1381 spin_unlock(&queue->fastopenq->lock);
1382
1383 /* Initialize the child socket. Have to fix some values to take
1384 * into account the child is a Fast Open socket and is created
1385 * only out of the bits carried in the SYN packet.
1386 */
1387 tp = tcp_sk(child);
1388
1389 tp->fastopen_rsk = req;
1390 /* Do a hold on the listner sk so that if the listener is being
1391 * closed, the child that has been accepted can live on and still
1392 * access listen_lock.
1393 */
1394 sock_hold(sk);
1395 tcp_rsk(req)->listener = sk;
1396
1397 /* RFC1323: The window in SYN & SYN/ACK segments is never
1398 * scaled. So correct it appropriately.
1399 */
1400 tp->snd_wnd = ntohs(tcp_hdr(skb)->window);
1401
1402 /* Activate the retrans timer so that SYNACK can be retransmitted.
1403 * The request socket is not added to the SYN table of the parent
1404 * because it's been added to the accept queue directly.
1405 */
1406 inet_csk_reset_xmit_timer(child, ICSK_TIME_RETRANS,
1407 TCP_TIMEOUT_INIT, TCP_RTO_MAX);
1408
1409 /* Add the child socket directly into the accept queue */
1410 inet_csk_reqsk_queue_add(sk, req, child);
1411
1412 /* Now finish processing the fastopen child socket. */
1413 inet_csk(child)->icsk_af_ops->rebuild_header(child);
1414 tcp_init_congestion_control(child);
1415 tcp_mtup_init(child);
Jerry Chu168a8f52012-08-31 12:29:13 +00001416 tcp_init_metrics(child);
Eric Dumazet6ae70532013-10-01 10:23:44 -07001417 tcp_init_buffer_space(child);
Jerry Chu168a8f52012-08-31 12:29:13 +00001418
1419 /* Queue the data carried in the SYN packet. We need to first
1420 * bump skb's refcnt because the caller will attempt to free it.
1421 *
1422 * XXX (TFO) - we honor a zero-payload TFO request for now.
1423 * (Any reason not to?)
1424 */
1425 if (TCP_SKB_CB(skb)->end_seq == TCP_SKB_CB(skb)->seq + 1) {
1426 /* Don't queue the skb if there is no payload in SYN.
1427 * XXX (TFO) - How about SYN+FIN?
1428 */
1429 tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
1430 } else {
1431 skb = skb_get(skb);
1432 skb_dst_drop(skb);
1433 __skb_pull(skb, tcp_hdr(skb)->doff * 4);
1434 skb_set_owner_r(skb, child);
1435 __skb_queue_tail(&child->sk_receive_queue, skb);
1436 tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
Yuchung Cheng6f736012012-10-19 15:14:44 +00001437 tp->syn_data_acked = 1;
Jerry Chu168a8f52012-08-31 12:29:13 +00001438 }
1439 sk->sk_data_ready(sk, 0);
1440 bh_unlock_sock(child);
1441 sock_put(child);
1442 WARN_ON(req->sk == NULL);
1443 return 0;
1444}
1445
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1447{
1448 struct tcp_options_received tmp_opt;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001449 struct request_sock *req;
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001450 struct inet_request_sock *ireq;
William Allen Simpson4957faade2009-12-02 18:25:27 +00001451 struct tcp_sock *tp = tcp_sk(sk);
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001452 struct dst_entry *dst = NULL;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001453 __be32 saddr = ip_hdr(skb)->saddr;
1454 __be32 daddr = ip_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 __u32 isn = TCP_SKB_CB(skb)->when;
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001456 bool want_cookie = false;
Jerry Chu168a8f52012-08-31 12:29:13 +00001457 struct flowi4 fl4;
1458 struct tcp_fastopen_cookie foc = { .len = -1 };
1459 struct tcp_fastopen_cookie valid_foc = { .len = -1 };
1460 struct sk_buff *skb_synack;
1461 int do_fastopen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462
1463 /* Never answer to SYNs send to broadcast or multicast */
Eric Dumazet511c3f92009-06-02 05:14:27 +00001464 if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465 goto drop;
1466
1467 /* TW buckets are converted to open requests without
1468 * limitations, they conserve resources and peer is
1469 * evidently real one.
1470 */
Hannes Frederic Sowa5ad37d52013-07-26 17:43:23 +02001471 if ((sysctl_tcp_syncookies == 2 ||
1472 inet_csk_reqsk_queue_is_full(sk)) && !isn) {
Eric Dumazet946cedc2011-08-30 03:21:44 +00001473 want_cookie = tcp_syn_flood_action(sk, skb, "TCP");
1474 if (!want_cookie)
1475 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476 }
1477
1478 /* Accept backlog is full. If we have already queued enough
1479 * of warm entries in syn queue, drop request. It is better than
1480 * clogging syn queue with openreqs with exponentially increasing
1481 * timeout.
1482 */
Nivedita Singhvi2aeef182013-01-28 17:52:37 +00001483 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1) {
1484 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 goto drop;
Nivedita Singhvi2aeef182013-01-28 17:52:37 +00001486 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487
Arnaldo Carvalho de Meloce4a7d02008-06-10 12:39:35 -07001488 req = inet_reqsk_alloc(&tcp_request_sock_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 if (!req)
1490 goto drop;
1491
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001492#ifdef CONFIG_TCP_MD5SIG
1493 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv4_ops;
1494#endif
1495
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496 tcp_clear_options(&tmp_opt);
William Allen Simpsonbee7ca92009-11-10 09:51:18 +00001497 tmp_opt.mss_clamp = TCP_MSS_DEFAULT;
William Allen Simpson4957faade2009-12-02 18:25:27 +00001498 tmp_opt.user_mss = tp->rx_opt.user_mss;
Christoph Paasch1a2c6182013-03-17 08:23:34 +00001499 tcp_parse_options(skb, &tmp_opt, 0, want_cookie ? NULL : &foc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500
Florian Westphal4dfc2812008-04-10 03:12:40 -07001501 if (want_cookie && !tmp_opt.saw_tstamp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502 tcp_clear_options(&tmp_opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505 tcp_openreq_init(req, &tmp_opt, skb);
1506
David S. Millerbb5b7c12009-12-15 20:56:42 -08001507 ireq = inet_rsk(req);
Eric Dumazet634fb9792013-10-09 15:21:29 -07001508 ireq->ir_loc_addr = daddr;
1509 ireq->ir_rmt_addr = saddr;
David S. Millerbb5b7c12009-12-15 20:56:42 -08001510 ireq->no_srccheck = inet_sk(sk)->transparent;
Christoph Paasch5dff7472012-09-26 11:59:09 +00001511 ireq->opt = tcp_v4_save_options(skb);
David S. Millerbb5b7c12009-12-15 20:56:42 -08001512
Paul Moore284904a2009-03-27 17:10:28 -04001513 if (security_inet_conn_request(sk, skb, req))
David S. Millerbb5b7c12009-12-15 20:56:42 -08001514 goto drop_and_free;
Paul Moore284904a2009-03-27 17:10:28 -04001515
Florian Westphal172d69e2010-06-21 11:48:45 +00001516 if (!want_cookie || tmp_opt.tstamp_ok)
Hannes Frederic Sowa5d134f12013-01-05 16:10:48 +00001517 TCP_ECN_create_request(req, skb, sock_net(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518
1519 if (want_cookie) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520 isn = cookie_v4_init_sequence(sk, skb, &req->mss);
Florian Westphal172d69e2010-06-21 11:48:45 +00001521 req->cookie_ts = tmp_opt.tstamp_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 } else if (!isn) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523 /* VJ's idea. We save last timestamp seen
1524 * from the destination in peer table, when entering
1525 * state TIME-WAIT, and check against it before
1526 * accepting new connection request.
1527 *
1528 * If "isn" is not zero, this request hit alive
1529 * timewait bucket, so that all the necessary checks
1530 * are made in the function processing timewait state.
1531 */
1532 if (tmp_opt.saw_tstamp &&
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001533 tcp_death_row.sysctl_tw_recycle &&
David S. Millerba3f7f02012-07-17 14:02:46 -07001534 (dst = inet_csk_route_req(sk, &fl4, req)) != NULL &&
David S. Miller81166dd2012-07-10 03:14:24 -07001535 fl4.daddr == saddr) {
1536 if (!tcp_peer_is_proven(req, dst, true)) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001537 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001538 goto drop_and_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539 }
1540 }
1541 /* Kill the following clause, if you dislike this way. */
1542 else if (!sysctl_tcp_syncookies &&
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001543 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 (sysctl_max_syn_backlog >> 2)) &&
David S. Miller81166dd2012-07-10 03:14:24 -07001545 !tcp_peer_is_proven(req, dst, false)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546 /* Without syncookies last quarter of
1547 * backlog is filled with destinations,
1548 * proven to be alive.
1549 * It means that we continue to communicate
1550 * to destinations, already remembered
1551 * to the moment of synflood.
1552 */
Joe Perchesafd465032012-03-12 07:03:32 +00001553 LIMIT_NETDEBUG(KERN_DEBUG pr_fmt("drop open request from %pI4/%u\n"),
Harvey Harrison673d57e2008-10-31 00:53:57 -07001554 &saddr, ntohs(tcp_hdr(skb)->source));
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001555 goto drop_and_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556 }
1557
Gerrit Renkera94f7232006-11-10 14:06:49 -08001558 isn = tcp_v4_init_sequence(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 }
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001560 tcp_rsk(req)->snt_isn = isn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561
Jerry Chu168a8f52012-08-31 12:29:13 +00001562 if (dst == NULL) {
1563 dst = inet_csk_route_req(sk, &fl4, req);
1564 if (dst == NULL)
1565 goto drop_and_free;
1566 }
1567 do_fastopen = tcp_fastopen_check(sk, skb, req, &foc, &valid_foc);
1568
1569 /* We don't call tcp_v4_send_synack() directly because we need
1570 * to make sure a child socket can be created successfully before
1571 * sending back synack!
1572 *
1573 * XXX (TFO) - Ideally one would simply call tcp_v4_send_synack()
1574 * (or better yet, call tcp_send_synack() in the child context
1575 * directly, but will have to fix bunch of other code first)
1576 * after syn_recv_sock() except one will need to first fix the
1577 * latter to remove its dependency on the current implementation
1578 * of tcp_v4_send_synack()->tcp_select_initial_window().
1579 */
1580 skb_synack = tcp_make_synack(sk, dst, req,
Jerry Chu168a8f52012-08-31 12:29:13 +00001581 fastopen_cookie_present(&valid_foc) ? &valid_foc : NULL);
1582
1583 if (skb_synack) {
Eric Dumazet634fb9792013-10-09 15:21:29 -07001584 __tcp_v4_send_check(skb_synack, ireq->ir_loc_addr, ireq->ir_rmt_addr);
Jerry Chu168a8f52012-08-31 12:29:13 +00001585 skb_set_queue_mapping(skb_synack, skb_get_queue_mapping(skb));
1586 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 goto drop_and_free;
1588
Jerry Chu168a8f52012-08-31 12:29:13 +00001589 if (likely(!do_fastopen)) {
1590 int err;
Eric Dumazet634fb9792013-10-09 15:21:29 -07001591 err = ip_build_and_send_pkt(skb_synack, sk, ireq->ir_loc_addr,
1592 ireq->ir_rmt_addr, ireq->opt);
Jerry Chu168a8f52012-08-31 12:29:13 +00001593 err = net_xmit_eval(err);
1594 if (err || want_cookie)
1595 goto drop_and_free;
1596
Neal Cardwell016818d2012-09-22 04:18:55 +00001597 tcp_rsk(req)->snt_synack = tcp_time_stamp;
Jerry Chu168a8f52012-08-31 12:29:13 +00001598 tcp_rsk(req)->listener = NULL;
1599 /* Add the request_sock to the SYN table */
1600 inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
1601 if (fastopen_cookie_present(&foc) && foc.len != 0)
1602 NET_INC_STATS_BH(sock_net(sk),
1603 LINUX_MIB_TCPFASTOPENPASSIVEFAIL);
Christoph Paasch1a2c6182013-03-17 08:23:34 +00001604 } else if (tcp_v4_conn_req_fastopen(sk, skb, skb_synack, req))
Jerry Chu168a8f52012-08-31 12:29:13 +00001605 goto drop_and_free;
1606
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607 return 0;
1608
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001609drop_and_release:
1610 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611drop_and_free:
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001612 reqsk_free(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613drop:
Vijay Subramanian848bf152013-01-31 08:24:06 +00001614 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615 return 0;
1616}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001617EXPORT_SYMBOL(tcp_v4_conn_request);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618
1619
1620/*
1621 * The three way handshake has completed - we got a valid synack -
1622 * now create the new socket.
1623 */
1624struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001625 struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626 struct dst_entry *dst)
1627{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001628 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 struct inet_sock *newinet;
1630 struct tcp_sock *newtp;
1631 struct sock *newsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001632#ifdef CONFIG_TCP_MD5SIG
1633 struct tcp_md5sig_key *key;
1634#endif
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001635 struct ip_options_rcu *inet_opt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636
1637 if (sk_acceptq_is_full(sk))
1638 goto exit_overflow;
1639
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640 newsk = tcp_create_openreq_child(sk, req, skb);
1641 if (!newsk)
Balazs Scheidler093d2822010-10-21 13:06:43 +02001642 goto exit_nonewsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643
Herbert Xubcd76112006-06-30 13:36:35 -07001644 newsk->sk_gso_type = SKB_GSO_TCPV4;
Neal Cardwellfae6ef82012-08-19 03:30:38 +00001645 inet_sk_rx_dst_set(newsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646
1647 newtp = tcp_sk(newsk);
1648 newinet = inet_sk(newsk);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001649 ireq = inet_rsk(req);
Eric Dumazet634fb9792013-10-09 15:21:29 -07001650 newinet->inet_daddr = ireq->ir_rmt_addr;
1651 newinet->inet_rcv_saddr = ireq->ir_loc_addr;
1652 newinet->inet_saddr = ireq->ir_loc_addr;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001653 inet_opt = ireq->opt;
1654 rcu_assign_pointer(newinet->inet_opt, inet_opt);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001655 ireq->opt = NULL;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001656 newinet->mc_index = inet_iif(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001657 newinet->mc_ttl = ip_hdr(skb)->ttl;
Jiri Benc4c507d22012-02-09 09:35:49 +00001658 newinet->rcv_tos = ip_hdr(skb)->tos;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001659 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001660 if (inet_opt)
1661 inet_csk(newsk)->icsk_ext_hdr_len = inet_opt->opt.optlen;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001662 newinet->inet_id = newtp->write_seq ^ jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663
Eric Dumazetdfd25ff2012-03-10 09:20:21 +00001664 if (!dst) {
1665 dst = inet_csk_route_child_sock(sk, newsk, req);
1666 if (!dst)
1667 goto put_and_exit;
1668 } else {
1669 /* syncookie case : see end of cookie_v4_check() */
1670 }
David S. Miller0e734412011-05-08 15:28:03 -07001671 sk_setup_caps(newsk, dst);
1672
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673 tcp_sync_mss(newsk, dst_mtu(dst));
David S. Miller0dbaee32010-12-13 12:52:14 -08001674 newtp->advmss = dst_metric_advmss(dst);
Tom Quetchenbachf5fff5d2008-09-21 00:21:51 -07001675 if (tcp_sk(sk)->rx_opt.user_mss &&
1676 tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1677 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1678
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679 tcp_initialize_rcv_mss(newsk);
1680
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001681#ifdef CONFIG_TCP_MD5SIG
1682 /* Copy over the MD5 key from the original socket */
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001683 key = tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&newinet->inet_daddr,
1684 AF_INET);
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001685 if (key != NULL) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001686 /*
1687 * We're using one, so create a matching key
1688 * on the newsk structure. If we fail to get
1689 * memory, then we end up not copying the key
1690 * across. Shucks.
1691 */
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001692 tcp_md5_do_add(newsk, (union tcp_md5_addr *)&newinet->inet_daddr,
1693 AF_INET, key->key, key->keylen, GFP_ATOMIC);
Eric Dumazeta4654192010-05-16 00:36:33 -07001694 sk_nocaps_add(newsk, NETIF_F_GSO_MASK);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001695 }
1696#endif
1697
David S. Miller0e734412011-05-08 15:28:03 -07001698 if (__inet_inherit_port(sk, newsk) < 0)
1699 goto put_and_exit;
Eric Dumazet9327f702009-12-04 03:46:54 +00001700 __inet_hash_nolisten(newsk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701
1702 return newsk;
1703
1704exit_overflow:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001705 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001706exit_nonewsk:
1707 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708exit:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001709 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710 return NULL;
David S. Miller0e734412011-05-08 15:28:03 -07001711put_and_exit:
Christoph Paasche337e242012-12-14 04:07:58 +00001712 inet_csk_prepare_forced_close(newsk);
1713 tcp_done(newsk);
David S. Miller0e734412011-05-08 15:28:03 -07001714 goto exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001716EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717
1718static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
1719{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001720 struct tcphdr *th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001721 const struct iphdr *iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722 struct sock *nsk;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001723 struct request_sock **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 /* Find possible connection requests. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001725 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
1726 iph->saddr, iph->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727 if (req)
Jerry Chu83368862012-08-31 12:29:12 +00001728 return tcp_check_req(sk, skb, req, prev, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001730 nsk = inet_lookup_established(sock_net(sk), &tcp_hashinfo, iph->saddr,
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001731 th->source, iph->daddr, th->dest, inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732
1733 if (nsk) {
1734 if (nsk->sk_state != TCP_TIME_WAIT) {
1735 bh_lock_sock(nsk);
1736 return nsk;
1737 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001738 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739 return NULL;
1740 }
1741
1742#ifdef CONFIG_SYN_COOKIES
Florian Westphalaf9b4732010-06-03 00:43:44 +00001743 if (!th->syn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
1745#endif
1746 return sk;
1747}
1748
Al Virob51655b2006-11-14 21:40:42 -08001749static __sum16 tcp_v4_checksum_init(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001751 const struct iphdr *iph = ip_hdr(skb);
1752
Patrick McHardy84fa7932006-08-29 16:44:56 -07001753 if (skb->ip_summed == CHECKSUM_COMPLETE) {
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001754 if (!tcp_v4_check(skb->len, iph->saddr,
1755 iph->daddr, skb->csum)) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001756 skb->ip_summed = CHECKSUM_UNNECESSARY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 return 0;
Herbert Xufb286bb2005-11-10 13:01:24 -08001758 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759 }
Herbert Xufb286bb2005-11-10 13:01:24 -08001760
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001761 skb->csum = csum_tcpudp_nofold(iph->saddr, iph->daddr,
Herbert Xufb286bb2005-11-10 13:01:24 -08001762 skb->len, IPPROTO_TCP, 0);
1763
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764 if (skb->len <= 76) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001765 return __skb_checksum_complete(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766 }
1767 return 0;
1768}
1769
1770
1771/* The socket must have it's spinlock held when we get
1772 * here.
1773 *
1774 * We have a potential double-lock case here, so even when
1775 * doing backlog processing we use the BH locking scheme.
1776 * This is because we cannot sleep with the original spinlock
1777 * held.
1778 */
1779int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1780{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001781 struct sock *rsk;
1782#ifdef CONFIG_TCP_MD5SIG
1783 /*
1784 * We really want to reject the packet as early as possible
1785 * if:
1786 * o We're expecting an MD5'd packet and this is no MD5 tcp option
1787 * o There is an MD5 option and we're not expecting one
1788 */
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001789 if (tcp_v4_inbound_md5_hash(sk, skb))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001790 goto discard;
1791#endif
1792
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
Eric Dumazet404e0a82012-07-29 23:20:37 +00001794 struct dst_entry *dst = sk->sk_rx_dst;
1795
Tom Herbertbdeab992011-08-14 19:45:55 +00001796 sock_rps_save_rxhash(sk, skb);
Eric Dumazet404e0a82012-07-29 23:20:37 +00001797 if (dst) {
Eric Dumazet505fbcf2012-07-27 06:23:40 +00001798 if (inet_sk(sk)->rx_dst_ifindex != skb->skb_iif ||
1799 dst->ops->check(dst, 0) == NULL) {
David S. Miller92101b32012-07-23 16:29:00 -07001800 dst_release(dst);
1801 sk->sk_rx_dst = NULL;
1802 }
1803 }
Vijay Subramanianc995ae22013-09-03 12:23:22 -07001804 tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805 return 0;
1806 }
1807
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07001808 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001809 goto csum_err;
1810
1811 if (sk->sk_state == TCP_LISTEN) {
1812 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
1813 if (!nsk)
1814 goto discard;
1815
1816 if (nsk != sk) {
Tom Herbertbdeab992011-08-14 19:45:55 +00001817 sock_rps_save_rxhash(nsk, skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001818 if (tcp_child_process(sk, nsk, skb)) {
1819 rsk = nsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001821 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822 return 0;
1823 }
Eric Dumazetca551582010-06-03 09:03:58 +00001824 } else
Tom Herbertbdeab992011-08-14 19:45:55 +00001825 sock_rps_save_rxhash(sk, skb);
Eric Dumazetca551582010-06-03 09:03:58 +00001826
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001827 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001828 rsk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001830 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831 return 0;
1832
1833reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001834 tcp_v4_send_reset(rsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835discard:
1836 kfree_skb(skb);
1837 /* Be careful here. If this function gets more complicated and
1838 * gcc suffers from register pressure on the x86, sk (in %ebx)
1839 * might be destroyed here. This current version compiles correctly,
1840 * but you have been warned.
1841 */
1842 return 0;
1843
1844csum_err:
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001845 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_CSUMERRORS);
Pavel Emelyanov63231bddf2008-07-16 20:22:25 -07001846 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847 goto discard;
1848}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001849EXPORT_SYMBOL(tcp_v4_do_rcv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850
David S. Miller160eb5a2012-06-27 22:01:22 -07001851void tcp_v4_early_demux(struct sk_buff *skb)
David S. Miller41063e92012-06-19 21:22:05 -07001852{
David S. Miller41063e92012-06-19 21:22:05 -07001853 const struct iphdr *iph;
1854 const struct tcphdr *th;
1855 struct sock *sk;
David S. Miller41063e92012-06-19 21:22:05 -07001856
David S. Miller41063e92012-06-19 21:22:05 -07001857 if (skb->pkt_type != PACKET_HOST)
David S. Miller160eb5a2012-06-27 22:01:22 -07001858 return;
David S. Miller41063e92012-06-19 21:22:05 -07001859
Eric Dumazet45f00f92012-10-22 21:42:47 +00001860 if (!pskb_may_pull(skb, skb_transport_offset(skb) + sizeof(struct tcphdr)))
David S. Miller160eb5a2012-06-27 22:01:22 -07001861 return;
David S. Miller41063e92012-06-19 21:22:05 -07001862
1863 iph = ip_hdr(skb);
Eric Dumazet45f00f92012-10-22 21:42:47 +00001864 th = tcp_hdr(skb);
David S. Miller41063e92012-06-19 21:22:05 -07001865
1866 if (th->doff < sizeof(struct tcphdr) / 4)
David S. Miller160eb5a2012-06-27 22:01:22 -07001867 return;
David S. Miller41063e92012-06-19 21:22:05 -07001868
Eric Dumazet45f00f92012-10-22 21:42:47 +00001869 sk = __inet_lookup_established(dev_net(skb->dev), &tcp_hashinfo,
David S. Miller41063e92012-06-19 21:22:05 -07001870 iph->saddr, th->source,
Vijay Subramanian7011d082012-06-23 17:38:10 +00001871 iph->daddr, ntohs(th->dest),
Eric Dumazet9cb429d2012-07-24 01:19:31 +00001872 skb->skb_iif);
David S. Miller41063e92012-06-19 21:22:05 -07001873 if (sk) {
1874 skb->sk = sk;
1875 skb->destructor = sock_edemux;
1876 if (sk->sk_state != TCP_TIME_WAIT) {
1877 struct dst_entry *dst = sk->sk_rx_dst;
Eric Dumazet505fbcf2012-07-27 06:23:40 +00001878
David S. Miller41063e92012-06-19 21:22:05 -07001879 if (dst)
1880 dst = dst_check(dst, 0);
David S. Miller92101b32012-07-23 16:29:00 -07001881 if (dst &&
Eric Dumazet505fbcf2012-07-27 06:23:40 +00001882 inet_sk(sk)->rx_dst_ifindex == skb->skb_iif)
David S. Miller92101b32012-07-23 16:29:00 -07001883 skb_dst_set_noref(skb, dst);
David S. Miller41063e92012-06-19 21:22:05 -07001884 }
1885 }
David S. Miller41063e92012-06-19 21:22:05 -07001886}
1887
Eric Dumazetb2fb4f52013-03-06 12:58:01 +00001888/* Packet is added to VJ-style prequeue for processing in process
1889 * context, if a reader task is waiting. Apparently, this exciting
1890 * idea (VJ's mail "Re: query about TCP header on tcp-ip" of 07 Sep 93)
1891 * failed somewhere. Latency? Burstiness? Well, at least now we will
1892 * see, why it failed. 8)8) --ANK
1893 *
1894 */
1895bool tcp_prequeue(struct sock *sk, struct sk_buff *skb)
1896{
1897 struct tcp_sock *tp = tcp_sk(sk);
1898
1899 if (sysctl_tcp_low_latency || !tp->ucopy.task)
1900 return false;
1901
1902 if (skb->len <= tcp_hdrlen(skb) &&
1903 skb_queue_len(&tp->ucopy.prequeue) == 0)
1904 return false;
1905
David S. Miller58717682013-04-30 03:50:54 -04001906 skb_dst_force(skb);
Eric Dumazetb2fb4f52013-03-06 12:58:01 +00001907 __skb_queue_tail(&tp->ucopy.prequeue, skb);
1908 tp->ucopy.memory += skb->truesize;
1909 if (tp->ucopy.memory > sk->sk_rcvbuf) {
1910 struct sk_buff *skb1;
1911
1912 BUG_ON(sock_owned_by_user(sk));
1913
1914 while ((skb1 = __skb_dequeue(&tp->ucopy.prequeue)) != NULL) {
1915 sk_backlog_rcv(sk, skb1);
1916 NET_INC_STATS_BH(sock_net(sk),
1917 LINUX_MIB_TCPPREQUEUEDROPPED);
1918 }
1919
1920 tp->ucopy.memory = 0;
1921 } else if (skb_queue_len(&tp->ucopy.prequeue) == 1) {
1922 wake_up_interruptible_sync_poll(sk_sleep(sk),
1923 POLLIN | POLLRDNORM | POLLRDBAND);
1924 if (!inet_csk_ack_scheduled(sk))
1925 inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
1926 (3 * tcp_rto_min(sk)) / 4,
1927 TCP_RTO_MAX);
1928 }
1929 return true;
1930}
1931EXPORT_SYMBOL(tcp_prequeue);
1932
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933/*
1934 * From tcp_input.c
1935 */
1936
1937int tcp_v4_rcv(struct sk_buff *skb)
1938{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001939 const struct iphdr *iph;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001940 const struct tcphdr *th;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941 struct sock *sk;
1942 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001943 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944
1945 if (skb->pkt_type != PACKET_HOST)
1946 goto discard_it;
1947
1948 /* Count it even if it's bad */
Pavel Emelyanov63231bddf2008-07-16 20:22:25 -07001949 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950
1951 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1952 goto discard_it;
1953
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001954 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955
1956 if (th->doff < sizeof(struct tcphdr) / 4)
1957 goto bad_packet;
1958 if (!pskb_may_pull(skb, th->doff * 4))
1959 goto discard_it;
1960
1961 /* An explanation is required here, I think.
1962 * Packet length and doff are validated by header prediction,
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -08001963 * provided case of th->doff==0 is eliminated.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964 * So, we defer the checks. */
Herbert Xu60476372007-04-09 11:59:39 -07001965 if (!skb_csum_unnecessary(skb) && tcp_v4_checksum_init(skb))
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00001966 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001968 th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001969 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1971 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1972 skb->len - th->doff * 4);
1973 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1974 TCP_SKB_CB(skb)->when = 0;
Eric Dumazetb82d1bb2011-09-27 02:20:08 -04001975 TCP_SKB_CB(skb)->ip_dsfield = ipv4_get_dsfield(iph);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976 TCP_SKB_CB(skb)->sacked = 0;
1977
Arnaldo Carvalho de Melo9a1f27c2008-10-07 11:41:57 -07001978 sk = __inet_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979 if (!sk)
1980 goto no_tcp_socket;
1981
Eric Dumazetbb134d52010-03-09 05:55:56 +00001982process:
1983 if (sk->sk_state == TCP_TIME_WAIT)
1984 goto do_time_wait;
1985
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001986 if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
1987 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
Stephen Hemmingerd218d112010-01-11 16:28:01 -08001988 goto discard_and_relse;
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001989 }
Stephen Hemmingerd218d112010-01-11 16:28:01 -08001990
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1992 goto discard_and_relse;
Patrick McHardyb59c2702006-01-06 23:06:10 -08001993 nf_reset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001995 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996 goto discard_and_relse;
1997
Eliezer Tamir8b80cda2013-07-10 17:13:26 +03001998 sk_mark_napi_id(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999 skb->dev = NULL;
2000
Ingo Molnarc6366182006-07-03 00:25:13 -07002001 bh_lock_sock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002 ret = 0;
2003 if (!sock_owned_by_user(sk)) {
Chris Leech1a2449a2006-05-23 18:05:53 -07002004#ifdef CONFIG_NET_DMA
2005 struct tcp_sock *tp = tcp_sk(sk);
2006 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
Dave Jianga2bd1142012-04-04 16:10:46 -07002007 tp->ucopy.dma_chan = net_dma_find_channel();
Chris Leech1a2449a2006-05-23 18:05:53 -07002008 if (tp->ucopy.dma_chan)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002009 ret = tcp_v4_do_rcv(sk, skb);
Chris Leech1a2449a2006-05-23 18:05:53 -07002010 else
2011#endif
2012 {
2013 if (!tcp_prequeue(sk, skb))
Shan Weiae8d7f82009-05-05 01:01:29 +00002014 ret = tcp_v4_do_rcv(sk, skb);
Chris Leech1a2449a2006-05-23 18:05:53 -07002015 }
Eric Dumazetda882c12012-04-22 23:38:54 +00002016 } else if (unlikely(sk_add_backlog(sk, skb,
2017 sk->sk_rcvbuf + sk->sk_sndbuf))) {
Zhu Yi6b03a532010-03-04 18:01:41 +00002018 bh_unlock_sock(sk);
Eric Dumazet6cce09f2010-03-07 23:21:57 +00002019 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
Zhu Yi6b03a532010-03-04 18:01:41 +00002020 goto discard_and_relse;
2021 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022 bh_unlock_sock(sk);
2023
2024 sock_put(sk);
2025
2026 return ret;
2027
2028no_tcp_socket:
2029 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
2030 goto discard_it;
2031
2032 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00002033csum_error:
2034 TCP_INC_STATS_BH(net, TCP_MIB_CSUMERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035bad_packet:
Pavel Emelyanov63231bddf2008-07-16 20:22:25 -07002036 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002037 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08002038 tcp_v4_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039 }
2040
2041discard_it:
2042 /* Discard frame. */
2043 kfree_skb(skb);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002044 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002045
2046discard_and_relse:
2047 sock_put(sk);
2048 goto discard_it;
2049
2050do_time_wait:
2051 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07002052 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002053 goto discard_it;
2054 }
2055
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00002056 if (skb->len < (th->doff << 2)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07002057 inet_twsk_put(inet_twsk(sk));
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +00002058 goto bad_packet;
2059 }
2060 if (tcp_checksum_complete(skb)) {
2061 inet_twsk_put(inet_twsk(sk));
2062 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07002064 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002065 case TCP_TW_SYN: {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09002066 struct sock *sk2 = inet_lookup_listener(dev_net(skb->dev),
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08002067 &tcp_hashinfo,
Tom Herbertda5e3632013-01-22 09:50:24 +00002068 iph->saddr, th->source,
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07002069 iph->daddr, th->dest,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002070 inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002071 if (sk2) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07002072 inet_twsk_deschedule(inet_twsk(sk), &tcp_death_row);
2073 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074 sk = sk2;
2075 goto process;
2076 }
2077 /* Fall through to ACK */
2078 }
2079 case TCP_TW_ACK:
2080 tcp_v4_timewait_ack(sk, skb);
2081 break;
2082 case TCP_TW_RST:
2083 goto no_tcp_socket;
2084 case TCP_TW_SUCCESS:;
2085 }
2086 goto discard_it;
2087}
2088
David S. Millerccb7c412010-12-01 18:09:13 -08002089static struct timewait_sock_ops tcp_timewait_sock_ops = {
2090 .twsk_obj_size = sizeof(struct tcp_timewait_sock),
2091 .twsk_unique = tcp_twsk_unique,
2092 .twsk_destructor= tcp_twsk_destructor,
David S. Millerccb7c412010-12-01 18:09:13 -08002093};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094
Eric Dumazet63d02d12012-08-09 14:11:00 +00002095void inet_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb)
Eric Dumazet5d299f32012-08-06 05:09:33 +00002096{
2097 struct dst_entry *dst = skb_dst(skb);
2098
2099 dst_hold(dst);
2100 sk->sk_rx_dst = dst;
2101 inet_sk(sk)->rx_dst_ifindex = skb->skb_iif;
2102}
Eric Dumazet63d02d12012-08-09 14:11:00 +00002103EXPORT_SYMBOL(inet_sk_rx_dst_set);
Eric Dumazet5d299f32012-08-06 05:09:33 +00002104
Stephen Hemminger3b401a82009-09-01 19:25:04 +00002105const struct inet_connection_sock_af_ops ipv4_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002106 .queue_xmit = ip_queue_xmit,
2107 .send_check = tcp_v4_send_check,
2108 .rebuild_header = inet_sk_rebuild_header,
Eric Dumazet5d299f32012-08-06 05:09:33 +00002109 .sk_rx_dst_set = inet_sk_rx_dst_set,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002110 .conn_request = tcp_v4_conn_request,
2111 .syn_recv_sock = tcp_v4_syn_recv_sock,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002112 .net_header_len = sizeof(struct iphdr),
2113 .setsockopt = ip_setsockopt,
2114 .getsockopt = ip_getsockopt,
2115 .addr2sockaddr = inet_csk_addr2sockaddr,
2116 .sockaddr_len = sizeof(struct sockaddr_in),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08002117 .bind_conflict = inet_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08002118#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002119 .compat_setsockopt = compat_ip_setsockopt,
2120 .compat_getsockopt = compat_ip_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08002121#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002122};
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002123EXPORT_SYMBOL(ipv4_specific);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002124
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08002125#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00002126static const struct tcp_sock_af_ops tcp_sock_ipv4_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08002127 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07002128 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08002129 .md5_parse = tcp_v4_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08002130};
Andrew Mortonb6332e62006-11-30 19:16:28 -08002131#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08002132
Linus Torvalds1da177e2005-04-16 15:20:36 -07002133/* NOTE: A lot of things set to zero explicitly by call to
2134 * sk_alloc() so need not be done here.
2135 */
2136static int tcp_v4_init_sock(struct sock *sk)
2137{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03002138 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139
Neal Cardwell900f65d2012-04-19 09:55:21 +00002140 tcp_init_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002141
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08002142 icsk->icsk_af_ops = &ipv4_specific;
Neal Cardwell900f65d2012-04-19 09:55:21 +00002143
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08002144#ifdef CONFIG_TCP_MD5SIG
David S. Millerac807fa2012-04-23 03:21:58 -04002145 tcp_sk(sk)->af_specific = &tcp_sock_ipv4_specific;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08002146#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002147
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148 return 0;
2149}
2150
Brian Haley7d06b2e2008-06-14 17:04:49 -07002151void tcp_v4_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002152{
2153 struct tcp_sock *tp = tcp_sk(sk);
2154
2155 tcp_clear_xmit_timers(sk);
2156
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03002157 tcp_cleanup_congestion_control(sk);
Stephen Hemminger317a76f2005-06-23 12:19:55 -07002158
Linus Torvalds1da177e2005-04-16 15:20:36 -07002159 /* Cleanup up the write buffer. */
David S. Millerfe067e82007-03-07 12:12:44 -08002160 tcp_write_queue_purge(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002161
2162 /* Cleans up our, hopefully empty, out_of_order_queue. */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002163 __skb_queue_purge(&tp->out_of_order_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08002165#ifdef CONFIG_TCP_MD5SIG
2166 /* Clean up the MD5 key list, if any */
2167 if (tp->md5sig_info) {
Eric Dumazeta915da9b2012-01-31 05:18:33 +00002168 tcp_clear_md5_list(sk);
Eric Dumazeta8afca02012-01-31 18:45:40 +00002169 kfree_rcu(tp->md5sig_info, rcu);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08002170 tp->md5sig_info = NULL;
2171 }
2172#endif
2173
Chris Leech1a2449a2006-05-23 18:05:53 -07002174#ifdef CONFIG_NET_DMA
2175 /* Cleans up our sk_async_wait_queue */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002176 __skb_queue_purge(&sk->sk_async_wait_queue);
Chris Leech1a2449a2006-05-23 18:05:53 -07002177#endif
2178
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179 /* Clean prequeue, it must be empty really */
2180 __skb_queue_purge(&tp->ucopy.prequeue);
2181
2182 /* Clean up a referenced TCP bind bucket. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002183 if (inet_csk(sk)->icsk_bind_hash)
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08002184 inet_put_port(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185
Jerry Chu168a8f52012-08-31 12:29:13 +00002186 BUG_ON(tp->fastopen_rsk != NULL);
William Allen Simpson435cf552009-12-02 18:17:05 +00002187
Yuchung Chengcf60af02012-07-19 06:43:09 +00002188 /* If socket is aborted during connect operation */
2189 tcp_free_fastopen_req(tp);
2190
Glauber Costa180d8cd2011-12-11 21:47:02 +00002191 sk_sockets_allocated_dec(sk);
Glauber Costad1a4c0b2011-12-11 21:47:04 +00002192 sock_release_memcg(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002194EXPORT_SYMBOL(tcp_v4_destroy_sock);
2195
2196#ifdef CONFIG_PROC_FS
2197/* Proc filesystem TCP sock list dumping. */
2198
Tom Herberta8b690f2010-06-07 00:43:42 -07002199/*
2200 * Get next listener socket follow cur. If cur is NULL, get first socket
2201 * starting from bucket given in st->bucket; when st->bucket is zero the
2202 * very first socket in the hash table is returned.
2203 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002204static void *listening_get_next(struct seq_file *seq, void *cur)
2205{
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002206 struct inet_connection_sock *icsk;
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08002207 struct hlist_nulls_node *node;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208 struct sock *sk = cur;
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002209 struct inet_listen_hashbucket *ilb;
Jianjun Kong5799de02008-11-03 02:49:10 -08002210 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002211 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002212
2213 if (!sk) {
Tom Herberta8b690f2010-06-07 00:43:42 -07002214 ilb = &tcp_hashinfo.listening_hash[st->bucket];
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002215 spin_lock_bh(&ilb->lock);
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08002216 sk = sk_nulls_head(&ilb->head);
Tom Herberta8b690f2010-06-07 00:43:42 -07002217 st->offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002218 goto get_sk;
2219 }
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002220 ilb = &tcp_hashinfo.listening_hash[st->bucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002221 ++st->num;
Tom Herberta8b690f2010-06-07 00:43:42 -07002222 ++st->offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002223
2224 if (st->state == TCP_SEQ_STATE_OPENREQ) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002225 struct request_sock *req = cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226
Eric Dumazet72a3eff2006-11-16 02:30:37 -08002227 icsk = inet_csk(st->syn_wait_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228 req = req->dl_next;
2229 while (1) {
2230 while (req) {
Daniel Lezcanobdccc4c2008-07-19 00:15:13 -07002231 if (req->rsk_ops->family == st->family) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232 cur = req;
2233 goto out;
2234 }
2235 req = req->dl_next;
2236 }
Eric Dumazet72a3eff2006-11-16 02:30:37 -08002237 if (++st->sbucket >= icsk->icsk_accept_queue.listen_opt->nr_table_entries)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238 break;
2239get_req:
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002240 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002241 }
Eric Dumazet1bde5ac2010-12-23 09:32:46 -08002242 sk = sk_nulls_next(st->syn_wait_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243 st->state = TCP_SEQ_STATE_LISTENING;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002244 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245 } else {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002246 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002247 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2248 if (reqsk_queue_len(&icsk->icsk_accept_queue))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249 goto start_req;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002250 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Eric Dumazet1bde5ac2010-12-23 09:32:46 -08002251 sk = sk_nulls_next(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002252 }
2253get_sk:
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08002254 sk_nulls_for_each_from(sk, node) {
Pavel Emelyanov8475ef92010-11-22 03:26:12 +00002255 if (!net_eq(sock_net(sk), net))
2256 continue;
2257 if (sk->sk_family == st->family) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002258 cur = sk;
2259 goto out;
2260 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002261 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002262 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2263 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002264start_req:
2265 st->uid = sock_i_uid(sk);
2266 st->syn_wait_sk = sk;
2267 st->state = TCP_SEQ_STATE_OPENREQ;
2268 st->sbucket = 0;
2269 goto get_req;
2270 }
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002271 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272 }
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002273 spin_unlock_bh(&ilb->lock);
Tom Herberta8b690f2010-06-07 00:43:42 -07002274 st->offset = 0;
Arnaldo Carvalho de Melo0f7ff922005-08-09 19:59:44 -07002275 if (++st->bucket < INET_LHTABLE_SIZE) {
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002276 ilb = &tcp_hashinfo.listening_hash[st->bucket];
2277 spin_lock_bh(&ilb->lock);
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08002278 sk = sk_nulls_head(&ilb->head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279 goto get_sk;
2280 }
2281 cur = NULL;
2282out:
2283 return cur;
2284}
2285
2286static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
2287{
Tom Herberta8b690f2010-06-07 00:43:42 -07002288 struct tcp_iter_state *st = seq->private;
2289 void *rc;
2290
2291 st->bucket = 0;
2292 st->offset = 0;
2293 rc = listening_get_next(seq, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294
2295 while (rc && *pos) {
2296 rc = listening_get_next(seq, rc);
2297 --*pos;
2298 }
2299 return rc;
2300}
2301
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002302static inline bool empty_bucket(const struct tcp_iter_state *st)
Andi Kleen6eac5602008-08-28 01:08:02 -07002303{
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002304 return hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].chain);
Andi Kleen6eac5602008-08-28 01:08:02 -07002305}
2306
Tom Herberta8b690f2010-06-07 00:43:42 -07002307/*
2308 * Get first established socket starting from bucket given in st->bucket.
2309 * If st->bucket is zero, the very first socket in the hash is returned.
2310 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311static void *established_get_first(struct seq_file *seq)
2312{
Jianjun Kong5799de02008-11-03 02:49:10 -08002313 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002314 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315 void *rc = NULL;
2316
Tom Herberta8b690f2010-06-07 00:43:42 -07002317 st->offset = 0;
2318 for (; st->bucket <= tcp_hashinfo.ehash_mask; ++st->bucket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002319 struct sock *sk;
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002320 struct hlist_nulls_node *node;
Eric Dumazet9db66bdc2008-11-20 20:39:09 -08002321 spinlock_t *lock = inet_ehash_lockp(&tcp_hashinfo, st->bucket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322
Andi Kleen6eac5602008-08-28 01:08:02 -07002323 /* Lockless fast path for the common case of empty buckets */
2324 if (empty_bucket(st))
2325 continue;
2326
Eric Dumazet9db66bdc2008-11-20 20:39:09 -08002327 spin_lock_bh(lock);
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002328 sk_nulls_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002329 if (sk->sk_family != st->family ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002330 !net_eq(sock_net(sk), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331 continue;
2332 }
2333 rc = sk;
2334 goto out;
2335 }
Eric Dumazet9db66bdc2008-11-20 20:39:09 -08002336 spin_unlock_bh(lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337 }
2338out:
2339 return rc;
2340}
2341
2342static void *established_get_next(struct seq_file *seq, void *cur)
2343{
2344 struct sock *sk = cur;
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002345 struct hlist_nulls_node *node;
Jianjun Kong5799de02008-11-03 02:49:10 -08002346 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002347 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348
2349 ++st->num;
Tom Herberta8b690f2010-06-07 00:43:42 -07002350 ++st->offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002351
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002352 sk = sk_nulls_next(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002353
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002354 sk_nulls_for_each_from(sk, node) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002355 if (sk->sk_family == st->family && net_eq(sock_net(sk), net))
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002356 return sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002357 }
2358
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002359 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
2360 ++st->bucket;
2361 return established_get_first(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002362}
2363
2364static void *established_get_idx(struct seq_file *seq, loff_t pos)
2365{
Tom Herberta8b690f2010-06-07 00:43:42 -07002366 struct tcp_iter_state *st = seq->private;
2367 void *rc;
2368
2369 st->bucket = 0;
2370 rc = established_get_first(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371
2372 while (rc && pos) {
2373 rc = established_get_next(seq, rc);
2374 --pos;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002375 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002376 return rc;
2377}
2378
2379static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
2380{
2381 void *rc;
Jianjun Kong5799de02008-11-03 02:49:10 -08002382 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002383
Linus Torvalds1da177e2005-04-16 15:20:36 -07002384 st->state = TCP_SEQ_STATE_LISTENING;
2385 rc = listening_get_idx(seq, &pos);
2386
2387 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002388 st->state = TCP_SEQ_STATE_ESTABLISHED;
2389 rc = established_get_idx(seq, pos);
2390 }
2391
2392 return rc;
2393}
2394
Tom Herberta8b690f2010-06-07 00:43:42 -07002395static void *tcp_seek_last_pos(struct seq_file *seq)
2396{
2397 struct tcp_iter_state *st = seq->private;
2398 int offset = st->offset;
2399 int orig_num = st->num;
2400 void *rc = NULL;
2401
2402 switch (st->state) {
2403 case TCP_SEQ_STATE_OPENREQ:
2404 case TCP_SEQ_STATE_LISTENING:
2405 if (st->bucket >= INET_LHTABLE_SIZE)
2406 break;
2407 st->state = TCP_SEQ_STATE_LISTENING;
2408 rc = listening_get_next(seq, NULL);
2409 while (offset-- && rc)
2410 rc = listening_get_next(seq, rc);
2411 if (rc)
2412 break;
2413 st->bucket = 0;
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002414 st->state = TCP_SEQ_STATE_ESTABLISHED;
Tom Herberta8b690f2010-06-07 00:43:42 -07002415 /* Fallthrough */
2416 case TCP_SEQ_STATE_ESTABLISHED:
Tom Herberta8b690f2010-06-07 00:43:42 -07002417 if (st->bucket > tcp_hashinfo.ehash_mask)
2418 break;
2419 rc = established_get_first(seq);
2420 while (offset-- && rc)
2421 rc = established_get_next(seq, rc);
2422 }
2423
2424 st->num = orig_num;
2425
2426 return rc;
2427}
2428
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
2430{
Jianjun Kong5799de02008-11-03 02:49:10 -08002431 struct tcp_iter_state *st = seq->private;
Tom Herberta8b690f2010-06-07 00:43:42 -07002432 void *rc;
2433
2434 if (*pos && *pos == st->last_pos) {
2435 rc = tcp_seek_last_pos(seq);
2436 if (rc)
2437 goto out;
2438 }
2439
Linus Torvalds1da177e2005-04-16 15:20:36 -07002440 st->state = TCP_SEQ_STATE_LISTENING;
2441 st->num = 0;
Tom Herberta8b690f2010-06-07 00:43:42 -07002442 st->bucket = 0;
2443 st->offset = 0;
2444 rc = *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2445
2446out:
2447 st->last_pos = *pos;
2448 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002449}
2450
2451static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2452{
Tom Herberta8b690f2010-06-07 00:43:42 -07002453 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002454 void *rc = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002455
2456 if (v == SEQ_START_TOKEN) {
2457 rc = tcp_get_idx(seq, 0);
2458 goto out;
2459 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002460
2461 switch (st->state) {
2462 case TCP_SEQ_STATE_OPENREQ:
2463 case TCP_SEQ_STATE_LISTENING:
2464 rc = listening_get_next(seq, v);
2465 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002466 st->state = TCP_SEQ_STATE_ESTABLISHED;
Tom Herberta8b690f2010-06-07 00:43:42 -07002467 st->bucket = 0;
2468 st->offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002469 rc = established_get_first(seq);
2470 }
2471 break;
2472 case TCP_SEQ_STATE_ESTABLISHED:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002473 rc = established_get_next(seq, v);
2474 break;
2475 }
2476out:
2477 ++*pos;
Tom Herberta8b690f2010-06-07 00:43:42 -07002478 st->last_pos = *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002479 return rc;
2480}
2481
2482static void tcp_seq_stop(struct seq_file *seq, void *v)
2483{
Jianjun Kong5799de02008-11-03 02:49:10 -08002484 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002485
2486 switch (st->state) {
2487 case TCP_SEQ_STATE_OPENREQ:
2488 if (v) {
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002489 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
2490 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002491 }
2492 case TCP_SEQ_STATE_LISTENING:
2493 if (v != SEQ_START_TOKEN)
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002494 spin_unlock_bh(&tcp_hashinfo.listening_hash[st->bucket].lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002495 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002496 case TCP_SEQ_STATE_ESTABLISHED:
2497 if (v)
Eric Dumazet9db66bdc2008-11-20 20:39:09 -08002498 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002499 break;
2500 }
2501}
2502
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002503int tcp_seq_open(struct inode *inode, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002504{
Al Virod9dda782013-03-31 18:16:14 -04002505 struct tcp_seq_afinfo *afinfo = PDE_DATA(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002506 struct tcp_iter_state *s;
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002507 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002508
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002509 err = seq_open_net(inode, file, &afinfo->seq_ops,
2510 sizeof(struct tcp_iter_state));
2511 if (err < 0)
2512 return err;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002513
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002514 s = ((struct seq_file *)file->private_data)->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002515 s->family = afinfo->family;
Tom Herberta8b690f2010-06-07 00:43:42 -07002516 s->last_pos = 0;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002517 return 0;
2518}
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002519EXPORT_SYMBOL(tcp_seq_open);
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002520
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002521int tcp_proc_register(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002522{
2523 int rc = 0;
2524 struct proc_dir_entry *p;
2525
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002526 afinfo->seq_ops.start = tcp_seq_start;
2527 afinfo->seq_ops.next = tcp_seq_next;
2528 afinfo->seq_ops.stop = tcp_seq_stop;
2529
Denis V. Lunev84841c32008-05-02 04:10:08 -07002530 p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net,
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002531 afinfo->seq_fops, afinfo);
Denis V. Lunev84841c32008-05-02 04:10:08 -07002532 if (!p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002533 rc = -ENOMEM;
2534 return rc;
2535}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002536EXPORT_SYMBOL(tcp_proc_register);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002537
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002538void tcp_proc_unregister(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002539{
Gao fengece31ff2013-02-18 01:34:56 +00002540 remove_proc_entry(afinfo->name, net->proc_net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002541}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002542EXPORT_SYMBOL(tcp_proc_unregister);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002543
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002544static void get_openreq4(const struct sock *sk, const struct request_sock *req,
Tetsuo Handa652586d2013-11-14 14:31:57 -08002545 struct seq_file *f, int i, kuid_t uid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002546{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002547 const struct inet_request_sock *ireq = inet_rsk(req);
Eric Dumazeta399a802012-08-08 21:13:53 +00002548 long delta = req->expires - jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002549
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002550 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
Tetsuo Handa652586d2013-11-14 14:31:57 -08002551 " %02X %08X:%08X %02X:%08lX %08X %5u %8d %u %d %pK",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002552 i,
Eric Dumazet634fb9792013-10-09 15:21:29 -07002553 ireq->ir_loc_addr,
Eric Dumazetc720c7e2009-10-15 06:30:45 +00002554 ntohs(inet_sk(sk)->inet_sport),
Eric Dumazet634fb9792013-10-09 15:21:29 -07002555 ireq->ir_rmt_addr,
2556 ntohs(ireq->ir_rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002557 TCP_SYN_RECV,
2558 0, 0, /* could print option size, but that is af dependent. */
2559 1, /* timers active (only the expire timer) */
Eric Dumazeta399a802012-08-08 21:13:53 +00002560 jiffies_delta_to_clock_t(delta),
Eric Dumazete6c022a2012-10-27 23:16:46 +00002561 req->num_timeout,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06002562 from_kuid_munged(seq_user_ns(f), uid),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002563 0, /* non standard timer */
2564 0, /* open_requests have no inode */
2565 atomic_read(&sk->sk_refcnt),
Tetsuo Handa652586d2013-11-14 14:31:57 -08002566 req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002567}
2568
Tetsuo Handa652586d2013-11-14 14:31:57 -08002569static void get_tcp4_sock(struct sock *sk, struct seq_file *f, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002570{
2571 int timer_active;
2572 unsigned long timer_expires;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002573 const struct tcp_sock *tp = tcp_sk(sk);
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002574 const struct inet_connection_sock *icsk = inet_csk(sk);
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002575 const struct inet_sock *inet = inet_sk(sk);
Jerry Chu168a8f52012-08-31 12:29:13 +00002576 struct fastopen_queue *fastopenq = icsk->icsk_accept_queue.fastopenq;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00002577 __be32 dest = inet->inet_daddr;
2578 __be32 src = inet->inet_rcv_saddr;
2579 __u16 destp = ntohs(inet->inet_dport);
2580 __u16 srcp = ntohs(inet->inet_sport);
Eric Dumazet49d09002009-12-03 16:06:13 -08002581 int rx_queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002582
Nandita Dukkipati6ba8a3b2013-03-11 10:00:43 +00002583 if (icsk->icsk_pending == ICSK_TIME_RETRANS ||
2584 icsk->icsk_pending == ICSK_TIME_EARLY_RETRANS ||
2585 icsk->icsk_pending == ICSK_TIME_LOSS_PROBE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002586 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002587 timer_expires = icsk->icsk_timeout;
2588 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002589 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002590 timer_expires = icsk->icsk_timeout;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002591 } else if (timer_pending(&sk->sk_timer)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002592 timer_active = 2;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002593 timer_expires = sk->sk_timer.expires;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002594 } else {
2595 timer_active = 0;
2596 timer_expires = jiffies;
2597 }
2598
Eric Dumazet49d09002009-12-03 16:06:13 -08002599 if (sk->sk_state == TCP_LISTEN)
2600 rx_queue = sk->sk_ack_backlog;
2601 else
2602 /*
2603 * because we dont lock socket, we might find a transient negative value
2604 */
2605 rx_queue = max_t(int, tp->rcv_nxt - tp->copied_seq, 0);
2606
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002607 seq_printf(f, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
Tetsuo Handa652586d2013-11-14 14:31:57 -08002608 "%08X %5u %8d %lu %d %pK %lu %lu %u %u %d",
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002609 i, src, srcp, dest, destp, sk->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07002610 tp->write_seq - tp->snd_una,
Eric Dumazet49d09002009-12-03 16:06:13 -08002611 rx_queue,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002612 timer_active,
Eric Dumazeta399a802012-08-08 21:13:53 +00002613 jiffies_delta_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002614 icsk->icsk_retransmits,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06002615 from_kuid_munged(seq_user_ns(f), sock_i_uid(sk)),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03002616 icsk->icsk_probes_out,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002617 sock_i_ino(sk),
2618 atomic_read(&sk->sk_refcnt), sk,
Stephen Hemminger7be87352008-06-27 20:00:19 -07002619 jiffies_to_clock_t(icsk->icsk_rto),
2620 jiffies_to_clock_t(icsk->icsk_ack.ato),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002621 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002622 tp->snd_cwnd,
Jerry Chu168a8f52012-08-31 12:29:13 +00002623 sk->sk_state == TCP_LISTEN ?
2624 (fastopenq ? fastopenq->max_qlen : 0) :
Tetsuo Handa652586d2013-11-14 14:31:57 -08002625 (tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002626}
2627
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002628static void get_timewait4_sock(const struct inet_timewait_sock *tw,
Tetsuo Handa652586d2013-11-14 14:31:57 -08002629 struct seq_file *f, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002630{
Al Viro23f33c22006-09-27 18:43:50 -07002631 __be32 dest, src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002632 __u16 destp, srcp;
Eric Dumazeta399a802012-08-08 21:13:53 +00002633 long delta = tw->tw_ttd - jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002634
2635 dest = tw->tw_daddr;
2636 src = tw->tw_rcv_saddr;
2637 destp = ntohs(tw->tw_dport);
2638 srcp = ntohs(tw->tw_sport);
2639
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002640 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
Tetsuo Handa652586d2013-11-14 14:31:57 -08002641 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002642 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
Eric Dumazeta399a802012-08-08 21:13:53 +00002643 3, jiffies_delta_to_clock_t(delta), 0, 0, 0, 0,
Tetsuo Handa652586d2013-11-14 14:31:57 -08002644 atomic_read(&tw->tw_refcnt), tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002645}
2646
2647#define TMPSZ 150
2648
2649static int tcp4_seq_show(struct seq_file *seq, void *v)
2650{
Jianjun Kong5799de02008-11-03 02:49:10 -08002651 struct tcp_iter_state *st;
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002652 struct sock *sk = v;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002653
Tetsuo Handa652586d2013-11-14 14:31:57 -08002654 seq_setwidth(seq, TMPSZ - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002655 if (v == SEQ_START_TOKEN) {
Tetsuo Handa652586d2013-11-14 14:31:57 -08002656 seq_puts(seq, " sl local_address rem_address st tx_queue "
Linus Torvalds1da177e2005-04-16 15:20:36 -07002657 "rx_queue tr tm->when retrnsmt uid timeout "
2658 "inode");
2659 goto out;
2660 }
2661 st = seq->private;
2662
2663 switch (st->state) {
2664 case TCP_SEQ_STATE_LISTENING:
2665 case TCP_SEQ_STATE_ESTABLISHED:
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002666 if (sk->sk_state == TCP_TIME_WAIT)
Tetsuo Handa652586d2013-11-14 14:31:57 -08002667 get_timewait4_sock(v, seq, st->num);
Eric Dumazet05dbc7b2013-10-03 00:22:02 -07002668 else
Tetsuo Handa652586d2013-11-14 14:31:57 -08002669 get_tcp4_sock(v, seq, st->num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002670 break;
2671 case TCP_SEQ_STATE_OPENREQ:
Tetsuo Handa652586d2013-11-14 14:31:57 -08002672 get_openreq4(st->syn_wait_sk, v, seq, st->num, st->uid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002673 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002674 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002675out:
Tetsuo Handa652586d2013-11-14 14:31:57 -08002676 seq_pad(seq, '\n');
Linus Torvalds1da177e2005-04-16 15:20:36 -07002677 return 0;
2678}
2679
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002680static const struct file_operations tcp_afinfo_seq_fops = {
2681 .owner = THIS_MODULE,
2682 .open = tcp_seq_open,
2683 .read = seq_read,
2684 .llseek = seq_lseek,
2685 .release = seq_release_net
2686};
2687
Linus Torvalds1da177e2005-04-16 15:20:36 -07002688static struct tcp_seq_afinfo tcp4_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002689 .name = "tcp",
2690 .family = AF_INET,
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002691 .seq_fops = &tcp_afinfo_seq_fops,
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002692 .seq_ops = {
2693 .show = tcp4_seq_show,
2694 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002695};
2696
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002697static int __net_init tcp4_proc_init_net(struct net *net)
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002698{
2699 return tcp_proc_register(net, &tcp4_seq_afinfo);
2700}
2701
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002702static void __net_exit tcp4_proc_exit_net(struct net *net)
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002703{
2704 tcp_proc_unregister(net, &tcp4_seq_afinfo);
2705}
2706
2707static struct pernet_operations tcp4_net_ops = {
2708 .init = tcp4_proc_init_net,
2709 .exit = tcp4_proc_exit_net,
2710};
2711
Linus Torvalds1da177e2005-04-16 15:20:36 -07002712int __init tcp4_proc_init(void)
2713{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002714 return register_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002715}
2716
2717void tcp4_proc_exit(void)
2718{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002719 unregister_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002720}
2721#endif /* CONFIG_PROC_FS */
2722
2723struct proto tcp_prot = {
2724 .name = "TCP",
2725 .owner = THIS_MODULE,
2726 .close = tcp_close,
2727 .connect = tcp_v4_connect,
2728 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002729 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002730 .ioctl = tcp_ioctl,
2731 .init = tcp_v4_init_sock,
2732 .destroy = tcp_v4_destroy_sock,
2733 .shutdown = tcp_shutdown,
2734 .setsockopt = tcp_setsockopt,
2735 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002736 .recvmsg = tcp_recvmsg,
Changli Gao7ba42912010-07-10 20:41:55 +00002737 .sendmsg = tcp_sendmsg,
2738 .sendpage = tcp_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002739 .backlog_rcv = tcp_v4_do_rcv,
Eric Dumazet46d3cea2012-07-11 05:50:31 +00002740 .release_cb = tcp_release_cb,
Eric Dumazet563d34d2012-07-23 09:48:52 +02002741 .mtu_reduced = tcp_v4_mtu_reduced,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08002742 .hash = inet_hash,
2743 .unhash = inet_unhash,
2744 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002745 .enter_memory_pressure = tcp_enter_memory_pressure,
Eric Dumazetc9bee3b72013-07-22 20:27:07 -07002746 .stream_memory_free = tcp_stream_memory_free,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002747 .sockets_allocated = &tcp_sockets_allocated,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07002748 .orphan_count = &tcp_orphan_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002749 .memory_allocated = &tcp_memory_allocated,
2750 .memory_pressure = &tcp_memory_pressure,
Eric W. Biedermana4fe34b2013-10-19 16:25:36 -07002751 .sysctl_mem = sysctl_tcp_mem,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002752 .sysctl_wmem = sysctl_tcp_wmem,
2753 .sysctl_rmem = sysctl_tcp_rmem,
2754 .max_header = MAX_TCP_HEADER,
2755 .obj_size = sizeof(struct tcp_sock),
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002756 .slab_flags = SLAB_DESTROY_BY_RCU,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002757 .twsk_prot = &tcp_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002758 .rsk_prot = &tcp_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07002759 .h.hashinfo = &tcp_hashinfo,
Changli Gao7ba42912010-07-10 20:41:55 +00002760 .no_autobind = true,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002761#ifdef CONFIG_COMPAT
2762 .compat_setsockopt = compat_tcp_setsockopt,
2763 .compat_getsockopt = compat_tcp_getsockopt,
2764#endif
Andrew Mortonc255a452012-07-31 16:43:02 -07002765#ifdef CONFIG_MEMCG_KMEM
Glauber Costad1a4c0b2011-12-11 21:47:04 +00002766 .init_cgroup = tcp_init_cgroup,
2767 .destroy_cgroup = tcp_destroy_cgroup,
2768 .proto_cgroup = tcp_proto_cgroup,
2769#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002770};
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002771EXPORT_SYMBOL(tcp_prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002772
Denis V. Lunev046ee902008-04-03 14:31:33 -07002773static int __net_init tcp_sk_init(struct net *net)
2774{
Hannes Frederic Sowa5d134f12013-01-05 16:10:48 +00002775 net->ipv4.sysctl_tcp_ecn = 2;
Eric Dumazetbe9f4a42012-07-19 07:34:03 +00002776 return 0;
Denis V. Lunev046ee902008-04-03 14:31:33 -07002777}
2778
2779static void __net_exit tcp_sk_exit(struct net *net)
2780{
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002781}
2782
2783static void __net_exit tcp_sk_exit_batch(struct list_head *net_exit_list)
2784{
2785 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET);
Denis V. Lunev046ee902008-04-03 14:31:33 -07002786}
2787
2788static struct pernet_operations __net_initdata tcp_sk_ops = {
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002789 .init = tcp_sk_init,
2790 .exit = tcp_sk_exit,
2791 .exit_batch = tcp_sk_exit_batch,
Denis V. Lunev046ee902008-04-03 14:31:33 -07002792};
2793
Denis V. Lunev9b0f9762008-02-29 11:13:15 -08002794void __init tcp_v4_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002795{
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002796 inet_hashinfo_init(&tcp_hashinfo);
Eric W. Biederman6a1b3052009-02-22 00:10:18 -08002797 if (register_pernet_subsys(&tcp_sk_ops))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002798 panic("Failed to create the TCP control socket.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002799}