blob: 65b8ebfd078a35e909c7cbf0c4e1c7bda594ac2f [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>
63
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020064#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070065#include <net/icmp.h>
Arnaldo Carvalho de Melo304a1612005-08-09 19:59:20 -070066#include <net/inet_hashtables.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070067#include <net/tcp.h>
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -030068#include <net/transp_v6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070069#include <net/ipv6.h>
70#include <net/inet_common.h>
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -080071#include <net/timewait_sock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070072#include <net/xfrm.h>
Chris Leech1a2449a2006-05-23 18:05:53 -070073#include <net/netdma.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
75#include <linux/inet.h>
76#include <linux/ipv6.h>
77#include <linux/stddef.h>
78#include <linux/proc_fs.h>
79#include <linux/seq_file.h>
80
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080081#include <linux/crypto.h>
82#include <linux/scatterlist.h>
83
Brian Haleyab32ea52006-09-22 14:15:41 -070084int sysctl_tcp_tw_reuse __read_mostly;
85int sysctl_tcp_low_latency __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080088#ifdef CONFIG_TCP_MD5SIG
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -020089static struct tcp_md5sig_key *tcp_v4_md5_do_lookup(struct sock *sk,
90 __be32 addr);
Adam Langley49a72df2008-07-19 00:01:42 -070091static int tcp_v4_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
92 __be32 daddr, __be32 saddr, struct tcphdr *th);
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +090093#else
94static inline
95struct tcp_md5sig_key *tcp_v4_md5_do_lookup(struct sock *sk, __be32 addr)
96{
97 return NULL;
98}
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080099#endif
100
Eric Dumazet5caea4e2008-11-20 00:40:07 -0800101struct inet_hashinfo tcp_hashinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102
Gerrit Renkera94f7232006-11-10 14:06:49 -0800103static inline __u32 tcp_v4_init_sequence(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700105 return secure_tcp_sequence_number(ip_hdr(skb)->daddr,
106 ip_hdr(skb)->saddr,
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700107 tcp_hdr(skb)->dest,
108 tcp_hdr(skb)->source);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109}
110
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800111int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp)
112{
113 const struct tcp_timewait_sock *tcptw = tcp_twsk(sktw);
114 struct tcp_sock *tp = tcp_sk(sk);
115
116 /* With PAWS, it is safe from the viewpoint
117 of data integrity. Even without PAWS it is safe provided sequence
118 spaces do not overlap i.e. at data rates <= 80Mbit/sec.
119
120 Actually, the idea is close to VJ's one, only timestamp cache is
121 held not per host, but per port pair and TW bucket is used as state
122 holder.
123
124 If TW bucket has been already destroyed we fall back to VJ's scheme
125 and use initial timestamp retrieved from peer table.
126 */
127 if (tcptw->tw_ts_recent_stamp &&
128 (twp == NULL || (sysctl_tcp_tw_reuse &&
James Morris9d729f72007-03-04 16:12:44 -0800129 get_seconds() - tcptw->tw_ts_recent_stamp > 1))) {
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800130 tp->write_seq = tcptw->tw_snd_nxt + 65535 + 2;
131 if (tp->write_seq == 0)
132 tp->write_seq = 1;
133 tp->rx_opt.ts_recent = tcptw->tw_ts_recent;
134 tp->rx_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp;
135 sock_hold(sktw);
136 return 1;
137 }
138
139 return 0;
140}
141
142EXPORT_SYMBOL_GPL(tcp_twsk_unique);
143
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144/* This will initiate an outgoing connection. */
145int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
146{
147 struct inet_sock *inet = inet_sk(sk);
148 struct tcp_sock *tp = tcp_sk(sk);
149 struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
150 struct rtable *rt;
Al Virobada8ad2006-09-26 21:27:15 -0700151 __be32 daddr, nexthop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 int tmp;
153 int err;
154
155 if (addr_len < sizeof(struct sockaddr_in))
156 return -EINVAL;
157
158 if (usin->sin_family != AF_INET)
159 return -EAFNOSUPPORT;
160
161 nexthop = daddr = usin->sin_addr.s_addr;
162 if (inet->opt && inet->opt->srr) {
163 if (!daddr)
164 return -EINVAL;
165 nexthop = inet->opt->faddr;
166 }
167
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000168 tmp = ip_route_connect(&rt, nexthop, inet->inet_saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
170 IPPROTO_TCP,
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000171 inet->inet_sport, usin->sin_port, sk, 1);
Wei Dong584bdf82007-05-31 22:49:28 -0700172 if (tmp < 0) {
173 if (tmp == -ENETUNREACH)
Pavel Emelyanov7c73a6f2008-07-16 20:20:11 -0700174 IP_INC_STATS_BH(sock_net(sk), IPSTATS_MIB_OUTNOROUTES);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 return tmp;
Wei Dong584bdf82007-05-31 22:49:28 -0700176 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177
178 if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
179 ip_rt_put(rt);
180 return -ENETUNREACH;
181 }
182
183 if (!inet->opt || !inet->opt->srr)
184 daddr = rt->rt_dst;
185
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000186 if (!inet->inet_saddr)
187 inet->inet_saddr = rt->rt_src;
188 inet->inet_rcv_saddr = inet->inet_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000190 if (tp->rx_opt.ts_recent_stamp && inet->inet_daddr != daddr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 /* Reset inherited state */
192 tp->rx_opt.ts_recent = 0;
193 tp->rx_opt.ts_recent_stamp = 0;
194 tp->write_seq = 0;
195 }
196
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -0700197 if (tcp_death_row.sysctl_tw_recycle &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 !tp->rx_opt.ts_recent_stamp && rt->rt_dst == daddr) {
199 struct inet_peer *peer = rt_get_peer(rt);
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200200 /*
201 * VJ's idea. We save last timestamp seen from
202 * the destination in peer table, when entering state
203 * TIME-WAIT * and initialize rx_opt.ts_recent from it,
204 * when trying new connection.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 */
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200206 if (peer != NULL &&
Eric Dumazet2c1409a2009-11-12 09:33:09 +0000207 (u32)get_seconds() - peer->tcp_ts_stamp <= TCP_PAWS_MSL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp;
209 tp->rx_opt.ts_recent = peer->tcp_ts;
210 }
211 }
212
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000213 inet->inet_dport = usin->sin_port;
214 inet->inet_daddr = daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800216 inet_csk(sk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 if (inet->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800218 inet_csk(sk)->icsk_ext_hdr_len = inet->opt->optlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219
William Allen Simpsonbee7ca92009-11-10 09:51:18 +0000220 tp->rx_opt.mss_clamp = TCP_MSS_DEFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221
222 /* Socket identity is still unknown (sport may be zero).
223 * However we set state to SYN-SENT and not releasing socket
224 * lock select source port, enter ourselves into the hash tables and
225 * complete initialization after this.
226 */
227 tcp_set_state(sk, TCP_SYN_SENT);
Arnaldo Carvalho de Meloa7f5e7f2005-12-13 23:25:31 -0800228 err = inet_hash_connect(&tcp_death_row, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 if (err)
230 goto failure;
231
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200232 err = ip_route_newports(&rt, IPPROTO_TCP,
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000233 inet->inet_sport, inet->inet_dport, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 if (err)
235 goto failure;
236
237 /* OK, now commit destination to socket. */
Herbert Xubcd76112006-06-30 13:36:35 -0700238 sk->sk_gso_type = SKB_GSO_TCPV4;
Arnaldo Carvalho de Melo6cbb0df2005-08-09 19:49:02 -0700239 sk_setup_caps(sk, &rt->u.dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240
241 if (!tp->write_seq)
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000242 tp->write_seq = secure_tcp_sequence_number(inet->inet_saddr,
243 inet->inet_daddr,
244 inet->inet_sport,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 usin->sin_port);
246
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000247 inet->inet_id = tp->write_seq ^ jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248
249 err = tcp_connect(sk);
250 rt = NULL;
251 if (err)
252 goto failure;
253
254 return 0;
255
256failure:
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200257 /*
258 * This unhashes the socket and releases the local port,
259 * if necessary.
260 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 tcp_set_state(sk, TCP_CLOSE);
262 ip_rt_put(rt);
263 sk->sk_route_caps = 0;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000264 inet->inet_dport = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 return err;
266}
267
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268/*
269 * This routine does path mtu discovery as defined in RFC1191.
270 */
Stephen Hemminger40efc6f2006-01-03 16:03:49 -0800271static void do_pmtu_discovery(struct sock *sk, struct iphdr *iph, u32 mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272{
273 struct dst_entry *dst;
274 struct inet_sock *inet = inet_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275
276 /* We are not interested in TCP_LISTEN and open_requests (SYN-ACKs
277 * send out by Linux are always <576bytes so they should go through
278 * unfragmented).
279 */
280 if (sk->sk_state == TCP_LISTEN)
281 return;
282
283 /* We don't check in the destentry if pmtu discovery is forbidden
284 * on this route. We just assume that no packet_to_big packets
285 * are send back when pmtu discovery is not active.
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900286 * There is a small race when the user changes this flag in the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 * route, but I think that's acceptable.
288 */
289 if ((dst = __sk_dst_check(sk, 0)) == NULL)
290 return;
291
292 dst->ops->update_pmtu(dst, mtu);
293
294 /* Something is about to be wrong... Remember soft error
295 * for the case, if this connection will not able to recover.
296 */
297 if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
298 sk->sk_err_soft = EMSGSIZE;
299
300 mtu = dst_mtu(dst);
301
302 if (inet->pmtudisc != IP_PMTUDISC_DONT &&
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800303 inet_csk(sk)->icsk_pmtu_cookie > mtu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 tcp_sync_mss(sk, mtu);
305
306 /* Resend the TCP packet because it's
307 * clear that the old packet has been
308 * dropped. This is the new "fast" path mtu
309 * discovery.
310 */
311 tcp_simple_retransmit(sk);
312 } /* else let the usual retransmit timer handle it */
313}
314
315/*
316 * This routine is called by the ICMP module when it gets some
317 * sort of error condition. If err < 0 then the socket should
318 * be closed and the error returned to the user. If err > 0
319 * it's just the icmp type << 8 | icmp code. After adjustment
320 * header points to the first 8 bytes of the tcp header. We need
321 * to find the appropriate port.
322 *
323 * The locking strategy used here is very "optimistic". When
324 * someone else accesses the socket the ICMP is just dropped
325 * and for some paths there is no check at all.
326 * A more general error queue to queue errors for later handling
327 * is probably better.
328 *
329 */
330
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000331void tcp_v4_err(struct sk_buff *icmp_skb, u32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332{
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000333 struct iphdr *iph = (struct iphdr *)icmp_skb->data;
334 struct tcphdr *th = (struct tcphdr *)(icmp_skb->data + (iph->ihl << 2));
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000335 struct inet_connection_sock *icsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 struct tcp_sock *tp;
337 struct inet_sock *inet;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000338 const int type = icmp_hdr(icmp_skb)->type;
339 const int code = icmp_hdr(icmp_skb)->code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 struct sock *sk;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000341 struct sk_buff *skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 __u32 seq;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000343 __u32 remaining;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 int err;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000345 struct net *net = dev_net(icmp_skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000347 if (icmp_skb->len < (iph->ihl << 2) + 8) {
Pavel Emelyanovdcfc23c2008-07-14 23:03:00 -0700348 ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 return;
350 }
351
Pavel Emelyanovfd54d712008-07-14 23:01:40 -0700352 sk = inet_lookup(net, &tcp_hashinfo, iph->daddr, th->dest,
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000353 iph->saddr, th->source, inet_iif(icmp_skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 if (!sk) {
Pavel Emelyanovdcfc23c2008-07-14 23:03:00 -0700355 ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 return;
357 }
358 if (sk->sk_state == TCP_TIME_WAIT) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700359 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 return;
361 }
362
363 bh_lock_sock(sk);
364 /* If too many ICMPs get dropped on busy
365 * servers this needs to be solved differently.
366 */
367 if (sock_owned_by_user(sk))
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700368 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369
370 if (sk->sk_state == TCP_CLOSE)
371 goto out;
372
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000373 icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 tp = tcp_sk(sk);
375 seq = ntohl(th->seq);
376 if (sk->sk_state != TCP_LISTEN &&
377 !between(seq, tp->snd_una, tp->snd_nxt)) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700378 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 goto out;
380 }
381
382 switch (type) {
383 case ICMP_SOURCE_QUENCH:
384 /* Just silently ignore these. */
385 goto out;
386 case ICMP_PARAMETERPROB:
387 err = EPROTO;
388 break;
389 case ICMP_DEST_UNREACH:
390 if (code > NR_ICMP_UNREACH)
391 goto out;
392
393 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
394 if (!sock_owned_by_user(sk))
395 do_pmtu_discovery(sk, iph, info);
396 goto out;
397 }
398
399 err = icmp_err_convert[code].errno;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000400 /* check if icmp_skb allows revert of backoff
401 * (see draft-zimmermann-tcp-lcd) */
402 if (code != ICMP_NET_UNREACH && code != ICMP_HOST_UNREACH)
403 break;
404 if (seq != tp->snd_una || !icsk->icsk_retransmits ||
405 !icsk->icsk_backoff)
406 break;
407
408 icsk->icsk_backoff--;
409 inet_csk(sk)->icsk_rto = __tcp_set_rto(tp) <<
410 icsk->icsk_backoff;
411 tcp_bound_rto(sk);
412
413 skb = tcp_write_queue_head(sk);
414 BUG_ON(!skb);
415
416 remaining = icsk->icsk_rto - min(icsk->icsk_rto,
417 tcp_time_stamp - TCP_SKB_CB(skb)->when);
418
419 if (remaining) {
420 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
421 remaining, TCP_RTO_MAX);
422 } else if (sock_owned_by_user(sk)) {
423 /* RTO revert clocked out retransmission,
424 * but socket is locked. Will defer. */
425 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
426 HZ/20, TCP_RTO_MAX);
427 } else {
428 /* RTO revert clocked out retransmission.
429 * Will retransmit now */
430 tcp_retransmit_timer(sk);
431 }
432
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 break;
434 case ICMP_TIME_EXCEEDED:
435 err = EHOSTUNREACH;
436 break;
437 default:
438 goto out;
439 }
440
441 switch (sk->sk_state) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700442 struct request_sock *req, **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 case TCP_LISTEN:
444 if (sock_owned_by_user(sk))
445 goto out;
446
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700447 req = inet_csk_search_req(sk, &prev, th->dest,
448 iph->daddr, iph->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 if (!req)
450 goto out;
451
452 /* ICMPs are not backlogged, hence we cannot get
453 an established socket here.
454 */
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700455 WARN_ON(req->sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700457 if (seq != tcp_rsk(req)->snt_isn) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700458 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 goto out;
460 }
461
462 /*
463 * Still in SYN_RECV, just remove it silently.
464 * There is no good way to pass the error to the newly
465 * created socket, and POSIX does not want network
466 * errors returned from accept().
467 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700468 inet_csk_reqsk_queue_drop(sk, req, prev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 goto out;
470
471 case TCP_SYN_SENT:
472 case TCP_SYN_RECV: /* Cannot happen.
473 It can f.e. if SYNs crossed.
474 */
475 if (!sock_owned_by_user(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 sk->sk_err = err;
477
478 sk->sk_error_report(sk);
479
480 tcp_done(sk);
481 } else {
482 sk->sk_err_soft = err;
483 }
484 goto out;
485 }
486
487 /* If we've already connected we will keep trying
488 * until we time out, or the user gives up.
489 *
490 * rfc1122 4.2.3.9 allows to consider as hard errors
491 * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
492 * but it is obsoleted by pmtu discovery).
493 *
494 * Note, that in modern internet, where routing is unreliable
495 * and in each dark corner broken firewalls sit, sending random
496 * errors ordered by their masters even this two messages finally lose
497 * their original sense (even Linux sends invalid PORT_UNREACHs)
498 *
499 * Now we are in compliance with RFCs.
500 * --ANK (980905)
501 */
502
503 inet = inet_sk(sk);
504 if (!sock_owned_by_user(sk) && inet->recverr) {
505 sk->sk_err = err;
506 sk->sk_error_report(sk);
507 } else { /* Only an error on timeout */
508 sk->sk_err_soft = err;
509 }
510
511out:
512 bh_unlock_sock(sk);
513 sock_put(sk);
514}
515
516/* This routine computes an IPv4 TCP checksum. */
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -0800517void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518{
519 struct inet_sock *inet = inet_sk(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700520 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521
Patrick McHardy84fa7932006-08-29 16:44:56 -0700522 if (skb->ip_summed == CHECKSUM_PARTIAL) {
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000523 th->check = ~tcp_v4_check(len, inet->inet_saddr,
524 inet->inet_daddr, 0);
Herbert Xu663ead32007-04-09 11:59:07 -0700525 skb->csum_start = skb_transport_header(skb) - skb->head;
Al Viroff1dcad2006-11-20 18:07:29 -0800526 skb->csum_offset = offsetof(struct tcphdr, check);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 } else {
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000528 th->check = tcp_v4_check(len, inet->inet_saddr,
529 inet->inet_daddr,
Joe Perches07f07572008-11-19 15:44:53 -0800530 csum_partial(th,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 th->doff << 2,
532 skb->csum));
533 }
534}
535
Herbert Xua430a432006-07-08 13:34:56 -0700536int tcp_v4_gso_send_check(struct sk_buff *skb)
537{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700538 const struct iphdr *iph;
Herbert Xua430a432006-07-08 13:34:56 -0700539 struct tcphdr *th;
540
541 if (!pskb_may_pull(skb, sizeof(*th)))
542 return -EINVAL;
543
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700544 iph = ip_hdr(skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700545 th = tcp_hdr(skb);
Herbert Xua430a432006-07-08 13:34:56 -0700546
547 th->check = 0;
Frederik Deweerdtba7808e2007-02-04 20:15:27 -0800548 th->check = ~tcp_v4_check(skb->len, iph->saddr, iph->daddr, 0);
Herbert Xu663ead32007-04-09 11:59:07 -0700549 skb->csum_start = skb_transport_header(skb) - skb->head;
Al Viroff1dcad2006-11-20 18:07:29 -0800550 skb->csum_offset = offsetof(struct tcphdr, check);
Patrick McHardy84fa7932006-08-29 16:44:56 -0700551 skb->ip_summed = CHECKSUM_PARTIAL;
Herbert Xua430a432006-07-08 13:34:56 -0700552 return 0;
553}
554
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555/*
556 * This routine will send an RST to the other tcp.
557 *
558 * Someone asks: why I NEVER use socket parameters (TOS, TTL etc.)
559 * for reset.
560 * Answer: if a packet caused RST, it is not for a socket
561 * existing in our system, if it is matched to a socket,
562 * it is just duplicate segment or bug in other side's TCP.
563 * So that we build reply only basing on parameters
564 * arrived with segment.
565 * Exception: precedence violation. We do not implement it in any case.
566 */
567
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800568static void tcp_v4_send_reset(struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700570 struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800571 struct {
572 struct tcphdr th;
573#ifdef CONFIG_TCP_MD5SIG
Al Viro714e85b2006-11-14 20:51:49 -0800574 __be32 opt[(TCPOLEN_MD5SIG_ALIGNED >> 2)];
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800575#endif
576 } rep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 struct ip_reply_arg arg;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800578#ifdef CONFIG_TCP_MD5SIG
579 struct tcp_md5sig_key *key;
580#endif
Pavel Emelyanova86b1e32008-07-16 20:20:58 -0700581 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582
583 /* Never send a reset in response to a reset. */
584 if (th->rst)
585 return;
586
Eric Dumazet511c3f92009-06-02 05:14:27 +0000587 if (skb_rtable(skb)->rt_type != RTN_LOCAL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 return;
589
590 /* Swap the send and the receive. */
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800591 memset(&rep, 0, sizeof(rep));
592 rep.th.dest = th->source;
593 rep.th.source = th->dest;
594 rep.th.doff = sizeof(struct tcphdr) / 4;
595 rep.th.rst = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596
597 if (th->ack) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800598 rep.th.seq = th->ack_seq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800600 rep.th.ack = 1;
601 rep.th.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
602 skb->len - (th->doff << 2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 }
604
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200605 memset(&arg, 0, sizeof(arg));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800606 arg.iov[0].iov_base = (unsigned char *)&rep;
607 arg.iov[0].iov_len = sizeof(rep.th);
608
609#ifdef CONFIG_TCP_MD5SIG
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700610 key = sk ? tcp_v4_md5_do_lookup(sk, ip_hdr(skb)->daddr) : NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800611 if (key) {
612 rep.opt[0] = htonl((TCPOPT_NOP << 24) |
613 (TCPOPT_NOP << 16) |
614 (TCPOPT_MD5SIG << 8) |
615 TCPOLEN_MD5SIG);
616 /* Update length and the length the header thinks exists */
617 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
618 rep.th.doff = arg.iov[0].iov_len / 4;
619
Adam Langley49a72df2008-07-19 00:01:42 -0700620 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[1],
Ilpo Järvinen78e645cb2008-10-09 14:37:47 -0700621 key, ip_hdr(skb)->saddr,
622 ip_hdr(skb)->daddr, &rep.th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800623 }
624#endif
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700625 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
626 ip_hdr(skb)->saddr, /* XXX */
Ilpo Järvinen52cd5752008-10-08 11:34:06 -0700627 arg.iov[0].iov_len, IPPROTO_TCP, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700629 arg.flags = (sk && inet_sk(sk)->transparent) ? IP_REPLY_ARG_NOSRCCHECK : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630
Eric Dumazetadf30902009-06-02 05:19:30 +0000631 net = dev_net(skb_dst(skb)->dev);
Pavel Emelyanova86b1e32008-07-16 20:20:58 -0700632 ip_send_reply(net->ipv4.tcp_sock, skb,
Denis V. Lunev7feb49c2008-04-03 14:32:00 -0700633 &arg, arg.iov[0].iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634
Pavel Emelyanov63231bd2008-07-16 20:22:25 -0700635 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
636 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637}
638
639/* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
640 outside socket context is ugly, certainly. What can I do?
641 */
642
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900643static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
644 u32 win, u32 ts, int oif,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700645 struct tcp_md5sig_key *key,
646 int reply_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700648 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 struct {
650 struct tcphdr th;
Al Viro714e85b2006-11-14 20:51:49 -0800651 __be32 opt[(TCPOLEN_TSTAMP_ALIGNED >> 2)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800652#ifdef CONFIG_TCP_MD5SIG
Al Viro714e85b2006-11-14 20:51:49 -0800653 + (TCPOLEN_MD5SIG_ALIGNED >> 2)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800654#endif
655 ];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 } rep;
657 struct ip_reply_arg arg;
Eric Dumazetadf30902009-06-02 05:19:30 +0000658 struct net *net = dev_net(skb_dst(skb)->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659
660 memset(&rep.th, 0, sizeof(struct tcphdr));
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200661 memset(&arg, 0, sizeof(arg));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662
663 arg.iov[0].iov_base = (unsigned char *)&rep;
664 arg.iov[0].iov_len = sizeof(rep.th);
665 if (ts) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800666 rep.opt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
667 (TCPOPT_TIMESTAMP << 8) |
668 TCPOLEN_TIMESTAMP);
669 rep.opt[1] = htonl(tcp_time_stamp);
670 rep.opt[2] = htonl(ts);
Craig Schlentercb48cfe2007-01-09 00:11:15 -0800671 arg.iov[0].iov_len += TCPOLEN_TSTAMP_ALIGNED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 }
673
674 /* Swap the send and the receive. */
675 rep.th.dest = th->source;
676 rep.th.source = th->dest;
677 rep.th.doff = arg.iov[0].iov_len / 4;
678 rep.th.seq = htonl(seq);
679 rep.th.ack_seq = htonl(ack);
680 rep.th.ack = 1;
681 rep.th.window = htons(win);
682
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800683#ifdef CONFIG_TCP_MD5SIG
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800684 if (key) {
685 int offset = (ts) ? 3 : 0;
686
687 rep.opt[offset++] = htonl((TCPOPT_NOP << 24) |
688 (TCPOPT_NOP << 16) |
689 (TCPOPT_MD5SIG << 8) |
690 TCPOLEN_MD5SIG);
691 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
692 rep.th.doff = arg.iov[0].iov_len/4;
693
Adam Langley49a72df2008-07-19 00:01:42 -0700694 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[offset],
Adam Langley90b7e112008-07-31 20:49:48 -0700695 key, ip_hdr(skb)->saddr,
696 ip_hdr(skb)->daddr, &rep.th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800697 }
698#endif
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700699 arg.flags = reply_flags;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700700 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
701 ip_hdr(skb)->saddr, /* XXX */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 arg.iov[0].iov_len, IPPROTO_TCP, 0);
703 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900704 if (oif)
705 arg.bound_dev_if = oif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706
Pavel Emelyanova86b1e32008-07-16 20:20:58 -0700707 ip_send_reply(net->ipv4.tcp_sock, skb,
Denis V. Lunev7feb49c2008-04-03 14:32:00 -0700708 &arg, arg.iov[0].iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709
Pavel Emelyanov63231bd2008-07-16 20:22:25 -0700710 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711}
712
713static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
714{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700715 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800716 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900718 tcp_v4_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200719 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900720 tcptw->tw_ts_recent,
721 tw->tw_bound_dev_if,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700722 tcp_twsk_md5_key(tcptw),
723 tw->tw_transparent ? IP_REPLY_ARG_NOSRCCHECK : 0
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900724 );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700726 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727}
728
Gui Jianfeng6edafaa2008-08-06 23:50:04 -0700729static void tcp_v4_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200730 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731{
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900732 tcp_v4_send_ack(skb, tcp_rsk(req)->snt_isn + 1,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800733 tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900734 req->ts_recent,
735 0,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700736 tcp_v4_md5_do_lookup(sk, ip_hdr(skb)->daddr),
737 inet_rsk(req)->no_srccheck ? IP_REPLY_ARG_NOSRCCHECK : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738}
739
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740/*
Kris Katterjohn9bf1d832008-02-17 22:29:19 -0800741 * Send a SYN-ACK after having received a SYN.
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700742 * This still operates on a request_sock only, not on a big
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 * socket.
744 */
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000745static int __tcp_v4_send_synack(struct sock *sk, struct dst_entry *dst,
746 struct request_sock *req,
747 struct request_values *rvp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700749 const struct inet_request_sock *ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 int err = -1;
751 struct sk_buff * skb;
752
753 /* First, grab a route. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700754 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800755 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000757 skb = tcp_make_synack(sk, dst, req, rvp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758
759 if (skb) {
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700760 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761
Frederik Deweerdtba7808e2007-02-04 20:15:27 -0800762 th->check = tcp_v4_check(skb->len,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700763 ireq->loc_addr,
764 ireq->rmt_addr,
Joe Perches07f07572008-11-19 15:44:53 -0800765 csum_partial(th, skb->len,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 skb->csum));
767
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700768 err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,
769 ireq->rmt_addr,
770 ireq->opt);
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200771 err = net_xmit_eval(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 }
773
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 dst_release(dst);
775 return err;
776}
777
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000778static int tcp_v4_send_synack(struct sock *sk, struct request_sock *req,
779 struct request_values *rvp)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800780{
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000781 return __tcp_v4_send_synack(sk, NULL, req, rvp);
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800782}
783
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700785 * IPv4 request_sock destructor.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 */
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700787static void tcp_v4_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788{
Jesper Juhla51482b2005-11-08 09:41:34 -0800789 kfree(inet_rsk(req)->opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790}
791
Arnaldo Carvalho de Melo80e40da2006-01-04 01:58:06 -0200792#ifdef CONFIG_SYN_COOKIES
Stephen Hemminger40efc6f2006-01-03 16:03:49 -0800793static void syn_flood_warning(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794{
795 static unsigned long warntime;
796
797 if (time_after(jiffies, (warntime + HZ * 60))) {
798 warntime = jiffies;
799 printk(KERN_INFO
800 "possible SYN flooding on port %d. Sending cookies.\n",
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700801 ntohs(tcp_hdr(skb)->dest));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 }
803}
Arnaldo Carvalho de Melo80e40da2006-01-04 01:58:06 -0200804#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805
806/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700807 * Save and compile IPv4 options into the request_sock if needed.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 */
Stephen Hemminger40efc6f2006-01-03 16:03:49 -0800809static struct ip_options *tcp_v4_save_options(struct sock *sk,
810 struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811{
812 struct ip_options *opt = &(IPCB(skb)->opt);
813 struct ip_options *dopt = NULL;
814
815 if (opt && opt->optlen) {
816 int opt_size = optlength(opt);
817 dopt = kmalloc(opt_size, GFP_ATOMIC);
818 if (dopt) {
819 if (ip_options_echo(dopt, skb)) {
820 kfree(dopt);
821 dopt = NULL;
822 }
823 }
824 }
825 return dopt;
826}
827
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800828#ifdef CONFIG_TCP_MD5SIG
829/*
830 * RFC2385 MD5 checksumming requires a mapping of
831 * IP address->MD5 Key.
832 * We need to maintain these in the sk structure.
833 */
834
835/* Find the Key structure for an address. */
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200836static struct tcp_md5sig_key *
837 tcp_v4_md5_do_lookup(struct sock *sk, __be32 addr)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800838{
839 struct tcp_sock *tp = tcp_sk(sk);
840 int i;
841
842 if (!tp->md5sig_info || !tp->md5sig_info->entries4)
843 return NULL;
844 for (i = 0; i < tp->md5sig_info->entries4; i++) {
845 if (tp->md5sig_info->keys4[i].addr == addr)
David S. Millerf8ab18d2007-09-28 15:18:35 -0700846 return &tp->md5sig_info->keys4[i].base;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800847 }
848 return NULL;
849}
850
851struct tcp_md5sig_key *tcp_v4_md5_lookup(struct sock *sk,
852 struct sock *addr_sk)
853{
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000854 return tcp_v4_md5_do_lookup(sk, inet_sk(addr_sk)->inet_daddr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800855}
856
857EXPORT_SYMBOL(tcp_v4_md5_lookup);
858
Adrian Bunkf5b99bc2006-11-30 17:22:29 -0800859static struct tcp_md5sig_key *tcp_v4_reqsk_md5_lookup(struct sock *sk,
860 struct request_sock *req)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800861{
862 return tcp_v4_md5_do_lookup(sk, inet_rsk(req)->rmt_addr);
863}
864
865/* This can be called on a newly created socket, from other files */
866int tcp_v4_md5_do_add(struct sock *sk, __be32 addr,
867 u8 *newkey, u8 newkeylen)
868{
869 /* Add Key to the list */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700870 struct tcp_md5sig_key *key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800871 struct tcp_sock *tp = tcp_sk(sk);
872 struct tcp4_md5sig_key *keys;
873
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700874 key = tcp_v4_md5_do_lookup(sk, addr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800875 if (key) {
876 /* Pre-existing entry - just update that one. */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700877 kfree(key->key);
878 key->key = newkey;
879 key->keylen = newkeylen;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800880 } else {
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200881 struct tcp_md5sig_info *md5sig;
882
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800883 if (!tp->md5sig_info) {
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200884 tp->md5sig_info = kzalloc(sizeof(*tp->md5sig_info),
885 GFP_ATOMIC);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800886 if (!tp->md5sig_info) {
887 kfree(newkey);
888 return -ENOMEM;
889 }
David S. Miller3d7dbea2007-06-12 14:36:42 -0700890 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800891 }
Wu Fengguangaa133072009-09-02 23:45:45 -0700892 if (tcp_alloc_md5sig_pool(sk) == NULL) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800893 kfree(newkey);
894 return -ENOMEM;
895 }
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200896 md5sig = tp->md5sig_info;
897
898 if (md5sig->alloced4 == md5sig->entries4) {
899 keys = kmalloc((sizeof(*keys) *
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900900 (md5sig->entries4 + 1)), GFP_ATOMIC);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800901 if (!keys) {
902 kfree(newkey);
903 tcp_free_md5sig_pool();
904 return -ENOMEM;
905 }
906
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200907 if (md5sig->entries4)
908 memcpy(keys, md5sig->keys4,
909 sizeof(*keys) * md5sig->entries4);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800910
911 /* Free old key list, and reference new one */
YOSHIFUJI Hideakia80cc202007-11-20 17:30:06 -0800912 kfree(md5sig->keys4);
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200913 md5sig->keys4 = keys;
914 md5sig->alloced4++;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800915 }
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200916 md5sig->entries4++;
David S. Millerf8ab18d2007-09-28 15:18:35 -0700917 md5sig->keys4[md5sig->entries4 - 1].addr = addr;
918 md5sig->keys4[md5sig->entries4 - 1].base.key = newkey;
919 md5sig->keys4[md5sig->entries4 - 1].base.keylen = newkeylen;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800920 }
921 return 0;
922}
923
924EXPORT_SYMBOL(tcp_v4_md5_do_add);
925
926static int tcp_v4_md5_add_func(struct sock *sk, struct sock *addr_sk,
927 u8 *newkey, u8 newkeylen)
928{
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000929 return tcp_v4_md5_do_add(sk, inet_sk(addr_sk)->inet_daddr,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800930 newkey, newkeylen);
931}
932
933int tcp_v4_md5_do_del(struct sock *sk, __be32 addr)
934{
935 struct tcp_sock *tp = tcp_sk(sk);
936 int i;
937
938 for (i = 0; i < tp->md5sig_info->entries4; i++) {
939 if (tp->md5sig_info->keys4[i].addr == addr) {
940 /* Free the key */
David S. Millerf8ab18d2007-09-28 15:18:35 -0700941 kfree(tp->md5sig_info->keys4[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800942 tp->md5sig_info->entries4--;
943
944 if (tp->md5sig_info->entries4 == 0) {
945 kfree(tp->md5sig_info->keys4);
946 tp->md5sig_info->keys4 = NULL;
Leigh Brown8228a18d2006-12-17 17:12:30 -0800947 tp->md5sig_info->alloced4 = 0;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200948 } else if (tp->md5sig_info->entries4 != i) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800949 /* Need to do some manipulation */
YOSHIFUJI Hideaki354faf02007-11-20 17:30:31 -0800950 memmove(&tp->md5sig_info->keys4[i],
951 &tp->md5sig_info->keys4[i+1],
952 (tp->md5sig_info->entries4 - i) *
953 sizeof(struct tcp4_md5sig_key));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800954 }
955 tcp_free_md5sig_pool();
956 return 0;
957 }
958 }
959 return -ENOENT;
960}
961
962EXPORT_SYMBOL(tcp_v4_md5_do_del);
963
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200964static void tcp_v4_clear_md5_list(struct sock *sk)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800965{
966 struct tcp_sock *tp = tcp_sk(sk);
967
968 /* Free each key, then the set of key keys,
969 * the crypto element, and then decrement our
970 * hold on the last resort crypto.
971 */
972 if (tp->md5sig_info->entries4) {
973 int i;
974 for (i = 0; i < tp->md5sig_info->entries4; i++)
David S. Millerf8ab18d2007-09-28 15:18:35 -0700975 kfree(tp->md5sig_info->keys4[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800976 tp->md5sig_info->entries4 = 0;
977 tcp_free_md5sig_pool();
978 }
979 if (tp->md5sig_info->keys4) {
980 kfree(tp->md5sig_info->keys4);
981 tp->md5sig_info->keys4 = NULL;
982 tp->md5sig_info->alloced4 = 0;
983 }
984}
985
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200986static int tcp_v4_parse_md5_keys(struct sock *sk, char __user *optval,
987 int optlen)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800988{
989 struct tcp_md5sig cmd;
990 struct sockaddr_in *sin = (struct sockaddr_in *)&cmd.tcpm_addr;
991 u8 *newkey;
992
993 if (optlen < sizeof(cmd))
994 return -EINVAL;
995
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200996 if (copy_from_user(&cmd, optval, sizeof(cmd)))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800997 return -EFAULT;
998
999 if (sin->sin_family != AF_INET)
1000 return -EINVAL;
1001
1002 if (!cmd.tcpm_key || !cmd.tcpm_keylen) {
1003 if (!tcp_sk(sk)->md5sig_info)
1004 return -ENOENT;
1005 return tcp_v4_md5_do_del(sk, sin->sin_addr.s_addr);
1006 }
1007
1008 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
1009 return -EINVAL;
1010
1011 if (!tcp_sk(sk)->md5sig_info) {
1012 struct tcp_sock *tp = tcp_sk(sk);
Wu Fengguangaa133072009-09-02 23:45:45 -07001013 struct tcp_md5sig_info *p;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001014
Wu Fengguangaa133072009-09-02 23:45:45 -07001015 p = kzalloc(sizeof(*p), sk->sk_allocation);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001016 if (!p)
1017 return -EINVAL;
1018
1019 tp->md5sig_info = p;
David S. Miller3d7dbea2007-06-12 14:36:42 -07001020 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001021 }
1022
Wu Fengguangaa133072009-09-02 23:45:45 -07001023 newkey = kmemdup(cmd.tcpm_key, cmd.tcpm_keylen, sk->sk_allocation);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001024 if (!newkey)
1025 return -ENOMEM;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001026 return tcp_v4_md5_do_add(sk, sin->sin_addr.s_addr,
1027 newkey, cmd.tcpm_keylen);
1028}
1029
Adam Langley49a72df2008-07-19 00:01:42 -07001030static int tcp_v4_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
1031 __be32 daddr, __be32 saddr, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001032{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001033 struct tcp4_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -07001034 struct scatterlist sg;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001035
1036 bp = &hp->md5_blk.ip4;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001037
1038 /*
Adam Langley49a72df2008-07-19 00:01:42 -07001039 * 1. the TCP pseudo-header (in the order: source IP address,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001040 * destination IP address, zero-padded protocol number, and
1041 * segment length)
1042 */
1043 bp->saddr = saddr;
1044 bp->daddr = daddr;
1045 bp->pad = 0;
YOSHIFUJI Hideaki076fb722008-04-17 12:48:12 +09001046 bp->protocol = IPPROTO_TCP;
Adam Langley49a72df2008-07-19 00:01:42 -07001047 bp->len = cpu_to_be16(nbytes);
David S. Millerc7da57a2007-10-26 00:41:21 -07001048
Adam Langley49a72df2008-07-19 00:01:42 -07001049 sg_init_one(&sg, bp, sizeof(*bp));
1050 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
1051}
1052
1053static int tcp_v4_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
1054 __be32 daddr, __be32 saddr, struct tcphdr *th)
1055{
1056 struct tcp_md5sig_pool *hp;
1057 struct hash_desc *desc;
1058
1059 hp = tcp_get_md5sig_pool();
1060 if (!hp)
1061 goto clear_hash_noput;
1062 desc = &hp->md5_desc;
1063
1064 if (crypto_hash_init(desc))
1065 goto clear_hash;
1066 if (tcp_v4_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
1067 goto clear_hash;
1068 if (tcp_md5_hash_header(hp, th))
1069 goto clear_hash;
1070 if (tcp_md5_hash_key(hp, key))
1071 goto clear_hash;
1072 if (crypto_hash_final(desc, md5_hash))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001073 goto clear_hash;
1074
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001075 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001076 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -07001077
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001078clear_hash:
1079 tcp_put_md5sig_pool();
1080clear_hash_noput:
1081 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -07001082 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001083}
1084
Adam Langley49a72df2008-07-19 00:01:42 -07001085int tcp_v4_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
1086 struct sock *sk, struct request_sock *req,
1087 struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001088{
Adam Langley49a72df2008-07-19 00:01:42 -07001089 struct tcp_md5sig_pool *hp;
1090 struct hash_desc *desc;
1091 struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001092 __be32 saddr, daddr;
1093
1094 if (sk) {
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001095 saddr = inet_sk(sk)->inet_saddr;
1096 daddr = inet_sk(sk)->inet_daddr;
Adam Langley49a72df2008-07-19 00:01:42 -07001097 } else if (req) {
1098 saddr = inet_rsk(req)->loc_addr;
1099 daddr = inet_rsk(req)->rmt_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001100 } else {
Adam Langley49a72df2008-07-19 00:01:42 -07001101 const struct iphdr *iph = ip_hdr(skb);
1102 saddr = iph->saddr;
1103 daddr = iph->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001104 }
Adam Langley49a72df2008-07-19 00:01:42 -07001105
1106 hp = tcp_get_md5sig_pool();
1107 if (!hp)
1108 goto clear_hash_noput;
1109 desc = &hp->md5_desc;
1110
1111 if (crypto_hash_init(desc))
1112 goto clear_hash;
1113
1114 if (tcp_v4_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
1115 goto clear_hash;
1116 if (tcp_md5_hash_header(hp, th))
1117 goto clear_hash;
1118 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
1119 goto clear_hash;
1120 if (tcp_md5_hash_key(hp, key))
1121 goto clear_hash;
1122 if (crypto_hash_final(desc, md5_hash))
1123 goto clear_hash;
1124
1125 tcp_put_md5sig_pool();
1126 return 0;
1127
1128clear_hash:
1129 tcp_put_md5sig_pool();
1130clear_hash_noput:
1131 memset(md5_hash, 0, 16);
1132 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001133}
1134
Adam Langley49a72df2008-07-19 00:01:42 -07001135EXPORT_SYMBOL(tcp_v4_md5_hash_skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001136
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001137static int tcp_v4_inbound_md5_hash(struct sock *sk, struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001138{
1139 /*
1140 * This gets called for each TCP segment that arrives
1141 * so we want to be efficient.
1142 * We have 3 drop cases:
1143 * o No MD5 hash and one expected.
1144 * o MD5 hash and we're not expecting one.
1145 * o MD5 hash and its wrong.
1146 */
1147 __u8 *hash_location = NULL;
1148 struct tcp_md5sig_key *hash_expected;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001149 const struct iphdr *iph = ip_hdr(skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001150 struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001151 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001152 unsigned char newhash[16];
1153
1154 hash_expected = tcp_v4_md5_do_lookup(sk, iph->saddr);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +09001155 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001156
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001157 /* We've parsed the options - do we have a hash? */
1158 if (!hash_expected && !hash_location)
1159 return 0;
1160
1161 if (hash_expected && !hash_location) {
David S. Miller785957d2008-07-30 03:03:15 -07001162 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001163 return 1;
1164 }
1165
1166 if (!hash_expected && hash_location) {
David S. Miller785957d2008-07-30 03:03:15 -07001167 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001168 return 1;
1169 }
1170
1171 /* Okay, so this is hash_expected and hash_location -
1172 * so we need to calculate the checksum.
1173 */
Adam Langley49a72df2008-07-19 00:01:42 -07001174 genhash = tcp_v4_md5_hash_skb(newhash,
1175 hash_expected,
1176 NULL, NULL, skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001177
1178 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
1179 if (net_ratelimit()) {
Harvey Harrison673d57e2008-10-31 00:53:57 -07001180 printk(KERN_INFO "MD5 Hash failed for (%pI4, %d)->(%pI4, %d)%s\n",
1181 &iph->saddr, ntohs(th->source),
1182 &iph->daddr, ntohs(th->dest),
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001183 genhash ? " tcp_v4_calc_md5_hash failed" : "");
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001184 }
1185 return 1;
1186 }
1187 return 0;
1188}
1189
1190#endif
1191
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001192struct request_sock_ops tcp_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 .family = PF_INET,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001194 .obj_size = sizeof(struct tcp_request_sock),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 .rtx_syn_ack = tcp_v4_send_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001196 .send_ack = tcp_v4_reqsk_send_ack,
1197 .destructor = tcp_v4_reqsk_destructor,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198 .send_reset = tcp_v4_send_reset,
1199};
1200
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001201#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001202static const struct tcp_request_sock_ops tcp_request_sock_ipv4_ops = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001203 .md5_lookup = tcp_v4_reqsk_md5_lookup,
John Dykstrae3afe7b2009-07-16 05:04:51 +00001204 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001205};
Andrew Mortonb6332e62006-11-30 19:16:28 -08001206#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001207
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08001208static struct timewait_sock_ops tcp_timewait_sock_ops = {
1209 .twsk_obj_size = sizeof(struct tcp_timewait_sock),
1210 .twsk_unique = tcp_twsk_unique,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001211 .twsk_destructor= tcp_twsk_destructor,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08001212};
1213
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1215{
William Allen Simpson4957faade2009-12-02 18:25:27 +00001216 struct tcp_extend_values tmp_ext;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217 struct tcp_options_received tmp_opt;
William Allen Simpson4957faade2009-12-02 18:25:27 +00001218 u8 *hash_location;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001219 struct request_sock *req;
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001220 struct inet_request_sock *ireq;
William Allen Simpson4957faade2009-12-02 18:25:27 +00001221 struct tcp_sock *tp = tcp_sk(sk);
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001222 struct dst_entry *dst = NULL;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001223 __be32 saddr = ip_hdr(skb)->saddr;
1224 __be32 daddr = ip_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 __u32 isn = TCP_SKB_CB(skb)->when;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226#ifdef CONFIG_SYN_COOKIES
1227 int want_cookie = 0;
1228#else
1229#define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */
1230#endif
1231
1232 /* Never answer to SYNs send to broadcast or multicast */
Eric Dumazet511c3f92009-06-02 05:14:27 +00001233 if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 goto drop;
1235
1236 /* TW buckets are converted to open requests without
1237 * limitations, they conserve resources and peer is
1238 * evidently real one.
1239 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001240 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241#ifdef CONFIG_SYN_COOKIES
1242 if (sysctl_tcp_syncookies) {
1243 want_cookie = 1;
1244 } else
1245#endif
1246 goto drop;
1247 }
1248
1249 /* Accept backlog is full. If we have already queued enough
1250 * of warm entries in syn queue, drop request. It is better than
1251 * clogging syn queue with openreqs with exponentially increasing
1252 * timeout.
1253 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001254 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 goto drop;
1256
Arnaldo Carvalho de Meloce4a7d02008-06-10 12:39:35 -07001257 req = inet_reqsk_alloc(&tcp_request_sock_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 if (!req)
1259 goto drop;
1260
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001261#ifdef CONFIG_TCP_MD5SIG
1262 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv4_ops;
1263#endif
1264
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 tcp_clear_options(&tmp_opt);
William Allen Simpsonbee7ca92009-11-10 09:51:18 +00001266 tmp_opt.mss_clamp = TCP_MSS_DEFAULT;
William Allen Simpson4957faade2009-12-02 18:25:27 +00001267 tmp_opt.user_mss = tp->rx_opt.user_mss;
David S. Millerbb5b7c12009-12-15 20:56:42 -08001268 tcp_parse_options(skb, &tmp_opt, &hash_location, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269
William Allen Simpson4957faade2009-12-02 18:25:27 +00001270 if (tmp_opt.cookie_plus > 0 &&
1271 tmp_opt.saw_tstamp &&
1272 !tp->rx_opt.cookie_out_never &&
1273 (sysctl_tcp_cookie_size > 0 ||
1274 (tp->cookie_values != NULL &&
1275 tp->cookie_values->cookie_desired > 0))) {
1276 u8 *c;
1277 u32 *mess = &tmp_ext.cookie_bakery[COOKIE_DIGEST_WORDS];
1278 int l = tmp_opt.cookie_plus - TCPOLEN_COOKIE_BASE;
1279
1280 if (tcp_cookie_generator(&tmp_ext.cookie_bakery[0]) != 0)
1281 goto drop_and_release;
1282
1283 /* Secret recipe starts with IP addresses */
1284 *mess++ ^= daddr;
1285 *mess++ ^= saddr;
1286
1287 /* plus variable length Initiator Cookie */
1288 c = (u8 *)mess;
1289 while (l-- > 0)
1290 *c++ ^= *hash_location++;
1291
1292#ifdef CONFIG_SYN_COOKIES
1293 want_cookie = 0; /* not our kind of cookie */
1294#endif
1295 tmp_ext.cookie_out_never = 0; /* false */
1296 tmp_ext.cookie_plus = tmp_opt.cookie_plus;
1297 } else if (!tp->rx_opt.cookie_in_always) {
1298 /* redundant indications, but ensure initialization. */
1299 tmp_ext.cookie_out_never = 1; /* true */
1300 tmp_ext.cookie_plus = 0;
1301 } else {
1302 goto drop_and_release;
1303 }
1304 tmp_ext.cookie_in_always = tp->rx_opt.cookie_in_always;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305
Florian Westphal4dfc2812008-04-10 03:12:40 -07001306 if (want_cookie && !tmp_opt.saw_tstamp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 tcp_clear_options(&tmp_opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 tcp_openreq_init(req, &tmp_opt, skb);
1311
David S. Millerbb5b7c12009-12-15 20:56:42 -08001312 ireq = inet_rsk(req);
1313 ireq->loc_addr = daddr;
1314 ireq->rmt_addr = saddr;
1315 ireq->no_srccheck = inet_sk(sk)->transparent;
1316 ireq->opt = tcp_v4_save_options(sk, skb);
1317
Paul Moore284904a2009-03-27 17:10:28 -04001318 if (security_inet_conn_request(sk, skb, req))
David S. Millerbb5b7c12009-12-15 20:56:42 -08001319 goto drop_and_free;
Paul Moore284904a2009-03-27 17:10:28 -04001320
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 if (!want_cookie)
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001322 TCP_ECN_create_request(req, tcp_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323
1324 if (want_cookie) {
1325#ifdef CONFIG_SYN_COOKIES
1326 syn_flood_warning(skb);
Florian Westphal4dfc2812008-04-10 03:12:40 -07001327 req->cookie_ts = tmp_opt.tstamp_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328#endif
1329 isn = cookie_v4_init_sequence(sk, skb, &req->mss);
1330 } else if (!isn) {
1331 struct inet_peer *peer = NULL;
1332
1333 /* VJ's idea. We save last timestamp seen
1334 * from the destination in peer table, when entering
1335 * state TIME-WAIT, and check against it before
1336 * accepting new connection request.
1337 *
1338 * If "isn" is not zero, this request hit alive
1339 * timewait bucket, so that all the necessary checks
1340 * are made in the function processing timewait state.
1341 */
1342 if (tmp_opt.saw_tstamp &&
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001343 tcp_death_row.sysctl_tw_recycle &&
David S. Millerbb5b7c12009-12-15 20:56:42 -08001344 (dst = inet_csk_route_req(sk, req)) != NULL &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 (peer = rt_get_peer((struct rtable *)dst)) != NULL &&
1346 peer->v4daddr == saddr) {
Eric Dumazet2c1409a2009-11-12 09:33:09 +00001347 if ((u32)get_seconds() - peer->tcp_ts_stamp < TCP_PAWS_MSL &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 (s32)(peer->tcp_ts - req->ts_recent) >
1349 TCP_PAWS_WINDOW) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001350 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001351 goto drop_and_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 }
1353 }
1354 /* Kill the following clause, if you dislike this way. */
1355 else if (!sysctl_tcp_syncookies &&
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001356 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 (sysctl_max_syn_backlog >> 2)) &&
1358 (!peer || !peer->tcp_ts_stamp) &&
1359 (!dst || !dst_metric(dst, RTAX_RTT))) {
1360 /* Without syncookies last quarter of
1361 * backlog is filled with destinations,
1362 * proven to be alive.
1363 * It means that we continue to communicate
1364 * to destinations, already remembered
1365 * to the moment of synflood.
1366 */
Harvey Harrison673d57e2008-10-31 00:53:57 -07001367 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open request from %pI4/%u\n",
1368 &saddr, ntohs(tcp_hdr(skb)->source));
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001369 goto drop_and_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 }
1371
Gerrit Renkera94f7232006-11-10 14:06:49 -08001372 isn = tcp_v4_init_sequence(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 }
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001374 tcp_rsk(req)->snt_isn = isn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375
William Allen Simpson4957faade2009-12-02 18:25:27 +00001376 if (__tcp_v4_send_synack(sk, dst, req,
1377 (struct request_values *)&tmp_ext) ||
1378 want_cookie)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379 goto drop_and_free;
1380
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001381 inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 return 0;
1383
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001384drop_and_release:
1385 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386drop_and_free:
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001387 reqsk_free(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388drop:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 return 0;
1390}
1391
1392
1393/*
1394 * The three way handshake has completed - we got a valid synack -
1395 * now create the new socket.
1396 */
1397struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001398 struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 struct dst_entry *dst)
1400{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001401 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 struct inet_sock *newinet;
1403 struct tcp_sock *newtp;
1404 struct sock *newsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001405#ifdef CONFIG_TCP_MD5SIG
1406 struct tcp_md5sig_key *key;
1407#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408
1409 if (sk_acceptq_is_full(sk))
1410 goto exit_overflow;
1411
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001412 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 goto exit;
1414
1415 newsk = tcp_create_openreq_child(sk, req, skb);
1416 if (!newsk)
1417 goto exit;
1418
Herbert Xubcd76112006-06-30 13:36:35 -07001419 newsk->sk_gso_type = SKB_GSO_TCPV4;
Arnaldo Carvalho de Melo6cbb0df2005-08-09 19:49:02 -07001420 sk_setup_caps(newsk, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421
1422 newtp = tcp_sk(newsk);
1423 newinet = inet_sk(newsk);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001424 ireq = inet_rsk(req);
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001425 newinet->inet_daddr = ireq->rmt_addr;
1426 newinet->inet_rcv_saddr = ireq->loc_addr;
1427 newinet->inet_saddr = ireq->loc_addr;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001428 newinet->opt = ireq->opt;
1429 ireq->opt = NULL;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001430 newinet->mc_index = inet_iif(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001431 newinet->mc_ttl = ip_hdr(skb)->ttl;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001432 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433 if (newinet->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001434 inet_csk(newsk)->icsk_ext_hdr_len = newinet->opt->optlen;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001435 newinet->inet_id = newtp->write_seq ^ jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436
John Heffner5d424d52006-03-20 17:53:41 -08001437 tcp_mtup_init(newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 tcp_sync_mss(newsk, dst_mtu(dst));
1439 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
Tom Quetchenbachf5fff5d2008-09-21 00:21:51 -07001440 if (tcp_sk(sk)->rx_opt.user_mss &&
1441 tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1442 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1443
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 tcp_initialize_rcv_mss(newsk);
1445
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001446#ifdef CONFIG_TCP_MD5SIG
1447 /* Copy over the MD5 key from the original socket */
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001448 key = tcp_v4_md5_do_lookup(sk, newinet->inet_daddr);
1449 if (key != NULL) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001450 /*
1451 * We're using one, so create a matching key
1452 * on the newsk structure. If we fail to get
1453 * memory, then we end up not copying the key
1454 * across. Shucks.
1455 */
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -02001456 char *newkey = kmemdup(key->key, key->keylen, GFP_ATOMIC);
1457 if (newkey != NULL)
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001458 tcp_v4_md5_do_add(newsk, newinet->inet_daddr,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001459 newkey, key->keylen);
Adam Langley49a72df2008-07-19 00:01:42 -07001460 newsk->sk_route_caps &= ~NETIF_F_GSO_MASK;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001461 }
1462#endif
1463
Eric Dumazet9327f702009-12-04 03:46:54 +00001464 __inet_hash_nolisten(newsk, NULL);
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001465 __inet_inherit_port(sk, newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466
1467 return newsk;
1468
1469exit_overflow:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001470 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471exit:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001472 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 dst_release(dst);
1474 return NULL;
1475}
1476
1477static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
1478{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001479 struct tcphdr *th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001480 const struct iphdr *iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481 struct sock *nsk;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001482 struct request_sock **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483 /* Find possible connection requests. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001484 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
1485 iph->saddr, iph->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 if (req)
1487 return tcp_check_req(sk, skb, req, prev);
1488
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001489 nsk = inet_lookup_established(sock_net(sk), &tcp_hashinfo, iph->saddr,
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001490 th->source, iph->daddr, th->dest, inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491
1492 if (nsk) {
1493 if (nsk->sk_state != TCP_TIME_WAIT) {
1494 bh_lock_sock(nsk);
1495 return nsk;
1496 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001497 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498 return NULL;
1499 }
1500
1501#ifdef CONFIG_SYN_COOKIES
1502 if (!th->rst && !th->syn && th->ack)
1503 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
1504#endif
1505 return sk;
1506}
1507
Al Virob51655b2006-11-14 21:40:42 -08001508static __sum16 tcp_v4_checksum_init(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001510 const struct iphdr *iph = ip_hdr(skb);
1511
Patrick McHardy84fa7932006-08-29 16:44:56 -07001512 if (skb->ip_summed == CHECKSUM_COMPLETE) {
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001513 if (!tcp_v4_check(skb->len, iph->saddr,
1514 iph->daddr, skb->csum)) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001515 skb->ip_summed = CHECKSUM_UNNECESSARY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 return 0;
Herbert Xufb286bb2005-11-10 13:01:24 -08001517 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518 }
Herbert Xufb286bb2005-11-10 13:01:24 -08001519
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001520 skb->csum = csum_tcpudp_nofold(iph->saddr, iph->daddr,
Herbert Xufb286bb2005-11-10 13:01:24 -08001521 skb->len, IPPROTO_TCP, 0);
1522
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523 if (skb->len <= 76) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001524 return __skb_checksum_complete(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 }
1526 return 0;
1527}
1528
1529
1530/* The socket must have it's spinlock held when we get
1531 * here.
1532 *
1533 * We have a potential double-lock case here, so even when
1534 * doing backlog processing we use the BH locking scheme.
1535 * This is because we cannot sleep with the original spinlock
1536 * held.
1537 */
1538int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1539{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001540 struct sock *rsk;
1541#ifdef CONFIG_TCP_MD5SIG
1542 /*
1543 * We really want to reject the packet as early as possible
1544 * if:
1545 * o We're expecting an MD5'd packet and this is no MD5 tcp option
1546 * o There is an MD5 option and we're not expecting one
1547 */
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001548 if (tcp_v4_inbound_md5_hash(sk, skb))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001549 goto discard;
1550#endif
1551
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1553 TCP_CHECK_TIMER(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001554 if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001555 rsk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001557 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558 TCP_CHECK_TIMER(sk);
1559 return 0;
1560 }
1561
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07001562 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 goto csum_err;
1564
1565 if (sk->sk_state == TCP_LISTEN) {
1566 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
1567 if (!nsk)
1568 goto discard;
1569
1570 if (nsk != sk) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001571 if (tcp_child_process(sk, nsk, skb)) {
1572 rsk = nsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001574 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 return 0;
1576 }
1577 }
1578
1579 TCP_CHECK_TIMER(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001580 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001581 rsk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001583 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 TCP_CHECK_TIMER(sk);
1585 return 0;
1586
1587reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001588 tcp_v4_send_reset(rsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589discard:
1590 kfree_skb(skb);
1591 /* Be careful here. If this function gets more complicated and
1592 * gcc suffers from register pressure on the x86, sk (in %ebx)
1593 * might be destroyed here. This current version compiles correctly,
1594 * but you have been warned.
1595 */
1596 return 0;
1597
1598csum_err:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001599 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600 goto discard;
1601}
1602
1603/*
1604 * From tcp_input.c
1605 */
1606
1607int tcp_v4_rcv(struct sk_buff *skb)
1608{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001609 const struct iphdr *iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610 struct tcphdr *th;
1611 struct sock *sk;
1612 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001613 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614
1615 if (skb->pkt_type != PACKET_HOST)
1616 goto discard_it;
1617
1618 /* Count it even if it's bad */
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001619 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620
1621 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1622 goto discard_it;
1623
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001624 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625
1626 if (th->doff < sizeof(struct tcphdr) / 4)
1627 goto bad_packet;
1628 if (!pskb_may_pull(skb, th->doff * 4))
1629 goto discard_it;
1630
1631 /* An explanation is required here, I think.
1632 * Packet length and doff are validated by header prediction,
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -08001633 * provided case of th->doff==0 is eliminated.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634 * So, we defer the checks. */
Herbert Xu60476372007-04-09 11:59:39 -07001635 if (!skb_csum_unnecessary(skb) && tcp_v4_checksum_init(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 goto bad_packet;
1637
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001638 th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001639 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1641 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1642 skb->len - th->doff * 4);
1643 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1644 TCP_SKB_CB(skb)->when = 0;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001645 TCP_SKB_CB(skb)->flags = iph->tos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646 TCP_SKB_CB(skb)->sacked = 0;
1647
Arnaldo Carvalho de Melo9a1f27c2008-10-07 11:41:57 -07001648 sk = __inet_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 if (!sk)
1650 goto no_tcp_socket;
1651
1652process:
1653 if (sk->sk_state == TCP_TIME_WAIT)
1654 goto do_time_wait;
1655
1656 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1657 goto discard_and_relse;
Patrick McHardyb59c2702006-01-06 23:06:10 -08001658 nf_reset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001660 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 goto discard_and_relse;
1662
1663 skb->dev = NULL;
1664
Ingo Molnarc6366182006-07-03 00:25:13 -07001665 bh_lock_sock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 ret = 0;
1667 if (!sock_owned_by_user(sk)) {
Chris Leech1a2449a2006-05-23 18:05:53 -07001668#ifdef CONFIG_NET_DMA
1669 struct tcp_sock *tp = tcp_sk(sk);
1670 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
Dan Williamsf67b4592009-01-06 11:38:15 -07001671 tp->ucopy.dma_chan = dma_find_channel(DMA_MEMCPY);
Chris Leech1a2449a2006-05-23 18:05:53 -07001672 if (tp->ucopy.dma_chan)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673 ret = tcp_v4_do_rcv(sk, skb);
Chris Leech1a2449a2006-05-23 18:05:53 -07001674 else
1675#endif
1676 {
1677 if (!tcp_prequeue(sk, skb))
Shan Weiae8d7f82009-05-05 01:01:29 +00001678 ret = tcp_v4_do_rcv(sk, skb);
Chris Leech1a2449a2006-05-23 18:05:53 -07001679 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 } else
1681 sk_add_backlog(sk, skb);
1682 bh_unlock_sock(sk);
1683
1684 sock_put(sk);
1685
1686 return ret;
1687
1688no_tcp_socket:
1689 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1690 goto discard_it;
1691
1692 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1693bad_packet:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001694 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001696 tcp_v4_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 }
1698
1699discard_it:
1700 /* Discard frame. */
1701 kfree_skb(skb);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001702 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703
1704discard_and_relse:
1705 sock_put(sk);
1706 goto discard_it;
1707
1708do_time_wait:
1709 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001710 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711 goto discard_it;
1712 }
1713
1714 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001715 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001716 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717 goto discard_it;
1718 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001719 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720 case TCP_TW_SYN: {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001721 struct sock *sk2 = inet_lookup_listener(dev_net(skb->dev),
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001722 &tcp_hashinfo,
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001723 iph->daddr, th->dest,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001724 inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725 if (sk2) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001726 inet_twsk_deschedule(inet_twsk(sk), &tcp_death_row);
1727 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728 sk = sk2;
1729 goto process;
1730 }
1731 /* Fall through to ACK */
1732 }
1733 case TCP_TW_ACK:
1734 tcp_v4_timewait_ack(sk, skb);
1735 break;
1736 case TCP_TW_RST:
1737 goto no_tcp_socket;
1738 case TCP_TW_SUCCESS:;
1739 }
1740 goto discard_it;
1741}
1742
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743/* VJ's idea. Save last timestamp seen from this destination
1744 * and hold it at least for normal timewait interval to use for duplicate
1745 * segment detection in subsequent connections, before they enter synchronized
1746 * state.
1747 */
1748
1749int tcp_v4_remember_stamp(struct sock *sk)
1750{
1751 struct inet_sock *inet = inet_sk(sk);
1752 struct tcp_sock *tp = tcp_sk(sk);
1753 struct rtable *rt = (struct rtable *)__sk_dst_get(sk);
1754 struct inet_peer *peer = NULL;
1755 int release_it = 0;
1756
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001757 if (!rt || rt->rt_dst != inet->inet_daddr) {
1758 peer = inet_getpeer(inet->inet_daddr, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759 release_it = 1;
1760 } else {
1761 if (!rt->peer)
1762 rt_bind_peer(rt, 1);
1763 peer = rt->peer;
1764 }
1765
1766 if (peer) {
1767 if ((s32)(peer->tcp_ts - tp->rx_opt.ts_recent) <= 0 ||
Eric Dumazet2c1409a2009-11-12 09:33:09 +00001768 ((u32)get_seconds() - peer->tcp_ts_stamp > TCP_PAWS_MSL &&
1769 peer->tcp_ts_stamp <= (u32)tp->rx_opt.ts_recent_stamp)) {
1770 peer->tcp_ts_stamp = (u32)tp->rx_opt.ts_recent_stamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 peer->tcp_ts = tp->rx_opt.ts_recent;
1772 }
1773 if (release_it)
1774 inet_putpeer(peer);
1775 return 1;
1776 }
1777
1778 return 0;
1779}
1780
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001781int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001783 struct inet_peer *peer = inet_getpeer(tw->tw_daddr, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784
1785 if (peer) {
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001786 const struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
1787
1788 if ((s32)(peer->tcp_ts - tcptw->tw_ts_recent) <= 0 ||
Eric Dumazet2c1409a2009-11-12 09:33:09 +00001789 ((u32)get_seconds() - peer->tcp_ts_stamp > TCP_PAWS_MSL &&
1790 peer->tcp_ts_stamp <= (u32)tcptw->tw_ts_recent_stamp)) {
1791 peer->tcp_ts_stamp = (u32)tcptw->tw_ts_recent_stamp;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001792 peer->tcp_ts = tcptw->tw_ts_recent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793 }
1794 inet_putpeer(peer);
1795 return 1;
1796 }
1797
1798 return 0;
1799}
1800
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001801const struct inet_connection_sock_af_ops ipv4_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001802 .queue_xmit = ip_queue_xmit,
1803 .send_check = tcp_v4_send_check,
1804 .rebuild_header = inet_sk_rebuild_header,
1805 .conn_request = tcp_v4_conn_request,
1806 .syn_recv_sock = tcp_v4_syn_recv_sock,
1807 .remember_stamp = tcp_v4_remember_stamp,
1808 .net_header_len = sizeof(struct iphdr),
1809 .setsockopt = ip_setsockopt,
1810 .getsockopt = ip_getsockopt,
1811 .addr2sockaddr = inet_csk_addr2sockaddr,
1812 .sockaddr_len = sizeof(struct sockaddr_in),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001813 .bind_conflict = inet_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001814#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001815 .compat_setsockopt = compat_ip_setsockopt,
1816 .compat_getsockopt = compat_ip_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001817#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818};
1819
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001820#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001821static const struct tcp_sock_af_ops tcp_sock_ipv4_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001822 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001823 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001824 .md5_add = tcp_v4_md5_add_func,
1825 .md5_parse = tcp_v4_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001826};
Andrew Mortonb6332e62006-11-30 19:16:28 -08001827#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001828
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829/* NOTE: A lot of things set to zero explicitly by call to
1830 * sk_alloc() so need not be done here.
1831 */
1832static int tcp_v4_init_sock(struct sock *sk)
1833{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001834 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835 struct tcp_sock *tp = tcp_sk(sk);
1836
1837 skb_queue_head_init(&tp->out_of_order_queue);
1838 tcp_init_xmit_timers(sk);
1839 tcp_prequeue_init(tp);
1840
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001841 icsk->icsk_rto = TCP_TIMEOUT_INIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842 tp->mdev = TCP_TIMEOUT_INIT;
1843
1844 /* So many TCP implementations out there (incorrectly) count the
1845 * initial SYN frame in their delayed-ACK and congestion control
1846 * algorithms that we must have the following bandaid to talk
1847 * efficiently to them. -DaveM
1848 */
1849 tp->snd_cwnd = 2;
1850
1851 /* See draft-stevens-tcpca-spec-01 for discussion of the
1852 * initialization of these values.
1853 */
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07001854 tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855 tp->snd_cwnd_clamp = ~0;
William Allen Simpsonbee7ca92009-11-10 09:51:18 +00001856 tp->mss_cache = TCP_MSS_DEFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857
1858 tp->reordering = sysctl_tcp_reordering;
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001859 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860
1861 sk->sk_state = TCP_CLOSE;
1862
1863 sk->sk_write_space = sk_stream_write_space;
1864 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1865
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001866 icsk->icsk_af_ops = &ipv4_specific;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001867 icsk->icsk_sync_mss = tcp_sync_mss;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001868#ifdef CONFIG_TCP_MD5SIG
1869 tp->af_specific = &tcp_sock_ipv4_specific;
1870#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871
William Allen Simpson435cf552009-12-02 18:17:05 +00001872 /* TCP Cookie Transactions */
1873 if (sysctl_tcp_cookie_size > 0) {
1874 /* Default, cookies without s_data_payload. */
1875 tp->cookie_values =
1876 kzalloc(sizeof(*tp->cookie_values),
1877 sk->sk_allocation);
1878 if (tp->cookie_values != NULL)
1879 kref_init(&tp->cookie_values->kref);
1880 }
1881 /* Presumed zeroed, in order of appearance:
1882 * cookie_in_always, cookie_out_never,
1883 * s_data_constant, s_data_in, s_data_out
1884 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1886 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1887
Herbert Xueb4dea52008-12-29 23:04:08 -08001888 local_bh_disable();
Eric Dumazet17483762008-11-25 21:16:35 -08001889 percpu_counter_inc(&tcp_sockets_allocated);
Herbert Xueb4dea52008-12-29 23:04:08 -08001890 local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891
1892 return 0;
1893}
1894
Brian Haley7d06b2e2008-06-14 17:04:49 -07001895void tcp_v4_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896{
1897 struct tcp_sock *tp = tcp_sk(sk);
1898
1899 tcp_clear_xmit_timers(sk);
1900
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001901 tcp_cleanup_congestion_control(sk);
Stephen Hemminger317a76f2005-06-23 12:19:55 -07001902
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903 /* Cleanup up the write buffer. */
David S. Millerfe067e82007-03-07 12:12:44 -08001904 tcp_write_queue_purge(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905
1906 /* Cleans up our, hopefully empty, out_of_order_queue. */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001907 __skb_queue_purge(&tp->out_of_order_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001909#ifdef CONFIG_TCP_MD5SIG
1910 /* Clean up the MD5 key list, if any */
1911 if (tp->md5sig_info) {
1912 tcp_v4_clear_md5_list(sk);
1913 kfree(tp->md5sig_info);
1914 tp->md5sig_info = NULL;
1915 }
1916#endif
1917
Chris Leech1a2449a2006-05-23 18:05:53 -07001918#ifdef CONFIG_NET_DMA
1919 /* Cleans up our sk_async_wait_queue */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001920 __skb_queue_purge(&sk->sk_async_wait_queue);
Chris Leech1a2449a2006-05-23 18:05:53 -07001921#endif
1922
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923 /* Clean prequeue, it must be empty really */
1924 __skb_queue_purge(&tp->ucopy.prequeue);
1925
1926 /* Clean up a referenced TCP bind bucket. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001927 if (inet_csk(sk)->icsk_bind_hash)
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001928 inet_put_port(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929
1930 /*
1931 * If sendmsg cached page exists, toss it.
1932 */
1933 if (sk->sk_sndmsg_page) {
1934 __free_page(sk->sk_sndmsg_page);
1935 sk->sk_sndmsg_page = NULL;
1936 }
1937
William Allen Simpson435cf552009-12-02 18:17:05 +00001938 /* TCP Cookie Transactions */
1939 if (tp->cookie_values != NULL) {
1940 kref_put(&tp->cookie_values->kref,
1941 tcp_cookie_values_release);
1942 tp->cookie_values = NULL;
1943 }
1944
Eric Dumazet17483762008-11-25 21:16:35 -08001945 percpu_counter_dec(&tcp_sockets_allocated);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946}
1947
1948EXPORT_SYMBOL(tcp_v4_destroy_sock);
1949
1950#ifdef CONFIG_PROC_FS
1951/* Proc filesystem TCP sock list dumping. */
1952
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001953static inline struct inet_timewait_sock *tw_head(struct hlist_nulls_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954{
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001955 return hlist_nulls_empty(head) ? NULL :
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001956 list_entry(head->first, struct inet_timewait_sock, tw_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957}
1958
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001959static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001960{
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001961 return !is_a_nulls(tw->tw_node.next) ?
1962 hlist_nulls_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963}
1964
1965static void *listening_get_next(struct seq_file *seq, void *cur)
1966{
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001967 struct inet_connection_sock *icsk;
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08001968 struct hlist_nulls_node *node;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969 struct sock *sk = cur;
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001970 struct inet_listen_hashbucket *ilb;
Jianjun Kong5799de02008-11-03 02:49:10 -08001971 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07001972 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973
1974 if (!sk) {
1975 st->bucket = 0;
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001976 ilb = &tcp_hashinfo.listening_hash[0];
1977 spin_lock_bh(&ilb->lock);
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08001978 sk = sk_nulls_head(&ilb->head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979 goto get_sk;
1980 }
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001981 ilb = &tcp_hashinfo.listening_hash[st->bucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982 ++st->num;
1983
1984 if (st->state == TCP_SEQ_STATE_OPENREQ) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001985 struct request_sock *req = cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001987 icsk = inet_csk(st->syn_wait_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988 req = req->dl_next;
1989 while (1) {
1990 while (req) {
Daniel Lezcanobdccc4c2008-07-19 00:15:13 -07001991 if (req->rsk_ops->family == st->family) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992 cur = req;
1993 goto out;
1994 }
1995 req = req->dl_next;
1996 }
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001997 if (++st->sbucket >= icsk->icsk_accept_queue.listen_opt->nr_table_entries)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998 break;
1999get_req:
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002000 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002001 }
2002 sk = sk_next(st->syn_wait_sk);
2003 st->state = TCP_SEQ_STATE_LISTENING;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002004 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005 } else {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002006 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002007 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2008 if (reqsk_queue_len(&icsk->icsk_accept_queue))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002009 goto start_req;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002010 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011 sk = sk_next(sk);
2012 }
2013get_sk:
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08002014 sk_nulls_for_each_from(sk, node) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002015 if (sk->sk_family == st->family && net_eq(sock_net(sk), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016 cur = sk;
2017 goto out;
2018 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002019 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002020 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2021 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022start_req:
2023 st->uid = sock_i_uid(sk);
2024 st->syn_wait_sk = sk;
2025 st->state = TCP_SEQ_STATE_OPENREQ;
2026 st->sbucket = 0;
2027 goto get_req;
2028 }
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002029 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030 }
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002031 spin_unlock_bh(&ilb->lock);
Arnaldo Carvalho de Melo0f7ff922005-08-09 19:59:44 -07002032 if (++st->bucket < INET_LHTABLE_SIZE) {
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002033 ilb = &tcp_hashinfo.listening_hash[st->bucket];
2034 spin_lock_bh(&ilb->lock);
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08002035 sk = sk_nulls_head(&ilb->head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036 goto get_sk;
2037 }
2038 cur = NULL;
2039out:
2040 return cur;
2041}
2042
2043static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
2044{
2045 void *rc = listening_get_next(seq, NULL);
2046
2047 while (rc && *pos) {
2048 rc = listening_get_next(seq, rc);
2049 --*pos;
2050 }
2051 return rc;
2052}
2053
Andi Kleen6eac5602008-08-28 01:08:02 -07002054static inline int empty_bucket(struct tcp_iter_state *st)
2055{
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002056 return hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].chain) &&
2057 hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].twchain);
Andi Kleen6eac5602008-08-28 01:08:02 -07002058}
2059
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060static void *established_get_first(struct seq_file *seq)
2061{
Jianjun Kong5799de02008-11-03 02:49:10 -08002062 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002063 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064 void *rc = NULL;
2065
Eric Dumazetf373b532009-10-09 00:16:19 +00002066 for (st->bucket = 0; st->bucket <= tcp_hashinfo.ehash_mask; ++st->bucket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067 struct sock *sk;
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002068 struct hlist_nulls_node *node;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002069 struct inet_timewait_sock *tw;
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002070 spinlock_t *lock = inet_ehash_lockp(&tcp_hashinfo, st->bucket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002071
Andi Kleen6eac5602008-08-28 01:08:02 -07002072 /* Lockless fast path for the common case of empty buckets */
2073 if (empty_bucket(st))
2074 continue;
2075
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002076 spin_lock_bh(lock);
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002077 sk_nulls_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002078 if (sk->sk_family != st->family ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002079 !net_eq(sock_net(sk), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080 continue;
2081 }
2082 rc = sk;
2083 goto out;
2084 }
2085 st->state = TCP_SEQ_STATE_TIME_WAIT;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002086 inet_twsk_for_each(tw, node,
Eric Dumazetdbca9b2752007-02-08 14:16:46 -08002087 &tcp_hashinfo.ehash[st->bucket].twchain) {
Pavel Emelyanov28518fc2008-03-21 15:52:00 -07002088 if (tw->tw_family != st->family ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002089 !net_eq(twsk_net(tw), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002090 continue;
2091 }
2092 rc = tw;
2093 goto out;
2094 }
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002095 spin_unlock_bh(lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096 st->state = TCP_SEQ_STATE_ESTABLISHED;
2097 }
2098out:
2099 return rc;
2100}
2101
2102static void *established_get_next(struct seq_file *seq, void *cur)
2103{
2104 struct sock *sk = cur;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002105 struct inet_timewait_sock *tw;
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002106 struct hlist_nulls_node *node;
Jianjun Kong5799de02008-11-03 02:49:10 -08002107 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002108 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109
2110 ++st->num;
2111
2112 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
2113 tw = cur;
2114 tw = tw_next(tw);
2115get_tw:
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002116 while (tw && (tw->tw_family != st->family || !net_eq(twsk_net(tw), net))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002117 tw = tw_next(tw);
2118 }
2119 if (tw) {
2120 cur = tw;
2121 goto out;
2122 }
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002123 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002124 st->state = TCP_SEQ_STATE_ESTABLISHED;
2125
Andi Kleen6eac5602008-08-28 01:08:02 -07002126 /* Look for next non empty bucket */
Eric Dumazetf373b532009-10-09 00:16:19 +00002127 while (++st->bucket <= tcp_hashinfo.ehash_mask &&
Andi Kleen6eac5602008-08-28 01:08:02 -07002128 empty_bucket(st))
2129 ;
Eric Dumazetf373b532009-10-09 00:16:19 +00002130 if (st->bucket > tcp_hashinfo.ehash_mask)
Andi Kleen6eac5602008-08-28 01:08:02 -07002131 return NULL;
2132
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002133 spin_lock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002134 sk = sk_nulls_head(&tcp_hashinfo.ehash[st->bucket].chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002135 } else
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002136 sk = sk_nulls_next(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002138 sk_nulls_for_each_from(sk, node) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002139 if (sk->sk_family == st->family && net_eq(sock_net(sk), net))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140 goto found;
2141 }
2142
2143 st->state = TCP_SEQ_STATE_TIME_WAIT;
Eric Dumazetdbca9b2752007-02-08 14:16:46 -08002144 tw = tw_head(&tcp_hashinfo.ehash[st->bucket].twchain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145 goto get_tw;
2146found:
2147 cur = sk;
2148out:
2149 return cur;
2150}
2151
2152static void *established_get_idx(struct seq_file *seq, loff_t pos)
2153{
2154 void *rc = established_get_first(seq);
2155
2156 while (rc && pos) {
2157 rc = established_get_next(seq, rc);
2158 --pos;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002159 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002160 return rc;
2161}
2162
2163static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
2164{
2165 void *rc;
Jianjun Kong5799de02008-11-03 02:49:10 -08002166 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002167
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168 st->state = TCP_SEQ_STATE_LISTENING;
2169 rc = listening_get_idx(seq, &pos);
2170
2171 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002172 st->state = TCP_SEQ_STATE_ESTABLISHED;
2173 rc = established_get_idx(seq, pos);
2174 }
2175
2176 return rc;
2177}
2178
2179static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
2180{
Jianjun Kong5799de02008-11-03 02:49:10 -08002181 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182 st->state = TCP_SEQ_STATE_LISTENING;
2183 st->num = 0;
2184 return *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2185}
2186
2187static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2188{
2189 void *rc = NULL;
Jianjun Kong5799de02008-11-03 02:49:10 -08002190 struct tcp_iter_state *st;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191
2192 if (v == SEQ_START_TOKEN) {
2193 rc = tcp_get_idx(seq, 0);
2194 goto out;
2195 }
2196 st = seq->private;
2197
2198 switch (st->state) {
2199 case TCP_SEQ_STATE_OPENREQ:
2200 case TCP_SEQ_STATE_LISTENING:
2201 rc = listening_get_next(seq, v);
2202 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002203 st->state = TCP_SEQ_STATE_ESTABLISHED;
2204 rc = established_get_first(seq);
2205 }
2206 break;
2207 case TCP_SEQ_STATE_ESTABLISHED:
2208 case TCP_SEQ_STATE_TIME_WAIT:
2209 rc = established_get_next(seq, v);
2210 break;
2211 }
2212out:
2213 ++*pos;
2214 return rc;
2215}
2216
2217static void tcp_seq_stop(struct seq_file *seq, void *v)
2218{
Jianjun Kong5799de02008-11-03 02:49:10 -08002219 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002220
2221 switch (st->state) {
2222 case TCP_SEQ_STATE_OPENREQ:
2223 if (v) {
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002224 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
2225 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226 }
2227 case TCP_SEQ_STATE_LISTENING:
2228 if (v != SEQ_START_TOKEN)
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002229 spin_unlock_bh(&tcp_hashinfo.listening_hash[st->bucket].lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230 break;
2231 case TCP_SEQ_STATE_TIME_WAIT:
2232 case TCP_SEQ_STATE_ESTABLISHED:
2233 if (v)
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002234 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235 break;
2236 }
2237}
2238
2239static int tcp_seq_open(struct inode *inode, struct file *file)
2240{
2241 struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242 struct tcp_iter_state *s;
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002243 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002245 err = seq_open_net(inode, file, &afinfo->seq_ops,
2246 sizeof(struct tcp_iter_state));
2247 if (err < 0)
2248 return err;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002249
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002250 s = ((struct seq_file *)file->private_data)->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002251 s->family = afinfo->family;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002252 return 0;
2253}
2254
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002255int tcp_proc_register(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256{
2257 int rc = 0;
2258 struct proc_dir_entry *p;
2259
Denis V. Lunev68fcadd2008-04-13 22:13:30 -07002260 afinfo->seq_fops.open = tcp_seq_open;
2261 afinfo->seq_fops.read = seq_read;
2262 afinfo->seq_fops.llseek = seq_lseek;
2263 afinfo->seq_fops.release = seq_release_net;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002264
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002265 afinfo->seq_ops.start = tcp_seq_start;
2266 afinfo->seq_ops.next = tcp_seq_next;
2267 afinfo->seq_ops.stop = tcp_seq_stop;
2268
Denis V. Lunev84841c32008-05-02 04:10:08 -07002269 p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net,
2270 &afinfo->seq_fops, afinfo);
2271 if (!p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272 rc = -ENOMEM;
2273 return rc;
2274}
2275
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002276void tcp_proc_unregister(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002277{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002278 proc_net_remove(net, afinfo->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279}
2280
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002281static void get_openreq4(struct sock *sk, struct request_sock *req,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002282 struct seq_file *f, int i, int uid, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002284 const struct inet_request_sock *ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002285 int ttd = req->expires - jiffies;
2286
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002287 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
2288 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p%n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289 i,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002290 ireq->loc_addr,
Eric Dumazetc720c7e2009-10-15 06:30:45 +00002291 ntohs(inet_sk(sk)->inet_sport),
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002292 ireq->rmt_addr,
2293 ntohs(ireq->rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294 TCP_SYN_RECV,
2295 0, 0, /* could print option size, but that is af dependent. */
2296 1, /* timers active (only the expire timer) */
2297 jiffies_to_clock_t(ttd),
2298 req->retrans,
2299 uid,
2300 0, /* non standard timer */
2301 0, /* open_requests have no inode */
2302 atomic_read(&sk->sk_refcnt),
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002303 req,
2304 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305}
2306
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002307static void get_tcp4_sock(struct sock *sk, struct seq_file *f, int i, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002308{
2309 int timer_active;
2310 unsigned long timer_expires;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002311 struct tcp_sock *tp = tcp_sk(sk);
2312 const struct inet_connection_sock *icsk = inet_csk(sk);
2313 struct inet_sock *inet = inet_sk(sk);
Eric Dumazetc720c7e2009-10-15 06:30:45 +00002314 __be32 dest = inet->inet_daddr;
2315 __be32 src = inet->inet_rcv_saddr;
2316 __u16 destp = ntohs(inet->inet_dport);
2317 __u16 srcp = ntohs(inet->inet_sport);
Eric Dumazet49d09002009-12-03 16:06:13 -08002318 int rx_queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002319
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002320 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002321 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002322 timer_expires = icsk->icsk_timeout;
2323 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002324 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002325 timer_expires = icsk->icsk_timeout;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002326 } else if (timer_pending(&sk->sk_timer)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002327 timer_active = 2;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002328 timer_expires = sk->sk_timer.expires;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329 } else {
2330 timer_active = 0;
2331 timer_expires = jiffies;
2332 }
2333
Eric Dumazet49d09002009-12-03 16:06:13 -08002334 if (sk->sk_state == TCP_LISTEN)
2335 rx_queue = sk->sk_ack_backlog;
2336 else
2337 /*
2338 * because we dont lock socket, we might find a transient negative value
2339 */
2340 rx_queue = max_t(int, tp->rcv_nxt - tp->copied_seq, 0);
2341
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002342 seq_printf(f, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
Stephen Hemminger7be87352008-06-27 20:00:19 -07002343 "%08X %5d %8d %lu %d %p %lu %lu %u %u %d%n",
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002344 i, src, srcp, dest, destp, sk->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07002345 tp->write_seq - tp->snd_una,
Eric Dumazet49d09002009-12-03 16:06:13 -08002346 rx_queue,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002347 timer_active,
2348 jiffies_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002349 icsk->icsk_retransmits,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002350 sock_i_uid(sk),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03002351 icsk->icsk_probes_out,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002352 sock_i_ino(sk),
2353 atomic_read(&sk->sk_refcnt), sk,
Stephen Hemminger7be87352008-06-27 20:00:19 -07002354 jiffies_to_clock_t(icsk->icsk_rto),
2355 jiffies_to_clock_t(icsk->icsk_ack.ato),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002356 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002357 tp->snd_cwnd,
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07002358 tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002359 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002360}
2361
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002362static void get_timewait4_sock(struct inet_timewait_sock *tw,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002363 struct seq_file *f, int i, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002364{
Al Viro23f33c22006-09-27 18:43:50 -07002365 __be32 dest, src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366 __u16 destp, srcp;
2367 int ttd = tw->tw_ttd - jiffies;
2368
2369 if (ttd < 0)
2370 ttd = 0;
2371
2372 dest = tw->tw_daddr;
2373 src = tw->tw_rcv_saddr;
2374 destp = ntohs(tw->tw_dport);
2375 srcp = ntohs(tw->tw_sport);
2376
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002377 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
2378 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p%n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002379 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
2380 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002381 atomic_read(&tw->tw_refcnt), tw, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002382}
2383
2384#define TMPSZ 150
2385
2386static int tcp4_seq_show(struct seq_file *seq, void *v)
2387{
Jianjun Kong5799de02008-11-03 02:49:10 -08002388 struct tcp_iter_state *st;
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002389 int len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002390
2391 if (v == SEQ_START_TOKEN) {
2392 seq_printf(seq, "%-*s\n", TMPSZ - 1,
2393 " sl local_address rem_address st tx_queue "
2394 "rx_queue tr tm->when retrnsmt uid timeout "
2395 "inode");
2396 goto out;
2397 }
2398 st = seq->private;
2399
2400 switch (st->state) {
2401 case TCP_SEQ_STATE_LISTENING:
2402 case TCP_SEQ_STATE_ESTABLISHED:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002403 get_tcp4_sock(v, seq, st->num, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002404 break;
2405 case TCP_SEQ_STATE_OPENREQ:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002406 get_openreq4(st->syn_wait_sk, v, seq, st->num, st->uid, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002407 break;
2408 case TCP_SEQ_STATE_TIME_WAIT:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002409 get_timewait4_sock(v, seq, st->num, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002410 break;
2411 }
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002412 seq_printf(seq, "%*s\n", TMPSZ - 1 - len, "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002413out:
2414 return 0;
2415}
2416
Linus Torvalds1da177e2005-04-16 15:20:36 -07002417static struct tcp_seq_afinfo tcp4_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002418 .name = "tcp",
2419 .family = AF_INET,
Denis V. Lunev5f4472c2008-04-13 22:13:53 -07002420 .seq_fops = {
2421 .owner = THIS_MODULE,
2422 },
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002423 .seq_ops = {
2424 .show = tcp4_seq_show,
2425 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002426};
2427
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002428static int tcp4_proc_init_net(struct net *net)
2429{
2430 return tcp_proc_register(net, &tcp4_seq_afinfo);
2431}
2432
2433static void tcp4_proc_exit_net(struct net *net)
2434{
2435 tcp_proc_unregister(net, &tcp4_seq_afinfo);
2436}
2437
2438static struct pernet_operations tcp4_net_ops = {
2439 .init = tcp4_proc_init_net,
2440 .exit = tcp4_proc_exit_net,
2441};
2442
Linus Torvalds1da177e2005-04-16 15:20:36 -07002443int __init tcp4_proc_init(void)
2444{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002445 return register_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002446}
2447
2448void tcp4_proc_exit(void)
2449{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002450 unregister_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002451}
2452#endif /* CONFIG_PROC_FS */
2453
Herbert Xubf296b12008-12-15 23:43:36 -08002454struct sk_buff **tcp4_gro_receive(struct sk_buff **head, struct sk_buff *skb)
2455{
Herbert Xu36e7b1b2009-04-27 05:44:45 -07002456 struct iphdr *iph = skb_gro_network_header(skb);
Herbert Xubf296b12008-12-15 23:43:36 -08002457
2458 switch (skb->ip_summed) {
2459 case CHECKSUM_COMPLETE:
Herbert Xu86911732009-01-29 14:19:50 +00002460 if (!tcp_v4_check(skb_gro_len(skb), iph->saddr, iph->daddr,
Herbert Xubf296b12008-12-15 23:43:36 -08002461 skb->csum)) {
2462 skb->ip_summed = CHECKSUM_UNNECESSARY;
2463 break;
2464 }
2465
2466 /* fall through */
2467 case CHECKSUM_NONE:
2468 NAPI_GRO_CB(skb)->flush = 1;
2469 return NULL;
2470 }
2471
2472 return tcp_gro_receive(head, skb);
2473}
2474EXPORT_SYMBOL(tcp4_gro_receive);
2475
2476int tcp4_gro_complete(struct sk_buff *skb)
2477{
2478 struct iphdr *iph = ip_hdr(skb);
2479 struct tcphdr *th = tcp_hdr(skb);
2480
2481 th->check = ~tcp_v4_check(skb->len - skb_transport_offset(skb),
2482 iph->saddr, iph->daddr, 0);
2483 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV4;
2484
2485 return tcp_gro_complete(skb);
2486}
2487EXPORT_SYMBOL(tcp4_gro_complete);
2488
Linus Torvalds1da177e2005-04-16 15:20:36 -07002489struct proto tcp_prot = {
2490 .name = "TCP",
2491 .owner = THIS_MODULE,
2492 .close = tcp_close,
2493 .connect = tcp_v4_connect,
2494 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002495 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002496 .ioctl = tcp_ioctl,
2497 .init = tcp_v4_init_sock,
2498 .destroy = tcp_v4_destroy_sock,
2499 .shutdown = tcp_shutdown,
2500 .setsockopt = tcp_setsockopt,
2501 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002502 .recvmsg = tcp_recvmsg,
2503 .backlog_rcv = tcp_v4_do_rcv,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08002504 .hash = inet_hash,
2505 .unhash = inet_unhash,
2506 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002507 .enter_memory_pressure = tcp_enter_memory_pressure,
2508 .sockets_allocated = &tcp_sockets_allocated,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07002509 .orphan_count = &tcp_orphan_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002510 .memory_allocated = &tcp_memory_allocated,
2511 .memory_pressure = &tcp_memory_pressure,
2512 .sysctl_mem = sysctl_tcp_mem,
2513 .sysctl_wmem = sysctl_tcp_wmem,
2514 .sysctl_rmem = sysctl_tcp_rmem,
2515 .max_header = MAX_TCP_HEADER,
2516 .obj_size = sizeof(struct tcp_sock),
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002517 .slab_flags = SLAB_DESTROY_BY_RCU,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002518 .twsk_prot = &tcp_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002519 .rsk_prot = &tcp_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07002520 .h.hashinfo = &tcp_hashinfo,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002521#ifdef CONFIG_COMPAT
2522 .compat_setsockopt = compat_tcp_setsockopt,
2523 .compat_getsockopt = compat_tcp_getsockopt,
2524#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002525};
2526
Denis V. Lunev046ee902008-04-03 14:31:33 -07002527
2528static int __net_init tcp_sk_init(struct net *net)
2529{
2530 return inet_ctl_sock_create(&net->ipv4.tcp_sock,
2531 PF_INET, SOCK_RAW, IPPROTO_TCP, net);
2532}
2533
2534static void __net_exit tcp_sk_exit(struct net *net)
2535{
2536 inet_ctl_sock_destroy(net->ipv4.tcp_sock);
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002537}
2538
2539static void __net_exit tcp_sk_exit_batch(struct list_head *net_exit_list)
2540{
2541 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET);
Denis V. Lunev046ee902008-04-03 14:31:33 -07002542}
2543
2544static struct pernet_operations __net_initdata tcp_sk_ops = {
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002545 .init = tcp_sk_init,
2546 .exit = tcp_sk_exit,
2547 .exit_batch = tcp_sk_exit_batch,
Denis V. Lunev046ee902008-04-03 14:31:33 -07002548};
2549
Denis V. Lunev9b0f9762008-02-29 11:13:15 -08002550void __init tcp_v4_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002551{
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002552 inet_hashinfo_init(&tcp_hashinfo);
Eric W. Biederman6a1b3052009-02-22 00:10:18 -08002553 if (register_pernet_subsys(&tcp_sk_ops))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002554 panic("Failed to create the TCP control socket.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555}
2556
2557EXPORT_SYMBOL(ipv4_specific);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002558EXPORT_SYMBOL(tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002559EXPORT_SYMBOL(tcp_prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002560EXPORT_SYMBOL(tcp_v4_conn_request);
2561EXPORT_SYMBOL(tcp_v4_connect);
2562EXPORT_SYMBOL(tcp_v4_do_rcv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002563EXPORT_SYMBOL(tcp_v4_remember_stamp);
2564EXPORT_SYMBOL(tcp_v4_send_check);
2565EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
2566
2567#ifdef CONFIG_PROC_FS
2568EXPORT_SYMBOL(tcp_proc_register);
2569EXPORT_SYMBOL(tcp_proc_unregister);
2570#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002571EXPORT_SYMBOL(sysctl_tcp_low_latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002572