blob: 1ed230716d51baa64501e5c6354ec5e50ff20048 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
79#include <linux/inet.h>
80#include <linux/ipv6.h>
81#include <linux/stddef.h>
82#include <linux/proc_fs.h>
83#include <linux/seq_file.h>
84
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080085#include <linux/crypto.h>
86#include <linux/scatterlist.h>
87
Brian Haleyab32ea52006-09-22 14:15:41 -070088int sysctl_tcp_tw_reuse __read_mostly;
89int sysctl_tcp_low_latency __read_mostly;
Eric Dumazet4bc2f182010-07-09 21:22:10 +000090EXPORT_SYMBOL(sysctl_tcp_low_latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080093#ifdef CONFIG_TCP_MD5SIG
Eric Dumazeta915da9b2012-01-31 05:18:33 +000094static int tcp_v4_md5_hash_hdr(char *md5_hash, const struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -040095 __be32 daddr, __be32 saddr, const struct tcphdr *th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080096#endif
97
Eric Dumazet5caea4e2008-11-20 00:40:07 -080098struct inet_hashinfo tcp_hashinfo;
Eric Dumazet4bc2f182010-07-09 21:22:10 +000099EXPORT_SYMBOL(tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400101static inline __u32 tcp_v4_init_sequence(const struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700103 return secure_tcp_sequence_number(ip_hdr(skb)->daddr,
104 ip_hdr(skb)->saddr,
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700105 tcp_hdr(skb)->dest,
106 tcp_hdr(skb)->source);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107}
108
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800109int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp)
110{
111 const struct tcp_timewait_sock *tcptw = tcp_twsk(sktw);
112 struct tcp_sock *tp = tcp_sk(sk);
113
114 /* With PAWS, it is safe from the viewpoint
115 of data integrity. Even without PAWS it is safe provided sequence
116 spaces do not overlap i.e. at data rates <= 80Mbit/sec.
117
118 Actually, the idea is close to VJ's one, only timestamp cache is
119 held not per host, but per port pair and TW bucket is used as state
120 holder.
121
122 If TW bucket has been already destroyed we fall back to VJ's scheme
123 and use initial timestamp retrieved from peer table.
124 */
125 if (tcptw->tw_ts_recent_stamp &&
126 (twp == NULL || (sysctl_tcp_tw_reuse &&
James Morris9d729f72007-03-04 16:12:44 -0800127 get_seconds() - tcptw->tw_ts_recent_stamp > 1))) {
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800128 tp->write_seq = tcptw->tw_snd_nxt + 65535 + 2;
129 if (tp->write_seq == 0)
130 tp->write_seq = 1;
131 tp->rx_opt.ts_recent = tcptw->tw_ts_recent;
132 tp->rx_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp;
133 sock_hold(sktw);
134 return 1;
135 }
136
137 return 0;
138}
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800139EXPORT_SYMBOL_GPL(tcp_twsk_unique);
140
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141/* This will initiate an outgoing connection. */
142int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
143{
David S. Miller2d7192d2011-04-26 13:28:44 -0700144 struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 struct inet_sock *inet = inet_sk(sk);
146 struct tcp_sock *tp = tcp_sk(sk);
David S. Millerdca8b082011-02-24 13:38:12 -0800147 __be16 orig_sport, orig_dport;
Al Virobada8ad2006-09-26 21:27:15 -0700148 __be32 daddr, nexthop;
David S. Millerda905bd2011-05-06 16:11:19 -0700149 struct flowi4 *fl4;
David S. Miller2d7192d2011-04-26 13:28:44 -0700150 struct rtable *rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 int err;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000152 struct ip_options_rcu *inet_opt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
154 if (addr_len < sizeof(struct sockaddr_in))
155 return -EINVAL;
156
157 if (usin->sin_family != AF_INET)
158 return -EAFNOSUPPORT;
159
160 nexthop = daddr = usin->sin_addr.s_addr;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000161 inet_opt = rcu_dereference_protected(inet->inet_opt,
162 sock_owned_by_user(sk));
163 if (inet_opt && inet_opt->opt.srr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 if (!daddr)
165 return -EINVAL;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000166 nexthop = inet_opt->opt.faddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 }
168
David S. Millerdca8b082011-02-24 13:38:12 -0800169 orig_sport = inet->inet_sport;
170 orig_dport = usin->sin_port;
David S. Millerda905bd2011-05-06 16:11:19 -0700171 fl4 = &inet->cork.fl.u.ip4;
172 rt = ip_route_connect(fl4, nexthop, inet->inet_saddr,
David S. Millerb23dd4f2011-03-02 14:31:35 -0800173 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
174 IPPROTO_TCP,
175 orig_sport, orig_dport, sk, true);
176 if (IS_ERR(rt)) {
177 err = PTR_ERR(rt);
178 if (err == -ENETUNREACH)
Pavel Emelyanov7c73a6f2008-07-16 20:20:11 -0700179 IP_INC_STATS_BH(sock_net(sk), IPSTATS_MIB_OUTNOROUTES);
David S. Millerb23dd4f2011-03-02 14:31:35 -0800180 return err;
Wei Dong584bdf82007-05-31 22:49:28 -0700181 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182
183 if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
184 ip_rt_put(rt);
185 return -ENETUNREACH;
186 }
187
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000188 if (!inet_opt || !inet_opt->opt.srr)
David S. Millerda905bd2011-05-06 16:11:19 -0700189 daddr = fl4->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000191 if (!inet->inet_saddr)
David S. Millerda905bd2011-05-06 16:11:19 -0700192 inet->inet_saddr = fl4->saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000193 inet->inet_rcv_saddr = inet->inet_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000195 if (tp->rx_opt.ts_recent_stamp && inet->inet_daddr != daddr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 /* Reset inherited state */
197 tp->rx_opt.ts_recent = 0;
198 tp->rx_opt.ts_recent_stamp = 0;
Pavel Emelyanovee995282012-04-19 03:40:39 +0000199 if (likely(!tp->repair))
200 tp->write_seq = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 }
202
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -0700203 if (tcp_death_row.sysctl_tw_recycle &&
David S. Miller81166dd2012-07-10 03:14:24 -0700204 !tp->rx_opt.ts_recent_stamp && fl4->daddr == daddr)
205 tcp_fetch_timewait_stamp(sk, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000207 inet->inet_dport = usin->sin_port;
208 inet->inet_daddr = daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800210 inet_csk(sk)->icsk_ext_hdr_len = 0;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000211 if (inet_opt)
212 inet_csk(sk)->icsk_ext_hdr_len = inet_opt->opt.optlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
William Allen Simpsonbee7ca92009-11-10 09:51:18 +0000214 tp->rx_opt.mss_clamp = TCP_MSS_DEFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
216 /* Socket identity is still unknown (sport may be zero).
217 * However we set state to SYN-SENT and not releasing socket
218 * lock select source port, enter ourselves into the hash tables and
219 * complete initialization after this.
220 */
221 tcp_set_state(sk, TCP_SYN_SENT);
Arnaldo Carvalho de Meloa7f5e7f2005-12-13 23:25:31 -0800222 err = inet_hash_connect(&tcp_death_row, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 if (err)
224 goto failure;
225
David S. Millerda905bd2011-05-06 16:11:19 -0700226 rt = ip_route_newports(fl4, rt, orig_sport, orig_dport,
David S. Millerb23dd4f2011-03-02 14:31:35 -0800227 inet->inet_sport, inet->inet_dport, sk);
228 if (IS_ERR(rt)) {
229 err = PTR_ERR(rt);
230 rt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 goto failure;
David S. Millerb23dd4f2011-03-02 14:31:35 -0800232 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 /* OK, now commit destination to socket. */
Herbert Xubcd76112006-06-30 13:36:35 -0700234 sk->sk_gso_type = SKB_GSO_TCPV4;
Changli Gaod8d1f302010-06-10 23:31:35 -0700235 sk_setup_caps(sk, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236
Pavel Emelyanovee995282012-04-19 03:40:39 +0000237 if (!tp->write_seq && likely(!tp->repair))
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000238 tp->write_seq = secure_tcp_sequence_number(inet->inet_saddr,
239 inet->inet_daddr,
240 inet->inet_sport,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 usin->sin_port);
242
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000243 inet->inet_id = tp->write_seq ^ jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
Andrey Vagin2b916472012-11-22 01:13:58 +0000245 err = tcp_connect(sk);
Pavel Emelyanovee995282012-04-19 03:40:39 +0000246
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 rt = NULL;
248 if (err)
249 goto failure;
250
251 return 0;
252
253failure:
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200254 /*
255 * This unhashes the socket and releases the local port,
256 * if necessary.
257 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 tcp_set_state(sk, TCP_CLOSE);
259 ip_rt_put(rt);
260 sk->sk_route_caps = 0;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000261 inet->inet_dport = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 return err;
263}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000264EXPORT_SYMBOL(tcp_v4_connect);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266/*
Eric Dumazet563d34d2012-07-23 09:48:52 +0200267 * This routine reacts to ICMP_FRAG_NEEDED mtu indications as defined in RFC1191.
268 * It can be called through tcp_release_cb() if socket was owned by user
269 * at the time tcp_v4_err() was called to handle ICMP message.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 */
Eric Dumazet563d34d2012-07-23 09:48:52 +0200271static void tcp_v4_mtu_reduced(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272{
273 struct dst_entry *dst;
274 struct inet_sock *inet = inet_sk(sk);
Eric Dumazet563d34d2012-07-23 09:48:52 +0200275 u32 mtu = tcp_sk(sk)->mtu_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276
277 /* We are not interested in TCP_LISTEN and open_requests (SYN-ACKs
278 * send out by Linux are always <576bytes so they should go through
279 * unfragmented).
280 */
281 if (sk->sk_state == TCP_LISTEN)
282 return;
283
David S. Miller80d0a692012-07-16 03:28:06 -0700284 dst = inet_csk_update_pmtu(sk, mtu);
285 if (!dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 return;
287
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 /* Something is about to be wrong... Remember soft error
289 * for the case, if this connection will not able to recover.
290 */
291 if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
292 sk->sk_err_soft = EMSGSIZE;
293
294 mtu = dst_mtu(dst);
295
296 if (inet->pmtudisc != IP_PMTUDISC_DONT &&
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800297 inet_csk(sk)->icsk_pmtu_cookie > mtu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 tcp_sync_mss(sk, mtu);
299
300 /* Resend the TCP packet because it's
301 * clear that the old packet has been
302 * dropped. This is the new "fast" path mtu
303 * discovery.
304 */
305 tcp_simple_retransmit(sk);
306 } /* else let the usual retransmit timer handle it */
307}
308
David S. Miller55be7a92012-07-11 21:27:49 -0700309static void do_redirect(struct sk_buff *skb, struct sock *sk)
310{
311 struct dst_entry *dst = __sk_dst_check(sk, 0);
312
David S. Miller1ed5c482012-07-12 00:41:25 -0700313 if (dst)
David S. Miller6700c272012-07-17 03:29:28 -0700314 dst->ops->redirect(dst, sk, skb);
David S. Miller55be7a92012-07-11 21:27:49 -0700315}
316
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317/*
318 * This routine is called by the ICMP module when it gets some
319 * sort of error condition. If err < 0 then the socket should
320 * be closed and the error returned to the user. If err > 0
321 * it's just the icmp type << 8 | icmp code. After adjustment
322 * header points to the first 8 bytes of the tcp header. We need
323 * to find the appropriate port.
324 *
325 * The locking strategy used here is very "optimistic". When
326 * someone else accesses the socket the ICMP is just dropped
327 * and for some paths there is no check at all.
328 * A more general error queue to queue errors for later handling
329 * is probably better.
330 *
331 */
332
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000333void tcp_v4_err(struct sk_buff *icmp_skb, u32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000335 const struct iphdr *iph = (const struct iphdr *)icmp_skb->data;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000336 struct tcphdr *th = (struct tcphdr *)(icmp_skb->data + (iph->ihl << 2));
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000337 struct inet_connection_sock *icsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 struct tcp_sock *tp;
339 struct inet_sock *inet;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000340 const int type = icmp_hdr(icmp_skb)->type;
341 const int code = icmp_hdr(icmp_skb)->code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 struct sock *sk;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000343 struct sk_buff *skb;
Jerry Chu168a8f52012-08-31 12:29:13 +0000344 struct request_sock *req;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 __u32 seq;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000346 __u32 remaining;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 int err;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000348 struct net *net = dev_net(icmp_skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000350 if (icmp_skb->len < (iph->ihl << 2) + 8) {
Pavel Emelyanovdcfc23c2008-07-14 23:03:00 -0700351 ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 return;
353 }
354
Pavel Emelyanovfd54d712008-07-14 23:01:40 -0700355 sk = inet_lookup(net, &tcp_hashinfo, iph->daddr, th->dest,
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000356 iph->saddr, th->source, inet_iif(icmp_skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 if (!sk) {
Pavel Emelyanovdcfc23c2008-07-14 23:03:00 -0700358 ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 return;
360 }
361 if (sk->sk_state == TCP_TIME_WAIT) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700362 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 return;
364 }
365
366 bh_lock_sock(sk);
367 /* If too many ICMPs get dropped on busy
368 * servers this needs to be solved differently.
Eric Dumazet563d34d2012-07-23 09:48:52 +0200369 * We do take care of PMTU discovery (RFC1191) special case :
370 * we can receive locally generated ICMP messages while socket is held.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 */
Eric Dumazet563d34d2012-07-23 09:48:52 +0200372 if (sock_owned_by_user(sk) &&
373 type != ICMP_DEST_UNREACH &&
374 code != ICMP_FRAG_NEEDED)
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700375 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376
377 if (sk->sk_state == TCP_CLOSE)
378 goto out;
379
stephen hemminger97e3ecd12010-03-18 11:27:32 +0000380 if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
381 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
382 goto out;
383 }
384
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000385 icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 tp = tcp_sk(sk);
Jerry Chu168a8f52012-08-31 12:29:13 +0000387 req = tp->fastopen_rsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 seq = ntohl(th->seq);
389 if (sk->sk_state != TCP_LISTEN &&
Jerry Chu168a8f52012-08-31 12:29:13 +0000390 !between(seq, tp->snd_una, tp->snd_nxt) &&
391 (req == NULL || seq != tcp_rsk(req)->snt_isn)) {
392 /* For a Fast Open socket, allow seq to be snt_isn. */
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700393 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 goto out;
395 }
396
397 switch (type) {
David S. Miller55be7a92012-07-11 21:27:49 -0700398 case ICMP_REDIRECT:
399 do_redirect(icmp_skb, sk);
400 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 case ICMP_SOURCE_QUENCH:
402 /* Just silently ignore these. */
403 goto out;
404 case ICMP_PARAMETERPROB:
405 err = EPROTO;
406 break;
407 case ICMP_DEST_UNREACH:
408 if (code > NR_ICMP_UNREACH)
409 goto out;
410
411 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
Eric Dumazet563d34d2012-07-23 09:48:52 +0200412 tp->mtu_info = info;
Eric Dumazet144d56e2012-08-20 00:22:46 +0000413 if (!sock_owned_by_user(sk)) {
Eric Dumazet563d34d2012-07-23 09:48:52 +0200414 tcp_v4_mtu_reduced(sk);
Eric Dumazet144d56e2012-08-20 00:22:46 +0000415 } else {
416 if (!test_and_set_bit(TCP_MTU_REDUCED_DEFERRED, &tp->tsq_flags))
417 sock_hold(sk);
418 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 goto out;
420 }
421
422 err = icmp_err_convert[code].errno;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000423 /* check if icmp_skb allows revert of backoff
424 * (see draft-zimmermann-tcp-lcd) */
425 if (code != ICMP_NET_UNREACH && code != ICMP_HOST_UNREACH)
426 break;
427 if (seq != tp->snd_una || !icsk->icsk_retransmits ||
428 !icsk->icsk_backoff)
429 break;
430
Jerry Chu168a8f52012-08-31 12:29:13 +0000431 /* XXX (TFO) - revisit the following logic for TFO */
432
David S. Miller8f49c272010-11-12 13:35:00 -0800433 if (sock_owned_by_user(sk))
434 break;
435
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000436 icsk->icsk_backoff--;
Jerry Chu9ad7c042011-06-08 11:08:38 +0000437 inet_csk(sk)->icsk_rto = (tp->srtt ? __tcp_set_rto(tp) :
438 TCP_TIMEOUT_INIT) << icsk->icsk_backoff;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000439 tcp_bound_rto(sk);
440
441 skb = tcp_write_queue_head(sk);
442 BUG_ON(!skb);
443
444 remaining = icsk->icsk_rto - min(icsk->icsk_rto,
445 tcp_time_stamp - TCP_SKB_CB(skb)->when);
446
447 if (remaining) {
448 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
449 remaining, TCP_RTO_MAX);
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000450 } else {
451 /* RTO revert clocked out retransmission.
452 * Will retransmit now */
453 tcp_retransmit_timer(sk);
454 }
455
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 break;
457 case ICMP_TIME_EXCEEDED:
458 err = EHOSTUNREACH;
459 break;
460 default:
461 goto out;
462 }
463
Jerry Chu168a8f52012-08-31 12:29:13 +0000464 /* XXX (TFO) - if it's a TFO socket and has been accepted, rather
465 * than following the TCP_SYN_RECV case and closing the socket,
466 * we ignore the ICMP error and keep trying like a fully established
467 * socket. Is this the right thing to do?
468 */
469 if (req && req->sk == NULL)
470 goto out;
471
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 switch (sk->sk_state) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700473 struct request_sock *req, **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 case TCP_LISTEN:
475 if (sock_owned_by_user(sk))
476 goto out;
477
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700478 req = inet_csk_search_req(sk, &prev, th->dest,
479 iph->daddr, iph->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 if (!req)
481 goto out;
482
483 /* ICMPs are not backlogged, hence we cannot get
484 an established socket here.
485 */
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700486 WARN_ON(req->sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700488 if (seq != tcp_rsk(req)->snt_isn) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700489 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 goto out;
491 }
492
493 /*
494 * Still in SYN_RECV, just remove it silently.
495 * There is no good way to pass the error to the newly
496 * created socket, and POSIX does not want network
497 * errors returned from accept().
498 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700499 inet_csk_reqsk_queue_drop(sk, req, prev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 goto out;
501
502 case TCP_SYN_SENT:
503 case TCP_SYN_RECV: /* Cannot happen.
Jerry Chu168a8f52012-08-31 12:29:13 +0000504 It can f.e. if SYNs crossed,
505 or Fast Open.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 */
507 if (!sock_owned_by_user(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 sk->sk_err = err;
509
510 sk->sk_error_report(sk);
511
512 tcp_done(sk);
513 } else {
514 sk->sk_err_soft = err;
515 }
516 goto out;
517 }
518
519 /* If we've already connected we will keep trying
520 * until we time out, or the user gives up.
521 *
522 * rfc1122 4.2.3.9 allows to consider as hard errors
523 * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
524 * but it is obsoleted by pmtu discovery).
525 *
526 * Note, that in modern internet, where routing is unreliable
527 * and in each dark corner broken firewalls sit, sending random
528 * errors ordered by their masters even this two messages finally lose
529 * their original sense (even Linux sends invalid PORT_UNREACHs)
530 *
531 * Now we are in compliance with RFCs.
532 * --ANK (980905)
533 */
534
535 inet = inet_sk(sk);
536 if (!sock_owned_by_user(sk) && inet->recverr) {
537 sk->sk_err = err;
538 sk->sk_error_report(sk);
539 } else { /* Only an error on timeout */
540 sk->sk_err_soft = err;
541 }
542
543out:
544 bh_unlock_sock(sk);
545 sock_put(sk);
546}
547
Herbert Xu419f9f82010-04-11 02:15:53 +0000548static void __tcp_v4_send_check(struct sk_buff *skb,
549 __be32 saddr, __be32 daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700551 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552
Patrick McHardy84fa7932006-08-29 16:44:56 -0700553 if (skb->ip_summed == CHECKSUM_PARTIAL) {
Herbert Xu419f9f82010-04-11 02:15:53 +0000554 th->check = ~tcp_v4_check(skb->len, saddr, daddr, 0);
Herbert Xu663ead32007-04-09 11:59:07 -0700555 skb->csum_start = skb_transport_header(skb) - skb->head;
Al Viroff1dcad2006-11-20 18:07:29 -0800556 skb->csum_offset = offsetof(struct tcphdr, check);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 } else {
Herbert Xu419f9f82010-04-11 02:15:53 +0000558 th->check = tcp_v4_check(skb->len, saddr, daddr,
Joe Perches07f07572008-11-19 15:44:53 -0800559 csum_partial(th,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 th->doff << 2,
561 skb->csum));
562 }
563}
564
Herbert Xu419f9f82010-04-11 02:15:53 +0000565/* This routine computes an IPv4 TCP checksum. */
Herbert Xubb296242010-04-11 02:15:55 +0000566void tcp_v4_send_check(struct sock *sk, struct sk_buff *skb)
Herbert Xu419f9f82010-04-11 02:15:53 +0000567{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400568 const struct inet_sock *inet = inet_sk(sk);
Herbert Xu419f9f82010-04-11 02:15:53 +0000569
570 __tcp_v4_send_check(skb, inet->inet_saddr, inet->inet_daddr);
571}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000572EXPORT_SYMBOL(tcp_v4_send_check);
Herbert Xu419f9f82010-04-11 02:15:53 +0000573
Herbert Xua430a432006-07-08 13:34:56 -0700574int tcp_v4_gso_send_check(struct sk_buff *skb)
575{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700576 const struct iphdr *iph;
Herbert Xua430a432006-07-08 13:34:56 -0700577 struct tcphdr *th;
578
579 if (!pskb_may_pull(skb, sizeof(*th)))
580 return -EINVAL;
581
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700582 iph = ip_hdr(skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700583 th = tcp_hdr(skb);
Herbert Xua430a432006-07-08 13:34:56 -0700584
585 th->check = 0;
Patrick McHardy84fa7932006-08-29 16:44:56 -0700586 skb->ip_summed = CHECKSUM_PARTIAL;
Herbert Xu419f9f82010-04-11 02:15:53 +0000587 __tcp_v4_send_check(skb, iph->saddr, iph->daddr);
Herbert Xua430a432006-07-08 13:34:56 -0700588 return 0;
589}
590
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591/*
592 * This routine will send an RST to the other tcp.
593 *
594 * Someone asks: why I NEVER use socket parameters (TOS, TTL etc.)
595 * for reset.
596 * Answer: if a packet caused RST, it is not for a socket
597 * existing in our system, if it is matched to a socket,
598 * it is just duplicate segment or bug in other side's TCP.
599 * So that we build reply only basing on parameters
600 * arrived with segment.
601 * Exception: precedence violation. We do not implement it in any case.
602 */
603
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800604static void tcp_v4_send_reset(struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400606 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800607 struct {
608 struct tcphdr th;
609#ifdef CONFIG_TCP_MD5SIG
Al Viro714e85b2006-11-14 20:51:49 -0800610 __be32 opt[(TCPOLEN_MD5SIG_ALIGNED >> 2)];
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800611#endif
612 } rep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 struct ip_reply_arg arg;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800614#ifdef CONFIG_TCP_MD5SIG
615 struct tcp_md5sig_key *key;
Shawn Lu658ddaa2012-01-31 22:35:48 +0000616 const __u8 *hash_location = NULL;
617 unsigned char newhash[16];
618 int genhash;
619 struct sock *sk1 = NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800620#endif
Pavel Emelyanova86b1e32008-07-16 20:20:58 -0700621 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622
623 /* Never send a reset in response to a reset. */
624 if (th->rst)
625 return;
626
Eric Dumazet511c3f92009-06-02 05:14:27 +0000627 if (skb_rtable(skb)->rt_type != RTN_LOCAL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 return;
629
630 /* Swap the send and the receive. */
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800631 memset(&rep, 0, sizeof(rep));
632 rep.th.dest = th->source;
633 rep.th.source = th->dest;
634 rep.th.doff = sizeof(struct tcphdr) / 4;
635 rep.th.rst = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636
637 if (th->ack) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800638 rep.th.seq = th->ack_seq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800640 rep.th.ack = 1;
641 rep.th.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
642 skb->len - (th->doff << 2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 }
644
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200645 memset(&arg, 0, sizeof(arg));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800646 arg.iov[0].iov_base = (unsigned char *)&rep;
647 arg.iov[0].iov_len = sizeof(rep.th);
648
649#ifdef CONFIG_TCP_MD5SIG
Shawn Lu658ddaa2012-01-31 22:35:48 +0000650 hash_location = tcp_parse_md5sig_option(th);
651 if (!sk && hash_location) {
652 /*
653 * active side is lost. Try to find listening socket through
654 * source port, and then find md5 key through listening socket.
655 * we are not loose security here:
656 * Incoming packet is checked with md5 hash with finding key,
657 * no RST generated if md5 hash doesn't match.
658 */
659 sk1 = __inet_lookup_listener(dev_net(skb_dst(skb)->dev),
660 &tcp_hashinfo, ip_hdr(skb)->daddr,
661 ntohs(th->source), inet_iif(skb));
662 /* don't send rst if it can't find key */
663 if (!sk1)
664 return;
665 rcu_read_lock();
666 key = tcp_md5_do_lookup(sk1, (union tcp_md5_addr *)
667 &ip_hdr(skb)->saddr, AF_INET);
668 if (!key)
669 goto release_sk1;
670
671 genhash = tcp_v4_md5_hash_skb(newhash, key, NULL, NULL, skb);
672 if (genhash || memcmp(hash_location, newhash, 16) != 0)
673 goto release_sk1;
674 } else {
675 key = sk ? tcp_md5_do_lookup(sk, (union tcp_md5_addr *)
676 &ip_hdr(skb)->saddr,
677 AF_INET) : NULL;
678 }
679
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800680 if (key) {
681 rep.opt[0] = htonl((TCPOPT_NOP << 24) |
682 (TCPOPT_NOP << 16) |
683 (TCPOPT_MD5SIG << 8) |
684 TCPOLEN_MD5SIG);
685 /* Update length and the length the header thinks exists */
686 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
687 rep.th.doff = arg.iov[0].iov_len / 4;
688
Adam Langley49a72df2008-07-19 00:01:42 -0700689 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[1],
Ilpo Järvinen78e645cb2008-10-09 14:37:47 -0700690 key, ip_hdr(skb)->saddr,
691 ip_hdr(skb)->daddr, &rep.th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800692 }
693#endif
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700694 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
695 ip_hdr(skb)->saddr, /* XXX */
Ilpo Järvinen52cd5752008-10-08 11:34:06 -0700696 arg.iov[0].iov_len, IPPROTO_TCP, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700698 arg.flags = (sk && inet_sk(sk)->transparent) ? IP_REPLY_ARG_NOSRCCHECK : 0;
Shawn Lue2446ea2012-02-04 12:38:09 +0000699 /* When socket is gone, all binding information is lost.
Alexey Kuznetsov4c675252012-10-12 04:34:17 +0000700 * routing might fail in this case. No choice here, if we choose to force
701 * input interface, we will misroute in case of asymmetric route.
Shawn Lue2446ea2012-02-04 12:38:09 +0000702 */
Alexey Kuznetsov4c675252012-10-12 04:34:17 +0000703 if (sk)
704 arg.bound_dev_if = sk->sk_bound_dev_if;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705
Eric Dumazetadf30902009-06-02 05:19:30 +0000706 net = dev_net(skb_dst(skb)->dev);
Eric Dumazet66b13d92011-10-24 03:06:21 -0400707 arg.tos = ip_hdr(skb)->tos;
Eric Dumazetbe9f4a42012-07-19 07:34:03 +0000708 ip_send_unicast_reply(net, skb, ip_hdr(skb)->saddr,
David S. Miller70e73412012-06-28 03:21:41 -0700709 ip_hdr(skb)->daddr, &arg, arg.iov[0].iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710
Pavel Emelyanov63231bd2008-07-16 20:22:25 -0700711 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
712 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
Shawn Lu658ddaa2012-01-31 22:35:48 +0000713
714#ifdef CONFIG_TCP_MD5SIG
715release_sk1:
716 if (sk1) {
717 rcu_read_unlock();
718 sock_put(sk1);
719 }
720#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721}
722
723/* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
724 outside socket context is ugly, certainly. What can I do?
725 */
726
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900727static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
728 u32 win, u32 ts, int oif,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700729 struct tcp_md5sig_key *key,
Eric Dumazet66b13d92011-10-24 03:06:21 -0400730 int reply_flags, u8 tos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400732 const struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 struct {
734 struct tcphdr th;
Al Viro714e85b2006-11-14 20:51:49 -0800735 __be32 opt[(TCPOLEN_TSTAMP_ALIGNED >> 2)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800736#ifdef CONFIG_TCP_MD5SIG
Al Viro714e85b2006-11-14 20:51:49 -0800737 + (TCPOLEN_MD5SIG_ALIGNED >> 2)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800738#endif
739 ];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 } rep;
741 struct ip_reply_arg arg;
Eric Dumazetadf30902009-06-02 05:19:30 +0000742 struct net *net = dev_net(skb_dst(skb)->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743
744 memset(&rep.th, 0, sizeof(struct tcphdr));
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200745 memset(&arg, 0, sizeof(arg));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746
747 arg.iov[0].iov_base = (unsigned char *)&rep;
748 arg.iov[0].iov_len = sizeof(rep.th);
749 if (ts) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800750 rep.opt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
751 (TCPOPT_TIMESTAMP << 8) |
752 TCPOLEN_TIMESTAMP);
753 rep.opt[1] = htonl(tcp_time_stamp);
754 rep.opt[2] = htonl(ts);
Craig Schlentercb48cfe2007-01-09 00:11:15 -0800755 arg.iov[0].iov_len += TCPOLEN_TSTAMP_ALIGNED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 }
757
758 /* Swap the send and the receive. */
759 rep.th.dest = th->source;
760 rep.th.source = th->dest;
761 rep.th.doff = arg.iov[0].iov_len / 4;
762 rep.th.seq = htonl(seq);
763 rep.th.ack_seq = htonl(ack);
764 rep.th.ack = 1;
765 rep.th.window = htons(win);
766
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800767#ifdef CONFIG_TCP_MD5SIG
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800768 if (key) {
769 int offset = (ts) ? 3 : 0;
770
771 rep.opt[offset++] = htonl((TCPOPT_NOP << 24) |
772 (TCPOPT_NOP << 16) |
773 (TCPOPT_MD5SIG << 8) |
774 TCPOLEN_MD5SIG);
775 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
776 rep.th.doff = arg.iov[0].iov_len/4;
777
Adam Langley49a72df2008-07-19 00:01:42 -0700778 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[offset],
Adam Langley90b7e112008-07-31 20:49:48 -0700779 key, ip_hdr(skb)->saddr,
780 ip_hdr(skb)->daddr, &rep.th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800781 }
782#endif
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700783 arg.flags = reply_flags;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700784 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
785 ip_hdr(skb)->saddr, /* XXX */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 arg.iov[0].iov_len, IPPROTO_TCP, 0);
787 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900788 if (oif)
789 arg.bound_dev_if = oif;
Eric Dumazet66b13d92011-10-24 03:06:21 -0400790 arg.tos = tos;
Eric Dumazetbe9f4a42012-07-19 07:34:03 +0000791 ip_send_unicast_reply(net, skb, ip_hdr(skb)->saddr,
David S. Miller70e73412012-06-28 03:21:41 -0700792 ip_hdr(skb)->daddr, &arg, arg.iov[0].iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793
Pavel Emelyanov63231bd2008-07-16 20:22:25 -0700794 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795}
796
797static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
798{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700799 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800800 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900802 tcp_v4_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200803 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900804 tcptw->tw_ts_recent,
805 tw->tw_bound_dev_if,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700806 tcp_twsk_md5_key(tcptw),
Eric Dumazet66b13d92011-10-24 03:06:21 -0400807 tw->tw_transparent ? IP_REPLY_ARG_NOSRCCHECK : 0,
808 tw->tw_tos
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900809 );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700811 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812}
813
Gui Jianfeng6edafaa2008-08-06 23:50:04 -0700814static void tcp_v4_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200815 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816{
Jerry Chu168a8f52012-08-31 12:29:13 +0000817 /* sk->sk_state == TCP_LISTEN -> for regular TCP_SYN_RECV
818 * sk->sk_state == TCP_SYN_RECV -> for Fast Open.
819 */
820 tcp_v4_send_ack(skb, (sk->sk_state == TCP_LISTEN) ?
821 tcp_rsk(req)->snt_isn + 1 : tcp_sk(sk)->snd_nxt,
822 tcp_rsk(req)->rcv_nxt, req->rcv_wnd,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900823 req->ts_recent,
824 0,
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000825 tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&ip_hdr(skb)->daddr,
826 AF_INET),
Eric Dumazet66b13d92011-10-24 03:06:21 -0400827 inet_rsk(req)->no_srccheck ? IP_REPLY_ARG_NOSRCCHECK : 0,
828 ip_hdr(skb)->tos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829}
830
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831/*
Kris Katterjohn9bf1d832008-02-17 22:29:19 -0800832 * Send a SYN-ACK after having received a SYN.
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700833 * This still operates on a request_sock only, not on a big
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 * socket.
835 */
Octavian Purdila72659ec2010-01-17 19:09:39 -0800836static int tcp_v4_send_synack(struct sock *sk, struct dst_entry *dst,
837 struct request_sock *req,
Eric Dumazetfff32692012-06-01 01:47:50 +0000838 struct request_values *rvp,
Eric Dumazet7586ece2012-06-20 05:02:19 +0000839 u16 queue_mapping,
840 bool nocache)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700842 const struct inet_request_sock *ireq = inet_rsk(req);
David S. Miller6bd023f2011-05-18 18:32:03 -0400843 struct flowi4 fl4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 int err = -1;
845 struct sk_buff * skb;
846
847 /* First, grab a route. */
David S. Millerba3f7f02012-07-17 14:02:46 -0700848 if (!dst && (dst = inet_csk_route_req(sk, &fl4, req)) == NULL)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800849 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850
Jerry Chu83368862012-08-31 12:29:12 +0000851 skb = tcp_make_synack(sk, dst, req, rvp, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852
853 if (skb) {
Herbert Xu419f9f82010-04-11 02:15:53 +0000854 __tcp_v4_send_check(skb, ireq->loc_addr, ireq->rmt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855
Eric Dumazetfff32692012-06-01 01:47:50 +0000856 skb_set_queue_mapping(skb, queue_mapping);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700857 err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,
858 ireq->rmt_addr,
859 ireq->opt);
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200860 err = net_xmit_eval(err);
Neal Cardwell016818d2012-09-22 04:18:55 +0000861 if (!tcp_rsk(req)->snt_synack && !err)
862 tcp_rsk(req)->snt_synack = tcp_time_stamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 }
864
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 return err;
866}
867
Octavian Purdila72659ec2010-01-17 19:09:39 -0800868static int tcp_v4_rtx_synack(struct sock *sk, struct request_sock *req,
Eric Dumazete6c022a2012-10-27 23:16:46 +0000869 struct request_values *rvp)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800870{
Eric Dumazete6c022a2012-10-27 23:16:46 +0000871 int res = tcp_v4_send_synack(sk, NULL, req, rvp, 0, false);
872
873 if (!res)
874 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_RETRANSSEGS);
875 return res;
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800876}
877
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700879 * IPv4 request_sock destructor.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 */
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700881static void tcp_v4_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882{
Jesper Juhla51482b2005-11-08 09:41:34 -0800883 kfree(inet_rsk(req)->opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884}
885
Eric Dumazet946cedc2011-08-30 03:21:44 +0000886/*
Eric Dumazeta2a385d2012-05-16 23:15:34 +0000887 * Return true if a syncookie should be sent
Eric Dumazet946cedc2011-08-30 03:21:44 +0000888 */
Eric Dumazeta2a385d2012-05-16 23:15:34 +0000889bool tcp_syn_flood_action(struct sock *sk,
Eric Dumazet946cedc2011-08-30 03:21:44 +0000890 const struct sk_buff *skb,
891 const char *proto)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892{
Eric Dumazet946cedc2011-08-30 03:21:44 +0000893 const char *msg = "Dropping request";
Eric Dumazeta2a385d2012-05-16 23:15:34 +0000894 bool want_cookie = false;
Eric Dumazet946cedc2011-08-30 03:21:44 +0000895 struct listen_sock *lopt;
896
897
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000899#ifdef CONFIG_SYN_COOKIES
Eric Dumazet946cedc2011-08-30 03:21:44 +0000900 if (sysctl_tcp_syncookies) {
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000901 msg = "Sending cookies";
Eric Dumazeta2a385d2012-05-16 23:15:34 +0000902 want_cookie = true;
Eric Dumazet946cedc2011-08-30 03:21:44 +0000903 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPREQQFULLDOCOOKIES);
904 } else
Arnaldo Carvalho de Melo80e40da2006-01-04 01:58:06 -0200905#endif
Eric Dumazet946cedc2011-08-30 03:21:44 +0000906 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPREQQFULLDROP);
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000907
Eric Dumazet946cedc2011-08-30 03:21:44 +0000908 lopt = inet_csk(sk)->icsk_accept_queue.listen_opt;
909 if (!lopt->synflood_warned) {
910 lopt->synflood_warned = 1;
Joe Perchesafd465032012-03-12 07:03:32 +0000911 pr_info("%s: Possible SYN flooding on port %d. %s. Check SNMP counters.\n",
Eric Dumazet946cedc2011-08-30 03:21:44 +0000912 proto, ntohs(tcp_hdr(skb)->dest), msg);
913 }
914 return want_cookie;
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000915}
Eric Dumazet946cedc2011-08-30 03:21:44 +0000916EXPORT_SYMBOL(tcp_syn_flood_action);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917
918/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700919 * Save and compile IPv4 options into the request_sock if needed.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 */
Christoph Paasch5dff7472012-09-26 11:59:09 +0000921static struct ip_options_rcu *tcp_v4_save_options(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922{
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000923 const struct ip_options *opt = &(IPCB(skb)->opt);
924 struct ip_options_rcu *dopt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925
926 if (opt && opt->optlen) {
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000927 int opt_size = sizeof(*dopt) + opt->optlen;
928
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 dopt = kmalloc(opt_size, GFP_ATOMIC);
930 if (dopt) {
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000931 if (ip_options_echo(&dopt->opt, skb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 kfree(dopt);
933 dopt = NULL;
934 }
935 }
936 }
937 return dopt;
938}
939
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800940#ifdef CONFIG_TCP_MD5SIG
941/*
942 * RFC2385 MD5 checksumming requires a mapping of
943 * IP address->MD5 Key.
944 * We need to maintain these in the sk structure.
945 */
946
947/* Find the Key structure for an address. */
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000948struct tcp_md5sig_key *tcp_md5_do_lookup(struct sock *sk,
949 const union tcp_md5_addr *addr,
950 int family)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800951{
952 struct tcp_sock *tp = tcp_sk(sk);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000953 struct tcp_md5sig_key *key;
954 struct hlist_node *pos;
955 unsigned int size = sizeof(struct in_addr);
Eric Dumazeta8afca02012-01-31 18:45:40 +0000956 struct tcp_md5sig_info *md5sig;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800957
Eric Dumazeta8afca02012-01-31 18:45:40 +0000958 /* caller either holds rcu_read_lock() or socket lock */
959 md5sig = rcu_dereference_check(tp->md5sig_info,
Eric Dumazetb4fb05e2012-03-07 04:45:43 +0000960 sock_owned_by_user(sk) ||
961 lockdep_is_held(&sk->sk_lock.slock));
Eric Dumazeta8afca02012-01-31 18:45:40 +0000962 if (!md5sig)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800963 return NULL;
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000964#if IS_ENABLED(CONFIG_IPV6)
965 if (family == AF_INET6)
966 size = sizeof(struct in6_addr);
967#endif
Eric Dumazeta8afca02012-01-31 18:45:40 +0000968 hlist_for_each_entry_rcu(key, pos, &md5sig->head, node) {
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000969 if (key->family != family)
970 continue;
971 if (!memcmp(&key->addr, addr, size))
972 return key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800973 }
974 return NULL;
975}
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000976EXPORT_SYMBOL(tcp_md5_do_lookup);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800977
978struct tcp_md5sig_key *tcp_v4_md5_lookup(struct sock *sk,
979 struct sock *addr_sk)
980{
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000981 union tcp_md5_addr *addr;
982
983 addr = (union tcp_md5_addr *)&inet_sk(addr_sk)->inet_daddr;
984 return tcp_md5_do_lookup(sk, addr, AF_INET);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800985}
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800986EXPORT_SYMBOL(tcp_v4_md5_lookup);
987
Adrian Bunkf5b99bc2006-11-30 17:22:29 -0800988static struct tcp_md5sig_key *tcp_v4_reqsk_md5_lookup(struct sock *sk,
989 struct request_sock *req)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800990{
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000991 union tcp_md5_addr *addr;
992
993 addr = (union tcp_md5_addr *)&inet_rsk(req)->rmt_addr;
994 return tcp_md5_do_lookup(sk, addr, AF_INET);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800995}
996
997/* This can be called on a newly created socket, from other files */
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000998int tcp_md5_do_add(struct sock *sk, const union tcp_md5_addr *addr,
999 int family, const u8 *newkey, u8 newkeylen, gfp_t gfp)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001000{
1001 /* Add Key to the list */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -07001002 struct tcp_md5sig_key *key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001003 struct tcp_sock *tp = tcp_sk(sk);
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001004 struct tcp_md5sig_info *md5sig;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001005
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001006 key = tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&addr, AF_INET);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001007 if (key) {
1008 /* Pre-existing entry - just update that one. */
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001009 memcpy(key->key, newkey, newkeylen);
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -07001010 key->keylen = newkeylen;
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001011 return 0;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001012 }
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001013
Eric Dumazeta8afca02012-01-31 18:45:40 +00001014 md5sig = rcu_dereference_protected(tp->md5sig_info,
1015 sock_owned_by_user(sk));
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001016 if (!md5sig) {
1017 md5sig = kmalloc(sizeof(*md5sig), gfp);
1018 if (!md5sig)
1019 return -ENOMEM;
1020
1021 sk_nocaps_add(sk, NETIF_F_GSO_MASK);
1022 INIT_HLIST_HEAD(&md5sig->head);
Eric Dumazeta8afca02012-01-31 18:45:40 +00001023 rcu_assign_pointer(tp->md5sig_info, md5sig);
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001024 }
1025
Eric Dumazet5f3d9cb2012-01-31 10:56:48 +00001026 key = sock_kmalloc(sk, sizeof(*key), gfp);
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001027 if (!key)
1028 return -ENOMEM;
1029 if (hlist_empty(&md5sig->head) && !tcp_alloc_md5sig_pool(sk)) {
Eric Dumazet5f3d9cb2012-01-31 10:56:48 +00001030 sock_kfree_s(sk, key, sizeof(*key));
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001031 return -ENOMEM;
1032 }
1033
1034 memcpy(key->key, newkey, newkeylen);
1035 key->keylen = newkeylen;
1036 key->family = family;
1037 memcpy(&key->addr, addr,
1038 (family == AF_INET6) ? sizeof(struct in6_addr) :
1039 sizeof(struct in_addr));
1040 hlist_add_head_rcu(&key->node, &md5sig->head);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001041 return 0;
1042}
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001043EXPORT_SYMBOL(tcp_md5_do_add);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001044
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001045int tcp_md5_do_del(struct sock *sk, const union tcp_md5_addr *addr, int family)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001046{
1047 struct tcp_sock *tp = tcp_sk(sk);
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001048 struct tcp_md5sig_key *key;
Eric Dumazeta8afca02012-01-31 18:45:40 +00001049 struct tcp_md5sig_info *md5sig;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001050
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001051 key = tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&addr, AF_INET);
1052 if (!key)
1053 return -ENOENT;
1054 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);
Eric Dumazeta8afca02012-01-31 18:45:40 +00001057 md5sig = rcu_dereference_protected(tp->md5sig_info,
1058 sock_owned_by_user(sk));
1059 if (hlist_empty(&md5sig->head))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001060 tcp_free_md5sig_pool();
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001061 return 0;
1062}
1063EXPORT_SYMBOL(tcp_md5_do_del);
1064
stephen hemmingere0683e702012-10-26 14:31:40 +00001065static void tcp_clear_md5_list(struct sock *sk)
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001066{
1067 struct tcp_sock *tp = tcp_sk(sk);
1068 struct tcp_md5sig_key *key;
1069 struct hlist_node *pos, *n;
Eric Dumazeta8afca02012-01-31 18:45:40 +00001070 struct tcp_md5sig_info *md5sig;
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001071
Eric Dumazeta8afca02012-01-31 18:45:40 +00001072 md5sig = rcu_dereference_protected(tp->md5sig_info, 1);
1073
1074 if (!hlist_empty(&md5sig->head))
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001075 tcp_free_md5sig_pool();
Eric Dumazeta8afca02012-01-31 18:45:40 +00001076 hlist_for_each_entry_safe(key, pos, n, &md5sig->head, node) {
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001077 hlist_del_rcu(&key->node);
Eric Dumazet5f3d9cb2012-01-31 10:56:48 +00001078 atomic_sub(sizeof(*key), &sk->sk_omem_alloc);
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001079 kfree_rcu(key, rcu);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001080 }
1081}
1082
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001083static int tcp_v4_parse_md5_keys(struct sock *sk, char __user *optval,
1084 int optlen)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001085{
1086 struct tcp_md5sig cmd;
1087 struct sockaddr_in *sin = (struct sockaddr_in *)&cmd.tcpm_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001088
1089 if (optlen < sizeof(cmd))
1090 return -EINVAL;
1091
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001092 if (copy_from_user(&cmd, optval, sizeof(cmd)))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001093 return -EFAULT;
1094
1095 if (sin->sin_family != AF_INET)
1096 return -EINVAL;
1097
Eric Dumazeta8afca02012-01-31 18:45:40 +00001098 if (!cmd.tcpm_key || !cmd.tcpm_keylen)
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001099 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin->sin_addr.s_addr,
1100 AF_INET);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001101
1102 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
1103 return -EINVAL;
1104
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001105 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin->sin_addr.s_addr,
1106 AF_INET, cmd.tcpm_key, cmd.tcpm_keylen,
1107 GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001108}
1109
Adam Langley49a72df2008-07-19 00:01:42 -07001110static int tcp_v4_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
1111 __be32 daddr, __be32 saddr, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001112{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001113 struct tcp4_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -07001114 struct scatterlist sg;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001115
1116 bp = &hp->md5_blk.ip4;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001117
1118 /*
Adam Langley49a72df2008-07-19 00:01:42 -07001119 * 1. the TCP pseudo-header (in the order: source IP address,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001120 * destination IP address, zero-padded protocol number, and
1121 * segment length)
1122 */
1123 bp->saddr = saddr;
1124 bp->daddr = daddr;
1125 bp->pad = 0;
YOSHIFUJI Hideaki076fb722008-04-17 12:48:12 +09001126 bp->protocol = IPPROTO_TCP;
Adam Langley49a72df2008-07-19 00:01:42 -07001127 bp->len = cpu_to_be16(nbytes);
David S. Millerc7da57a2007-10-26 00:41:21 -07001128
Adam Langley49a72df2008-07-19 00:01:42 -07001129 sg_init_one(&sg, bp, sizeof(*bp));
1130 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
1131}
1132
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001133static int tcp_v4_md5_hash_hdr(char *md5_hash, const struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -04001134 __be32 daddr, __be32 saddr, const struct tcphdr *th)
Adam Langley49a72df2008-07-19 00:01:42 -07001135{
1136 struct tcp_md5sig_pool *hp;
1137 struct hash_desc *desc;
1138
1139 hp = tcp_get_md5sig_pool();
1140 if (!hp)
1141 goto clear_hash_noput;
1142 desc = &hp->md5_desc;
1143
1144 if (crypto_hash_init(desc))
1145 goto clear_hash;
1146 if (tcp_v4_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
1147 goto clear_hash;
1148 if (tcp_md5_hash_header(hp, th))
1149 goto clear_hash;
1150 if (tcp_md5_hash_key(hp, key))
1151 goto clear_hash;
1152 if (crypto_hash_final(desc, md5_hash))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001153 goto clear_hash;
1154
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001155 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001156 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -07001157
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001158clear_hash:
1159 tcp_put_md5sig_pool();
1160clear_hash_noput:
1161 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -07001162 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001163}
1164
Adam Langley49a72df2008-07-19 00:01:42 -07001165int tcp_v4_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -04001166 const struct sock *sk, const struct request_sock *req,
1167 const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001168{
Adam Langley49a72df2008-07-19 00:01:42 -07001169 struct tcp_md5sig_pool *hp;
1170 struct hash_desc *desc;
Eric Dumazet318cf7a2011-10-24 02:46:04 -04001171 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001172 __be32 saddr, daddr;
1173
1174 if (sk) {
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001175 saddr = inet_sk(sk)->inet_saddr;
1176 daddr = inet_sk(sk)->inet_daddr;
Adam Langley49a72df2008-07-19 00:01:42 -07001177 } else if (req) {
1178 saddr = inet_rsk(req)->loc_addr;
1179 daddr = inet_rsk(req)->rmt_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001180 } else {
Adam Langley49a72df2008-07-19 00:01:42 -07001181 const struct iphdr *iph = ip_hdr(skb);
1182 saddr = iph->saddr;
1183 daddr = iph->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001184 }
Adam Langley49a72df2008-07-19 00:01:42 -07001185
1186 hp = tcp_get_md5sig_pool();
1187 if (!hp)
1188 goto clear_hash_noput;
1189 desc = &hp->md5_desc;
1190
1191 if (crypto_hash_init(desc))
1192 goto clear_hash;
1193
1194 if (tcp_v4_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
1195 goto clear_hash;
1196 if (tcp_md5_hash_header(hp, th))
1197 goto clear_hash;
1198 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
1199 goto clear_hash;
1200 if (tcp_md5_hash_key(hp, key))
1201 goto clear_hash;
1202 if (crypto_hash_final(desc, md5_hash))
1203 goto clear_hash;
1204
1205 tcp_put_md5sig_pool();
1206 return 0;
1207
1208clear_hash:
1209 tcp_put_md5sig_pool();
1210clear_hash_noput:
1211 memset(md5_hash, 0, 16);
1212 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001213}
Adam Langley49a72df2008-07-19 00:01:42 -07001214EXPORT_SYMBOL(tcp_v4_md5_hash_skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001215
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001216static bool tcp_v4_inbound_md5_hash(struct sock *sk, const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001217{
1218 /*
1219 * This gets called for each TCP segment that arrives
1220 * so we want to be efficient.
1221 * We have 3 drop cases:
1222 * o No MD5 hash and one expected.
1223 * o MD5 hash and we're not expecting one.
1224 * o MD5 hash and its wrong.
1225 */
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001226 const __u8 *hash_location = NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001227 struct tcp_md5sig_key *hash_expected;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001228 const struct iphdr *iph = ip_hdr(skb);
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001229 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001230 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001231 unsigned char newhash[16];
1232
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001233 hash_expected = tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&iph->saddr,
1234 AF_INET);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +09001235 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001236
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001237 /* We've parsed the options - do we have a hash? */
1238 if (!hash_expected && !hash_location)
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001239 return false;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001240
1241 if (hash_expected && !hash_location) {
David S. Miller785957d2008-07-30 03:03:15 -07001242 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001243 return true;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001244 }
1245
1246 if (!hash_expected && hash_location) {
David S. Miller785957d2008-07-30 03:03:15 -07001247 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001248 return true;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001249 }
1250
1251 /* Okay, so this is hash_expected and hash_location -
1252 * so we need to calculate the checksum.
1253 */
Adam Langley49a72df2008-07-19 00:01:42 -07001254 genhash = tcp_v4_md5_hash_skb(newhash,
1255 hash_expected,
1256 NULL, NULL, skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001257
1258 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
Joe Perchese87cc472012-05-13 21:56:26 +00001259 net_info_ratelimited("MD5 Hash failed for (%pI4, %d)->(%pI4, %d)%s\n",
1260 &iph->saddr, ntohs(th->source),
1261 &iph->daddr, ntohs(th->dest),
1262 genhash ? " tcp_v4_calc_md5_hash failed"
1263 : "");
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001264 return true;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001265 }
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001266 return false;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001267}
1268
1269#endif
1270
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001271struct request_sock_ops tcp_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 .family = PF_INET,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001273 .obj_size = sizeof(struct tcp_request_sock),
Octavian Purdila72659ec2010-01-17 19:09:39 -08001274 .rtx_syn_ack = tcp_v4_rtx_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001275 .send_ack = tcp_v4_reqsk_send_ack,
1276 .destructor = tcp_v4_reqsk_destructor,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277 .send_reset = tcp_v4_send_reset,
Octavian Purdila72659ec2010-01-17 19:09:39 -08001278 .syn_ack_timeout = tcp_syn_ack_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279};
1280
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001281#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001282static const struct tcp_request_sock_ops tcp_request_sock_ipv4_ops = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001283 .md5_lookup = tcp_v4_reqsk_md5_lookup,
John Dykstrae3afe7b2009-07-16 05:04:51 +00001284 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001285};
Andrew Mortonb6332e62006-11-30 19:16:28 -08001286#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001287
Jerry Chu168a8f52012-08-31 12:29:13 +00001288static bool tcp_fastopen_check(struct sock *sk, struct sk_buff *skb,
1289 struct request_sock *req,
1290 struct tcp_fastopen_cookie *foc,
1291 struct tcp_fastopen_cookie *valid_foc)
1292{
1293 bool skip_cookie = false;
1294 struct fastopen_queue *fastopenq;
1295
1296 if (likely(!fastopen_cookie_present(foc))) {
1297 /* See include/net/tcp.h for the meaning of these knobs */
1298 if ((sysctl_tcp_fastopen & TFO_SERVER_ALWAYS) ||
1299 ((sysctl_tcp_fastopen & TFO_SERVER_COOKIE_NOT_REQD) &&
1300 (TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(skb)->seq + 1)))
1301 skip_cookie = true; /* no cookie to validate */
1302 else
1303 return false;
1304 }
1305 fastopenq = inet_csk(sk)->icsk_accept_queue.fastopenq;
1306 /* A FO option is present; bump the counter. */
1307 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPFASTOPENPASSIVE);
1308
1309 /* Make sure the listener has enabled fastopen, and we don't
1310 * exceed the max # of pending TFO requests allowed before trying
1311 * to validating the cookie in order to avoid burning CPU cycles
1312 * unnecessarily.
1313 *
1314 * XXX (TFO) - The implication of checking the max_qlen before
1315 * processing a cookie request is that clients can't differentiate
1316 * between qlen overflow causing Fast Open to be disabled
1317 * temporarily vs a server not supporting Fast Open at all.
1318 */
1319 if ((sysctl_tcp_fastopen & TFO_SERVER_ENABLE) == 0 ||
1320 fastopenq == NULL || fastopenq->max_qlen == 0)
1321 return false;
1322
1323 if (fastopenq->qlen >= fastopenq->max_qlen) {
1324 struct request_sock *req1;
1325 spin_lock(&fastopenq->lock);
1326 req1 = fastopenq->rskq_rst_head;
1327 if ((req1 == NULL) || time_after(req1->expires, jiffies)) {
1328 spin_unlock(&fastopenq->lock);
1329 NET_INC_STATS_BH(sock_net(sk),
1330 LINUX_MIB_TCPFASTOPENLISTENOVERFLOW);
1331 /* Avoid bumping LINUX_MIB_TCPFASTOPENPASSIVEFAIL*/
1332 foc->len = -1;
1333 return false;
1334 }
1335 fastopenq->rskq_rst_head = req1->dl_next;
1336 fastopenq->qlen--;
1337 spin_unlock(&fastopenq->lock);
1338 reqsk_free(req1);
1339 }
1340 if (skip_cookie) {
1341 tcp_rsk(req)->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
1342 return true;
1343 }
1344 if (foc->len == TCP_FASTOPEN_COOKIE_SIZE) {
1345 if ((sysctl_tcp_fastopen & TFO_SERVER_COOKIE_NOT_CHKED) == 0) {
1346 tcp_fastopen_cookie_gen(ip_hdr(skb)->saddr, valid_foc);
1347 if ((valid_foc->len != TCP_FASTOPEN_COOKIE_SIZE) ||
1348 memcmp(&foc->val[0], &valid_foc->val[0],
1349 TCP_FASTOPEN_COOKIE_SIZE) != 0)
1350 return false;
1351 valid_foc->len = -1;
1352 }
1353 /* Acknowledge the data received from the peer. */
1354 tcp_rsk(req)->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
1355 return true;
1356 } else if (foc->len == 0) { /* Client requesting a cookie */
1357 tcp_fastopen_cookie_gen(ip_hdr(skb)->saddr, valid_foc);
1358 NET_INC_STATS_BH(sock_net(sk),
1359 LINUX_MIB_TCPFASTOPENCOOKIEREQD);
1360 } else {
1361 /* Client sent a cookie with wrong size. Treat it
1362 * the same as invalid and return a valid one.
1363 */
1364 tcp_fastopen_cookie_gen(ip_hdr(skb)->saddr, valid_foc);
1365 }
1366 return false;
1367}
1368
1369static int tcp_v4_conn_req_fastopen(struct sock *sk,
1370 struct sk_buff *skb,
1371 struct sk_buff *skb_synack,
1372 struct request_sock *req,
1373 struct request_values *rvp)
1374{
1375 struct tcp_sock *tp = tcp_sk(sk);
1376 struct request_sock_queue *queue = &inet_csk(sk)->icsk_accept_queue;
1377 const struct inet_request_sock *ireq = inet_rsk(req);
1378 struct sock *child;
Neal Cardwell016818d2012-09-22 04:18:55 +00001379 int err;
Jerry Chu168a8f52012-08-31 12:29:13 +00001380
Eric Dumazete6c022a2012-10-27 23:16:46 +00001381 req->num_retrans = 0;
1382 req->num_timeout = 0;
Jerry Chu168a8f52012-08-31 12:29:13 +00001383 req->sk = NULL;
1384
1385 child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, req, NULL);
1386 if (child == NULL) {
1387 NET_INC_STATS_BH(sock_net(sk),
1388 LINUX_MIB_TCPFASTOPENPASSIVEFAIL);
1389 kfree_skb(skb_synack);
1390 return -1;
1391 }
Neal Cardwell016818d2012-09-22 04:18:55 +00001392 err = ip_build_and_send_pkt(skb_synack, sk, ireq->loc_addr,
1393 ireq->rmt_addr, ireq->opt);
1394 err = net_xmit_eval(err);
1395 if (!err)
1396 tcp_rsk(req)->snt_synack = tcp_time_stamp;
Jerry Chu168a8f52012-08-31 12:29:13 +00001397 /* XXX (TFO) - is it ok to ignore error and continue? */
1398
1399 spin_lock(&queue->fastopenq->lock);
1400 queue->fastopenq->qlen++;
1401 spin_unlock(&queue->fastopenq->lock);
1402
1403 /* Initialize the child socket. Have to fix some values to take
1404 * into account the child is a Fast Open socket and is created
1405 * only out of the bits carried in the SYN packet.
1406 */
1407 tp = tcp_sk(child);
1408
1409 tp->fastopen_rsk = req;
1410 /* Do a hold on the listner sk so that if the listener is being
1411 * closed, the child that has been accepted can live on and still
1412 * access listen_lock.
1413 */
1414 sock_hold(sk);
1415 tcp_rsk(req)->listener = sk;
1416
1417 /* RFC1323: The window in SYN & SYN/ACK segments is never
1418 * scaled. So correct it appropriately.
1419 */
1420 tp->snd_wnd = ntohs(tcp_hdr(skb)->window);
1421
1422 /* Activate the retrans timer so that SYNACK can be retransmitted.
1423 * The request socket is not added to the SYN table of the parent
1424 * because it's been added to the accept queue directly.
1425 */
1426 inet_csk_reset_xmit_timer(child, ICSK_TIME_RETRANS,
1427 TCP_TIMEOUT_INIT, TCP_RTO_MAX);
1428
1429 /* Add the child socket directly into the accept queue */
1430 inet_csk_reqsk_queue_add(sk, req, child);
1431
1432 /* Now finish processing the fastopen child socket. */
1433 inet_csk(child)->icsk_af_ops->rebuild_header(child);
1434 tcp_init_congestion_control(child);
1435 tcp_mtup_init(child);
1436 tcp_init_buffer_space(child);
1437 tcp_init_metrics(child);
1438
1439 /* Queue the data carried in the SYN packet. We need to first
1440 * bump skb's refcnt because the caller will attempt to free it.
1441 *
1442 * XXX (TFO) - we honor a zero-payload TFO request for now.
1443 * (Any reason not to?)
1444 */
1445 if (TCP_SKB_CB(skb)->end_seq == TCP_SKB_CB(skb)->seq + 1) {
1446 /* Don't queue the skb if there is no payload in SYN.
1447 * XXX (TFO) - How about SYN+FIN?
1448 */
1449 tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
1450 } else {
1451 skb = skb_get(skb);
1452 skb_dst_drop(skb);
1453 __skb_pull(skb, tcp_hdr(skb)->doff * 4);
1454 skb_set_owner_r(skb, child);
1455 __skb_queue_tail(&child->sk_receive_queue, skb);
1456 tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
Yuchung Cheng6f736012012-10-19 15:14:44 +00001457 tp->syn_data_acked = 1;
Jerry Chu168a8f52012-08-31 12:29:13 +00001458 }
1459 sk->sk_data_ready(sk, 0);
1460 bh_unlock_sock(child);
1461 sock_put(child);
1462 WARN_ON(req->sk == NULL);
1463 return 0;
1464}
1465
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1467{
William Allen Simpson4957faade2009-12-02 18:25:27 +00001468 struct tcp_extend_values tmp_ext;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 struct tcp_options_received tmp_opt;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001470 const u8 *hash_location;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001471 struct request_sock *req;
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001472 struct inet_request_sock *ireq;
William Allen Simpson4957faade2009-12-02 18:25:27 +00001473 struct tcp_sock *tp = tcp_sk(sk);
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001474 struct dst_entry *dst = NULL;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001475 __be32 saddr = ip_hdr(skb)->saddr;
1476 __be32 daddr = ip_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477 __u32 isn = TCP_SKB_CB(skb)->when;
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001478 bool want_cookie = false;
Jerry Chu168a8f52012-08-31 12:29:13 +00001479 struct flowi4 fl4;
1480 struct tcp_fastopen_cookie foc = { .len = -1 };
1481 struct tcp_fastopen_cookie valid_foc = { .len = -1 };
1482 struct sk_buff *skb_synack;
1483 int do_fastopen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484
1485 /* Never answer to SYNs send to broadcast or multicast */
Eric Dumazet511c3f92009-06-02 05:14:27 +00001486 if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 goto drop;
1488
1489 /* TW buckets are converted to open requests without
1490 * limitations, they conserve resources and peer is
1491 * evidently real one.
1492 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001493 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
Eric Dumazet946cedc2011-08-30 03:21:44 +00001494 want_cookie = tcp_syn_flood_action(sk, skb, "TCP");
1495 if (!want_cookie)
1496 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 }
1498
1499 /* Accept backlog is full. If we have already queued enough
1500 * of warm entries in syn queue, drop request. It is better than
1501 * clogging syn queue with openreqs with exponentially increasing
1502 * timeout.
1503 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001504 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505 goto drop;
1506
Arnaldo Carvalho de Meloce4a7d02008-06-10 12:39:35 -07001507 req = inet_reqsk_alloc(&tcp_request_sock_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 if (!req)
1509 goto drop;
1510
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001511#ifdef CONFIG_TCP_MD5SIG
1512 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv4_ops;
1513#endif
1514
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515 tcp_clear_options(&tmp_opt);
William Allen Simpsonbee7ca92009-11-10 09:51:18 +00001516 tmp_opt.mss_clamp = TCP_MSS_DEFAULT;
William Allen Simpson4957faade2009-12-02 18:25:27 +00001517 tmp_opt.user_mss = tp->rx_opt.user_mss;
Jerry Chu168a8f52012-08-31 12:29:13 +00001518 tcp_parse_options(skb, &tmp_opt, &hash_location, 0,
1519 want_cookie ? NULL : &foc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520
William Allen Simpson4957faade2009-12-02 18:25:27 +00001521 if (tmp_opt.cookie_plus > 0 &&
1522 tmp_opt.saw_tstamp &&
1523 !tp->rx_opt.cookie_out_never &&
1524 (sysctl_tcp_cookie_size > 0 ||
1525 (tp->cookie_values != NULL &&
1526 tp->cookie_values->cookie_desired > 0))) {
1527 u8 *c;
1528 u32 *mess = &tmp_ext.cookie_bakery[COOKIE_DIGEST_WORDS];
1529 int l = tmp_opt.cookie_plus - TCPOLEN_COOKIE_BASE;
1530
1531 if (tcp_cookie_generator(&tmp_ext.cookie_bakery[0]) != 0)
1532 goto drop_and_release;
1533
1534 /* Secret recipe starts with IP addresses */
Eric Dumazet0eae88f2010-04-20 19:06:52 -07001535 *mess++ ^= (__force u32)daddr;
1536 *mess++ ^= (__force u32)saddr;
William Allen Simpson4957faade2009-12-02 18:25:27 +00001537
1538 /* plus variable length Initiator Cookie */
1539 c = (u8 *)mess;
1540 while (l-- > 0)
1541 *c++ ^= *hash_location++;
1542
Eric Dumazeta2a385d2012-05-16 23:15:34 +00001543 want_cookie = false; /* not our kind of cookie */
William Allen Simpson4957faade2009-12-02 18:25:27 +00001544 tmp_ext.cookie_out_never = 0; /* false */
1545 tmp_ext.cookie_plus = tmp_opt.cookie_plus;
1546 } else if (!tp->rx_opt.cookie_in_always) {
1547 /* redundant indications, but ensure initialization. */
1548 tmp_ext.cookie_out_never = 1; /* true */
1549 tmp_ext.cookie_plus = 0;
1550 } else {
1551 goto drop_and_release;
1552 }
1553 tmp_ext.cookie_in_always = tp->rx_opt.cookie_in_always;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554
Florian Westphal4dfc2812008-04-10 03:12:40 -07001555 if (want_cookie && !tmp_opt.saw_tstamp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556 tcp_clear_options(&tmp_opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 tcp_openreq_init(req, &tmp_opt, skb);
1560
David S. Millerbb5b7c12009-12-15 20:56:42 -08001561 ireq = inet_rsk(req);
1562 ireq->loc_addr = daddr;
1563 ireq->rmt_addr = saddr;
1564 ireq->no_srccheck = inet_sk(sk)->transparent;
Christoph Paasch5dff7472012-09-26 11:59:09 +00001565 ireq->opt = tcp_v4_save_options(skb);
David S. Millerbb5b7c12009-12-15 20:56:42 -08001566
Paul Moore284904a2009-03-27 17:10:28 -04001567 if (security_inet_conn_request(sk, skb, req))
David S. Millerbb5b7c12009-12-15 20:56:42 -08001568 goto drop_and_free;
Paul Moore284904a2009-03-27 17:10:28 -04001569
Florian Westphal172d69e2010-06-21 11:48:45 +00001570 if (!want_cookie || tmp_opt.tstamp_ok)
Eric Dumazetbd14b1b2012-05-04 05:14:02 +00001571 TCP_ECN_create_request(req, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572
1573 if (want_cookie) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 isn = cookie_v4_init_sequence(sk, skb, &req->mss);
Florian Westphal172d69e2010-06-21 11:48:45 +00001575 req->cookie_ts = tmp_opt.tstamp_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576 } else if (!isn) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577 /* VJ's idea. We save last timestamp seen
1578 * from the destination in peer table, when entering
1579 * state TIME-WAIT, and check against it before
1580 * accepting new connection request.
1581 *
1582 * If "isn" is not zero, this request hit alive
1583 * timewait bucket, so that all the necessary checks
1584 * are made in the function processing timewait state.
1585 */
1586 if (tmp_opt.saw_tstamp &&
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001587 tcp_death_row.sysctl_tw_recycle &&
David S. Millerba3f7f02012-07-17 14:02:46 -07001588 (dst = inet_csk_route_req(sk, &fl4, req)) != NULL &&
David S. Miller81166dd2012-07-10 03:14:24 -07001589 fl4.daddr == saddr) {
1590 if (!tcp_peer_is_proven(req, dst, true)) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001591 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001592 goto drop_and_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593 }
1594 }
1595 /* Kill the following clause, if you dislike this way. */
1596 else if (!sysctl_tcp_syncookies &&
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001597 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598 (sysctl_max_syn_backlog >> 2)) &&
David S. Miller81166dd2012-07-10 03:14:24 -07001599 !tcp_peer_is_proven(req, dst, false)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600 /* Without syncookies last quarter of
1601 * backlog is filled with destinations,
1602 * proven to be alive.
1603 * It means that we continue to communicate
1604 * to destinations, already remembered
1605 * to the moment of synflood.
1606 */
Joe Perchesafd465032012-03-12 07:03:32 +00001607 LIMIT_NETDEBUG(KERN_DEBUG pr_fmt("drop open request from %pI4/%u\n"),
Harvey Harrison673d57e2008-10-31 00:53:57 -07001608 &saddr, ntohs(tcp_hdr(skb)->source));
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001609 goto drop_and_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610 }
1611
Gerrit Renkera94f7232006-11-10 14:06:49 -08001612 isn = tcp_v4_init_sequence(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613 }
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001614 tcp_rsk(req)->snt_isn = isn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615
Jerry Chu168a8f52012-08-31 12:29:13 +00001616 if (dst == NULL) {
1617 dst = inet_csk_route_req(sk, &fl4, req);
1618 if (dst == NULL)
1619 goto drop_and_free;
1620 }
1621 do_fastopen = tcp_fastopen_check(sk, skb, req, &foc, &valid_foc);
1622
1623 /* We don't call tcp_v4_send_synack() directly because we need
1624 * to make sure a child socket can be created successfully before
1625 * sending back synack!
1626 *
1627 * XXX (TFO) - Ideally one would simply call tcp_v4_send_synack()
1628 * (or better yet, call tcp_send_synack() in the child context
1629 * directly, but will have to fix bunch of other code first)
1630 * after syn_recv_sock() except one will need to first fix the
1631 * latter to remove its dependency on the current implementation
1632 * of tcp_v4_send_synack()->tcp_select_initial_window().
1633 */
1634 skb_synack = tcp_make_synack(sk, dst, req,
1635 (struct request_values *)&tmp_ext,
1636 fastopen_cookie_present(&valid_foc) ? &valid_foc : NULL);
1637
1638 if (skb_synack) {
1639 __tcp_v4_send_check(skb_synack, ireq->loc_addr, ireq->rmt_addr);
1640 skb_set_queue_mapping(skb_synack, skb_get_queue_mapping(skb));
1641 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 goto drop_and_free;
1643
Jerry Chu168a8f52012-08-31 12:29:13 +00001644 if (likely(!do_fastopen)) {
1645 int err;
1646 err = ip_build_and_send_pkt(skb_synack, sk, ireq->loc_addr,
1647 ireq->rmt_addr, ireq->opt);
1648 err = net_xmit_eval(err);
1649 if (err || want_cookie)
1650 goto drop_and_free;
1651
Neal Cardwell016818d2012-09-22 04:18:55 +00001652 tcp_rsk(req)->snt_synack = tcp_time_stamp;
Jerry Chu168a8f52012-08-31 12:29:13 +00001653 tcp_rsk(req)->listener = NULL;
1654 /* Add the request_sock to the SYN table */
1655 inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
1656 if (fastopen_cookie_present(&foc) && foc.len != 0)
1657 NET_INC_STATS_BH(sock_net(sk),
1658 LINUX_MIB_TCPFASTOPENPASSIVEFAIL);
1659 } else if (tcp_v4_conn_req_fastopen(sk, skb, skb_synack, req,
1660 (struct request_values *)&tmp_ext))
1661 goto drop_and_free;
1662
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 return 0;
1664
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001665drop_and_release:
1666 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667drop_and_free:
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001668 reqsk_free(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669drop:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 return 0;
1671}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001672EXPORT_SYMBOL(tcp_v4_conn_request);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673
1674
1675/*
1676 * The three way handshake has completed - we got a valid synack -
1677 * now create the new socket.
1678 */
1679struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001680 struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 struct dst_entry *dst)
1682{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001683 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684 struct inet_sock *newinet;
1685 struct tcp_sock *newtp;
1686 struct sock *newsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001687#ifdef CONFIG_TCP_MD5SIG
1688 struct tcp_md5sig_key *key;
1689#endif
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001690 struct ip_options_rcu *inet_opt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691
1692 if (sk_acceptq_is_full(sk))
1693 goto exit_overflow;
1694
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 newsk = tcp_create_openreq_child(sk, req, skb);
1696 if (!newsk)
Balazs Scheidler093d2822010-10-21 13:06:43 +02001697 goto exit_nonewsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698
Herbert Xubcd76112006-06-30 13:36:35 -07001699 newsk->sk_gso_type = SKB_GSO_TCPV4;
Neal Cardwellfae6ef82012-08-19 03:30:38 +00001700 inet_sk_rx_dst_set(newsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701
1702 newtp = tcp_sk(newsk);
1703 newinet = inet_sk(newsk);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001704 ireq = inet_rsk(req);
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001705 newinet->inet_daddr = ireq->rmt_addr;
1706 newinet->inet_rcv_saddr = ireq->loc_addr;
1707 newinet->inet_saddr = ireq->loc_addr;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001708 inet_opt = ireq->opt;
1709 rcu_assign_pointer(newinet->inet_opt, inet_opt);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001710 ireq->opt = NULL;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001711 newinet->mc_index = inet_iif(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001712 newinet->mc_ttl = ip_hdr(skb)->ttl;
Jiri Benc4c507d22012-02-09 09:35:49 +00001713 newinet->rcv_tos = ip_hdr(skb)->tos;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001714 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001715 if (inet_opt)
1716 inet_csk(newsk)->icsk_ext_hdr_len = inet_opt->opt.optlen;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001717 newinet->inet_id = newtp->write_seq ^ jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718
Eric Dumazetdfd25ff2012-03-10 09:20:21 +00001719 if (!dst) {
1720 dst = inet_csk_route_child_sock(sk, newsk, req);
1721 if (!dst)
1722 goto put_and_exit;
1723 } else {
1724 /* syncookie case : see end of cookie_v4_check() */
1725 }
David S. Miller0e734412011-05-08 15:28:03 -07001726 sk_setup_caps(newsk, dst);
1727
John Heffner5d424d52006-03-20 17:53:41 -08001728 tcp_mtup_init(newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 tcp_sync_mss(newsk, dst_mtu(dst));
David S. Miller0dbaee32010-12-13 12:52:14 -08001730 newtp->advmss = dst_metric_advmss(dst);
Tom Quetchenbachf5fff5d2008-09-21 00:21:51 -07001731 if (tcp_sk(sk)->rx_opt.user_mss &&
1732 tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1733 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1734
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735 tcp_initialize_rcv_mss(newsk);
Neal Cardwell623df482012-09-22 04:18:54 +00001736 tcp_synack_rtt_meas(newsk, req);
Eric Dumazete6c022a2012-10-27 23:16:46 +00001737 newtp->total_retrans = req->num_retrans;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001739#ifdef CONFIG_TCP_MD5SIG
1740 /* Copy over the MD5 key from the original socket */
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001741 key = tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&newinet->inet_daddr,
1742 AF_INET);
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001743 if (key != NULL) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001744 /*
1745 * We're using one, so create a matching key
1746 * on the newsk structure. If we fail to get
1747 * memory, then we end up not copying the key
1748 * across. Shucks.
1749 */
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001750 tcp_md5_do_add(newsk, (union tcp_md5_addr *)&newinet->inet_daddr,
1751 AF_INET, key->key, key->keylen, GFP_ATOMIC);
Eric Dumazeta4654192010-05-16 00:36:33 -07001752 sk_nocaps_add(newsk, NETIF_F_GSO_MASK);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001753 }
1754#endif
1755
David S. Miller0e734412011-05-08 15:28:03 -07001756 if (__inet_inherit_port(sk, newsk) < 0)
1757 goto put_and_exit;
Eric Dumazet9327f702009-12-04 03:46:54 +00001758 __inet_hash_nolisten(newsk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759
1760 return newsk;
1761
1762exit_overflow:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001763 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001764exit_nonewsk:
1765 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766exit:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001767 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 return NULL;
David S. Miller0e734412011-05-08 15:28:03 -07001769put_and_exit:
Eric Dumazet709e8692011-11-14 10:56:56 +00001770 tcp_clear_xmit_timers(newsk);
Eric Dumazetd8a6e652011-11-30 01:02:41 +00001771 tcp_cleanup_congestion_control(newsk);
Eric Dumazet918eb392011-11-02 12:42:56 +00001772 bh_unlock_sock(newsk);
David S. Miller0e734412011-05-08 15:28:03 -07001773 sock_put(newsk);
1774 goto exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001776EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777
1778static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
1779{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001780 struct tcphdr *th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001781 const struct iphdr *iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782 struct sock *nsk;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001783 struct request_sock **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 /* Find possible connection requests. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001785 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
1786 iph->saddr, iph->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787 if (req)
Jerry Chu83368862012-08-31 12:29:12 +00001788 return tcp_check_req(sk, skb, req, prev, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001790 nsk = inet_lookup_established(sock_net(sk), &tcp_hashinfo, iph->saddr,
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001791 th->source, iph->daddr, th->dest, inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792
1793 if (nsk) {
1794 if (nsk->sk_state != TCP_TIME_WAIT) {
1795 bh_lock_sock(nsk);
1796 return nsk;
1797 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001798 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799 return NULL;
1800 }
1801
1802#ifdef CONFIG_SYN_COOKIES
Florian Westphalaf9b4732010-06-03 00:43:44 +00001803 if (!th->syn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
1805#endif
1806 return sk;
1807}
1808
Al Virob51655b2006-11-14 21:40:42 -08001809static __sum16 tcp_v4_checksum_init(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001811 const struct iphdr *iph = ip_hdr(skb);
1812
Patrick McHardy84fa7932006-08-29 16:44:56 -07001813 if (skb->ip_summed == CHECKSUM_COMPLETE) {
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001814 if (!tcp_v4_check(skb->len, iph->saddr,
1815 iph->daddr, skb->csum)) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001816 skb->ip_summed = CHECKSUM_UNNECESSARY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 return 0;
Herbert Xufb286bb2005-11-10 13:01:24 -08001818 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819 }
Herbert Xufb286bb2005-11-10 13:01:24 -08001820
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001821 skb->csum = csum_tcpudp_nofold(iph->saddr, iph->daddr,
Herbert Xufb286bb2005-11-10 13:01:24 -08001822 skb->len, IPPROTO_TCP, 0);
1823
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824 if (skb->len <= 76) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001825 return __skb_checksum_complete(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 }
1827 return 0;
1828}
1829
1830
1831/* The socket must have it's spinlock held when we get
1832 * here.
1833 *
1834 * We have a potential double-lock case here, so even when
1835 * doing backlog processing we use the BH locking scheme.
1836 * This is because we cannot sleep with the original spinlock
1837 * held.
1838 */
1839int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1840{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001841 struct sock *rsk;
1842#ifdef CONFIG_TCP_MD5SIG
1843 /*
1844 * We really want to reject the packet as early as possible
1845 * if:
1846 * o We're expecting an MD5'd packet and this is no MD5 tcp option
1847 * o There is an MD5 option and we're not expecting one
1848 */
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001849 if (tcp_v4_inbound_md5_hash(sk, skb))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001850 goto discard;
1851#endif
1852
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
Eric Dumazet404e0a82012-07-29 23:20:37 +00001854 struct dst_entry *dst = sk->sk_rx_dst;
1855
Tom Herbertbdeab992011-08-14 19:45:55 +00001856 sock_rps_save_rxhash(sk, skb);
Eric Dumazet404e0a82012-07-29 23:20:37 +00001857 if (dst) {
Eric Dumazet505fbcf2012-07-27 06:23:40 +00001858 if (inet_sk(sk)->rx_dst_ifindex != skb->skb_iif ||
1859 dst->ops->check(dst, 0) == NULL) {
David S. Miller92101b32012-07-23 16:29:00 -07001860 dst_release(dst);
1861 sk->sk_rx_dst = NULL;
1862 }
1863 }
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001864 if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001865 rsk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001867 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868 return 0;
1869 }
1870
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07001871 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872 goto csum_err;
1873
1874 if (sk->sk_state == TCP_LISTEN) {
1875 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
1876 if (!nsk)
1877 goto discard;
1878
1879 if (nsk != sk) {
Tom Herbertbdeab992011-08-14 19:45:55 +00001880 sock_rps_save_rxhash(nsk, skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001881 if (tcp_child_process(sk, nsk, skb)) {
1882 rsk = nsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001884 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885 return 0;
1886 }
Eric Dumazetca551582010-06-03 09:03:58 +00001887 } else
Tom Herbertbdeab992011-08-14 19:45:55 +00001888 sock_rps_save_rxhash(sk, skb);
Eric Dumazetca551582010-06-03 09:03:58 +00001889
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001890 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001891 rsk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001893 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894 return 0;
1895
1896reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001897 tcp_v4_send_reset(rsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898discard:
1899 kfree_skb(skb);
1900 /* Be careful here. If this function gets more complicated and
1901 * gcc suffers from register pressure on the x86, sk (in %ebx)
1902 * might be destroyed here. This current version compiles correctly,
1903 * but you have been warned.
1904 */
1905 return 0;
1906
1907csum_err:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001908 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 goto discard;
1910}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001911EXPORT_SYMBOL(tcp_v4_do_rcv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912
David S. Miller160eb5a2012-06-27 22:01:22 -07001913void tcp_v4_early_demux(struct sk_buff *skb)
David S. Miller41063e92012-06-19 21:22:05 -07001914{
David S. Miller41063e92012-06-19 21:22:05 -07001915 const struct iphdr *iph;
1916 const struct tcphdr *th;
1917 struct sock *sk;
David S. Miller41063e92012-06-19 21:22:05 -07001918
David S. Miller41063e92012-06-19 21:22:05 -07001919 if (skb->pkt_type != PACKET_HOST)
David S. Miller160eb5a2012-06-27 22:01:22 -07001920 return;
David S. Miller41063e92012-06-19 21:22:05 -07001921
Eric Dumazet45f00f92012-10-22 21:42:47 +00001922 if (!pskb_may_pull(skb, skb_transport_offset(skb) + sizeof(struct tcphdr)))
David S. Miller160eb5a2012-06-27 22:01:22 -07001923 return;
David S. Miller41063e92012-06-19 21:22:05 -07001924
1925 iph = ip_hdr(skb);
Eric Dumazet45f00f92012-10-22 21:42:47 +00001926 th = tcp_hdr(skb);
David S. Miller41063e92012-06-19 21:22:05 -07001927
1928 if (th->doff < sizeof(struct tcphdr) / 4)
David S. Miller160eb5a2012-06-27 22:01:22 -07001929 return;
David S. Miller41063e92012-06-19 21:22:05 -07001930
Eric Dumazet45f00f92012-10-22 21:42:47 +00001931 sk = __inet_lookup_established(dev_net(skb->dev), &tcp_hashinfo,
David S. Miller41063e92012-06-19 21:22:05 -07001932 iph->saddr, th->source,
Vijay Subramanian7011d082012-06-23 17:38:10 +00001933 iph->daddr, ntohs(th->dest),
Eric Dumazet9cb429d2012-07-24 01:19:31 +00001934 skb->skb_iif);
David S. Miller41063e92012-06-19 21:22:05 -07001935 if (sk) {
1936 skb->sk = sk;
1937 skb->destructor = sock_edemux;
1938 if (sk->sk_state != TCP_TIME_WAIT) {
1939 struct dst_entry *dst = sk->sk_rx_dst;
Eric Dumazet505fbcf2012-07-27 06:23:40 +00001940
David S. Miller41063e92012-06-19 21:22:05 -07001941 if (dst)
1942 dst = dst_check(dst, 0);
David S. Miller92101b32012-07-23 16:29:00 -07001943 if (dst &&
Eric Dumazet505fbcf2012-07-27 06:23:40 +00001944 inet_sk(sk)->rx_dst_ifindex == skb->skb_iif)
David S. Miller92101b32012-07-23 16:29:00 -07001945 skb_dst_set_noref(skb, dst);
David S. Miller41063e92012-06-19 21:22:05 -07001946 }
1947 }
David S. Miller41063e92012-06-19 21:22:05 -07001948}
1949
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950/*
1951 * From tcp_input.c
1952 */
1953
1954int tcp_v4_rcv(struct sk_buff *skb)
1955{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001956 const struct iphdr *iph;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001957 const struct tcphdr *th;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958 struct sock *sk;
1959 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001960 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961
1962 if (skb->pkt_type != PACKET_HOST)
1963 goto discard_it;
1964
1965 /* Count it even if it's bad */
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001966 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967
1968 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1969 goto discard_it;
1970
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001971 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972
1973 if (th->doff < sizeof(struct tcphdr) / 4)
1974 goto bad_packet;
1975 if (!pskb_may_pull(skb, th->doff * 4))
1976 goto discard_it;
1977
1978 /* An explanation is required here, I think.
1979 * Packet length and doff are validated by header prediction,
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -08001980 * provided case of th->doff==0 is eliminated.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 * So, we defer the checks. */
Herbert Xu60476372007-04-09 11:59:39 -07001982 if (!skb_csum_unnecessary(skb) && tcp_v4_checksum_init(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983 goto bad_packet;
1984
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001985 th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001986 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1988 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1989 skb->len - th->doff * 4);
1990 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1991 TCP_SKB_CB(skb)->when = 0;
Eric Dumazetb82d1bb2011-09-27 02:20:08 -04001992 TCP_SKB_CB(skb)->ip_dsfield = ipv4_get_dsfield(iph);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993 TCP_SKB_CB(skb)->sacked = 0;
1994
Arnaldo Carvalho de Melo9a1f27c2008-10-07 11:41:57 -07001995 sk = __inet_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996 if (!sk)
1997 goto no_tcp_socket;
1998
Eric Dumazetbb134d52010-03-09 05:55:56 +00001999process:
2000 if (sk->sk_state == TCP_TIME_WAIT)
2001 goto do_time_wait;
2002
Eric Dumazet6cce09f2010-03-07 23:21:57 +00002003 if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
2004 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
Stephen Hemmingerd218d112010-01-11 16:28:01 -08002005 goto discard_and_relse;
Eric Dumazet6cce09f2010-03-07 23:21:57 +00002006 }
Stephen Hemmingerd218d112010-01-11 16:28:01 -08002007
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
2009 goto discard_and_relse;
Patrick McHardyb59c2702006-01-06 23:06:10 -08002010 nf_reset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07002012 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013 goto discard_and_relse;
2014
2015 skb->dev = NULL;
2016
Ingo Molnarc6366182006-07-03 00:25:13 -07002017 bh_lock_sock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002018 ret = 0;
2019 if (!sock_owned_by_user(sk)) {
Chris Leech1a2449a2006-05-23 18:05:53 -07002020#ifdef CONFIG_NET_DMA
2021 struct tcp_sock *tp = tcp_sk(sk);
2022 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
Dave Jianga2bd1142012-04-04 16:10:46 -07002023 tp->ucopy.dma_chan = net_dma_find_channel();
Chris Leech1a2449a2006-05-23 18:05:53 -07002024 if (tp->ucopy.dma_chan)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002025 ret = tcp_v4_do_rcv(sk, skb);
Chris Leech1a2449a2006-05-23 18:05:53 -07002026 else
2027#endif
2028 {
2029 if (!tcp_prequeue(sk, skb))
Shan Weiae8d7f82009-05-05 01:01:29 +00002030 ret = tcp_v4_do_rcv(sk, skb);
Chris Leech1a2449a2006-05-23 18:05:53 -07002031 }
Eric Dumazetda882c12012-04-22 23:38:54 +00002032 } else if (unlikely(sk_add_backlog(sk, skb,
2033 sk->sk_rcvbuf + sk->sk_sndbuf))) {
Zhu Yi6b03a532010-03-04 18:01:41 +00002034 bh_unlock_sock(sk);
Eric Dumazet6cce09f2010-03-07 23:21:57 +00002035 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
Zhu Yi6b03a532010-03-04 18:01:41 +00002036 goto discard_and_relse;
2037 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038 bh_unlock_sock(sk);
2039
2040 sock_put(sk);
2041
2042 return ret;
2043
2044no_tcp_socket:
2045 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
2046 goto discard_it;
2047
2048 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
2049bad_packet:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07002050 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002051 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08002052 tcp_v4_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002053 }
2054
2055discard_it:
2056 /* Discard frame. */
2057 kfree_skb(skb);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002058 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059
2060discard_and_relse:
2061 sock_put(sk);
2062 goto discard_it;
2063
2064do_time_wait:
2065 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07002066 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067 goto discard_it;
2068 }
2069
2070 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07002071 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07002072 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073 goto discard_it;
2074 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07002075 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076 case TCP_TW_SYN: {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09002077 struct sock *sk2 = inet_lookup_listener(dev_net(skb->dev),
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08002078 &tcp_hashinfo,
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07002079 iph->daddr, th->dest,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002080 inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081 if (sk2) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07002082 inet_twsk_deschedule(inet_twsk(sk), &tcp_death_row);
2083 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002084 sk = sk2;
2085 goto process;
2086 }
2087 /* Fall through to ACK */
2088 }
2089 case TCP_TW_ACK:
2090 tcp_v4_timewait_ack(sk, skb);
2091 break;
2092 case TCP_TW_RST:
2093 goto no_tcp_socket;
2094 case TCP_TW_SUCCESS:;
2095 }
2096 goto discard_it;
2097}
2098
David S. Millerccb7c412010-12-01 18:09:13 -08002099static struct timewait_sock_ops tcp_timewait_sock_ops = {
2100 .twsk_obj_size = sizeof(struct tcp_timewait_sock),
2101 .twsk_unique = tcp_twsk_unique,
2102 .twsk_destructor= tcp_twsk_destructor,
David S. Millerccb7c412010-12-01 18:09:13 -08002103};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104
Eric Dumazet63d02d12012-08-09 14:11:00 +00002105void inet_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb)
Eric Dumazet5d299f32012-08-06 05:09:33 +00002106{
2107 struct dst_entry *dst = skb_dst(skb);
2108
2109 dst_hold(dst);
2110 sk->sk_rx_dst = dst;
2111 inet_sk(sk)->rx_dst_ifindex = skb->skb_iif;
2112}
Eric Dumazet63d02d12012-08-09 14:11:00 +00002113EXPORT_SYMBOL(inet_sk_rx_dst_set);
Eric Dumazet5d299f32012-08-06 05:09:33 +00002114
Stephen Hemminger3b401a82009-09-01 19:25:04 +00002115const struct inet_connection_sock_af_ops ipv4_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002116 .queue_xmit = ip_queue_xmit,
2117 .send_check = tcp_v4_send_check,
2118 .rebuild_header = inet_sk_rebuild_header,
Eric Dumazet5d299f32012-08-06 05:09:33 +00002119 .sk_rx_dst_set = inet_sk_rx_dst_set,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002120 .conn_request = tcp_v4_conn_request,
2121 .syn_recv_sock = tcp_v4_syn_recv_sock,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002122 .net_header_len = sizeof(struct iphdr),
2123 .setsockopt = ip_setsockopt,
2124 .getsockopt = ip_getsockopt,
2125 .addr2sockaddr = inet_csk_addr2sockaddr,
2126 .sockaddr_len = sizeof(struct sockaddr_in),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08002127 .bind_conflict = inet_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08002128#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002129 .compat_setsockopt = compat_ip_setsockopt,
2130 .compat_getsockopt = compat_ip_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08002131#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132};
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002133EXPORT_SYMBOL(ipv4_specific);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08002135#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00002136static const struct tcp_sock_af_ops tcp_sock_ipv4_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08002137 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07002138 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08002139 .md5_parse = tcp_v4_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08002140};
Andrew Mortonb6332e62006-11-30 19:16:28 -08002141#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08002142
Linus Torvalds1da177e2005-04-16 15:20:36 -07002143/* NOTE: A lot of things set to zero explicitly by call to
2144 * sk_alloc() so need not be done here.
2145 */
2146static int tcp_v4_init_sock(struct sock *sk)
2147{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03002148 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149
Neal Cardwell900f65d2012-04-19 09:55:21 +00002150 tcp_init_sock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08002152 icsk->icsk_af_ops = &ipv4_specific;
Neal Cardwell900f65d2012-04-19 09:55:21 +00002153
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08002154#ifdef CONFIG_TCP_MD5SIG
David S. Millerac807fa2012-04-23 03:21:58 -04002155 tcp_sk(sk)->af_specific = &tcp_sock_ipv4_specific;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08002156#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002157
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158 return 0;
2159}
2160
Brian Haley7d06b2e2008-06-14 17:04:49 -07002161void tcp_v4_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162{
2163 struct tcp_sock *tp = tcp_sk(sk);
2164
2165 tcp_clear_xmit_timers(sk);
2166
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03002167 tcp_cleanup_congestion_control(sk);
Stephen Hemminger317a76f2005-06-23 12:19:55 -07002168
Linus Torvalds1da177e2005-04-16 15:20:36 -07002169 /* Cleanup up the write buffer. */
David S. Millerfe067e82007-03-07 12:12:44 -08002170 tcp_write_queue_purge(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002171
2172 /* Cleans up our, hopefully empty, out_of_order_queue. */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002173 __skb_queue_purge(&tp->out_of_order_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08002175#ifdef CONFIG_TCP_MD5SIG
2176 /* Clean up the MD5 key list, if any */
2177 if (tp->md5sig_info) {
Eric Dumazeta915da9b2012-01-31 05:18:33 +00002178 tcp_clear_md5_list(sk);
Eric Dumazeta8afca02012-01-31 18:45:40 +00002179 kfree_rcu(tp->md5sig_info, rcu);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08002180 tp->md5sig_info = NULL;
2181 }
2182#endif
2183
Chris Leech1a2449a2006-05-23 18:05:53 -07002184#ifdef CONFIG_NET_DMA
2185 /* Cleans up our sk_async_wait_queue */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002186 __skb_queue_purge(&sk->sk_async_wait_queue);
Chris Leech1a2449a2006-05-23 18:05:53 -07002187#endif
2188
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189 /* Clean prequeue, it must be empty really */
2190 __skb_queue_purge(&tp->ucopy.prequeue);
2191
2192 /* Clean up a referenced TCP bind bucket. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002193 if (inet_csk(sk)->icsk_bind_hash)
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08002194 inet_put_port(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195
William Allen Simpson435cf552009-12-02 18:17:05 +00002196 /* TCP Cookie Transactions */
2197 if (tp->cookie_values != NULL) {
2198 kref_put(&tp->cookie_values->kref,
2199 tcp_cookie_values_release);
2200 tp->cookie_values = NULL;
2201 }
Jerry Chu168a8f52012-08-31 12:29:13 +00002202 BUG_ON(tp->fastopen_rsk != NULL);
William Allen Simpson435cf552009-12-02 18:17:05 +00002203
Yuchung Chengcf60af02012-07-19 06:43:09 +00002204 /* If socket is aborted during connect operation */
2205 tcp_free_fastopen_req(tp);
2206
Glauber Costa180d8cd2011-12-11 21:47:02 +00002207 sk_sockets_allocated_dec(sk);
Glauber Costad1a4c0b2011-12-11 21:47:04 +00002208 sock_release_memcg(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210EXPORT_SYMBOL(tcp_v4_destroy_sock);
2211
2212#ifdef CONFIG_PROC_FS
2213/* Proc filesystem TCP sock list dumping. */
2214
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002215static inline struct inet_timewait_sock *tw_head(struct hlist_nulls_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216{
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002217 return hlist_nulls_empty(head) ? NULL :
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002218 list_entry(head->first, struct inet_timewait_sock, tw_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002219}
2220
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002221static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002222{
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002223 return !is_a_nulls(tw->tw_node.next) ?
2224 hlist_nulls_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225}
2226
Tom Herberta8b690f2010-06-07 00:43:42 -07002227/*
2228 * Get next listener socket follow cur. If cur is NULL, get first socket
2229 * starting from bucket given in st->bucket; when st->bucket is zero the
2230 * very first socket in the hash table is returned.
2231 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232static void *listening_get_next(struct seq_file *seq, void *cur)
2233{
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002234 struct inet_connection_sock *icsk;
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08002235 struct hlist_nulls_node *node;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236 struct sock *sk = cur;
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002237 struct inet_listen_hashbucket *ilb;
Jianjun Kong5799de02008-11-03 02:49:10 -08002238 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002239 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240
2241 if (!sk) {
Tom Herberta8b690f2010-06-07 00:43:42 -07002242 ilb = &tcp_hashinfo.listening_hash[st->bucket];
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002243 spin_lock_bh(&ilb->lock);
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08002244 sk = sk_nulls_head(&ilb->head);
Tom Herberta8b690f2010-06-07 00:43:42 -07002245 st->offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002246 goto get_sk;
2247 }
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002248 ilb = &tcp_hashinfo.listening_hash[st->bucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249 ++st->num;
Tom Herberta8b690f2010-06-07 00:43:42 -07002250 ++st->offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002251
2252 if (st->state == TCP_SEQ_STATE_OPENREQ) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002253 struct request_sock *req = cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002254
Eric Dumazet72a3eff2006-11-16 02:30:37 -08002255 icsk = inet_csk(st->syn_wait_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256 req = req->dl_next;
2257 while (1) {
2258 while (req) {
Daniel Lezcanobdccc4c2008-07-19 00:15:13 -07002259 if (req->rsk_ops->family == st->family) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260 cur = req;
2261 goto out;
2262 }
2263 req = req->dl_next;
2264 }
Eric Dumazet72a3eff2006-11-16 02:30:37 -08002265 if (++st->sbucket >= icsk->icsk_accept_queue.listen_opt->nr_table_entries)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266 break;
2267get_req:
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002268 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002269 }
Eric Dumazet1bde5ac2010-12-23 09:32:46 -08002270 sk = sk_nulls_next(st->syn_wait_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002271 st->state = TCP_SEQ_STATE_LISTENING;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002272 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002273 } else {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002274 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002275 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2276 if (reqsk_queue_len(&icsk->icsk_accept_queue))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002277 goto start_req;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002278 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Eric Dumazet1bde5ac2010-12-23 09:32:46 -08002279 sk = sk_nulls_next(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002280 }
2281get_sk:
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08002282 sk_nulls_for_each_from(sk, node) {
Pavel Emelyanov8475ef92010-11-22 03:26:12 +00002283 if (!net_eq(sock_net(sk), net))
2284 continue;
2285 if (sk->sk_family == st->family) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002286 cur = sk;
2287 goto out;
2288 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002289 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002290 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2291 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002292start_req:
2293 st->uid = sock_i_uid(sk);
2294 st->syn_wait_sk = sk;
2295 st->state = TCP_SEQ_STATE_OPENREQ;
2296 st->sbucket = 0;
2297 goto get_req;
2298 }
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002299 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002300 }
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002301 spin_unlock_bh(&ilb->lock);
Tom Herberta8b690f2010-06-07 00:43:42 -07002302 st->offset = 0;
Arnaldo Carvalho de Melo0f7ff922005-08-09 19:59:44 -07002303 if (++st->bucket < INET_LHTABLE_SIZE) {
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002304 ilb = &tcp_hashinfo.listening_hash[st->bucket];
2305 spin_lock_bh(&ilb->lock);
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08002306 sk = sk_nulls_head(&ilb->head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307 goto get_sk;
2308 }
2309 cur = NULL;
2310out:
2311 return cur;
2312}
2313
2314static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
2315{
Tom Herberta8b690f2010-06-07 00:43:42 -07002316 struct tcp_iter_state *st = seq->private;
2317 void *rc;
2318
2319 st->bucket = 0;
2320 st->offset = 0;
2321 rc = listening_get_next(seq, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322
2323 while (rc && *pos) {
2324 rc = listening_get_next(seq, rc);
2325 --*pos;
2326 }
2327 return rc;
2328}
2329
Eric Dumazeta2a385d2012-05-16 23:15:34 +00002330static inline bool empty_bucket(struct tcp_iter_state *st)
Andi Kleen6eac5602008-08-28 01:08:02 -07002331{
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002332 return hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].chain) &&
2333 hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].twchain);
Andi Kleen6eac5602008-08-28 01:08:02 -07002334}
2335
Tom Herberta8b690f2010-06-07 00:43:42 -07002336/*
2337 * Get first established socket starting from bucket given in st->bucket.
2338 * If st->bucket is zero, the very first socket in the hash is returned.
2339 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002340static void *established_get_first(struct seq_file *seq)
2341{
Jianjun Kong5799de02008-11-03 02:49:10 -08002342 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002343 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002344 void *rc = NULL;
2345
Tom Herberta8b690f2010-06-07 00:43:42 -07002346 st->offset = 0;
2347 for (; st->bucket <= tcp_hashinfo.ehash_mask; ++st->bucket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348 struct sock *sk;
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002349 struct hlist_nulls_node *node;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002350 struct inet_timewait_sock *tw;
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002351 spinlock_t *lock = inet_ehash_lockp(&tcp_hashinfo, st->bucket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002352
Andi Kleen6eac5602008-08-28 01:08:02 -07002353 /* Lockless fast path for the common case of empty buckets */
2354 if (empty_bucket(st))
2355 continue;
2356
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002357 spin_lock_bh(lock);
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002358 sk_nulls_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002359 if (sk->sk_family != st->family ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002360 !net_eq(sock_net(sk), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002361 continue;
2362 }
2363 rc = sk;
2364 goto out;
2365 }
2366 st->state = TCP_SEQ_STATE_TIME_WAIT;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002367 inet_twsk_for_each(tw, node,
Eric Dumazetdbca9b2752007-02-08 14:16:46 -08002368 &tcp_hashinfo.ehash[st->bucket].twchain) {
Pavel Emelyanov28518fc2008-03-21 15:52:00 -07002369 if (tw->tw_family != st->family ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002370 !net_eq(twsk_net(tw), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371 continue;
2372 }
2373 rc = tw;
2374 goto out;
2375 }
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002376 spin_unlock_bh(lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377 st->state = TCP_SEQ_STATE_ESTABLISHED;
2378 }
2379out:
2380 return rc;
2381}
2382
2383static void *established_get_next(struct seq_file *seq, void *cur)
2384{
2385 struct sock *sk = cur;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002386 struct inet_timewait_sock *tw;
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002387 struct hlist_nulls_node *node;
Jianjun Kong5799de02008-11-03 02:49:10 -08002388 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002389 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002390
2391 ++st->num;
Tom Herberta8b690f2010-06-07 00:43:42 -07002392 ++st->offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002393
2394 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
2395 tw = cur;
2396 tw = tw_next(tw);
2397get_tw:
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002398 while (tw && (tw->tw_family != st->family || !net_eq(twsk_net(tw), net))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002399 tw = tw_next(tw);
2400 }
2401 if (tw) {
2402 cur = tw;
2403 goto out;
2404 }
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002405 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002406 st->state = TCP_SEQ_STATE_ESTABLISHED;
2407
Andi Kleen6eac5602008-08-28 01:08:02 -07002408 /* Look for next non empty bucket */
Tom Herberta8b690f2010-06-07 00:43:42 -07002409 st->offset = 0;
Eric Dumazetf373b532009-10-09 00:16:19 +00002410 while (++st->bucket <= tcp_hashinfo.ehash_mask &&
Andi Kleen6eac5602008-08-28 01:08:02 -07002411 empty_bucket(st))
2412 ;
Eric Dumazetf373b532009-10-09 00:16:19 +00002413 if (st->bucket > tcp_hashinfo.ehash_mask)
Andi Kleen6eac5602008-08-28 01:08:02 -07002414 return NULL;
2415
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002416 spin_lock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002417 sk = sk_nulls_head(&tcp_hashinfo.ehash[st->bucket].chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002418 } else
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002419 sk = sk_nulls_next(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002420
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002421 sk_nulls_for_each_from(sk, node) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002422 if (sk->sk_family == st->family && net_eq(sock_net(sk), net))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002423 goto found;
2424 }
2425
2426 st->state = TCP_SEQ_STATE_TIME_WAIT;
Eric Dumazetdbca9b2752007-02-08 14:16:46 -08002427 tw = tw_head(&tcp_hashinfo.ehash[st->bucket].twchain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002428 goto get_tw;
2429found:
2430 cur = sk;
2431out:
2432 return cur;
2433}
2434
2435static void *established_get_idx(struct seq_file *seq, loff_t pos)
2436{
Tom Herberta8b690f2010-06-07 00:43:42 -07002437 struct tcp_iter_state *st = seq->private;
2438 void *rc;
2439
2440 st->bucket = 0;
2441 rc = established_get_first(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002442
2443 while (rc && pos) {
2444 rc = established_get_next(seq, rc);
2445 --pos;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002446 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002447 return rc;
2448}
2449
2450static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
2451{
2452 void *rc;
Jianjun Kong5799de02008-11-03 02:49:10 -08002453 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002454
Linus Torvalds1da177e2005-04-16 15:20:36 -07002455 st->state = TCP_SEQ_STATE_LISTENING;
2456 rc = listening_get_idx(seq, &pos);
2457
2458 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002459 st->state = TCP_SEQ_STATE_ESTABLISHED;
2460 rc = established_get_idx(seq, pos);
2461 }
2462
2463 return rc;
2464}
2465
Tom Herberta8b690f2010-06-07 00:43:42 -07002466static void *tcp_seek_last_pos(struct seq_file *seq)
2467{
2468 struct tcp_iter_state *st = seq->private;
2469 int offset = st->offset;
2470 int orig_num = st->num;
2471 void *rc = NULL;
2472
2473 switch (st->state) {
2474 case TCP_SEQ_STATE_OPENREQ:
2475 case TCP_SEQ_STATE_LISTENING:
2476 if (st->bucket >= INET_LHTABLE_SIZE)
2477 break;
2478 st->state = TCP_SEQ_STATE_LISTENING;
2479 rc = listening_get_next(seq, NULL);
2480 while (offset-- && rc)
2481 rc = listening_get_next(seq, rc);
2482 if (rc)
2483 break;
2484 st->bucket = 0;
2485 /* Fallthrough */
2486 case TCP_SEQ_STATE_ESTABLISHED:
2487 case TCP_SEQ_STATE_TIME_WAIT:
2488 st->state = TCP_SEQ_STATE_ESTABLISHED;
2489 if (st->bucket > tcp_hashinfo.ehash_mask)
2490 break;
2491 rc = established_get_first(seq);
2492 while (offset-- && rc)
2493 rc = established_get_next(seq, rc);
2494 }
2495
2496 st->num = orig_num;
2497
2498 return rc;
2499}
2500
Linus Torvalds1da177e2005-04-16 15:20:36 -07002501static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
2502{
Jianjun Kong5799de02008-11-03 02:49:10 -08002503 struct tcp_iter_state *st = seq->private;
Tom Herberta8b690f2010-06-07 00:43:42 -07002504 void *rc;
2505
2506 if (*pos && *pos == st->last_pos) {
2507 rc = tcp_seek_last_pos(seq);
2508 if (rc)
2509 goto out;
2510 }
2511
Linus Torvalds1da177e2005-04-16 15:20:36 -07002512 st->state = TCP_SEQ_STATE_LISTENING;
2513 st->num = 0;
Tom Herberta8b690f2010-06-07 00:43:42 -07002514 st->bucket = 0;
2515 st->offset = 0;
2516 rc = *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2517
2518out:
2519 st->last_pos = *pos;
2520 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002521}
2522
2523static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2524{
Tom Herberta8b690f2010-06-07 00:43:42 -07002525 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002526 void *rc = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002527
2528 if (v == SEQ_START_TOKEN) {
2529 rc = tcp_get_idx(seq, 0);
2530 goto out;
2531 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002532
2533 switch (st->state) {
2534 case TCP_SEQ_STATE_OPENREQ:
2535 case TCP_SEQ_STATE_LISTENING:
2536 rc = listening_get_next(seq, v);
2537 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002538 st->state = TCP_SEQ_STATE_ESTABLISHED;
Tom Herberta8b690f2010-06-07 00:43:42 -07002539 st->bucket = 0;
2540 st->offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002541 rc = established_get_first(seq);
2542 }
2543 break;
2544 case TCP_SEQ_STATE_ESTABLISHED:
2545 case TCP_SEQ_STATE_TIME_WAIT:
2546 rc = established_get_next(seq, v);
2547 break;
2548 }
2549out:
2550 ++*pos;
Tom Herberta8b690f2010-06-07 00:43:42 -07002551 st->last_pos = *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002552 return rc;
2553}
2554
2555static void tcp_seq_stop(struct seq_file *seq, void *v)
2556{
Jianjun Kong5799de02008-11-03 02:49:10 -08002557 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002558
2559 switch (st->state) {
2560 case TCP_SEQ_STATE_OPENREQ:
2561 if (v) {
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002562 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
2563 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002564 }
2565 case TCP_SEQ_STATE_LISTENING:
2566 if (v != SEQ_START_TOKEN)
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002567 spin_unlock_bh(&tcp_hashinfo.listening_hash[st->bucket].lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002568 break;
2569 case TCP_SEQ_STATE_TIME_WAIT:
2570 case TCP_SEQ_STATE_ESTABLISHED:
2571 if (v)
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002572 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002573 break;
2574 }
2575}
2576
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002577int tcp_seq_open(struct inode *inode, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002578{
2579 struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002580 struct tcp_iter_state *s;
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002581 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002582
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002583 err = seq_open_net(inode, file, &afinfo->seq_ops,
2584 sizeof(struct tcp_iter_state));
2585 if (err < 0)
2586 return err;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002587
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002588 s = ((struct seq_file *)file->private_data)->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002589 s->family = afinfo->family;
Tom Herberta8b690f2010-06-07 00:43:42 -07002590 s->last_pos = 0;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002591 return 0;
2592}
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002593EXPORT_SYMBOL(tcp_seq_open);
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002594
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002595int tcp_proc_register(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002596{
2597 int rc = 0;
2598 struct proc_dir_entry *p;
2599
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002600 afinfo->seq_ops.start = tcp_seq_start;
2601 afinfo->seq_ops.next = tcp_seq_next;
2602 afinfo->seq_ops.stop = tcp_seq_stop;
2603
Denis V. Lunev84841c32008-05-02 04:10:08 -07002604 p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net,
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002605 afinfo->seq_fops, afinfo);
Denis V. Lunev84841c32008-05-02 04:10:08 -07002606 if (!p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002607 rc = -ENOMEM;
2608 return rc;
2609}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002610EXPORT_SYMBOL(tcp_proc_register);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002611
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002612void tcp_proc_unregister(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002613{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002614 proc_net_remove(net, afinfo->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002615}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002616EXPORT_SYMBOL(tcp_proc_unregister);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002617
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002618static void get_openreq4(const struct sock *sk, const struct request_sock *req,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06002619 struct seq_file *f, int i, kuid_t uid, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002620{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002621 const struct inet_request_sock *ireq = inet_rsk(req);
Eric Dumazeta399a802012-08-08 21:13:53 +00002622 long delta = req->expires - jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002623
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002624 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
Dan Rosenberg71338aa2011-05-23 12:17:35 +00002625 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %pK%n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002626 i,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002627 ireq->loc_addr,
Eric Dumazetc720c7e2009-10-15 06:30:45 +00002628 ntohs(inet_sk(sk)->inet_sport),
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002629 ireq->rmt_addr,
2630 ntohs(ireq->rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002631 TCP_SYN_RECV,
2632 0, 0, /* could print option size, but that is af dependent. */
2633 1, /* timers active (only the expire timer) */
Eric Dumazeta399a802012-08-08 21:13:53 +00002634 jiffies_delta_to_clock_t(delta),
Eric Dumazete6c022a2012-10-27 23:16:46 +00002635 req->num_timeout,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06002636 from_kuid_munged(seq_user_ns(f), uid),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002637 0, /* non standard timer */
2638 0, /* open_requests have no inode */
2639 atomic_read(&sk->sk_refcnt),
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002640 req,
2641 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002642}
2643
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002644static void get_tcp4_sock(struct sock *sk, struct seq_file *f, int i, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002645{
2646 int timer_active;
2647 unsigned long timer_expires;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002648 const struct tcp_sock *tp = tcp_sk(sk);
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002649 const struct inet_connection_sock *icsk = inet_csk(sk);
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002650 const struct inet_sock *inet = inet_sk(sk);
Jerry Chu168a8f52012-08-31 12:29:13 +00002651 struct fastopen_queue *fastopenq = icsk->icsk_accept_queue.fastopenq;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00002652 __be32 dest = inet->inet_daddr;
2653 __be32 src = inet->inet_rcv_saddr;
2654 __u16 destp = ntohs(inet->inet_dport);
2655 __u16 srcp = ntohs(inet->inet_sport);
Eric Dumazet49d09002009-12-03 16:06:13 -08002656 int rx_queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002657
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002658 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002659 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002660 timer_expires = icsk->icsk_timeout;
2661 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002662 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002663 timer_expires = icsk->icsk_timeout;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002664 } else if (timer_pending(&sk->sk_timer)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002665 timer_active = 2;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002666 timer_expires = sk->sk_timer.expires;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002667 } else {
2668 timer_active = 0;
2669 timer_expires = jiffies;
2670 }
2671
Eric Dumazet49d09002009-12-03 16:06:13 -08002672 if (sk->sk_state == TCP_LISTEN)
2673 rx_queue = sk->sk_ack_backlog;
2674 else
2675 /*
2676 * because we dont lock socket, we might find a transient negative value
2677 */
2678 rx_queue = max_t(int, tp->rcv_nxt - tp->copied_seq, 0);
2679
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002680 seq_printf(f, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
Dan Rosenberg71338aa2011-05-23 12:17:35 +00002681 "%08X %5d %8d %lu %d %pK %lu %lu %u %u %d%n",
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002682 i, src, srcp, dest, destp, sk->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07002683 tp->write_seq - tp->snd_una,
Eric Dumazet49d09002009-12-03 16:06:13 -08002684 rx_queue,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002685 timer_active,
Eric Dumazeta399a802012-08-08 21:13:53 +00002686 jiffies_delta_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002687 icsk->icsk_retransmits,
Eric W. Biedermana7cb5a42012-05-24 01:10:10 -06002688 from_kuid_munged(seq_user_ns(f), sock_i_uid(sk)),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03002689 icsk->icsk_probes_out,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002690 sock_i_ino(sk),
2691 atomic_read(&sk->sk_refcnt), sk,
Stephen Hemminger7be87352008-06-27 20:00:19 -07002692 jiffies_to_clock_t(icsk->icsk_rto),
2693 jiffies_to_clock_t(icsk->icsk_ack.ato),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002694 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002695 tp->snd_cwnd,
Jerry Chu168a8f52012-08-31 12:29:13 +00002696 sk->sk_state == TCP_LISTEN ?
2697 (fastopenq ? fastopenq->max_qlen : 0) :
2698 (tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh),
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002699 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002700}
2701
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002702static void get_timewait4_sock(const struct inet_timewait_sock *tw,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002703 struct seq_file *f, int i, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002704{
Al Viro23f33c22006-09-27 18:43:50 -07002705 __be32 dest, src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002706 __u16 destp, srcp;
Eric Dumazeta399a802012-08-08 21:13:53 +00002707 long delta = tw->tw_ttd - jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002708
2709 dest = tw->tw_daddr;
2710 src = tw->tw_rcv_saddr;
2711 destp = ntohs(tw->tw_dport);
2712 srcp = ntohs(tw->tw_sport);
2713
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002714 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
Dan Rosenberg71338aa2011-05-23 12:17:35 +00002715 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK%n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002716 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
Eric Dumazeta399a802012-08-08 21:13:53 +00002717 3, jiffies_delta_to_clock_t(delta), 0, 0, 0, 0,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002718 atomic_read(&tw->tw_refcnt), tw, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002719}
2720
2721#define TMPSZ 150
2722
2723static int tcp4_seq_show(struct seq_file *seq, void *v)
2724{
Jianjun Kong5799de02008-11-03 02:49:10 -08002725 struct tcp_iter_state *st;
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002726 int len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002727
2728 if (v == SEQ_START_TOKEN) {
2729 seq_printf(seq, "%-*s\n", TMPSZ - 1,
2730 " sl local_address rem_address st tx_queue "
2731 "rx_queue tr tm->when retrnsmt uid timeout "
2732 "inode");
2733 goto out;
2734 }
2735 st = seq->private;
2736
2737 switch (st->state) {
2738 case TCP_SEQ_STATE_LISTENING:
2739 case TCP_SEQ_STATE_ESTABLISHED:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002740 get_tcp4_sock(v, seq, st->num, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002741 break;
2742 case TCP_SEQ_STATE_OPENREQ:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002743 get_openreq4(st->syn_wait_sk, v, seq, st->num, st->uid, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002744 break;
2745 case TCP_SEQ_STATE_TIME_WAIT:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002746 get_timewait4_sock(v, seq, st->num, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002747 break;
2748 }
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002749 seq_printf(seq, "%*s\n", TMPSZ - 1 - len, "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002750out:
2751 return 0;
2752}
2753
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002754static const struct file_operations tcp_afinfo_seq_fops = {
2755 .owner = THIS_MODULE,
2756 .open = tcp_seq_open,
2757 .read = seq_read,
2758 .llseek = seq_lseek,
2759 .release = seq_release_net
2760};
2761
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762static struct tcp_seq_afinfo tcp4_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002763 .name = "tcp",
2764 .family = AF_INET,
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002765 .seq_fops = &tcp_afinfo_seq_fops,
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002766 .seq_ops = {
2767 .show = tcp4_seq_show,
2768 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002769};
2770
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002771static int __net_init tcp4_proc_init_net(struct net *net)
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002772{
2773 return tcp_proc_register(net, &tcp4_seq_afinfo);
2774}
2775
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002776static void __net_exit tcp4_proc_exit_net(struct net *net)
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002777{
2778 tcp_proc_unregister(net, &tcp4_seq_afinfo);
2779}
2780
2781static struct pernet_operations tcp4_net_ops = {
2782 .init = tcp4_proc_init_net,
2783 .exit = tcp4_proc_exit_net,
2784};
2785
Linus Torvalds1da177e2005-04-16 15:20:36 -07002786int __init tcp4_proc_init(void)
2787{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002788 return register_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002789}
2790
2791void tcp4_proc_exit(void)
2792{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002793 unregister_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002794}
2795#endif /* CONFIG_PROC_FS */
2796
Herbert Xubf296b12008-12-15 23:43:36 -08002797struct sk_buff **tcp4_gro_receive(struct sk_buff **head, struct sk_buff *skb)
2798{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00002799 const struct iphdr *iph = skb_gro_network_header(skb);
Eric Dumazet861b6502012-09-27 02:14:53 +00002800 __wsum wsum;
2801 __sum16 sum;
Herbert Xubf296b12008-12-15 23:43:36 -08002802
2803 switch (skb->ip_summed) {
2804 case CHECKSUM_COMPLETE:
Herbert Xu86911732009-01-29 14:19:50 +00002805 if (!tcp_v4_check(skb_gro_len(skb), iph->saddr, iph->daddr,
Herbert Xubf296b12008-12-15 23:43:36 -08002806 skb->csum)) {
2807 skb->ip_summed = CHECKSUM_UNNECESSARY;
2808 break;
2809 }
Eric Dumazet861b6502012-09-27 02:14:53 +00002810flush:
Herbert Xubf296b12008-12-15 23:43:36 -08002811 NAPI_GRO_CB(skb)->flush = 1;
2812 return NULL;
Eric Dumazet861b6502012-09-27 02:14:53 +00002813
2814 case CHECKSUM_NONE:
2815 wsum = csum_tcpudp_nofold(iph->saddr, iph->daddr,
2816 skb_gro_len(skb), IPPROTO_TCP, 0);
2817 sum = csum_fold(skb_checksum(skb,
2818 skb_gro_offset(skb),
2819 skb_gro_len(skb),
2820 wsum));
2821 if (sum)
2822 goto flush;
2823
2824 skb->ip_summed = CHECKSUM_UNNECESSARY;
2825 break;
Herbert Xubf296b12008-12-15 23:43:36 -08002826 }
2827
2828 return tcp_gro_receive(head, skb);
2829}
Herbert Xubf296b12008-12-15 23:43:36 -08002830
2831int tcp4_gro_complete(struct sk_buff *skb)
2832{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00002833 const struct iphdr *iph = ip_hdr(skb);
Herbert Xubf296b12008-12-15 23:43:36 -08002834 struct tcphdr *th = tcp_hdr(skb);
2835
2836 th->check = ~tcp_v4_check(skb->len - skb_transport_offset(skb),
2837 iph->saddr, iph->daddr, 0);
2838 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV4;
2839
2840 return tcp_gro_complete(skb);
2841}
Herbert Xubf296b12008-12-15 23:43:36 -08002842
Linus Torvalds1da177e2005-04-16 15:20:36 -07002843struct proto tcp_prot = {
2844 .name = "TCP",
2845 .owner = THIS_MODULE,
2846 .close = tcp_close,
2847 .connect = tcp_v4_connect,
2848 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002849 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002850 .ioctl = tcp_ioctl,
2851 .init = tcp_v4_init_sock,
2852 .destroy = tcp_v4_destroy_sock,
2853 .shutdown = tcp_shutdown,
2854 .setsockopt = tcp_setsockopt,
2855 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002856 .recvmsg = tcp_recvmsg,
Changli Gao7ba42912010-07-10 20:41:55 +00002857 .sendmsg = tcp_sendmsg,
2858 .sendpage = tcp_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002859 .backlog_rcv = tcp_v4_do_rcv,
Eric Dumazet46d3cea2012-07-11 05:50:31 +00002860 .release_cb = tcp_release_cb,
Eric Dumazet563d34d2012-07-23 09:48:52 +02002861 .mtu_reduced = tcp_v4_mtu_reduced,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08002862 .hash = inet_hash,
2863 .unhash = inet_unhash,
2864 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002865 .enter_memory_pressure = tcp_enter_memory_pressure,
2866 .sockets_allocated = &tcp_sockets_allocated,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07002867 .orphan_count = &tcp_orphan_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002868 .memory_allocated = &tcp_memory_allocated,
2869 .memory_pressure = &tcp_memory_pressure,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002870 .sysctl_wmem = sysctl_tcp_wmem,
2871 .sysctl_rmem = sysctl_tcp_rmem,
2872 .max_header = MAX_TCP_HEADER,
2873 .obj_size = sizeof(struct tcp_sock),
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002874 .slab_flags = SLAB_DESTROY_BY_RCU,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002875 .twsk_prot = &tcp_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002876 .rsk_prot = &tcp_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07002877 .h.hashinfo = &tcp_hashinfo,
Changli Gao7ba42912010-07-10 20:41:55 +00002878 .no_autobind = true,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002879#ifdef CONFIG_COMPAT
2880 .compat_setsockopt = compat_tcp_setsockopt,
2881 .compat_getsockopt = compat_tcp_getsockopt,
2882#endif
Andrew Mortonc255a452012-07-31 16:43:02 -07002883#ifdef CONFIG_MEMCG_KMEM
Glauber Costad1a4c0b2011-12-11 21:47:04 +00002884 .init_cgroup = tcp_init_cgroup,
2885 .destroy_cgroup = tcp_destroy_cgroup,
2886 .proto_cgroup = tcp_proto_cgroup,
2887#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002888};
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002889EXPORT_SYMBOL(tcp_prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002890
Denis V. Lunev046ee902008-04-03 14:31:33 -07002891static int __net_init tcp_sk_init(struct net *net)
2892{
Eric Dumazetbe9f4a42012-07-19 07:34:03 +00002893 return 0;
Denis V. Lunev046ee902008-04-03 14:31:33 -07002894}
2895
2896static void __net_exit tcp_sk_exit(struct net *net)
2897{
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002898}
2899
2900static void __net_exit tcp_sk_exit_batch(struct list_head *net_exit_list)
2901{
2902 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET);
Denis V. Lunev046ee902008-04-03 14:31:33 -07002903}
2904
2905static struct pernet_operations __net_initdata tcp_sk_ops = {
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002906 .init = tcp_sk_init,
2907 .exit = tcp_sk_exit,
2908 .exit_batch = tcp_sk_exit_batch,
Denis V. Lunev046ee902008-04-03 14:31:33 -07002909};
2910
Denis V. Lunev9b0f9762008-02-29 11:13:15 -08002911void __init tcp_v4_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002912{
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002913 inet_hashinfo_init(&tcp_hashinfo);
Eric W. Biederman6a1b3052009-02-22 00:10:18 -08002914 if (register_pernet_subsys(&tcp_sk_ops))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002915 panic("Failed to create the TCP control socket.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002916}