blob: 94abee8cf563d68184db984004caf75a91fa4dcc [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
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
Herbert Xueb4dea52008-12-29 23:04:08 -080054#include <linux/bottom_half.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070055#include <linux/types.h>
56#include <linux/fcntl.h>
57#include <linux/module.h>
58#include <linux/random.h>
59#include <linux/cache.h>
60#include <linux/jhash.h>
61#include <linux/init.h>
62#include <linux/times.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090063#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070064
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020065#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070066#include <net/icmp.h>
Arnaldo Carvalho de Melo304a1612005-08-09 19:59:20 -070067#include <net/inet_hashtables.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070068#include <net/tcp.h>
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -030069#include <net/transp_v6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070070#include <net/ipv6.h>
71#include <net/inet_common.h>
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -080072#include <net/timewait_sock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070073#include <net/xfrm.h>
Chris Leech1a2449a2006-05-23 18:05:53 -070074#include <net/netdma.h>
David S. Miller6e5714e2011-08-03 20:50:44 -070075#include <net/secure_seq.h>
Glauber Costad1a4c0b2011-12-11 21:47:04 +000076#include <net/tcp_memcontrol.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
78#include <linux/inet.h>
79#include <linux/ipv6.h>
80#include <linux/stddef.h>
81#include <linux/proc_fs.h>
82#include <linux/seq_file.h>
83
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080084#include <linux/crypto.h>
85#include <linux/scatterlist.h>
86
Brian Haleyab32ea52006-09-22 14:15:41 -070087int sysctl_tcp_tw_reuse __read_mostly;
88int sysctl_tcp_low_latency __read_mostly;
Eric Dumazet4bc2f182010-07-09 21:22:10 +000089EXPORT_SYMBOL(sysctl_tcp_low_latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080092#ifdef CONFIG_TCP_MD5SIG
Eric Dumazeta915da9b2012-01-31 05:18:33 +000093static int tcp_v4_md5_hash_hdr(char *md5_hash, const struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -040094 __be32 daddr, __be32 saddr, const struct tcphdr *th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080095#endif
96
Eric Dumazet5caea4e2008-11-20 00:40:07 -080097struct inet_hashinfo tcp_hashinfo;
Eric Dumazet4bc2f182010-07-09 21:22:10 +000098EXPORT_SYMBOL(tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400100static inline __u32 tcp_v4_init_sequence(const struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700102 return secure_tcp_sequence_number(ip_hdr(skb)->daddr,
103 ip_hdr(skb)->saddr,
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700104 tcp_hdr(skb)->dest,
105 tcp_hdr(skb)->source);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106}
107
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800108int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp)
109{
110 const struct tcp_timewait_sock *tcptw = tcp_twsk(sktw);
111 struct tcp_sock *tp = tcp_sk(sk);
112
113 /* With PAWS, it is safe from the viewpoint
114 of data integrity. Even without PAWS it is safe provided sequence
115 spaces do not overlap i.e. at data rates <= 80Mbit/sec.
116
117 Actually, the idea is close to VJ's one, only timestamp cache is
118 held not per host, but per port pair and TW bucket is used as state
119 holder.
120
121 If TW bucket has been already destroyed we fall back to VJ's scheme
122 and use initial timestamp retrieved from peer table.
123 */
124 if (tcptw->tw_ts_recent_stamp &&
125 (twp == NULL || (sysctl_tcp_tw_reuse &&
James Morris9d729f72007-03-04 16:12:44 -0800126 get_seconds() - tcptw->tw_ts_recent_stamp > 1))) {
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800127 tp->write_seq = tcptw->tw_snd_nxt + 65535 + 2;
128 if (tp->write_seq == 0)
129 tp->write_seq = 1;
130 tp->rx_opt.ts_recent = tcptw->tw_ts_recent;
131 tp->rx_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp;
132 sock_hold(sktw);
133 return 1;
134 }
135
136 return 0;
137}
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800138EXPORT_SYMBOL_GPL(tcp_twsk_unique);
139
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140/* This will initiate an outgoing connection. */
141int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
142{
David S. Miller2d7192d2011-04-26 13:28:44 -0700143 struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 struct inet_sock *inet = inet_sk(sk);
145 struct tcp_sock *tp = tcp_sk(sk);
David S. Millerdca8b082011-02-24 13:38:12 -0800146 __be16 orig_sport, orig_dport;
Al Virobada8ad2006-09-26 21:27:15 -0700147 __be32 daddr, nexthop;
David S. Millerda905bd2011-05-06 16:11:19 -0700148 struct flowi4 *fl4;
David S. Miller2d7192d2011-04-26 13:28:44 -0700149 struct rtable *rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 int err;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000151 struct ip_options_rcu *inet_opt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152
153 if (addr_len < sizeof(struct sockaddr_in))
154 return -EINVAL;
155
156 if (usin->sin_family != AF_INET)
157 return -EAFNOSUPPORT;
158
159 nexthop = daddr = usin->sin_addr.s_addr;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000160 inet_opt = rcu_dereference_protected(inet->inet_opt,
161 sock_owned_by_user(sk));
162 if (inet_opt && inet_opt->opt.srr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 if (!daddr)
164 return -EINVAL;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000165 nexthop = inet_opt->opt.faddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 }
167
David S. Millerdca8b082011-02-24 13:38:12 -0800168 orig_sport = inet->inet_sport;
169 orig_dport = usin->sin_port;
David S. Millerda905bd2011-05-06 16:11:19 -0700170 fl4 = &inet->cork.fl.u.ip4;
171 rt = ip_route_connect(fl4, nexthop, inet->inet_saddr,
David S. Millerb23dd4f2011-03-02 14:31:35 -0800172 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
173 IPPROTO_TCP,
174 orig_sport, orig_dport, sk, true);
175 if (IS_ERR(rt)) {
176 err = PTR_ERR(rt);
177 if (err == -ENETUNREACH)
Pavel Emelyanov7c73a6f2008-07-16 20:20:11 -0700178 IP_INC_STATS_BH(sock_net(sk), IPSTATS_MIB_OUTNOROUTES);
David S. Millerb23dd4f2011-03-02 14:31:35 -0800179 return err;
Wei Dong584bdf82007-05-31 22:49:28 -0700180 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181
182 if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
183 ip_rt_put(rt);
184 return -ENETUNREACH;
185 }
186
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000187 if (!inet_opt || !inet_opt->opt.srr)
David S. Millerda905bd2011-05-06 16:11:19 -0700188 daddr = fl4->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000190 if (!inet->inet_saddr)
David S. Millerda905bd2011-05-06 16:11:19 -0700191 inet->inet_saddr = fl4->saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000192 inet->inet_rcv_saddr = inet->inet_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000194 if (tp->rx_opt.ts_recent_stamp && inet->inet_daddr != daddr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 /* Reset inherited state */
196 tp->rx_opt.ts_recent = 0;
197 tp->rx_opt.ts_recent_stamp = 0;
198 tp->write_seq = 0;
199 }
200
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -0700201 if (tcp_death_row.sysctl_tw_recycle &&
David S. Millerda905bd2011-05-06 16:11:19 -0700202 !tp->rx_opt.ts_recent_stamp && fl4->daddr == daddr) {
David S. Millered2361e2011-05-18 18:38:54 -0400203 struct inet_peer *peer = rt_get_peer(rt, fl4->daddr);
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200204 /*
205 * VJ's idea. We save last timestamp seen from
206 * the destination in peer table, when entering state
207 * TIME-WAIT * and initialize rx_opt.ts_recent from it,
208 * when trying new connection.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 */
Eric Dumazet317fe0e2010-06-16 04:52:13 +0000210 if (peer) {
211 inet_peer_refcheck(peer);
212 if ((u32)get_seconds() - peer->tcp_ts_stamp <= TCP_PAWS_MSL) {
213 tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp;
214 tp->rx_opt.ts_recent = peer->tcp_ts;
215 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 }
217 }
218
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000219 inet->inet_dport = usin->sin_port;
220 inet->inet_daddr = daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800222 inet_csk(sk)->icsk_ext_hdr_len = 0;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000223 if (inet_opt)
224 inet_csk(sk)->icsk_ext_hdr_len = inet_opt->opt.optlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225
William Allen Simpsonbee7ca92009-11-10 09:51:18 +0000226 tp->rx_opt.mss_clamp = TCP_MSS_DEFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227
228 /* Socket identity is still unknown (sport may be zero).
229 * However we set state to SYN-SENT and not releasing socket
230 * lock select source port, enter ourselves into the hash tables and
231 * complete initialization after this.
232 */
233 tcp_set_state(sk, TCP_SYN_SENT);
Arnaldo Carvalho de Meloa7f5e7f2005-12-13 23:25:31 -0800234 err = inet_hash_connect(&tcp_death_row, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 if (err)
236 goto failure;
237
David S. Millerda905bd2011-05-06 16:11:19 -0700238 rt = ip_route_newports(fl4, rt, orig_sport, orig_dport,
David S. Millerb23dd4f2011-03-02 14:31:35 -0800239 inet->inet_sport, inet->inet_dport, sk);
240 if (IS_ERR(rt)) {
241 err = PTR_ERR(rt);
242 rt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 goto failure;
David S. Millerb23dd4f2011-03-02 14:31:35 -0800244 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 /* OK, now commit destination to socket. */
Herbert Xubcd76112006-06-30 13:36:35 -0700246 sk->sk_gso_type = SKB_GSO_TCPV4;
Changli Gaod8d1f302010-06-10 23:31:35 -0700247 sk_setup_caps(sk, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248
249 if (!tp->write_seq)
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000250 tp->write_seq = secure_tcp_sequence_number(inet->inet_saddr,
251 inet->inet_daddr,
252 inet->inet_sport,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 usin->sin_port);
254
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000255 inet->inet_id = tp->write_seq ^ jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
257 err = tcp_connect(sk);
258 rt = NULL;
259 if (err)
260 goto failure;
261
262 return 0;
263
264failure:
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200265 /*
266 * This unhashes the socket and releases the local port,
267 * if necessary.
268 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 tcp_set_state(sk, TCP_CLOSE);
270 ip_rt_put(rt);
271 sk->sk_route_caps = 0;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000272 inet->inet_dport = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 return err;
274}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000275EXPORT_SYMBOL(tcp_v4_connect);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277/*
278 * This routine does path mtu discovery as defined in RFC1191.
279 */
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000280static void do_pmtu_discovery(struct sock *sk, const struct iphdr *iph, u32 mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281{
282 struct dst_entry *dst;
283 struct inet_sock *inet = inet_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284
285 /* We are not interested in TCP_LISTEN and open_requests (SYN-ACKs
286 * send out by Linux are always <576bytes so they should go through
287 * unfragmented).
288 */
289 if (sk->sk_state == TCP_LISTEN)
290 return;
291
292 /* We don't check in the destentry if pmtu discovery is forbidden
293 * on this route. We just assume that no packet_to_big packets
294 * are send back when pmtu discovery is not active.
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900295 * There is a small race when the user changes this flag in the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 * route, but I think that's acceptable.
297 */
298 if ((dst = __sk_dst_check(sk, 0)) == NULL)
299 return;
300
301 dst->ops->update_pmtu(dst, mtu);
302
303 /* Something is about to be wrong... Remember soft error
304 * for the case, if this connection will not able to recover.
305 */
306 if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
307 sk->sk_err_soft = EMSGSIZE;
308
309 mtu = dst_mtu(dst);
310
311 if (inet->pmtudisc != IP_PMTUDISC_DONT &&
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800312 inet_csk(sk)->icsk_pmtu_cookie > mtu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 tcp_sync_mss(sk, mtu);
314
315 /* Resend the TCP packet because it's
316 * clear that the old packet has been
317 * dropped. This is the new "fast" path mtu
318 * discovery.
319 */
320 tcp_simple_retransmit(sk);
321 } /* else let the usual retransmit timer handle it */
322}
323
324/*
325 * This routine is called by the ICMP module when it gets some
326 * sort of error condition. If err < 0 then the socket should
327 * be closed and the error returned to the user. If err > 0
328 * it's just the icmp type << 8 | icmp code. After adjustment
329 * header points to the first 8 bytes of the tcp header. We need
330 * to find the appropriate port.
331 *
332 * The locking strategy used here is very "optimistic". When
333 * someone else accesses the socket the ICMP is just dropped
334 * and for some paths there is no check at all.
335 * A more general error queue to queue errors for later handling
336 * is probably better.
337 *
338 */
339
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000340void tcp_v4_err(struct sk_buff *icmp_skb, u32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000342 const struct iphdr *iph = (const struct iphdr *)icmp_skb->data;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000343 struct tcphdr *th = (struct tcphdr *)(icmp_skb->data + (iph->ihl << 2));
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000344 struct inet_connection_sock *icsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 struct tcp_sock *tp;
346 struct inet_sock *inet;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000347 const int type = icmp_hdr(icmp_skb)->type;
348 const int code = icmp_hdr(icmp_skb)->code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 struct sock *sk;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000350 struct sk_buff *skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 __u32 seq;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000352 __u32 remaining;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 int err;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000354 struct net *net = dev_net(icmp_skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000356 if (icmp_skb->len < (iph->ihl << 2) + 8) {
Pavel Emelyanovdcfc23c2008-07-14 23:03:00 -0700357 ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 return;
359 }
360
Pavel Emelyanovfd54d712008-07-14 23:01:40 -0700361 sk = inet_lookup(net, &tcp_hashinfo, iph->daddr, th->dest,
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000362 iph->saddr, th->source, inet_iif(icmp_skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 if (!sk) {
Pavel Emelyanovdcfc23c2008-07-14 23:03:00 -0700364 ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 return;
366 }
367 if (sk->sk_state == TCP_TIME_WAIT) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700368 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 return;
370 }
371
372 bh_lock_sock(sk);
373 /* If too many ICMPs get dropped on busy
374 * servers this needs to be solved differently.
375 */
376 if (sock_owned_by_user(sk))
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700377 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378
379 if (sk->sk_state == TCP_CLOSE)
380 goto out;
381
stephen hemminger97e3ecd12010-03-18 11:27:32 +0000382 if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
383 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
384 goto out;
385 }
386
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000387 icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 tp = tcp_sk(sk);
389 seq = ntohl(th->seq);
390 if (sk->sk_state != TCP_LISTEN &&
391 !between(seq, tp->snd_una, tp->snd_nxt)) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700392 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 goto out;
394 }
395
396 switch (type) {
397 case ICMP_SOURCE_QUENCH:
398 /* Just silently ignore these. */
399 goto out;
400 case ICMP_PARAMETERPROB:
401 err = EPROTO;
402 break;
403 case ICMP_DEST_UNREACH:
404 if (code > NR_ICMP_UNREACH)
405 goto out;
406
407 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
408 if (!sock_owned_by_user(sk))
409 do_pmtu_discovery(sk, iph, info);
410 goto out;
411 }
412
413 err = icmp_err_convert[code].errno;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000414 /* check if icmp_skb allows revert of backoff
415 * (see draft-zimmermann-tcp-lcd) */
416 if (code != ICMP_NET_UNREACH && code != ICMP_HOST_UNREACH)
417 break;
418 if (seq != tp->snd_una || !icsk->icsk_retransmits ||
419 !icsk->icsk_backoff)
420 break;
421
David S. Miller8f49c272010-11-12 13:35:00 -0800422 if (sock_owned_by_user(sk))
423 break;
424
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000425 icsk->icsk_backoff--;
Jerry Chu9ad7c042011-06-08 11:08:38 +0000426 inet_csk(sk)->icsk_rto = (tp->srtt ? __tcp_set_rto(tp) :
427 TCP_TIMEOUT_INIT) << icsk->icsk_backoff;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000428 tcp_bound_rto(sk);
429
430 skb = tcp_write_queue_head(sk);
431 BUG_ON(!skb);
432
433 remaining = icsk->icsk_rto - min(icsk->icsk_rto,
434 tcp_time_stamp - TCP_SKB_CB(skb)->when);
435
436 if (remaining) {
437 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
438 remaining, TCP_RTO_MAX);
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000439 } else {
440 /* RTO revert clocked out retransmission.
441 * Will retransmit now */
442 tcp_retransmit_timer(sk);
443 }
444
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 break;
446 case ICMP_TIME_EXCEEDED:
447 err = EHOSTUNREACH;
448 break;
449 default:
450 goto out;
451 }
452
453 switch (sk->sk_state) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700454 struct request_sock *req, **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 case TCP_LISTEN:
456 if (sock_owned_by_user(sk))
457 goto out;
458
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700459 req = inet_csk_search_req(sk, &prev, th->dest,
460 iph->daddr, iph->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 if (!req)
462 goto out;
463
464 /* ICMPs are not backlogged, hence we cannot get
465 an established socket here.
466 */
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700467 WARN_ON(req->sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700469 if (seq != tcp_rsk(req)->snt_isn) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700470 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 goto out;
472 }
473
474 /*
475 * Still in SYN_RECV, just remove it silently.
476 * There is no good way to pass the error to the newly
477 * created socket, and POSIX does not want network
478 * errors returned from accept().
479 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700480 inet_csk_reqsk_queue_drop(sk, req, prev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 goto out;
482
483 case TCP_SYN_SENT:
484 case TCP_SYN_RECV: /* Cannot happen.
485 It can f.e. if SYNs crossed.
486 */
487 if (!sock_owned_by_user(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 sk->sk_err = err;
489
490 sk->sk_error_report(sk);
491
492 tcp_done(sk);
493 } else {
494 sk->sk_err_soft = err;
495 }
496 goto out;
497 }
498
499 /* If we've already connected we will keep trying
500 * until we time out, or the user gives up.
501 *
502 * rfc1122 4.2.3.9 allows to consider as hard errors
503 * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
504 * but it is obsoleted by pmtu discovery).
505 *
506 * Note, that in modern internet, where routing is unreliable
507 * and in each dark corner broken firewalls sit, sending random
508 * errors ordered by their masters even this two messages finally lose
509 * their original sense (even Linux sends invalid PORT_UNREACHs)
510 *
511 * Now we are in compliance with RFCs.
512 * --ANK (980905)
513 */
514
515 inet = inet_sk(sk);
516 if (!sock_owned_by_user(sk) && inet->recverr) {
517 sk->sk_err = err;
518 sk->sk_error_report(sk);
519 } else { /* Only an error on timeout */
520 sk->sk_err_soft = err;
521 }
522
523out:
524 bh_unlock_sock(sk);
525 sock_put(sk);
526}
527
Herbert Xu419f9f82010-04-11 02:15:53 +0000528static void __tcp_v4_send_check(struct sk_buff *skb,
529 __be32 saddr, __be32 daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700531 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532
Patrick McHardy84fa7932006-08-29 16:44:56 -0700533 if (skb->ip_summed == CHECKSUM_PARTIAL) {
Herbert Xu419f9f82010-04-11 02:15:53 +0000534 th->check = ~tcp_v4_check(skb->len, saddr, daddr, 0);
Herbert Xu663ead32007-04-09 11:59:07 -0700535 skb->csum_start = skb_transport_header(skb) - skb->head;
Al Viroff1dcad2006-11-20 18:07:29 -0800536 skb->csum_offset = offsetof(struct tcphdr, check);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 } else {
Herbert Xu419f9f82010-04-11 02:15:53 +0000538 th->check = tcp_v4_check(skb->len, saddr, daddr,
Joe Perches07f07572008-11-19 15:44:53 -0800539 csum_partial(th,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 th->doff << 2,
541 skb->csum));
542 }
543}
544
Herbert Xu419f9f82010-04-11 02:15:53 +0000545/* This routine computes an IPv4 TCP checksum. */
Herbert Xubb296242010-04-11 02:15:55 +0000546void tcp_v4_send_check(struct sock *sk, struct sk_buff *skb)
Herbert Xu419f9f82010-04-11 02:15:53 +0000547{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400548 const struct inet_sock *inet = inet_sk(sk);
Herbert Xu419f9f82010-04-11 02:15:53 +0000549
550 __tcp_v4_send_check(skb, inet->inet_saddr, inet->inet_daddr);
551}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000552EXPORT_SYMBOL(tcp_v4_send_check);
Herbert Xu419f9f82010-04-11 02:15:53 +0000553
Herbert Xua430a432006-07-08 13:34:56 -0700554int tcp_v4_gso_send_check(struct sk_buff *skb)
555{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700556 const struct iphdr *iph;
Herbert Xua430a432006-07-08 13:34:56 -0700557 struct tcphdr *th;
558
559 if (!pskb_may_pull(skb, sizeof(*th)))
560 return -EINVAL;
561
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700562 iph = ip_hdr(skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700563 th = tcp_hdr(skb);
Herbert Xua430a432006-07-08 13:34:56 -0700564
565 th->check = 0;
Patrick McHardy84fa7932006-08-29 16:44:56 -0700566 skb->ip_summed = CHECKSUM_PARTIAL;
Herbert Xu419f9f82010-04-11 02:15:53 +0000567 __tcp_v4_send_check(skb, iph->saddr, iph->daddr);
Herbert Xua430a432006-07-08 13:34:56 -0700568 return 0;
569}
570
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571/*
572 * This routine will send an RST to the other tcp.
573 *
574 * Someone asks: why I NEVER use socket parameters (TOS, TTL etc.)
575 * for reset.
576 * Answer: if a packet caused RST, it is not for a socket
577 * existing in our system, if it is matched to a socket,
578 * it is just duplicate segment or bug in other side's TCP.
579 * So that we build reply only basing on parameters
580 * arrived with segment.
581 * Exception: precedence violation. We do not implement it in any case.
582 */
583
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800584static void tcp_v4_send_reset(struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400586 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800587 struct {
588 struct tcphdr th;
589#ifdef CONFIG_TCP_MD5SIG
Al Viro714e85b2006-11-14 20:51:49 -0800590 __be32 opt[(TCPOLEN_MD5SIG_ALIGNED >> 2)];
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800591#endif
592 } rep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 struct ip_reply_arg arg;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800594#ifdef CONFIG_TCP_MD5SIG
595 struct tcp_md5sig_key *key;
Shawn Lu658ddaa2012-01-31 22:35:48 +0000596 const __u8 *hash_location = NULL;
597 unsigned char newhash[16];
598 int genhash;
599 struct sock *sk1 = NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800600#endif
Pavel Emelyanova86b1e32008-07-16 20:20:58 -0700601 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602
603 /* Never send a reset in response to a reset. */
604 if (th->rst)
605 return;
606
Eric Dumazet511c3f92009-06-02 05:14:27 +0000607 if (skb_rtable(skb)->rt_type != RTN_LOCAL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 return;
609
610 /* Swap the send and the receive. */
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800611 memset(&rep, 0, sizeof(rep));
612 rep.th.dest = th->source;
613 rep.th.source = th->dest;
614 rep.th.doff = sizeof(struct tcphdr) / 4;
615 rep.th.rst = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
617 if (th->ack) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800618 rep.th.seq = th->ack_seq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800620 rep.th.ack = 1;
621 rep.th.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
622 skb->len - (th->doff << 2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 }
624
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200625 memset(&arg, 0, sizeof(arg));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800626 arg.iov[0].iov_base = (unsigned char *)&rep;
627 arg.iov[0].iov_len = sizeof(rep.th);
628
629#ifdef CONFIG_TCP_MD5SIG
Shawn Lu658ddaa2012-01-31 22:35:48 +0000630 hash_location = tcp_parse_md5sig_option(th);
631 if (!sk && hash_location) {
632 /*
633 * active side is lost. Try to find listening socket through
634 * source port, and then find md5 key through listening socket.
635 * we are not loose security here:
636 * Incoming packet is checked with md5 hash with finding key,
637 * no RST generated if md5 hash doesn't match.
638 */
639 sk1 = __inet_lookup_listener(dev_net(skb_dst(skb)->dev),
640 &tcp_hashinfo, ip_hdr(skb)->daddr,
641 ntohs(th->source), inet_iif(skb));
642 /* don't send rst if it can't find key */
643 if (!sk1)
644 return;
645 rcu_read_lock();
646 key = tcp_md5_do_lookup(sk1, (union tcp_md5_addr *)
647 &ip_hdr(skb)->saddr, AF_INET);
648 if (!key)
649 goto release_sk1;
650
651 genhash = tcp_v4_md5_hash_skb(newhash, key, NULL, NULL, skb);
652 if (genhash || memcmp(hash_location, newhash, 16) != 0)
653 goto release_sk1;
654 } else {
655 key = sk ? tcp_md5_do_lookup(sk, (union tcp_md5_addr *)
656 &ip_hdr(skb)->saddr,
657 AF_INET) : NULL;
658 }
659
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800660 if (key) {
661 rep.opt[0] = htonl((TCPOPT_NOP << 24) |
662 (TCPOPT_NOP << 16) |
663 (TCPOPT_MD5SIG << 8) |
664 TCPOLEN_MD5SIG);
665 /* Update length and the length the header thinks exists */
666 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
667 rep.th.doff = arg.iov[0].iov_len / 4;
668
Adam Langley49a72df2008-07-19 00:01:42 -0700669 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[1],
Ilpo Järvinen78e645cb2008-10-09 14:37:47 -0700670 key, ip_hdr(skb)->saddr,
671 ip_hdr(skb)->daddr, &rep.th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800672 }
673#endif
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700674 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
675 ip_hdr(skb)->saddr, /* XXX */
Ilpo Järvinen52cd5752008-10-08 11:34:06 -0700676 arg.iov[0].iov_len, IPPROTO_TCP, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700678 arg.flags = (sk && inet_sk(sk)->transparent) ? IP_REPLY_ARG_NOSRCCHECK : 0;
Shawn Lue2446ea2012-02-04 12:38:09 +0000679 /* When socket is gone, all binding information is lost.
680 * routing might fail in this case. using iif for oif to
681 * make sure we can deliver it
682 */
683 arg.bound_dev_if = sk ? sk->sk_bound_dev_if : inet_iif(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684
Eric Dumazetadf30902009-06-02 05:19:30 +0000685 net = dev_net(skb_dst(skb)->dev);
Eric Dumazet66b13d92011-10-24 03:06:21 -0400686 arg.tos = ip_hdr(skb)->tos;
David S. Miller0a5ebb82011-05-09 13:22:43 -0700687 ip_send_reply(net->ipv4.tcp_sock, skb, ip_hdr(skb)->saddr,
Denis V. Lunev7feb49c2008-04-03 14:32:00 -0700688 &arg, arg.iov[0].iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689
Pavel Emelyanov63231bd2008-07-16 20:22:25 -0700690 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
691 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
Shawn Lu658ddaa2012-01-31 22:35:48 +0000692
693#ifdef CONFIG_TCP_MD5SIG
694release_sk1:
695 if (sk1) {
696 rcu_read_unlock();
697 sock_put(sk1);
698 }
699#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700}
701
702/* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
703 outside socket context is ugly, certainly. What can I do?
704 */
705
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900706static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
707 u32 win, u32 ts, int oif,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700708 struct tcp_md5sig_key *key,
Eric Dumazet66b13d92011-10-24 03:06:21 -0400709 int reply_flags, u8 tos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710{
Eric Dumazetcf533ea2011-10-21 05:22:42 -0400711 const struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 struct {
713 struct tcphdr th;
Al Viro714e85b2006-11-14 20:51:49 -0800714 __be32 opt[(TCPOLEN_TSTAMP_ALIGNED >> 2)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800715#ifdef CONFIG_TCP_MD5SIG
Al Viro714e85b2006-11-14 20:51:49 -0800716 + (TCPOLEN_MD5SIG_ALIGNED >> 2)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800717#endif
718 ];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 } rep;
720 struct ip_reply_arg arg;
Eric Dumazetadf30902009-06-02 05:19:30 +0000721 struct net *net = dev_net(skb_dst(skb)->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722
723 memset(&rep.th, 0, sizeof(struct tcphdr));
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200724 memset(&arg, 0, sizeof(arg));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725
726 arg.iov[0].iov_base = (unsigned char *)&rep;
727 arg.iov[0].iov_len = sizeof(rep.th);
728 if (ts) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800729 rep.opt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
730 (TCPOPT_TIMESTAMP << 8) |
731 TCPOLEN_TIMESTAMP);
732 rep.opt[1] = htonl(tcp_time_stamp);
733 rep.opt[2] = htonl(ts);
Craig Schlentercb48cfe2007-01-09 00:11:15 -0800734 arg.iov[0].iov_len += TCPOLEN_TSTAMP_ALIGNED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 }
736
737 /* Swap the send and the receive. */
738 rep.th.dest = th->source;
739 rep.th.source = th->dest;
740 rep.th.doff = arg.iov[0].iov_len / 4;
741 rep.th.seq = htonl(seq);
742 rep.th.ack_seq = htonl(ack);
743 rep.th.ack = 1;
744 rep.th.window = htons(win);
745
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800746#ifdef CONFIG_TCP_MD5SIG
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800747 if (key) {
748 int offset = (ts) ? 3 : 0;
749
750 rep.opt[offset++] = htonl((TCPOPT_NOP << 24) |
751 (TCPOPT_NOP << 16) |
752 (TCPOPT_MD5SIG << 8) |
753 TCPOLEN_MD5SIG);
754 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
755 rep.th.doff = arg.iov[0].iov_len/4;
756
Adam Langley49a72df2008-07-19 00:01:42 -0700757 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[offset],
Adam Langley90b7e112008-07-31 20:49:48 -0700758 key, ip_hdr(skb)->saddr,
759 ip_hdr(skb)->daddr, &rep.th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800760 }
761#endif
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700762 arg.flags = reply_flags;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700763 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
764 ip_hdr(skb)->saddr, /* XXX */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 arg.iov[0].iov_len, IPPROTO_TCP, 0);
766 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900767 if (oif)
768 arg.bound_dev_if = oif;
Eric Dumazet66b13d92011-10-24 03:06:21 -0400769 arg.tos = tos;
David S. Miller0a5ebb82011-05-09 13:22:43 -0700770 ip_send_reply(net->ipv4.tcp_sock, skb, ip_hdr(skb)->saddr,
Denis V. Lunev7feb49c2008-04-03 14:32:00 -0700771 &arg, arg.iov[0].iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772
Pavel Emelyanov63231bd2008-07-16 20:22:25 -0700773 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774}
775
776static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
777{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700778 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800779 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900781 tcp_v4_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200782 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900783 tcptw->tw_ts_recent,
784 tw->tw_bound_dev_if,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700785 tcp_twsk_md5_key(tcptw),
Eric Dumazet66b13d92011-10-24 03:06:21 -0400786 tw->tw_transparent ? IP_REPLY_ARG_NOSRCCHECK : 0,
787 tw->tw_tos
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900788 );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700790 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791}
792
Gui Jianfeng6edafaa2008-08-06 23:50:04 -0700793static void tcp_v4_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200794 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795{
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900796 tcp_v4_send_ack(skb, tcp_rsk(req)->snt_isn + 1,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800797 tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900798 req->ts_recent,
799 0,
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000800 tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&ip_hdr(skb)->daddr,
801 AF_INET),
Eric Dumazet66b13d92011-10-24 03:06:21 -0400802 inet_rsk(req)->no_srccheck ? IP_REPLY_ARG_NOSRCCHECK : 0,
803 ip_hdr(skb)->tos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804}
805
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806/*
Kris Katterjohn9bf1d832008-02-17 22:29:19 -0800807 * Send a SYN-ACK after having received a SYN.
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700808 * This still operates on a request_sock only, not on a big
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 * socket.
810 */
Octavian Purdila72659ec2010-01-17 19:09:39 -0800811static int tcp_v4_send_synack(struct sock *sk, struct dst_entry *dst,
812 struct request_sock *req,
813 struct request_values *rvp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700815 const struct inet_request_sock *ireq = inet_rsk(req);
David S. Miller6bd023f2011-05-18 18:32:03 -0400816 struct flowi4 fl4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 int err = -1;
818 struct sk_buff * skb;
819
820 /* First, grab a route. */
David S. Miller6bd023f2011-05-18 18:32:03 -0400821 if (!dst && (dst = inet_csk_route_req(sk, &fl4, req)) == NULL)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800822 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000824 skb = tcp_make_synack(sk, dst, req, rvp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825
826 if (skb) {
Herbert Xu419f9f82010-04-11 02:15:53 +0000827 __tcp_v4_send_check(skb, ireq->loc_addr, ireq->rmt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700829 err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,
830 ireq->rmt_addr,
831 ireq->opt);
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200832 err = net_xmit_eval(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 }
834
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 dst_release(dst);
836 return err;
837}
838
Octavian Purdila72659ec2010-01-17 19:09:39 -0800839static int tcp_v4_rtx_synack(struct sock *sk, struct request_sock *req,
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000840 struct request_values *rvp)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800841{
Octavian Purdila72659ec2010-01-17 19:09:39 -0800842 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_RETRANSSEGS);
843 return tcp_v4_send_synack(sk, NULL, req, rvp);
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800844}
845
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700847 * IPv4 request_sock destructor.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 */
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700849static void tcp_v4_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850{
Jesper Juhla51482b2005-11-08 09:41:34 -0800851 kfree(inet_rsk(req)->opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852}
853
Eric Dumazet946cedc2011-08-30 03:21:44 +0000854/*
855 * Return 1 if a syncookie should be sent
856 */
857int tcp_syn_flood_action(struct sock *sk,
858 const struct sk_buff *skb,
859 const char *proto)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860{
Eric Dumazet946cedc2011-08-30 03:21:44 +0000861 const char *msg = "Dropping request";
862 int want_cookie = 0;
863 struct listen_sock *lopt;
864
865
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000867#ifdef CONFIG_SYN_COOKIES
Eric Dumazet946cedc2011-08-30 03:21:44 +0000868 if (sysctl_tcp_syncookies) {
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000869 msg = "Sending cookies";
Eric Dumazet946cedc2011-08-30 03:21:44 +0000870 want_cookie = 1;
871 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPREQQFULLDOCOOKIES);
872 } else
Arnaldo Carvalho de Melo80e40da2006-01-04 01:58:06 -0200873#endif
Eric Dumazet946cedc2011-08-30 03:21:44 +0000874 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPREQQFULLDROP);
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000875
Eric Dumazet946cedc2011-08-30 03:21:44 +0000876 lopt = inet_csk(sk)->icsk_accept_queue.listen_opt;
877 if (!lopt->synflood_warned) {
878 lopt->synflood_warned = 1;
879 pr_info("%s: Possible SYN flooding on port %d. %s. "
880 " Check SNMP counters.\n",
881 proto, ntohs(tcp_hdr(skb)->dest), msg);
882 }
883 return want_cookie;
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000884}
Eric Dumazet946cedc2011-08-30 03:21:44 +0000885EXPORT_SYMBOL(tcp_syn_flood_action);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886
887/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700888 * Save and compile IPv4 options into the request_sock if needed.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 */
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000890static struct ip_options_rcu *tcp_v4_save_options(struct sock *sk,
891 struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892{
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000893 const struct ip_options *opt = &(IPCB(skb)->opt);
894 struct ip_options_rcu *dopt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895
896 if (opt && opt->optlen) {
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000897 int opt_size = sizeof(*dopt) + opt->optlen;
898
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 dopt = kmalloc(opt_size, GFP_ATOMIC);
900 if (dopt) {
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000901 if (ip_options_echo(&dopt->opt, skb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 kfree(dopt);
903 dopt = NULL;
904 }
905 }
906 }
907 return dopt;
908}
909
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800910#ifdef CONFIG_TCP_MD5SIG
911/*
912 * RFC2385 MD5 checksumming requires a mapping of
913 * IP address->MD5 Key.
914 * We need to maintain these in the sk structure.
915 */
916
917/* Find the Key structure for an address. */
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000918struct tcp_md5sig_key *tcp_md5_do_lookup(struct sock *sk,
919 const union tcp_md5_addr *addr,
920 int family)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800921{
922 struct tcp_sock *tp = tcp_sk(sk);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000923 struct tcp_md5sig_key *key;
924 struct hlist_node *pos;
925 unsigned int size = sizeof(struct in_addr);
Eric Dumazeta8afca02012-01-31 18:45:40 +0000926 struct tcp_md5sig_info *md5sig;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800927
Eric Dumazeta8afca02012-01-31 18:45:40 +0000928 /* caller either holds rcu_read_lock() or socket lock */
929 md5sig = rcu_dereference_check(tp->md5sig_info,
930 sock_owned_by_user(sk));
931 if (!md5sig)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800932 return NULL;
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000933#if IS_ENABLED(CONFIG_IPV6)
934 if (family == AF_INET6)
935 size = sizeof(struct in6_addr);
936#endif
Eric Dumazeta8afca02012-01-31 18:45:40 +0000937 hlist_for_each_entry_rcu(key, pos, &md5sig->head, node) {
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000938 if (key->family != family)
939 continue;
940 if (!memcmp(&key->addr, addr, size))
941 return key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800942 }
943 return NULL;
944}
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000945EXPORT_SYMBOL(tcp_md5_do_lookup);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800946
947struct tcp_md5sig_key *tcp_v4_md5_lookup(struct sock *sk,
948 struct sock *addr_sk)
949{
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000950 union tcp_md5_addr *addr;
951
952 addr = (union tcp_md5_addr *)&inet_sk(addr_sk)->inet_daddr;
953 return tcp_md5_do_lookup(sk, addr, AF_INET);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800954}
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800955EXPORT_SYMBOL(tcp_v4_md5_lookup);
956
Adrian Bunkf5b99bc2006-11-30 17:22:29 -0800957static struct tcp_md5sig_key *tcp_v4_reqsk_md5_lookup(struct sock *sk,
958 struct request_sock *req)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800959{
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000960 union tcp_md5_addr *addr;
961
962 addr = (union tcp_md5_addr *)&inet_rsk(req)->rmt_addr;
963 return tcp_md5_do_lookup(sk, addr, AF_INET);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800964}
965
966/* This can be called on a newly created socket, from other files */
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000967int tcp_md5_do_add(struct sock *sk, const union tcp_md5_addr *addr,
968 int family, const u8 *newkey, u8 newkeylen, gfp_t gfp)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800969{
970 /* Add Key to the list */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700971 struct tcp_md5sig_key *key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800972 struct tcp_sock *tp = tcp_sk(sk);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000973 struct tcp_md5sig_info *md5sig;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800974
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000975 key = tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&addr, AF_INET);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800976 if (key) {
977 /* Pre-existing entry - just update that one. */
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000978 memcpy(key->key, newkey, newkeylen);
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700979 key->keylen = newkeylen;
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000980 return 0;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800981 }
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000982
Eric Dumazeta8afca02012-01-31 18:45:40 +0000983 md5sig = rcu_dereference_protected(tp->md5sig_info,
984 sock_owned_by_user(sk));
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000985 if (!md5sig) {
986 md5sig = kmalloc(sizeof(*md5sig), gfp);
987 if (!md5sig)
988 return -ENOMEM;
989
990 sk_nocaps_add(sk, NETIF_F_GSO_MASK);
991 INIT_HLIST_HEAD(&md5sig->head);
Eric Dumazeta8afca02012-01-31 18:45:40 +0000992 rcu_assign_pointer(tp->md5sig_info, md5sig);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000993 }
994
Eric Dumazet5f3d9cb2012-01-31 10:56:48 +0000995 key = sock_kmalloc(sk, sizeof(*key), gfp);
Eric Dumazeta915da9b2012-01-31 05:18:33 +0000996 if (!key)
997 return -ENOMEM;
998 if (hlist_empty(&md5sig->head) && !tcp_alloc_md5sig_pool(sk)) {
Eric Dumazet5f3d9cb2012-01-31 10:56:48 +0000999 sock_kfree_s(sk, key, sizeof(*key));
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001000 return -ENOMEM;
1001 }
1002
1003 memcpy(key->key, newkey, newkeylen);
1004 key->keylen = newkeylen;
1005 key->family = family;
1006 memcpy(&key->addr, addr,
1007 (family == AF_INET6) ? sizeof(struct in6_addr) :
1008 sizeof(struct in_addr));
1009 hlist_add_head_rcu(&key->node, &md5sig->head);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001010 return 0;
1011}
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001012EXPORT_SYMBOL(tcp_md5_do_add);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001013
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001014int tcp_md5_do_del(struct sock *sk, const union tcp_md5_addr *addr, int family)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001015{
1016 struct tcp_sock *tp = tcp_sk(sk);
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001017 struct tcp_md5sig_key *key;
Eric Dumazeta8afca02012-01-31 18:45:40 +00001018 struct tcp_md5sig_info *md5sig;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001019
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001020 key = tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&addr, AF_INET);
1021 if (!key)
1022 return -ENOENT;
1023 hlist_del_rcu(&key->node);
Eric Dumazet5f3d9cb2012-01-31 10:56:48 +00001024 atomic_sub(sizeof(*key), &sk->sk_omem_alloc);
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001025 kfree_rcu(key, rcu);
Eric Dumazeta8afca02012-01-31 18:45:40 +00001026 md5sig = rcu_dereference_protected(tp->md5sig_info,
1027 sock_owned_by_user(sk));
1028 if (hlist_empty(&md5sig->head))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001029 tcp_free_md5sig_pool();
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001030 return 0;
1031}
1032EXPORT_SYMBOL(tcp_md5_do_del);
1033
1034void tcp_clear_md5_list(struct sock *sk)
1035{
1036 struct tcp_sock *tp = tcp_sk(sk);
1037 struct tcp_md5sig_key *key;
1038 struct hlist_node *pos, *n;
Eric Dumazeta8afca02012-01-31 18:45:40 +00001039 struct tcp_md5sig_info *md5sig;
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001040
Eric Dumazeta8afca02012-01-31 18:45:40 +00001041 md5sig = rcu_dereference_protected(tp->md5sig_info, 1);
1042
1043 if (!hlist_empty(&md5sig->head))
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001044 tcp_free_md5sig_pool();
Eric Dumazeta8afca02012-01-31 18:45:40 +00001045 hlist_for_each_entry_safe(key, pos, n, &md5sig->head, node) {
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001046 hlist_del_rcu(&key->node);
Eric Dumazet5f3d9cb2012-01-31 10:56:48 +00001047 atomic_sub(sizeof(*key), &sk->sk_omem_alloc);
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001048 kfree_rcu(key, rcu);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001049 }
1050}
1051
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001052static int tcp_v4_parse_md5_keys(struct sock *sk, char __user *optval,
1053 int optlen)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001054{
1055 struct tcp_md5sig cmd;
1056 struct sockaddr_in *sin = (struct sockaddr_in *)&cmd.tcpm_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001057
1058 if (optlen < sizeof(cmd))
1059 return -EINVAL;
1060
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001061 if (copy_from_user(&cmd, optval, sizeof(cmd)))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001062 return -EFAULT;
1063
1064 if (sin->sin_family != AF_INET)
1065 return -EINVAL;
1066
Eric Dumazeta8afca02012-01-31 18:45:40 +00001067 if (!cmd.tcpm_key || !cmd.tcpm_keylen)
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001068 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin->sin_addr.s_addr,
1069 AF_INET);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001070
1071 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
1072 return -EINVAL;
1073
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001074 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin->sin_addr.s_addr,
1075 AF_INET, cmd.tcpm_key, cmd.tcpm_keylen,
1076 GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001077}
1078
Adam Langley49a72df2008-07-19 00:01:42 -07001079static int tcp_v4_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
1080 __be32 daddr, __be32 saddr, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001081{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001082 struct tcp4_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -07001083 struct scatterlist sg;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001084
1085 bp = &hp->md5_blk.ip4;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001086
1087 /*
Adam Langley49a72df2008-07-19 00:01:42 -07001088 * 1. the TCP pseudo-header (in the order: source IP address,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001089 * destination IP address, zero-padded protocol number, and
1090 * segment length)
1091 */
1092 bp->saddr = saddr;
1093 bp->daddr = daddr;
1094 bp->pad = 0;
YOSHIFUJI Hideaki076fb722008-04-17 12:48:12 +09001095 bp->protocol = IPPROTO_TCP;
Adam Langley49a72df2008-07-19 00:01:42 -07001096 bp->len = cpu_to_be16(nbytes);
David S. Millerc7da57a2007-10-26 00:41:21 -07001097
Adam Langley49a72df2008-07-19 00:01:42 -07001098 sg_init_one(&sg, bp, sizeof(*bp));
1099 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
1100}
1101
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001102static int tcp_v4_md5_hash_hdr(char *md5_hash, const struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -04001103 __be32 daddr, __be32 saddr, const struct tcphdr *th)
Adam Langley49a72df2008-07-19 00:01:42 -07001104{
1105 struct tcp_md5sig_pool *hp;
1106 struct hash_desc *desc;
1107
1108 hp = tcp_get_md5sig_pool();
1109 if (!hp)
1110 goto clear_hash_noput;
1111 desc = &hp->md5_desc;
1112
1113 if (crypto_hash_init(desc))
1114 goto clear_hash;
1115 if (tcp_v4_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
1116 goto clear_hash;
1117 if (tcp_md5_hash_header(hp, th))
1118 goto clear_hash;
1119 if (tcp_md5_hash_key(hp, key))
1120 goto clear_hash;
1121 if (crypto_hash_final(desc, md5_hash))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001122 goto clear_hash;
1123
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001124 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001125 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -07001126
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001127clear_hash:
1128 tcp_put_md5sig_pool();
1129clear_hash_noput:
1130 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -07001131 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001132}
1133
Adam Langley49a72df2008-07-19 00:01:42 -07001134int tcp_v4_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
Eric Dumazet318cf7a2011-10-24 02:46:04 -04001135 const struct sock *sk, const struct request_sock *req,
1136 const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001137{
Adam Langley49a72df2008-07-19 00:01:42 -07001138 struct tcp_md5sig_pool *hp;
1139 struct hash_desc *desc;
Eric Dumazet318cf7a2011-10-24 02:46:04 -04001140 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001141 __be32 saddr, daddr;
1142
1143 if (sk) {
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001144 saddr = inet_sk(sk)->inet_saddr;
1145 daddr = inet_sk(sk)->inet_daddr;
Adam Langley49a72df2008-07-19 00:01:42 -07001146 } else if (req) {
1147 saddr = inet_rsk(req)->loc_addr;
1148 daddr = inet_rsk(req)->rmt_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001149 } else {
Adam Langley49a72df2008-07-19 00:01:42 -07001150 const struct iphdr *iph = ip_hdr(skb);
1151 saddr = iph->saddr;
1152 daddr = iph->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001153 }
Adam Langley49a72df2008-07-19 00:01:42 -07001154
1155 hp = tcp_get_md5sig_pool();
1156 if (!hp)
1157 goto clear_hash_noput;
1158 desc = &hp->md5_desc;
1159
1160 if (crypto_hash_init(desc))
1161 goto clear_hash;
1162
1163 if (tcp_v4_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
1164 goto clear_hash;
1165 if (tcp_md5_hash_header(hp, th))
1166 goto clear_hash;
1167 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
1168 goto clear_hash;
1169 if (tcp_md5_hash_key(hp, key))
1170 goto clear_hash;
1171 if (crypto_hash_final(desc, md5_hash))
1172 goto clear_hash;
1173
1174 tcp_put_md5sig_pool();
1175 return 0;
1176
1177clear_hash:
1178 tcp_put_md5sig_pool();
1179clear_hash_noput:
1180 memset(md5_hash, 0, 16);
1181 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001182}
Adam Langley49a72df2008-07-19 00:01:42 -07001183EXPORT_SYMBOL(tcp_v4_md5_hash_skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001184
Eric Dumazet318cf7a2011-10-24 02:46:04 -04001185static int tcp_v4_inbound_md5_hash(struct sock *sk, const struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001186{
1187 /*
1188 * This gets called for each TCP segment that arrives
1189 * so we want to be efficient.
1190 * We have 3 drop cases:
1191 * o No MD5 hash and one expected.
1192 * o MD5 hash and we're not expecting one.
1193 * o MD5 hash and its wrong.
1194 */
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001195 const __u8 *hash_location = NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001196 struct tcp_md5sig_key *hash_expected;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001197 const struct iphdr *iph = ip_hdr(skb);
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001198 const struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001199 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001200 unsigned char newhash[16];
1201
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001202 hash_expected = tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&iph->saddr,
1203 AF_INET);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +09001204 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001205
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001206 /* We've parsed the options - do we have a hash? */
1207 if (!hash_expected && !hash_location)
1208 return 0;
1209
1210 if (hash_expected && !hash_location) {
David S. Miller785957d2008-07-30 03:03:15 -07001211 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001212 return 1;
1213 }
1214
1215 if (!hash_expected && hash_location) {
David S. Miller785957d2008-07-30 03:03:15 -07001216 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001217 return 1;
1218 }
1219
1220 /* Okay, so this is hash_expected and hash_location -
1221 * so we need to calculate the checksum.
1222 */
Adam Langley49a72df2008-07-19 00:01:42 -07001223 genhash = tcp_v4_md5_hash_skb(newhash,
1224 hash_expected,
1225 NULL, NULL, skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001226
1227 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
1228 if (net_ratelimit()) {
Harvey Harrison673d57e2008-10-31 00:53:57 -07001229 printk(KERN_INFO "MD5 Hash failed for (%pI4, %d)->(%pI4, %d)%s\n",
1230 &iph->saddr, ntohs(th->source),
1231 &iph->daddr, ntohs(th->dest),
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001232 genhash ? " tcp_v4_calc_md5_hash failed" : "");
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001233 }
1234 return 1;
1235 }
1236 return 0;
1237}
1238
1239#endif
1240
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001241struct request_sock_ops tcp_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242 .family = PF_INET,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001243 .obj_size = sizeof(struct tcp_request_sock),
Octavian Purdila72659ec2010-01-17 19:09:39 -08001244 .rtx_syn_ack = tcp_v4_rtx_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001245 .send_ack = tcp_v4_reqsk_send_ack,
1246 .destructor = tcp_v4_reqsk_destructor,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 .send_reset = tcp_v4_send_reset,
Octavian Purdila72659ec2010-01-17 19:09:39 -08001248 .syn_ack_timeout = tcp_syn_ack_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249};
1250
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001251#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001252static const struct tcp_request_sock_ops tcp_request_sock_ipv4_ops = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001253 .md5_lookup = tcp_v4_reqsk_md5_lookup,
John Dykstrae3afe7b2009-07-16 05:04:51 +00001254 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001255};
Andrew Mortonb6332e62006-11-30 19:16:28 -08001256#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001257
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1259{
William Allen Simpson4957faade2009-12-02 18:25:27 +00001260 struct tcp_extend_values tmp_ext;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261 struct tcp_options_received tmp_opt;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001262 const u8 *hash_location;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001263 struct request_sock *req;
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001264 struct inet_request_sock *ireq;
William Allen Simpson4957faade2009-12-02 18:25:27 +00001265 struct tcp_sock *tp = tcp_sk(sk);
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001266 struct dst_entry *dst = NULL;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001267 __be32 saddr = ip_hdr(skb)->saddr;
1268 __be32 daddr = ip_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 __u32 isn = TCP_SKB_CB(skb)->when;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270 int want_cookie = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271
1272 /* Never answer to SYNs send to broadcast or multicast */
Eric Dumazet511c3f92009-06-02 05:14:27 +00001273 if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274 goto drop;
1275
1276 /* TW buckets are converted to open requests without
1277 * limitations, they conserve resources and peer is
1278 * evidently real one.
1279 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001280 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
Eric Dumazet946cedc2011-08-30 03:21:44 +00001281 want_cookie = tcp_syn_flood_action(sk, skb, "TCP");
1282 if (!want_cookie)
1283 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 }
1285
1286 /* Accept backlog is full. If we have already queued enough
1287 * of warm entries in syn queue, drop request. It is better than
1288 * clogging syn queue with openreqs with exponentially increasing
1289 * timeout.
1290 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001291 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 goto drop;
1293
Arnaldo Carvalho de Meloce4a7d02008-06-10 12:39:35 -07001294 req = inet_reqsk_alloc(&tcp_request_sock_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 if (!req)
1296 goto drop;
1297
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001298#ifdef CONFIG_TCP_MD5SIG
1299 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv4_ops;
1300#endif
1301
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 tcp_clear_options(&tmp_opt);
William Allen Simpsonbee7ca92009-11-10 09:51:18 +00001303 tmp_opt.mss_clamp = TCP_MSS_DEFAULT;
William Allen Simpson4957faade2009-12-02 18:25:27 +00001304 tmp_opt.user_mss = tp->rx_opt.user_mss;
David S. Millerbb5b7c12009-12-15 20:56:42 -08001305 tcp_parse_options(skb, &tmp_opt, &hash_location, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306
William Allen Simpson4957faade2009-12-02 18:25:27 +00001307 if (tmp_opt.cookie_plus > 0 &&
1308 tmp_opt.saw_tstamp &&
1309 !tp->rx_opt.cookie_out_never &&
1310 (sysctl_tcp_cookie_size > 0 ||
1311 (tp->cookie_values != NULL &&
1312 tp->cookie_values->cookie_desired > 0))) {
1313 u8 *c;
1314 u32 *mess = &tmp_ext.cookie_bakery[COOKIE_DIGEST_WORDS];
1315 int l = tmp_opt.cookie_plus - TCPOLEN_COOKIE_BASE;
1316
1317 if (tcp_cookie_generator(&tmp_ext.cookie_bakery[0]) != 0)
1318 goto drop_and_release;
1319
1320 /* Secret recipe starts with IP addresses */
Eric Dumazet0eae88f2010-04-20 19:06:52 -07001321 *mess++ ^= (__force u32)daddr;
1322 *mess++ ^= (__force u32)saddr;
William Allen Simpson4957faade2009-12-02 18:25:27 +00001323
1324 /* plus variable length Initiator Cookie */
1325 c = (u8 *)mess;
1326 while (l-- > 0)
1327 *c++ ^= *hash_location++;
1328
William Allen Simpson4957faade2009-12-02 18:25:27 +00001329 want_cookie = 0; /* not our kind of cookie */
William Allen Simpson4957faade2009-12-02 18:25:27 +00001330 tmp_ext.cookie_out_never = 0; /* false */
1331 tmp_ext.cookie_plus = tmp_opt.cookie_plus;
1332 } else if (!tp->rx_opt.cookie_in_always) {
1333 /* redundant indications, but ensure initialization. */
1334 tmp_ext.cookie_out_never = 1; /* true */
1335 tmp_ext.cookie_plus = 0;
1336 } else {
1337 goto drop_and_release;
1338 }
1339 tmp_ext.cookie_in_always = tp->rx_opt.cookie_in_always;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340
Florian Westphal4dfc2812008-04-10 03:12:40 -07001341 if (want_cookie && !tmp_opt.saw_tstamp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 tcp_clear_options(&tmp_opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 tcp_openreq_init(req, &tmp_opt, skb);
1346
David S. Millerbb5b7c12009-12-15 20:56:42 -08001347 ireq = inet_rsk(req);
1348 ireq->loc_addr = daddr;
1349 ireq->rmt_addr = saddr;
1350 ireq->no_srccheck = inet_sk(sk)->transparent;
1351 ireq->opt = tcp_v4_save_options(sk, skb);
1352
Paul Moore284904a2009-03-27 17:10:28 -04001353 if (security_inet_conn_request(sk, skb, req))
David S. Millerbb5b7c12009-12-15 20:56:42 -08001354 goto drop_and_free;
Paul Moore284904a2009-03-27 17:10:28 -04001355
Florian Westphal172d69e2010-06-21 11:48:45 +00001356 if (!want_cookie || tmp_opt.tstamp_ok)
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001357 TCP_ECN_create_request(req, tcp_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358
1359 if (want_cookie) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 isn = cookie_v4_init_sequence(sk, skb, &req->mss);
Florian Westphal172d69e2010-06-21 11:48:45 +00001361 req->cookie_ts = tmp_opt.tstamp_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 } else if (!isn) {
1363 struct inet_peer *peer = NULL;
David S. Miller6bd023f2011-05-18 18:32:03 -04001364 struct flowi4 fl4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365
1366 /* VJ's idea. We save last timestamp seen
1367 * from the destination in peer table, when entering
1368 * state TIME-WAIT, and check against it before
1369 * accepting new connection request.
1370 *
1371 * If "isn" is not zero, this request hit alive
1372 * timewait bucket, so that all the necessary checks
1373 * are made in the function processing timewait state.
1374 */
1375 if (tmp_opt.saw_tstamp &&
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001376 tcp_death_row.sysctl_tw_recycle &&
David S. Miller6bd023f2011-05-18 18:32:03 -04001377 (dst = inet_csk_route_req(sk, &fl4, req)) != NULL &&
David S. Millered2361e2011-05-18 18:38:54 -04001378 fl4.daddr == saddr &&
1379 (peer = rt_get_peer((struct rtable *)dst, fl4.daddr)) != NULL) {
Eric Dumazet317fe0e2010-06-16 04:52:13 +00001380 inet_peer_refcheck(peer);
Eric Dumazet2c1409a2009-11-12 09:33:09 +00001381 if ((u32)get_seconds() - peer->tcp_ts_stamp < TCP_PAWS_MSL &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 (s32)(peer->tcp_ts - req->ts_recent) >
1383 TCP_PAWS_WINDOW) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001384 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001385 goto drop_and_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 }
1387 }
1388 /* Kill the following clause, if you dislike this way. */
1389 else if (!sysctl_tcp_syncookies &&
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001390 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391 (sysctl_max_syn_backlog >> 2)) &&
1392 (!peer || !peer->tcp_ts_stamp) &&
1393 (!dst || !dst_metric(dst, RTAX_RTT))) {
1394 /* Without syncookies last quarter of
1395 * backlog is filled with destinations,
1396 * proven to be alive.
1397 * It means that we continue to communicate
1398 * to destinations, already remembered
1399 * to the moment of synflood.
1400 */
Harvey Harrison673d57e2008-10-31 00:53:57 -07001401 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open request from %pI4/%u\n",
1402 &saddr, ntohs(tcp_hdr(skb)->source));
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001403 goto drop_and_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 }
1405
Gerrit Renkera94f7232006-11-10 14:06:49 -08001406 isn = tcp_v4_init_sequence(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 }
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001408 tcp_rsk(req)->snt_isn = isn;
Jerry Chu9ad7c042011-06-08 11:08:38 +00001409 tcp_rsk(req)->snt_synack = tcp_time_stamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410
Octavian Purdila72659ec2010-01-17 19:09:39 -08001411 if (tcp_v4_send_synack(sk, dst, req,
1412 (struct request_values *)&tmp_ext) ||
William Allen Simpson4957faade2009-12-02 18:25:27 +00001413 want_cookie)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 goto drop_and_free;
1415
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001416 inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417 return 0;
1418
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001419drop_and_release:
1420 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421drop_and_free:
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001422 reqsk_free(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423drop:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 return 0;
1425}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001426EXPORT_SYMBOL(tcp_v4_conn_request);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427
1428
1429/*
1430 * The three way handshake has completed - we got a valid synack -
1431 * now create the new socket.
1432 */
1433struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001434 struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 struct dst_entry *dst)
1436{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001437 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 struct inet_sock *newinet;
1439 struct tcp_sock *newtp;
1440 struct sock *newsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001441#ifdef CONFIG_TCP_MD5SIG
1442 struct tcp_md5sig_key *key;
1443#endif
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001444 struct ip_options_rcu *inet_opt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445
1446 if (sk_acceptq_is_full(sk))
1447 goto exit_overflow;
1448
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 newsk = tcp_create_openreq_child(sk, req, skb);
1450 if (!newsk)
Balazs Scheidler093d2822010-10-21 13:06:43 +02001451 goto exit_nonewsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452
Herbert Xubcd76112006-06-30 13:36:35 -07001453 newsk->sk_gso_type = SKB_GSO_TCPV4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454
1455 newtp = tcp_sk(newsk);
1456 newinet = inet_sk(newsk);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001457 ireq = inet_rsk(req);
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001458 newinet->inet_daddr = ireq->rmt_addr;
1459 newinet->inet_rcv_saddr = ireq->loc_addr;
1460 newinet->inet_saddr = ireq->loc_addr;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001461 inet_opt = ireq->opt;
1462 rcu_assign_pointer(newinet->inet_opt, inet_opt);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001463 ireq->opt = NULL;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001464 newinet->mc_index = inet_iif(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001465 newinet->mc_ttl = ip_hdr(skb)->ttl;
Jiri Benc4c507d22012-02-09 09:35:49 +00001466 newinet->rcv_tos = ip_hdr(skb)->tos;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001467 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001468 if (inet_opt)
1469 inet_csk(newsk)->icsk_ext_hdr_len = inet_opt->opt.optlen;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001470 newinet->inet_id = newtp->write_seq ^ jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471
David S. Miller0e734412011-05-08 15:28:03 -07001472 if (!dst && (dst = inet_csk_route_child_sock(sk, newsk, req)) == NULL)
1473 goto put_and_exit;
1474
1475 sk_setup_caps(newsk, dst);
1476
John Heffner5d424d52006-03-20 17:53:41 -08001477 tcp_mtup_init(newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 tcp_sync_mss(newsk, dst_mtu(dst));
David S. Miller0dbaee32010-12-13 12:52:14 -08001479 newtp->advmss = dst_metric_advmss(dst);
Tom Quetchenbachf5fff5d2008-09-21 00:21:51 -07001480 if (tcp_sk(sk)->rx_opt.user_mss &&
1481 tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1482 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1483
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 tcp_initialize_rcv_mss(newsk);
Jerry Chu9ad7c042011-06-08 11:08:38 +00001485 if (tcp_rsk(req)->snt_synack)
1486 tcp_valid_rtt_meas(newsk,
1487 tcp_time_stamp - tcp_rsk(req)->snt_synack);
1488 newtp->total_retrans = req->retrans;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001490#ifdef CONFIG_TCP_MD5SIG
1491 /* Copy over the MD5 key from the original socket */
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001492 key = tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&newinet->inet_daddr,
1493 AF_INET);
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001494 if (key != NULL) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001495 /*
1496 * We're using one, so create a matching key
1497 * on the newsk structure. If we fail to get
1498 * memory, then we end up not copying the key
1499 * across. Shucks.
1500 */
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001501 tcp_md5_do_add(newsk, (union tcp_md5_addr *)&newinet->inet_daddr,
1502 AF_INET, key->key, key->keylen, GFP_ATOMIC);
Eric Dumazeta4654192010-05-16 00:36:33 -07001503 sk_nocaps_add(newsk, NETIF_F_GSO_MASK);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001504 }
1505#endif
1506
David S. Miller0e734412011-05-08 15:28:03 -07001507 if (__inet_inherit_port(sk, newsk) < 0)
1508 goto put_and_exit;
Eric Dumazet9327f702009-12-04 03:46:54 +00001509 __inet_hash_nolisten(newsk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510
1511 return newsk;
1512
1513exit_overflow:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001514 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001515exit_nonewsk:
1516 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517exit:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001518 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519 return NULL;
David S. Miller0e734412011-05-08 15:28:03 -07001520put_and_exit:
Eric Dumazet709e8692011-11-14 10:56:56 +00001521 tcp_clear_xmit_timers(newsk);
Eric Dumazetd8a6e652011-11-30 01:02:41 +00001522 tcp_cleanup_congestion_control(newsk);
Eric Dumazet918eb392011-11-02 12:42:56 +00001523 bh_unlock_sock(newsk);
David S. Miller0e734412011-05-08 15:28:03 -07001524 sock_put(newsk);
1525 goto exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001527EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528
1529static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
1530{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001531 struct tcphdr *th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001532 const struct iphdr *iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533 struct sock *nsk;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001534 struct request_sock **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535 /* Find possible connection requests. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001536 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
1537 iph->saddr, iph->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 if (req)
1539 return tcp_check_req(sk, skb, req, prev);
1540
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001541 nsk = inet_lookup_established(sock_net(sk), &tcp_hashinfo, iph->saddr,
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001542 th->source, iph->daddr, th->dest, inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543
1544 if (nsk) {
1545 if (nsk->sk_state != TCP_TIME_WAIT) {
1546 bh_lock_sock(nsk);
1547 return nsk;
1548 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001549 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 return NULL;
1551 }
1552
1553#ifdef CONFIG_SYN_COOKIES
Florian Westphalaf9b4732010-06-03 00:43:44 +00001554 if (!th->syn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
1556#endif
1557 return sk;
1558}
1559
Al Virob51655b2006-11-14 21:40:42 -08001560static __sum16 tcp_v4_checksum_init(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001562 const struct iphdr *iph = ip_hdr(skb);
1563
Patrick McHardy84fa7932006-08-29 16:44:56 -07001564 if (skb->ip_summed == CHECKSUM_COMPLETE) {
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001565 if (!tcp_v4_check(skb->len, iph->saddr,
1566 iph->daddr, skb->csum)) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001567 skb->ip_summed = CHECKSUM_UNNECESSARY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568 return 0;
Herbert Xufb286bb2005-11-10 13:01:24 -08001569 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 }
Herbert Xufb286bb2005-11-10 13:01:24 -08001571
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001572 skb->csum = csum_tcpudp_nofold(iph->saddr, iph->daddr,
Herbert Xufb286bb2005-11-10 13:01:24 -08001573 skb->len, IPPROTO_TCP, 0);
1574
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 if (skb->len <= 76) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001576 return __skb_checksum_complete(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577 }
1578 return 0;
1579}
1580
1581
1582/* The socket must have it's spinlock held when we get
1583 * here.
1584 *
1585 * We have a potential double-lock case here, so even when
1586 * doing backlog processing we use the BH locking scheme.
1587 * This is because we cannot sleep with the original spinlock
1588 * held.
1589 */
1590int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1591{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001592 struct sock *rsk;
1593#ifdef CONFIG_TCP_MD5SIG
1594 /*
1595 * We really want to reject the packet as early as possible
1596 * if:
1597 * o We're expecting an MD5'd packet and this is no MD5 tcp option
1598 * o There is an MD5 option and we're not expecting one
1599 */
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001600 if (tcp_v4_inbound_md5_hash(sk, skb))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001601 goto discard;
1602#endif
1603
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
Tom Herbertbdeab992011-08-14 19:45:55 +00001605 sock_rps_save_rxhash(sk, skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001606 if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001607 rsk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001609 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610 return 0;
1611 }
1612
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07001613 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614 goto csum_err;
1615
1616 if (sk->sk_state == TCP_LISTEN) {
1617 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
1618 if (!nsk)
1619 goto discard;
1620
1621 if (nsk != sk) {
Tom Herbertbdeab992011-08-14 19:45:55 +00001622 sock_rps_save_rxhash(nsk, skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001623 if (tcp_child_process(sk, nsk, skb)) {
1624 rsk = nsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001626 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 return 0;
1628 }
Eric Dumazetca551582010-06-03 09:03:58 +00001629 } else
Tom Herbertbdeab992011-08-14 19:45:55 +00001630 sock_rps_save_rxhash(sk, skb);
Eric Dumazetca551582010-06-03 09:03:58 +00001631
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001632 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001633 rsk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001635 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 return 0;
1637
1638reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001639 tcp_v4_send_reset(rsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640discard:
1641 kfree_skb(skb);
1642 /* Be careful here. If this function gets more complicated and
1643 * gcc suffers from register pressure on the x86, sk (in %ebx)
1644 * might be destroyed here. This current version compiles correctly,
1645 * but you have been warned.
1646 */
1647 return 0;
1648
1649csum_err:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001650 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 goto discard;
1652}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001653EXPORT_SYMBOL(tcp_v4_do_rcv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654
1655/*
1656 * From tcp_input.c
1657 */
1658
1659int tcp_v4_rcv(struct sk_buff *skb)
1660{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001661 const struct iphdr *iph;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001662 const struct tcphdr *th;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 struct sock *sk;
1664 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001665 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666
1667 if (skb->pkt_type != PACKET_HOST)
1668 goto discard_it;
1669
1670 /* Count it even if it's bad */
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001671 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672
1673 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1674 goto discard_it;
1675
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001676 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677
1678 if (th->doff < sizeof(struct tcphdr) / 4)
1679 goto bad_packet;
1680 if (!pskb_may_pull(skb, th->doff * 4))
1681 goto discard_it;
1682
1683 /* An explanation is required here, I think.
1684 * Packet length and doff are validated by header prediction,
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -08001685 * provided case of th->doff==0 is eliminated.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 * So, we defer the checks. */
Herbert Xu60476372007-04-09 11:59:39 -07001687 if (!skb_csum_unnecessary(skb) && tcp_v4_checksum_init(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688 goto bad_packet;
1689
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001690 th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001691 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1693 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1694 skb->len - th->doff * 4);
1695 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1696 TCP_SKB_CB(skb)->when = 0;
Eric Dumazetb82d1bb2011-09-27 02:20:08 -04001697 TCP_SKB_CB(skb)->ip_dsfield = ipv4_get_dsfield(iph);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698 TCP_SKB_CB(skb)->sacked = 0;
1699
Arnaldo Carvalho de Melo9a1f27c2008-10-07 11:41:57 -07001700 sk = __inet_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701 if (!sk)
1702 goto no_tcp_socket;
1703
Eric Dumazetbb134d52010-03-09 05:55:56 +00001704process:
1705 if (sk->sk_state == TCP_TIME_WAIT)
1706 goto do_time_wait;
1707
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001708 if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
1709 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
Stephen Hemmingerd218d112010-01-11 16:28:01 -08001710 goto discard_and_relse;
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001711 }
Stephen Hemmingerd218d112010-01-11 16:28:01 -08001712
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1714 goto discard_and_relse;
Patrick McHardyb59c2702006-01-06 23:06:10 -08001715 nf_reset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001717 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 goto discard_and_relse;
1719
1720 skb->dev = NULL;
1721
Ingo Molnarc6366182006-07-03 00:25:13 -07001722 bh_lock_sock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723 ret = 0;
1724 if (!sock_owned_by_user(sk)) {
Chris Leech1a2449a2006-05-23 18:05:53 -07001725#ifdef CONFIG_NET_DMA
1726 struct tcp_sock *tp = tcp_sk(sk);
1727 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
Dan Williamsf67b4592009-01-06 11:38:15 -07001728 tp->ucopy.dma_chan = dma_find_channel(DMA_MEMCPY);
Chris Leech1a2449a2006-05-23 18:05:53 -07001729 if (tp->ucopy.dma_chan)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730 ret = tcp_v4_do_rcv(sk, skb);
Chris Leech1a2449a2006-05-23 18:05:53 -07001731 else
1732#endif
1733 {
1734 if (!tcp_prequeue(sk, skb))
Shan Weiae8d7f82009-05-05 01:01:29 +00001735 ret = tcp_v4_do_rcv(sk, skb);
Chris Leech1a2449a2006-05-23 18:05:53 -07001736 }
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001737 } else if (unlikely(sk_add_backlog(sk, skb))) {
Zhu Yi6b03a532010-03-04 18:01:41 +00001738 bh_unlock_sock(sk);
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001739 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
Zhu Yi6b03a532010-03-04 18:01:41 +00001740 goto discard_and_relse;
1741 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742 bh_unlock_sock(sk);
1743
1744 sock_put(sk);
1745
1746 return ret;
1747
1748no_tcp_socket:
1749 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1750 goto discard_it;
1751
1752 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1753bad_packet:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001754 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001756 tcp_v4_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 }
1758
1759discard_it:
1760 /* Discard frame. */
1761 kfree_skb(skb);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001762 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001763
1764discard_and_relse:
1765 sock_put(sk);
1766 goto discard_it;
1767
1768do_time_wait:
1769 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001770 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 goto discard_it;
1772 }
1773
1774 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001775 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001776 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777 goto discard_it;
1778 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001779 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780 case TCP_TW_SYN: {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001781 struct sock *sk2 = inet_lookup_listener(dev_net(skb->dev),
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001782 &tcp_hashinfo,
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001783 iph->daddr, th->dest,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001784 inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 if (sk2) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001786 inet_twsk_deschedule(inet_twsk(sk), &tcp_death_row);
1787 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 sk = sk2;
1789 goto process;
1790 }
1791 /* Fall through to ACK */
1792 }
1793 case TCP_TW_ACK:
1794 tcp_v4_timewait_ack(sk, skb);
1795 break;
1796 case TCP_TW_RST:
1797 goto no_tcp_socket;
1798 case TCP_TW_SUCCESS:;
1799 }
1800 goto discard_it;
1801}
1802
David S. Miller3f419d22010-11-29 13:37:14 -08001803struct inet_peer *tcp_v4_get_peer(struct sock *sk, bool *release_it)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804{
David S. Miller3f419d22010-11-29 13:37:14 -08001805 struct rtable *rt = (struct rtable *) __sk_dst_get(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806 struct inet_sock *inet = inet_sk(sk);
David S. Miller3f419d22010-11-29 13:37:14 -08001807 struct inet_peer *peer;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808
David S. Millerc5216cc2011-05-06 22:36:30 -07001809 if (!rt ||
1810 inet->cork.fl.u.ip4.daddr != inet->inet_daddr) {
David S. Millerb534ecf2010-11-30 11:54:19 -08001811 peer = inet_getpeer_v4(inet->inet_daddr, 1);
David S. Miller3f419d22010-11-29 13:37:14 -08001812 *release_it = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 } else {
1814 if (!rt->peer)
David S. Millera48eff12011-05-18 18:42:43 -04001815 rt_bind_peer(rt, inet->inet_daddr, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816 peer = rt->peer;
David S. Miller3f419d22010-11-29 13:37:14 -08001817 *release_it = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818 }
1819
David S. Miller3f419d22010-11-29 13:37:14 -08001820 return peer;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821}
David S. Miller3f419d22010-11-29 13:37:14 -08001822EXPORT_SYMBOL(tcp_v4_get_peer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823
David S. Millerccb7c412010-12-01 18:09:13 -08001824void *tcp_v4_tw_get_peer(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825{
Eric Dumazetcf533ea2011-10-21 05:22:42 -04001826 const struct inet_timewait_sock *tw = inet_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827
David S. Millerccb7c412010-12-01 18:09:13 -08001828 return inet_getpeer_v4(tw->tw_daddr, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829}
David S. Millerccb7c412010-12-01 18:09:13 -08001830EXPORT_SYMBOL(tcp_v4_tw_get_peer);
1831
1832static struct timewait_sock_ops tcp_timewait_sock_ops = {
1833 .twsk_obj_size = sizeof(struct tcp_timewait_sock),
1834 .twsk_unique = tcp_twsk_unique,
1835 .twsk_destructor= tcp_twsk_destructor,
1836 .twsk_getpeer = tcp_v4_tw_get_peer,
1837};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001839const struct inet_connection_sock_af_ops ipv4_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001840 .queue_xmit = ip_queue_xmit,
1841 .send_check = tcp_v4_send_check,
1842 .rebuild_header = inet_sk_rebuild_header,
1843 .conn_request = tcp_v4_conn_request,
1844 .syn_recv_sock = tcp_v4_syn_recv_sock,
David S. Miller3f419d22010-11-29 13:37:14 -08001845 .get_peer = tcp_v4_get_peer,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001846 .net_header_len = sizeof(struct iphdr),
1847 .setsockopt = ip_setsockopt,
1848 .getsockopt = ip_getsockopt,
1849 .addr2sockaddr = inet_csk_addr2sockaddr,
1850 .sockaddr_len = sizeof(struct sockaddr_in),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001851 .bind_conflict = inet_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001852#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001853 .compat_setsockopt = compat_ip_setsockopt,
1854 .compat_getsockopt = compat_ip_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001855#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856};
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001857EXPORT_SYMBOL(ipv4_specific);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001859#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001860static const struct tcp_sock_af_ops tcp_sock_ipv4_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001861 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001862 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001863 .md5_parse = tcp_v4_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001864};
Andrew Mortonb6332e62006-11-30 19:16:28 -08001865#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001866
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867/* NOTE: A lot of things set to zero explicitly by call to
1868 * sk_alloc() so need not be done here.
1869 */
1870static int tcp_v4_init_sock(struct sock *sk)
1871{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001872 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873 struct tcp_sock *tp = tcp_sk(sk);
1874
1875 skb_queue_head_init(&tp->out_of_order_queue);
1876 tcp_init_xmit_timers(sk);
1877 tcp_prequeue_init(tp);
1878
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001879 icsk->icsk_rto = TCP_TIMEOUT_INIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880 tp->mdev = TCP_TIMEOUT_INIT;
1881
1882 /* So many TCP implementations out there (incorrectly) count the
1883 * initial SYN frame in their delayed-ACK and congestion control
1884 * algorithms that we must have the following bandaid to talk
1885 * efficiently to them. -DaveM
1886 */
Jerry Chu9ad7c042011-06-08 11:08:38 +00001887 tp->snd_cwnd = TCP_INIT_CWND;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888
1889 /* See draft-stevens-tcpca-spec-01 for discussion of the
1890 * initialization of these values.
1891 */
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07001892 tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893 tp->snd_cwnd_clamp = ~0;
William Allen Simpsonbee7ca92009-11-10 09:51:18 +00001894 tp->mss_cache = TCP_MSS_DEFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895
1896 tp->reordering = sysctl_tcp_reordering;
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001897 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898
1899 sk->sk_state = TCP_CLOSE;
1900
1901 sk->sk_write_space = sk_stream_write_space;
1902 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1903
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001904 icsk->icsk_af_ops = &ipv4_specific;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001905 icsk->icsk_sync_mss = tcp_sync_mss;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001906#ifdef CONFIG_TCP_MD5SIG
1907 tp->af_specific = &tcp_sock_ipv4_specific;
1908#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909
William Allen Simpson435cf552009-12-02 18:17:05 +00001910 /* TCP Cookie Transactions */
1911 if (sysctl_tcp_cookie_size > 0) {
1912 /* Default, cookies without s_data_payload. */
1913 tp->cookie_values =
1914 kzalloc(sizeof(*tp->cookie_values),
1915 sk->sk_allocation);
1916 if (tp->cookie_values != NULL)
1917 kref_init(&tp->cookie_values->kref);
1918 }
1919 /* Presumed zeroed, in order of appearance:
1920 * cookie_in_always, cookie_out_never,
1921 * s_data_constant, s_data_in, s_data_out
1922 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1924 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1925
Herbert Xueb4dea52008-12-29 23:04:08 -08001926 local_bh_disable();
Glauber Costad1a4c0b2011-12-11 21:47:04 +00001927 sock_update_memcg(sk);
Glauber Costa180d8cd2011-12-11 21:47:02 +00001928 sk_sockets_allocated_inc(sk);
Herbert Xueb4dea52008-12-29 23:04:08 -08001929 local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930
1931 return 0;
1932}
1933
Brian Haley7d06b2e2008-06-14 17:04:49 -07001934void tcp_v4_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935{
1936 struct tcp_sock *tp = tcp_sk(sk);
1937
1938 tcp_clear_xmit_timers(sk);
1939
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001940 tcp_cleanup_congestion_control(sk);
Stephen Hemminger317a76f2005-06-23 12:19:55 -07001941
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942 /* Cleanup up the write buffer. */
David S. Millerfe067e82007-03-07 12:12:44 -08001943 tcp_write_queue_purge(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944
1945 /* Cleans up our, hopefully empty, out_of_order_queue. */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001946 __skb_queue_purge(&tp->out_of_order_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001948#ifdef CONFIG_TCP_MD5SIG
1949 /* Clean up the MD5 key list, if any */
1950 if (tp->md5sig_info) {
Eric Dumazeta915da9b2012-01-31 05:18:33 +00001951 tcp_clear_md5_list(sk);
Eric Dumazeta8afca02012-01-31 18:45:40 +00001952 kfree_rcu(tp->md5sig_info, rcu);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001953 tp->md5sig_info = NULL;
1954 }
1955#endif
1956
Chris Leech1a2449a2006-05-23 18:05:53 -07001957#ifdef CONFIG_NET_DMA
1958 /* Cleans up our sk_async_wait_queue */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001959 __skb_queue_purge(&sk->sk_async_wait_queue);
Chris Leech1a2449a2006-05-23 18:05:53 -07001960#endif
1961
Linus Torvalds1da177e2005-04-16 15:20:36 -07001962 /* Clean prequeue, it must be empty really */
1963 __skb_queue_purge(&tp->ucopy.prequeue);
1964
1965 /* Clean up a referenced TCP bind bucket. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001966 if (inet_csk(sk)->icsk_bind_hash)
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001967 inet_put_port(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968
1969 /*
1970 * If sendmsg cached page exists, toss it.
1971 */
1972 if (sk->sk_sndmsg_page) {
1973 __free_page(sk->sk_sndmsg_page);
1974 sk->sk_sndmsg_page = NULL;
1975 }
1976
William Allen Simpson435cf552009-12-02 18:17:05 +00001977 /* TCP Cookie Transactions */
1978 if (tp->cookie_values != NULL) {
1979 kref_put(&tp->cookie_values->kref,
1980 tcp_cookie_values_release);
1981 tp->cookie_values = NULL;
1982 }
1983
Glauber Costa180d8cd2011-12-11 21:47:02 +00001984 sk_sockets_allocated_dec(sk);
Glauber Costad1a4c0b2011-12-11 21:47:04 +00001985 sock_release_memcg(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987EXPORT_SYMBOL(tcp_v4_destroy_sock);
1988
1989#ifdef CONFIG_PROC_FS
1990/* Proc filesystem TCP sock list dumping. */
1991
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001992static inline struct inet_timewait_sock *tw_head(struct hlist_nulls_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993{
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001994 return hlist_nulls_empty(head) ? NULL :
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001995 list_entry(head->first, struct inet_timewait_sock, tw_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996}
1997
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001998static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999{
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002000 return !is_a_nulls(tw->tw_node.next) ?
2001 hlist_nulls_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002}
2003
Tom Herberta8b690f2010-06-07 00:43:42 -07002004/*
2005 * Get next listener socket follow cur. If cur is NULL, get first socket
2006 * starting from bucket given in st->bucket; when st->bucket is zero the
2007 * very first socket in the hash table is returned.
2008 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002009static void *listening_get_next(struct seq_file *seq, void *cur)
2010{
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002011 struct inet_connection_sock *icsk;
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08002012 struct hlist_nulls_node *node;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013 struct sock *sk = cur;
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002014 struct inet_listen_hashbucket *ilb;
Jianjun Kong5799de02008-11-03 02:49:10 -08002015 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002016 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017
2018 if (!sk) {
Tom Herberta8b690f2010-06-07 00:43:42 -07002019 ilb = &tcp_hashinfo.listening_hash[st->bucket];
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002020 spin_lock_bh(&ilb->lock);
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08002021 sk = sk_nulls_head(&ilb->head);
Tom Herberta8b690f2010-06-07 00:43:42 -07002022 st->offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002023 goto get_sk;
2024 }
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002025 ilb = &tcp_hashinfo.listening_hash[st->bucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026 ++st->num;
Tom Herberta8b690f2010-06-07 00:43:42 -07002027 ++st->offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028
2029 if (st->state == TCP_SEQ_STATE_OPENREQ) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002030 struct request_sock *req = cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031
Eric Dumazet72a3eff2006-11-16 02:30:37 -08002032 icsk = inet_csk(st->syn_wait_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033 req = req->dl_next;
2034 while (1) {
2035 while (req) {
Daniel Lezcanobdccc4c2008-07-19 00:15:13 -07002036 if (req->rsk_ops->family == st->family) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002037 cur = req;
2038 goto out;
2039 }
2040 req = req->dl_next;
2041 }
Eric Dumazet72a3eff2006-11-16 02:30:37 -08002042 if (++st->sbucket >= icsk->icsk_accept_queue.listen_opt->nr_table_entries)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002043 break;
2044get_req:
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002045 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002046 }
Eric Dumazet1bde5ac2010-12-23 09:32:46 -08002047 sk = sk_nulls_next(st->syn_wait_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002048 st->state = TCP_SEQ_STATE_LISTENING;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002049 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050 } else {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002051 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002052 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2053 if (reqsk_queue_len(&icsk->icsk_accept_queue))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054 goto start_req;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002055 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Eric Dumazet1bde5ac2010-12-23 09:32:46 -08002056 sk = sk_nulls_next(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057 }
2058get_sk:
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08002059 sk_nulls_for_each_from(sk, node) {
Pavel Emelyanov8475ef92010-11-22 03:26:12 +00002060 if (!net_eq(sock_net(sk), net))
2061 continue;
2062 if (sk->sk_family == st->family) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063 cur = sk;
2064 goto out;
2065 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002066 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002067 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2068 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002069start_req:
2070 st->uid = sock_i_uid(sk);
2071 st->syn_wait_sk = sk;
2072 st->state = TCP_SEQ_STATE_OPENREQ;
2073 st->sbucket = 0;
2074 goto get_req;
2075 }
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002076 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077 }
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002078 spin_unlock_bh(&ilb->lock);
Tom Herberta8b690f2010-06-07 00:43:42 -07002079 st->offset = 0;
Arnaldo Carvalho de Melo0f7ff922005-08-09 19:59:44 -07002080 if (++st->bucket < INET_LHTABLE_SIZE) {
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002081 ilb = &tcp_hashinfo.listening_hash[st->bucket];
2082 spin_lock_bh(&ilb->lock);
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08002083 sk = sk_nulls_head(&ilb->head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002084 goto get_sk;
2085 }
2086 cur = NULL;
2087out:
2088 return cur;
2089}
2090
2091static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
2092{
Tom Herberta8b690f2010-06-07 00:43:42 -07002093 struct tcp_iter_state *st = seq->private;
2094 void *rc;
2095
2096 st->bucket = 0;
2097 st->offset = 0;
2098 rc = listening_get_next(seq, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002099
2100 while (rc && *pos) {
2101 rc = listening_get_next(seq, rc);
2102 --*pos;
2103 }
2104 return rc;
2105}
2106
Andi Kleen6eac5602008-08-28 01:08:02 -07002107static inline int empty_bucket(struct tcp_iter_state *st)
2108{
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002109 return hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].chain) &&
2110 hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].twchain);
Andi Kleen6eac5602008-08-28 01:08:02 -07002111}
2112
Tom Herberta8b690f2010-06-07 00:43:42 -07002113/*
2114 * Get first established socket starting from bucket given in st->bucket.
2115 * If st->bucket is zero, the very first socket in the hash is returned.
2116 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002117static void *established_get_first(struct seq_file *seq)
2118{
Jianjun Kong5799de02008-11-03 02:49:10 -08002119 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002120 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121 void *rc = NULL;
2122
Tom Herberta8b690f2010-06-07 00:43:42 -07002123 st->offset = 0;
2124 for (; st->bucket <= tcp_hashinfo.ehash_mask; ++st->bucket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125 struct sock *sk;
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002126 struct hlist_nulls_node *node;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002127 struct inet_timewait_sock *tw;
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002128 spinlock_t *lock = inet_ehash_lockp(&tcp_hashinfo, st->bucket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129
Andi Kleen6eac5602008-08-28 01:08:02 -07002130 /* Lockless fast path for the common case of empty buckets */
2131 if (empty_bucket(st))
2132 continue;
2133
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002134 spin_lock_bh(lock);
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002135 sk_nulls_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002136 if (sk->sk_family != st->family ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002137 !net_eq(sock_net(sk), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138 continue;
2139 }
2140 rc = sk;
2141 goto out;
2142 }
2143 st->state = TCP_SEQ_STATE_TIME_WAIT;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002144 inet_twsk_for_each(tw, node,
Eric Dumazetdbca9b2752007-02-08 14:16:46 -08002145 &tcp_hashinfo.ehash[st->bucket].twchain) {
Pavel Emelyanov28518fc2008-03-21 15:52:00 -07002146 if (tw->tw_family != st->family ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002147 !net_eq(twsk_net(tw), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148 continue;
2149 }
2150 rc = tw;
2151 goto out;
2152 }
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002153 spin_unlock_bh(lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002154 st->state = TCP_SEQ_STATE_ESTABLISHED;
2155 }
2156out:
2157 return rc;
2158}
2159
2160static void *established_get_next(struct seq_file *seq, void *cur)
2161{
2162 struct sock *sk = cur;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002163 struct inet_timewait_sock *tw;
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002164 struct hlist_nulls_node *node;
Jianjun Kong5799de02008-11-03 02:49:10 -08002165 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002166 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002167
2168 ++st->num;
Tom Herberta8b690f2010-06-07 00:43:42 -07002169 ++st->offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002170
2171 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
2172 tw = cur;
2173 tw = tw_next(tw);
2174get_tw:
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002175 while (tw && (tw->tw_family != st->family || !net_eq(twsk_net(tw), net))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002176 tw = tw_next(tw);
2177 }
2178 if (tw) {
2179 cur = tw;
2180 goto out;
2181 }
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002182 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183 st->state = TCP_SEQ_STATE_ESTABLISHED;
2184
Andi Kleen6eac5602008-08-28 01:08:02 -07002185 /* Look for next non empty bucket */
Tom Herberta8b690f2010-06-07 00:43:42 -07002186 st->offset = 0;
Eric Dumazetf373b532009-10-09 00:16:19 +00002187 while (++st->bucket <= tcp_hashinfo.ehash_mask &&
Andi Kleen6eac5602008-08-28 01:08:02 -07002188 empty_bucket(st))
2189 ;
Eric Dumazetf373b532009-10-09 00:16:19 +00002190 if (st->bucket > tcp_hashinfo.ehash_mask)
Andi Kleen6eac5602008-08-28 01:08:02 -07002191 return NULL;
2192
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002193 spin_lock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002194 sk = sk_nulls_head(&tcp_hashinfo.ehash[st->bucket].chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195 } else
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002196 sk = sk_nulls_next(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002198 sk_nulls_for_each_from(sk, node) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002199 if (sk->sk_family == st->family && net_eq(sock_net(sk), net))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200 goto found;
2201 }
2202
2203 st->state = TCP_SEQ_STATE_TIME_WAIT;
Eric Dumazetdbca9b2752007-02-08 14:16:46 -08002204 tw = tw_head(&tcp_hashinfo.ehash[st->bucket].twchain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205 goto get_tw;
2206found:
2207 cur = sk;
2208out:
2209 return cur;
2210}
2211
2212static void *established_get_idx(struct seq_file *seq, loff_t pos)
2213{
Tom Herberta8b690f2010-06-07 00:43:42 -07002214 struct tcp_iter_state *st = seq->private;
2215 void *rc;
2216
2217 st->bucket = 0;
2218 rc = established_get_first(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002219
2220 while (rc && pos) {
2221 rc = established_get_next(seq, rc);
2222 --pos;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002223 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002224 return rc;
2225}
2226
2227static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
2228{
2229 void *rc;
Jianjun Kong5799de02008-11-03 02:49:10 -08002230 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002231
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232 st->state = TCP_SEQ_STATE_LISTENING;
2233 rc = listening_get_idx(seq, &pos);
2234
2235 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236 st->state = TCP_SEQ_STATE_ESTABLISHED;
2237 rc = established_get_idx(seq, pos);
2238 }
2239
2240 return rc;
2241}
2242
Tom Herberta8b690f2010-06-07 00:43:42 -07002243static void *tcp_seek_last_pos(struct seq_file *seq)
2244{
2245 struct tcp_iter_state *st = seq->private;
2246 int offset = st->offset;
2247 int orig_num = st->num;
2248 void *rc = NULL;
2249
2250 switch (st->state) {
2251 case TCP_SEQ_STATE_OPENREQ:
2252 case TCP_SEQ_STATE_LISTENING:
2253 if (st->bucket >= INET_LHTABLE_SIZE)
2254 break;
2255 st->state = TCP_SEQ_STATE_LISTENING;
2256 rc = listening_get_next(seq, NULL);
2257 while (offset-- && rc)
2258 rc = listening_get_next(seq, rc);
2259 if (rc)
2260 break;
2261 st->bucket = 0;
2262 /* Fallthrough */
2263 case TCP_SEQ_STATE_ESTABLISHED:
2264 case TCP_SEQ_STATE_TIME_WAIT:
2265 st->state = TCP_SEQ_STATE_ESTABLISHED;
2266 if (st->bucket > tcp_hashinfo.ehash_mask)
2267 break;
2268 rc = established_get_first(seq);
2269 while (offset-- && rc)
2270 rc = established_get_next(seq, rc);
2271 }
2272
2273 st->num = orig_num;
2274
2275 return rc;
2276}
2277
Linus Torvalds1da177e2005-04-16 15:20:36 -07002278static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
2279{
Jianjun Kong5799de02008-11-03 02:49:10 -08002280 struct tcp_iter_state *st = seq->private;
Tom Herberta8b690f2010-06-07 00:43:42 -07002281 void *rc;
2282
2283 if (*pos && *pos == st->last_pos) {
2284 rc = tcp_seek_last_pos(seq);
2285 if (rc)
2286 goto out;
2287 }
2288
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289 st->state = TCP_SEQ_STATE_LISTENING;
2290 st->num = 0;
Tom Herberta8b690f2010-06-07 00:43:42 -07002291 st->bucket = 0;
2292 st->offset = 0;
2293 rc = *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2294
2295out:
2296 st->last_pos = *pos;
2297 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002298}
2299
2300static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2301{
Tom Herberta8b690f2010-06-07 00:43:42 -07002302 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002303 void *rc = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002304
2305 if (v == SEQ_START_TOKEN) {
2306 rc = tcp_get_idx(seq, 0);
2307 goto out;
2308 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309
2310 switch (st->state) {
2311 case TCP_SEQ_STATE_OPENREQ:
2312 case TCP_SEQ_STATE_LISTENING:
2313 rc = listening_get_next(seq, v);
2314 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315 st->state = TCP_SEQ_STATE_ESTABLISHED;
Tom Herberta8b690f2010-06-07 00:43:42 -07002316 st->bucket = 0;
2317 st->offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002318 rc = established_get_first(seq);
2319 }
2320 break;
2321 case TCP_SEQ_STATE_ESTABLISHED:
2322 case TCP_SEQ_STATE_TIME_WAIT:
2323 rc = established_get_next(seq, v);
2324 break;
2325 }
2326out:
2327 ++*pos;
Tom Herberta8b690f2010-06-07 00:43:42 -07002328 st->last_pos = *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329 return rc;
2330}
2331
2332static void tcp_seq_stop(struct seq_file *seq, void *v)
2333{
Jianjun Kong5799de02008-11-03 02:49:10 -08002334 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002335
2336 switch (st->state) {
2337 case TCP_SEQ_STATE_OPENREQ:
2338 if (v) {
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002339 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
2340 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002341 }
2342 case TCP_SEQ_STATE_LISTENING:
2343 if (v != SEQ_START_TOKEN)
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002344 spin_unlock_bh(&tcp_hashinfo.listening_hash[st->bucket].lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002345 break;
2346 case TCP_SEQ_STATE_TIME_WAIT:
2347 case TCP_SEQ_STATE_ESTABLISHED:
2348 if (v)
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002349 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002350 break;
2351 }
2352}
2353
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002354int tcp_seq_open(struct inode *inode, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002355{
2356 struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002357 struct tcp_iter_state *s;
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002358 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002359
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002360 err = seq_open_net(inode, file, &afinfo->seq_ops,
2361 sizeof(struct tcp_iter_state));
2362 if (err < 0)
2363 return err;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002364
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002365 s = ((struct seq_file *)file->private_data)->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366 s->family = afinfo->family;
Tom Herberta8b690f2010-06-07 00:43:42 -07002367 s->last_pos = 0;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002368 return 0;
2369}
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002370EXPORT_SYMBOL(tcp_seq_open);
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002371
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002372int tcp_proc_register(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002373{
2374 int rc = 0;
2375 struct proc_dir_entry *p;
2376
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002377 afinfo->seq_ops.start = tcp_seq_start;
2378 afinfo->seq_ops.next = tcp_seq_next;
2379 afinfo->seq_ops.stop = tcp_seq_stop;
2380
Denis V. Lunev84841c32008-05-02 04:10:08 -07002381 p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net,
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002382 afinfo->seq_fops, afinfo);
Denis V. Lunev84841c32008-05-02 04:10:08 -07002383 if (!p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002384 rc = -ENOMEM;
2385 return rc;
2386}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002387EXPORT_SYMBOL(tcp_proc_register);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002388
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002389void tcp_proc_unregister(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002390{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002391 proc_net_remove(net, afinfo->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002393EXPORT_SYMBOL(tcp_proc_unregister);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002394
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002395static void get_openreq4(const struct sock *sk, const struct request_sock *req,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002396 struct seq_file *f, int i, int uid, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002397{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002398 const struct inet_request_sock *ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002399 int ttd = req->expires - jiffies;
2400
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002401 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
Dan Rosenberg71338aa2011-05-23 12:17:35 +00002402 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %pK%n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002403 i,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002404 ireq->loc_addr,
Eric Dumazetc720c7e2009-10-15 06:30:45 +00002405 ntohs(inet_sk(sk)->inet_sport),
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002406 ireq->rmt_addr,
2407 ntohs(ireq->rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002408 TCP_SYN_RECV,
2409 0, 0, /* could print option size, but that is af dependent. */
2410 1, /* timers active (only the expire timer) */
2411 jiffies_to_clock_t(ttd),
2412 req->retrans,
2413 uid,
2414 0, /* non standard timer */
2415 0, /* open_requests have no inode */
2416 atomic_read(&sk->sk_refcnt),
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002417 req,
2418 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002419}
2420
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002421static void get_tcp4_sock(struct sock *sk, struct seq_file *f, int i, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002422{
2423 int timer_active;
2424 unsigned long timer_expires;
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002425 const struct tcp_sock *tp = tcp_sk(sk);
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002426 const struct inet_connection_sock *icsk = inet_csk(sk);
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002427 const struct inet_sock *inet = inet_sk(sk);
Eric Dumazetc720c7e2009-10-15 06:30:45 +00002428 __be32 dest = inet->inet_daddr;
2429 __be32 src = inet->inet_rcv_saddr;
2430 __u16 destp = ntohs(inet->inet_dport);
2431 __u16 srcp = ntohs(inet->inet_sport);
Eric Dumazet49d09002009-12-03 16:06:13 -08002432 int rx_queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002434 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002435 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002436 timer_expires = icsk->icsk_timeout;
2437 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002438 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002439 timer_expires = icsk->icsk_timeout;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002440 } else if (timer_pending(&sk->sk_timer)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002441 timer_active = 2;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002442 timer_expires = sk->sk_timer.expires;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002443 } else {
2444 timer_active = 0;
2445 timer_expires = jiffies;
2446 }
2447
Eric Dumazet49d09002009-12-03 16:06:13 -08002448 if (sk->sk_state == TCP_LISTEN)
2449 rx_queue = sk->sk_ack_backlog;
2450 else
2451 /*
2452 * because we dont lock socket, we might find a transient negative value
2453 */
2454 rx_queue = max_t(int, tp->rcv_nxt - tp->copied_seq, 0);
2455
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002456 seq_printf(f, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
Dan Rosenberg71338aa2011-05-23 12:17:35 +00002457 "%08X %5d %8d %lu %d %pK %lu %lu %u %u %d%n",
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002458 i, src, srcp, dest, destp, sk->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07002459 tp->write_seq - tp->snd_una,
Eric Dumazet49d09002009-12-03 16:06:13 -08002460 rx_queue,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002461 timer_active,
2462 jiffies_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002463 icsk->icsk_retransmits,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002464 sock_i_uid(sk),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03002465 icsk->icsk_probes_out,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002466 sock_i_ino(sk),
2467 atomic_read(&sk->sk_refcnt), sk,
Stephen Hemminger7be87352008-06-27 20:00:19 -07002468 jiffies_to_clock_t(icsk->icsk_rto),
2469 jiffies_to_clock_t(icsk->icsk_ack.ato),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002470 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002471 tp->snd_cwnd,
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07002472 tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002473 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002474}
2475
Eric Dumazetcf533ea2011-10-21 05:22:42 -04002476static void get_timewait4_sock(const struct inet_timewait_sock *tw,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002477 struct seq_file *f, int i, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002478{
Al Viro23f33c22006-09-27 18:43:50 -07002479 __be32 dest, src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002480 __u16 destp, srcp;
2481 int ttd = tw->tw_ttd - jiffies;
2482
2483 if (ttd < 0)
2484 ttd = 0;
2485
2486 dest = tw->tw_daddr;
2487 src = tw->tw_rcv_saddr;
2488 destp = ntohs(tw->tw_dport);
2489 srcp = ntohs(tw->tw_sport);
2490
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002491 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
Dan Rosenberg71338aa2011-05-23 12:17:35 +00002492 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK%n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002493 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
2494 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002495 atomic_read(&tw->tw_refcnt), tw, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002496}
2497
2498#define TMPSZ 150
2499
2500static int tcp4_seq_show(struct seq_file *seq, void *v)
2501{
Jianjun Kong5799de02008-11-03 02:49:10 -08002502 struct tcp_iter_state *st;
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002503 int len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002504
2505 if (v == SEQ_START_TOKEN) {
2506 seq_printf(seq, "%-*s\n", TMPSZ - 1,
2507 " sl local_address rem_address st tx_queue "
2508 "rx_queue tr tm->when retrnsmt uid timeout "
2509 "inode");
2510 goto out;
2511 }
2512 st = seq->private;
2513
2514 switch (st->state) {
2515 case TCP_SEQ_STATE_LISTENING:
2516 case TCP_SEQ_STATE_ESTABLISHED:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002517 get_tcp4_sock(v, seq, st->num, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002518 break;
2519 case TCP_SEQ_STATE_OPENREQ:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002520 get_openreq4(st->syn_wait_sk, v, seq, st->num, st->uid, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002521 break;
2522 case TCP_SEQ_STATE_TIME_WAIT:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002523 get_timewait4_sock(v, seq, st->num, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002524 break;
2525 }
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002526 seq_printf(seq, "%*s\n", TMPSZ - 1 - len, "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002527out:
2528 return 0;
2529}
2530
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002531static const struct file_operations tcp_afinfo_seq_fops = {
2532 .owner = THIS_MODULE,
2533 .open = tcp_seq_open,
2534 .read = seq_read,
2535 .llseek = seq_lseek,
2536 .release = seq_release_net
2537};
2538
Linus Torvalds1da177e2005-04-16 15:20:36 -07002539static struct tcp_seq_afinfo tcp4_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002540 .name = "tcp",
2541 .family = AF_INET,
Arjan van de Ven73cb88e2011-10-30 06:46:30 +00002542 .seq_fops = &tcp_afinfo_seq_fops,
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002543 .seq_ops = {
2544 .show = tcp4_seq_show,
2545 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002546};
2547
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002548static int __net_init tcp4_proc_init_net(struct net *net)
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002549{
2550 return tcp_proc_register(net, &tcp4_seq_afinfo);
2551}
2552
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002553static void __net_exit tcp4_proc_exit_net(struct net *net)
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002554{
2555 tcp_proc_unregister(net, &tcp4_seq_afinfo);
2556}
2557
2558static struct pernet_operations tcp4_net_ops = {
2559 .init = tcp4_proc_init_net,
2560 .exit = tcp4_proc_exit_net,
2561};
2562
Linus Torvalds1da177e2005-04-16 15:20:36 -07002563int __init tcp4_proc_init(void)
2564{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002565 return register_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002566}
2567
2568void tcp4_proc_exit(void)
2569{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002570 unregister_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002571}
2572#endif /* CONFIG_PROC_FS */
2573
Herbert Xubf296b12008-12-15 23:43:36 -08002574struct sk_buff **tcp4_gro_receive(struct sk_buff **head, struct sk_buff *skb)
2575{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00002576 const struct iphdr *iph = skb_gro_network_header(skb);
Herbert Xubf296b12008-12-15 23:43:36 -08002577
2578 switch (skb->ip_summed) {
2579 case CHECKSUM_COMPLETE:
Herbert Xu86911732009-01-29 14:19:50 +00002580 if (!tcp_v4_check(skb_gro_len(skb), iph->saddr, iph->daddr,
Herbert Xubf296b12008-12-15 23:43:36 -08002581 skb->csum)) {
2582 skb->ip_summed = CHECKSUM_UNNECESSARY;
2583 break;
2584 }
2585
2586 /* fall through */
2587 case CHECKSUM_NONE:
2588 NAPI_GRO_CB(skb)->flush = 1;
2589 return NULL;
2590 }
2591
2592 return tcp_gro_receive(head, skb);
2593}
Herbert Xubf296b12008-12-15 23:43:36 -08002594
2595int tcp4_gro_complete(struct sk_buff *skb)
2596{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00002597 const struct iphdr *iph = ip_hdr(skb);
Herbert Xubf296b12008-12-15 23:43:36 -08002598 struct tcphdr *th = tcp_hdr(skb);
2599
2600 th->check = ~tcp_v4_check(skb->len - skb_transport_offset(skb),
2601 iph->saddr, iph->daddr, 0);
2602 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV4;
2603
2604 return tcp_gro_complete(skb);
2605}
Herbert Xubf296b12008-12-15 23:43:36 -08002606
Linus Torvalds1da177e2005-04-16 15:20:36 -07002607struct proto tcp_prot = {
2608 .name = "TCP",
2609 .owner = THIS_MODULE,
2610 .close = tcp_close,
2611 .connect = tcp_v4_connect,
2612 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002613 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002614 .ioctl = tcp_ioctl,
2615 .init = tcp_v4_init_sock,
2616 .destroy = tcp_v4_destroy_sock,
2617 .shutdown = tcp_shutdown,
2618 .setsockopt = tcp_setsockopt,
2619 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002620 .recvmsg = tcp_recvmsg,
Changli Gao7ba42912010-07-10 20:41:55 +00002621 .sendmsg = tcp_sendmsg,
2622 .sendpage = tcp_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002623 .backlog_rcv = tcp_v4_do_rcv,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08002624 .hash = inet_hash,
2625 .unhash = inet_unhash,
2626 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002627 .enter_memory_pressure = tcp_enter_memory_pressure,
2628 .sockets_allocated = &tcp_sockets_allocated,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07002629 .orphan_count = &tcp_orphan_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002630 .memory_allocated = &tcp_memory_allocated,
2631 .memory_pressure = &tcp_memory_pressure,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002632 .sysctl_wmem = sysctl_tcp_wmem,
2633 .sysctl_rmem = sysctl_tcp_rmem,
2634 .max_header = MAX_TCP_HEADER,
2635 .obj_size = sizeof(struct tcp_sock),
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002636 .slab_flags = SLAB_DESTROY_BY_RCU,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002637 .twsk_prot = &tcp_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002638 .rsk_prot = &tcp_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07002639 .h.hashinfo = &tcp_hashinfo,
Changli Gao7ba42912010-07-10 20:41:55 +00002640 .no_autobind = true,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002641#ifdef CONFIG_COMPAT
2642 .compat_setsockopt = compat_tcp_setsockopt,
2643 .compat_getsockopt = compat_tcp_getsockopt,
2644#endif
Glauber Costad1a4c0b2011-12-11 21:47:04 +00002645#ifdef CONFIG_CGROUP_MEM_RES_CTLR_KMEM
2646 .init_cgroup = tcp_init_cgroup,
2647 .destroy_cgroup = tcp_destroy_cgroup,
2648 .proto_cgroup = tcp_proto_cgroup,
2649#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002650};
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002651EXPORT_SYMBOL(tcp_prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002652
Denis V. Lunev046ee902008-04-03 14:31:33 -07002653static int __net_init tcp_sk_init(struct net *net)
2654{
2655 return inet_ctl_sock_create(&net->ipv4.tcp_sock,
2656 PF_INET, SOCK_RAW, IPPROTO_TCP, net);
2657}
2658
2659static void __net_exit tcp_sk_exit(struct net *net)
2660{
2661 inet_ctl_sock_destroy(net->ipv4.tcp_sock);
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002662}
2663
2664static void __net_exit tcp_sk_exit_batch(struct list_head *net_exit_list)
2665{
2666 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET);
Denis V. Lunev046ee902008-04-03 14:31:33 -07002667}
2668
2669static struct pernet_operations __net_initdata tcp_sk_ops = {
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002670 .init = tcp_sk_init,
2671 .exit = tcp_sk_exit,
2672 .exit_batch = tcp_sk_exit_batch,
Denis V. Lunev046ee902008-04-03 14:31:33 -07002673};
2674
Denis V. Lunev9b0f9762008-02-29 11:13:15 -08002675void __init tcp_v4_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002676{
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002677 inet_hashinfo_init(&tcp_hashinfo);
Eric W. Biederman6a1b3052009-02-22 00:10:18 -08002678 if (register_pernet_subsys(&tcp_sk_ops))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002679 panic("Failed to create the TCP control socket.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002680}