blob: 70df40980a87a201e79f036aebabcfcc9dbb68c4 [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 */
Octavian Purdila72659ec2010-01-17 19:09:39 -0800745static 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
Octavian Purdila72659ec2010-01-17 19:09:39 -0800778static int tcp_v4_rtx_synack(struct sock *sk, struct request_sock *req,
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000779 struct request_values *rvp)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800780{
Octavian Purdila72659ec2010-01-17 19:09:39 -0800781 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_RETRANSSEGS);
782 return tcp_v4_send_synack(sk, NULL, req, rvp);
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800783}
784
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700786 * IPv4 request_sock destructor.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 */
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700788static void tcp_v4_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789{
Jesper Juhla51482b2005-11-08 09:41:34 -0800790 kfree(inet_rsk(req)->opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791}
792
Arnaldo Carvalho de Melo80e40da2006-01-04 01:58:06 -0200793#ifdef CONFIG_SYN_COOKIES
Stephen Hemminger40efc6f2006-01-03 16:03:49 -0800794static void syn_flood_warning(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795{
796 static unsigned long warntime;
797
798 if (time_after(jiffies, (warntime + HZ * 60))) {
799 warntime = jiffies;
800 printk(KERN_INFO
801 "possible SYN flooding on port %d. Sending cookies.\n",
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700802 ntohs(tcp_hdr(skb)->dest));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 }
804}
Arnaldo Carvalho de Melo80e40da2006-01-04 01:58:06 -0200805#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806
807/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700808 * Save and compile IPv4 options into the request_sock if needed.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 */
Stephen Hemminger40efc6f2006-01-03 16:03:49 -0800810static struct ip_options *tcp_v4_save_options(struct sock *sk,
811 struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812{
813 struct ip_options *opt = &(IPCB(skb)->opt);
814 struct ip_options *dopt = NULL;
815
816 if (opt && opt->optlen) {
817 int opt_size = optlength(opt);
818 dopt = kmalloc(opt_size, GFP_ATOMIC);
819 if (dopt) {
820 if (ip_options_echo(dopt, skb)) {
821 kfree(dopt);
822 dopt = NULL;
823 }
824 }
825 }
826 return dopt;
827}
828
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800829#ifdef CONFIG_TCP_MD5SIG
830/*
831 * RFC2385 MD5 checksumming requires a mapping of
832 * IP address->MD5 Key.
833 * We need to maintain these in the sk structure.
834 */
835
836/* Find the Key structure for an address. */
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200837static struct tcp_md5sig_key *
838 tcp_v4_md5_do_lookup(struct sock *sk, __be32 addr)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800839{
840 struct tcp_sock *tp = tcp_sk(sk);
841 int i;
842
843 if (!tp->md5sig_info || !tp->md5sig_info->entries4)
844 return NULL;
845 for (i = 0; i < tp->md5sig_info->entries4; i++) {
846 if (tp->md5sig_info->keys4[i].addr == addr)
David S. Millerf8ab18d2007-09-28 15:18:35 -0700847 return &tp->md5sig_info->keys4[i].base;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800848 }
849 return NULL;
850}
851
852struct tcp_md5sig_key *tcp_v4_md5_lookup(struct sock *sk,
853 struct sock *addr_sk)
854{
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000855 return tcp_v4_md5_do_lookup(sk, inet_sk(addr_sk)->inet_daddr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800856}
857
858EXPORT_SYMBOL(tcp_v4_md5_lookup);
859
Adrian Bunkf5b99bc2006-11-30 17:22:29 -0800860static struct tcp_md5sig_key *tcp_v4_reqsk_md5_lookup(struct sock *sk,
861 struct request_sock *req)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800862{
863 return tcp_v4_md5_do_lookup(sk, inet_rsk(req)->rmt_addr);
864}
865
866/* This can be called on a newly created socket, from other files */
867int tcp_v4_md5_do_add(struct sock *sk, __be32 addr,
868 u8 *newkey, u8 newkeylen)
869{
870 /* Add Key to the list */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700871 struct tcp_md5sig_key *key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800872 struct tcp_sock *tp = tcp_sk(sk);
873 struct tcp4_md5sig_key *keys;
874
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700875 key = tcp_v4_md5_do_lookup(sk, addr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800876 if (key) {
877 /* Pre-existing entry - just update that one. */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700878 kfree(key->key);
879 key->key = newkey;
880 key->keylen = newkeylen;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800881 } else {
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200882 struct tcp_md5sig_info *md5sig;
883
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800884 if (!tp->md5sig_info) {
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200885 tp->md5sig_info = kzalloc(sizeof(*tp->md5sig_info),
886 GFP_ATOMIC);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800887 if (!tp->md5sig_info) {
888 kfree(newkey);
889 return -ENOMEM;
890 }
David S. Miller3d7dbea2007-06-12 14:36:42 -0700891 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800892 }
Wu Fengguangaa133072009-09-02 23:45:45 -0700893 if (tcp_alloc_md5sig_pool(sk) == NULL) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800894 kfree(newkey);
895 return -ENOMEM;
896 }
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200897 md5sig = tp->md5sig_info;
898
899 if (md5sig->alloced4 == md5sig->entries4) {
900 keys = kmalloc((sizeof(*keys) *
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900901 (md5sig->entries4 + 1)), GFP_ATOMIC);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800902 if (!keys) {
903 kfree(newkey);
904 tcp_free_md5sig_pool();
905 return -ENOMEM;
906 }
907
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200908 if (md5sig->entries4)
909 memcpy(keys, md5sig->keys4,
910 sizeof(*keys) * md5sig->entries4);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800911
912 /* Free old key list, and reference new one */
YOSHIFUJI Hideakia80cc202007-11-20 17:30:06 -0800913 kfree(md5sig->keys4);
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200914 md5sig->keys4 = keys;
915 md5sig->alloced4++;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800916 }
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200917 md5sig->entries4++;
David S. Millerf8ab18d2007-09-28 15:18:35 -0700918 md5sig->keys4[md5sig->entries4 - 1].addr = addr;
919 md5sig->keys4[md5sig->entries4 - 1].base.key = newkey;
920 md5sig->keys4[md5sig->entries4 - 1].base.keylen = newkeylen;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800921 }
922 return 0;
923}
924
925EXPORT_SYMBOL(tcp_v4_md5_do_add);
926
927static int tcp_v4_md5_add_func(struct sock *sk, struct sock *addr_sk,
928 u8 *newkey, u8 newkeylen)
929{
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000930 return tcp_v4_md5_do_add(sk, inet_sk(addr_sk)->inet_daddr,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800931 newkey, newkeylen);
932}
933
934int tcp_v4_md5_do_del(struct sock *sk, __be32 addr)
935{
936 struct tcp_sock *tp = tcp_sk(sk);
937 int i;
938
939 for (i = 0; i < tp->md5sig_info->entries4; i++) {
940 if (tp->md5sig_info->keys4[i].addr == addr) {
941 /* Free the key */
David S. Millerf8ab18d2007-09-28 15:18:35 -0700942 kfree(tp->md5sig_info->keys4[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800943 tp->md5sig_info->entries4--;
944
945 if (tp->md5sig_info->entries4 == 0) {
946 kfree(tp->md5sig_info->keys4);
947 tp->md5sig_info->keys4 = NULL;
Leigh Brown8228a18d2006-12-17 17:12:30 -0800948 tp->md5sig_info->alloced4 = 0;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200949 } else if (tp->md5sig_info->entries4 != i) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800950 /* Need to do some manipulation */
YOSHIFUJI Hideaki354faf02007-11-20 17:30:31 -0800951 memmove(&tp->md5sig_info->keys4[i],
952 &tp->md5sig_info->keys4[i+1],
953 (tp->md5sig_info->entries4 - i) *
954 sizeof(struct tcp4_md5sig_key));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800955 }
956 tcp_free_md5sig_pool();
957 return 0;
958 }
959 }
960 return -ENOENT;
961}
962
963EXPORT_SYMBOL(tcp_v4_md5_do_del);
964
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200965static void tcp_v4_clear_md5_list(struct sock *sk)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800966{
967 struct tcp_sock *tp = tcp_sk(sk);
968
969 /* Free each key, then the set of key keys,
970 * the crypto element, and then decrement our
971 * hold on the last resort crypto.
972 */
973 if (tp->md5sig_info->entries4) {
974 int i;
975 for (i = 0; i < tp->md5sig_info->entries4; i++)
David S. Millerf8ab18d2007-09-28 15:18:35 -0700976 kfree(tp->md5sig_info->keys4[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800977 tp->md5sig_info->entries4 = 0;
978 tcp_free_md5sig_pool();
979 }
980 if (tp->md5sig_info->keys4) {
981 kfree(tp->md5sig_info->keys4);
982 tp->md5sig_info->keys4 = NULL;
983 tp->md5sig_info->alloced4 = 0;
984 }
985}
986
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200987static int tcp_v4_parse_md5_keys(struct sock *sk, char __user *optval,
988 int optlen)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800989{
990 struct tcp_md5sig cmd;
991 struct sockaddr_in *sin = (struct sockaddr_in *)&cmd.tcpm_addr;
992 u8 *newkey;
993
994 if (optlen < sizeof(cmd))
995 return -EINVAL;
996
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200997 if (copy_from_user(&cmd, optval, sizeof(cmd)))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800998 return -EFAULT;
999
1000 if (sin->sin_family != AF_INET)
1001 return -EINVAL;
1002
1003 if (!cmd.tcpm_key || !cmd.tcpm_keylen) {
1004 if (!tcp_sk(sk)->md5sig_info)
1005 return -ENOENT;
1006 return tcp_v4_md5_do_del(sk, sin->sin_addr.s_addr);
1007 }
1008
1009 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
1010 return -EINVAL;
1011
1012 if (!tcp_sk(sk)->md5sig_info) {
1013 struct tcp_sock *tp = tcp_sk(sk);
Wu Fengguangaa133072009-09-02 23:45:45 -07001014 struct tcp_md5sig_info *p;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001015
Wu Fengguangaa133072009-09-02 23:45:45 -07001016 p = kzalloc(sizeof(*p), sk->sk_allocation);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001017 if (!p)
1018 return -EINVAL;
1019
1020 tp->md5sig_info = p;
David S. Miller3d7dbea2007-06-12 14:36:42 -07001021 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001022 }
1023
Wu Fengguangaa133072009-09-02 23:45:45 -07001024 newkey = kmemdup(cmd.tcpm_key, cmd.tcpm_keylen, sk->sk_allocation);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001025 if (!newkey)
1026 return -ENOMEM;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001027 return tcp_v4_md5_do_add(sk, sin->sin_addr.s_addr,
1028 newkey, cmd.tcpm_keylen);
1029}
1030
Adam Langley49a72df2008-07-19 00:01:42 -07001031static int tcp_v4_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
1032 __be32 daddr, __be32 saddr, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001033{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001034 struct tcp4_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -07001035 struct scatterlist sg;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001036
1037 bp = &hp->md5_blk.ip4;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001038
1039 /*
Adam Langley49a72df2008-07-19 00:01:42 -07001040 * 1. the TCP pseudo-header (in the order: source IP address,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001041 * destination IP address, zero-padded protocol number, and
1042 * segment length)
1043 */
1044 bp->saddr = saddr;
1045 bp->daddr = daddr;
1046 bp->pad = 0;
YOSHIFUJI Hideaki076fb722008-04-17 12:48:12 +09001047 bp->protocol = IPPROTO_TCP;
Adam Langley49a72df2008-07-19 00:01:42 -07001048 bp->len = cpu_to_be16(nbytes);
David S. Millerc7da57a2007-10-26 00:41:21 -07001049
Adam Langley49a72df2008-07-19 00:01:42 -07001050 sg_init_one(&sg, bp, sizeof(*bp));
1051 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
1052}
1053
1054static int tcp_v4_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
1055 __be32 daddr, __be32 saddr, struct tcphdr *th)
1056{
1057 struct tcp_md5sig_pool *hp;
1058 struct hash_desc *desc;
1059
1060 hp = tcp_get_md5sig_pool();
1061 if (!hp)
1062 goto clear_hash_noput;
1063 desc = &hp->md5_desc;
1064
1065 if (crypto_hash_init(desc))
1066 goto clear_hash;
1067 if (tcp_v4_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
1068 goto clear_hash;
1069 if (tcp_md5_hash_header(hp, th))
1070 goto clear_hash;
1071 if (tcp_md5_hash_key(hp, key))
1072 goto clear_hash;
1073 if (crypto_hash_final(desc, md5_hash))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001074 goto clear_hash;
1075
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001076 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001077 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -07001078
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001079clear_hash:
1080 tcp_put_md5sig_pool();
1081clear_hash_noput:
1082 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -07001083 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001084}
1085
Adam Langley49a72df2008-07-19 00:01:42 -07001086int tcp_v4_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
1087 struct sock *sk, struct request_sock *req,
1088 struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001089{
Adam Langley49a72df2008-07-19 00:01:42 -07001090 struct tcp_md5sig_pool *hp;
1091 struct hash_desc *desc;
1092 struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001093 __be32 saddr, daddr;
1094
1095 if (sk) {
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001096 saddr = inet_sk(sk)->inet_saddr;
1097 daddr = inet_sk(sk)->inet_daddr;
Adam Langley49a72df2008-07-19 00:01:42 -07001098 } else if (req) {
1099 saddr = inet_rsk(req)->loc_addr;
1100 daddr = inet_rsk(req)->rmt_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001101 } else {
Adam Langley49a72df2008-07-19 00:01:42 -07001102 const struct iphdr *iph = ip_hdr(skb);
1103 saddr = iph->saddr;
1104 daddr = iph->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001105 }
Adam Langley49a72df2008-07-19 00:01:42 -07001106
1107 hp = tcp_get_md5sig_pool();
1108 if (!hp)
1109 goto clear_hash_noput;
1110 desc = &hp->md5_desc;
1111
1112 if (crypto_hash_init(desc))
1113 goto clear_hash;
1114
1115 if (tcp_v4_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
1116 goto clear_hash;
1117 if (tcp_md5_hash_header(hp, th))
1118 goto clear_hash;
1119 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
1120 goto clear_hash;
1121 if (tcp_md5_hash_key(hp, key))
1122 goto clear_hash;
1123 if (crypto_hash_final(desc, md5_hash))
1124 goto clear_hash;
1125
1126 tcp_put_md5sig_pool();
1127 return 0;
1128
1129clear_hash:
1130 tcp_put_md5sig_pool();
1131clear_hash_noput:
1132 memset(md5_hash, 0, 16);
1133 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001134}
1135
Adam Langley49a72df2008-07-19 00:01:42 -07001136EXPORT_SYMBOL(tcp_v4_md5_hash_skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001137
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001138static int tcp_v4_inbound_md5_hash(struct sock *sk, struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001139{
1140 /*
1141 * This gets called for each TCP segment that arrives
1142 * so we want to be efficient.
1143 * We have 3 drop cases:
1144 * o No MD5 hash and one expected.
1145 * o MD5 hash and we're not expecting one.
1146 * o MD5 hash and its wrong.
1147 */
1148 __u8 *hash_location = NULL;
1149 struct tcp_md5sig_key *hash_expected;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001150 const struct iphdr *iph = ip_hdr(skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001151 struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001152 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001153 unsigned char newhash[16];
1154
1155 hash_expected = tcp_v4_md5_do_lookup(sk, iph->saddr);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +09001156 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001157
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001158 /* We've parsed the options - do we have a hash? */
1159 if (!hash_expected && !hash_location)
1160 return 0;
1161
1162 if (hash_expected && !hash_location) {
David S. Miller785957d2008-07-30 03:03:15 -07001163 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001164 return 1;
1165 }
1166
1167 if (!hash_expected && hash_location) {
David S. Miller785957d2008-07-30 03:03:15 -07001168 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001169 return 1;
1170 }
1171
1172 /* Okay, so this is hash_expected and hash_location -
1173 * so we need to calculate the checksum.
1174 */
Adam Langley49a72df2008-07-19 00:01:42 -07001175 genhash = tcp_v4_md5_hash_skb(newhash,
1176 hash_expected,
1177 NULL, NULL, skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001178
1179 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
1180 if (net_ratelimit()) {
Harvey Harrison673d57e2008-10-31 00:53:57 -07001181 printk(KERN_INFO "MD5 Hash failed for (%pI4, %d)->(%pI4, %d)%s\n",
1182 &iph->saddr, ntohs(th->source),
1183 &iph->daddr, ntohs(th->dest),
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001184 genhash ? " tcp_v4_calc_md5_hash failed" : "");
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001185 }
1186 return 1;
1187 }
1188 return 0;
1189}
1190
1191#endif
1192
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001193struct request_sock_ops tcp_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 .family = PF_INET,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001195 .obj_size = sizeof(struct tcp_request_sock),
Octavian Purdila72659ec2010-01-17 19:09:39 -08001196 .rtx_syn_ack = tcp_v4_rtx_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001197 .send_ack = tcp_v4_reqsk_send_ack,
1198 .destructor = tcp_v4_reqsk_destructor,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 .send_reset = tcp_v4_send_reset,
Octavian Purdila72659ec2010-01-17 19:09:39 -08001200 .syn_ack_timeout = tcp_syn_ack_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201};
1202
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001203#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001204static const struct tcp_request_sock_ops tcp_request_sock_ipv4_ops = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001205 .md5_lookup = tcp_v4_reqsk_md5_lookup,
John Dykstrae3afe7b2009-07-16 05:04:51 +00001206 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001207};
Andrew Mortonb6332e62006-11-30 19:16:28 -08001208#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001209
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08001210static struct timewait_sock_ops tcp_timewait_sock_ops = {
1211 .twsk_obj_size = sizeof(struct tcp_timewait_sock),
1212 .twsk_unique = tcp_twsk_unique,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001213 .twsk_destructor= tcp_twsk_destructor,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08001214};
1215
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1217{
William Allen Simpson4957faade2009-12-02 18:25:27 +00001218 struct tcp_extend_values tmp_ext;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 struct tcp_options_received tmp_opt;
William Allen Simpson4957faade2009-12-02 18:25:27 +00001220 u8 *hash_location;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001221 struct request_sock *req;
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001222 struct inet_request_sock *ireq;
William Allen Simpson4957faade2009-12-02 18:25:27 +00001223 struct tcp_sock *tp = tcp_sk(sk);
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001224 struct dst_entry *dst = NULL;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001225 __be32 saddr = ip_hdr(skb)->saddr;
1226 __be32 daddr = ip_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 __u32 isn = TCP_SKB_CB(skb)->when;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228#ifdef CONFIG_SYN_COOKIES
1229 int want_cookie = 0;
1230#else
1231#define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */
1232#endif
1233
1234 /* Never answer to SYNs send to broadcast or multicast */
Eric Dumazet511c3f92009-06-02 05:14:27 +00001235 if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236 goto drop;
1237
1238 /* TW buckets are converted to open requests without
1239 * limitations, they conserve resources and peer is
1240 * evidently real one.
1241 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001242 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243#ifdef CONFIG_SYN_COOKIES
1244 if (sysctl_tcp_syncookies) {
1245 want_cookie = 1;
1246 } else
1247#endif
1248 goto drop;
1249 }
1250
1251 /* Accept backlog is full. If we have already queued enough
1252 * of warm entries in syn queue, drop request. It is better than
1253 * clogging syn queue with openreqs with exponentially increasing
1254 * timeout.
1255 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001256 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 goto drop;
1258
Arnaldo Carvalho de Meloce4a7d02008-06-10 12:39:35 -07001259 req = inet_reqsk_alloc(&tcp_request_sock_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 if (!req)
1261 goto drop;
1262
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001263#ifdef CONFIG_TCP_MD5SIG
1264 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv4_ops;
1265#endif
1266
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 tcp_clear_options(&tmp_opt);
William Allen Simpsonbee7ca92009-11-10 09:51:18 +00001268 tmp_opt.mss_clamp = TCP_MSS_DEFAULT;
William Allen Simpson4957faade2009-12-02 18:25:27 +00001269 tmp_opt.user_mss = tp->rx_opt.user_mss;
David S. Millerbb5b7c12009-12-15 20:56:42 -08001270 tcp_parse_options(skb, &tmp_opt, &hash_location, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271
William Allen Simpson4957faade2009-12-02 18:25:27 +00001272 if (tmp_opt.cookie_plus > 0 &&
1273 tmp_opt.saw_tstamp &&
1274 !tp->rx_opt.cookie_out_never &&
1275 (sysctl_tcp_cookie_size > 0 ||
1276 (tp->cookie_values != NULL &&
1277 tp->cookie_values->cookie_desired > 0))) {
1278 u8 *c;
1279 u32 *mess = &tmp_ext.cookie_bakery[COOKIE_DIGEST_WORDS];
1280 int l = tmp_opt.cookie_plus - TCPOLEN_COOKIE_BASE;
1281
1282 if (tcp_cookie_generator(&tmp_ext.cookie_bakery[0]) != 0)
1283 goto drop_and_release;
1284
1285 /* Secret recipe starts with IP addresses */
1286 *mess++ ^= daddr;
1287 *mess++ ^= saddr;
1288
1289 /* plus variable length Initiator Cookie */
1290 c = (u8 *)mess;
1291 while (l-- > 0)
1292 *c++ ^= *hash_location++;
1293
1294#ifdef CONFIG_SYN_COOKIES
1295 want_cookie = 0; /* not our kind of cookie */
1296#endif
1297 tmp_ext.cookie_out_never = 0; /* false */
1298 tmp_ext.cookie_plus = tmp_opt.cookie_plus;
1299 } else if (!tp->rx_opt.cookie_in_always) {
1300 /* redundant indications, but ensure initialization. */
1301 tmp_ext.cookie_out_never = 1; /* true */
1302 tmp_ext.cookie_plus = 0;
1303 } else {
1304 goto drop_and_release;
1305 }
1306 tmp_ext.cookie_in_always = tp->rx_opt.cookie_in_always;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307
Florian Westphal4dfc2812008-04-10 03:12:40 -07001308 if (want_cookie && !tmp_opt.saw_tstamp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 tcp_clear_options(&tmp_opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 tcp_openreq_init(req, &tmp_opt, skb);
1313
David S. Millerbb5b7c12009-12-15 20:56:42 -08001314 ireq = inet_rsk(req);
1315 ireq->loc_addr = daddr;
1316 ireq->rmt_addr = saddr;
1317 ireq->no_srccheck = inet_sk(sk)->transparent;
1318 ireq->opt = tcp_v4_save_options(sk, skb);
1319
Paul Moore284904a2009-03-27 17:10:28 -04001320 if (security_inet_conn_request(sk, skb, req))
David S. Millerbb5b7c12009-12-15 20:56:42 -08001321 goto drop_and_free;
Paul Moore284904a2009-03-27 17:10:28 -04001322
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323 if (!want_cookie)
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001324 TCP_ECN_create_request(req, tcp_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325
1326 if (want_cookie) {
1327#ifdef CONFIG_SYN_COOKIES
1328 syn_flood_warning(skb);
Florian Westphal4dfc2812008-04-10 03:12:40 -07001329 req->cookie_ts = tmp_opt.tstamp_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330#endif
1331 isn = cookie_v4_init_sequence(sk, skb, &req->mss);
1332 } else if (!isn) {
1333 struct inet_peer *peer = NULL;
1334
1335 /* VJ's idea. We save last timestamp seen
1336 * from the destination in peer table, when entering
1337 * state TIME-WAIT, and check against it before
1338 * accepting new connection request.
1339 *
1340 * If "isn" is not zero, this request hit alive
1341 * timewait bucket, so that all the necessary checks
1342 * are made in the function processing timewait state.
1343 */
1344 if (tmp_opt.saw_tstamp &&
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001345 tcp_death_row.sysctl_tw_recycle &&
David S. Millerbb5b7c12009-12-15 20:56:42 -08001346 (dst = inet_csk_route_req(sk, req)) != NULL &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 (peer = rt_get_peer((struct rtable *)dst)) != NULL &&
1348 peer->v4daddr == saddr) {
Eric Dumazet2c1409a2009-11-12 09:33:09 +00001349 if ((u32)get_seconds() - peer->tcp_ts_stamp < TCP_PAWS_MSL &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 (s32)(peer->tcp_ts - req->ts_recent) >
1351 TCP_PAWS_WINDOW) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001352 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001353 goto drop_and_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354 }
1355 }
1356 /* Kill the following clause, if you dislike this way. */
1357 else if (!sysctl_tcp_syncookies &&
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001358 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 (sysctl_max_syn_backlog >> 2)) &&
1360 (!peer || !peer->tcp_ts_stamp) &&
1361 (!dst || !dst_metric(dst, RTAX_RTT))) {
1362 /* Without syncookies last quarter of
1363 * backlog is filled with destinations,
1364 * proven to be alive.
1365 * It means that we continue to communicate
1366 * to destinations, already remembered
1367 * to the moment of synflood.
1368 */
Harvey Harrison673d57e2008-10-31 00:53:57 -07001369 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open request from %pI4/%u\n",
1370 &saddr, ntohs(tcp_hdr(skb)->source));
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001371 goto drop_and_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 }
1373
Gerrit Renkera94f7232006-11-10 14:06:49 -08001374 isn = tcp_v4_init_sequence(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375 }
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001376 tcp_rsk(req)->snt_isn = isn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377
Octavian Purdila72659ec2010-01-17 19:09:39 -08001378 if (tcp_v4_send_synack(sk, dst, req,
1379 (struct request_values *)&tmp_ext) ||
William Allen Simpson4957faade2009-12-02 18:25:27 +00001380 want_cookie)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 goto drop_and_free;
1382
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001383 inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 return 0;
1385
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001386drop_and_release:
1387 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388drop_and_free:
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001389 reqsk_free(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390drop:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391 return 0;
1392}
1393
1394
1395/*
1396 * The three way handshake has completed - we got a valid synack -
1397 * now create the new socket.
1398 */
1399struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001400 struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401 struct dst_entry *dst)
1402{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001403 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 struct inet_sock *newinet;
1405 struct tcp_sock *newtp;
1406 struct sock *newsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001407#ifdef CONFIG_TCP_MD5SIG
1408 struct tcp_md5sig_key *key;
1409#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410
1411 if (sk_acceptq_is_full(sk))
1412 goto exit_overflow;
1413
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001414 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415 goto exit;
1416
1417 newsk = tcp_create_openreq_child(sk, req, skb);
1418 if (!newsk)
1419 goto exit;
1420
Herbert Xubcd76112006-06-30 13:36:35 -07001421 newsk->sk_gso_type = SKB_GSO_TCPV4;
Arnaldo Carvalho de Melo6cbb0df2005-08-09 19:49:02 -07001422 sk_setup_caps(newsk, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423
1424 newtp = tcp_sk(newsk);
1425 newinet = inet_sk(newsk);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001426 ireq = inet_rsk(req);
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001427 newinet->inet_daddr = ireq->rmt_addr;
1428 newinet->inet_rcv_saddr = ireq->loc_addr;
1429 newinet->inet_saddr = ireq->loc_addr;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001430 newinet->opt = ireq->opt;
1431 ireq->opt = NULL;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001432 newinet->mc_index = inet_iif(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001433 newinet->mc_ttl = ip_hdr(skb)->ttl;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001434 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 if (newinet->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001436 inet_csk(newsk)->icsk_ext_hdr_len = newinet->opt->optlen;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001437 newinet->inet_id = newtp->write_seq ^ jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438
John Heffner5d424d52006-03-20 17:53:41 -08001439 tcp_mtup_init(newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440 tcp_sync_mss(newsk, dst_mtu(dst));
1441 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
Tom Quetchenbachf5fff5d2008-09-21 00:21:51 -07001442 if (tcp_sk(sk)->rx_opt.user_mss &&
1443 tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1444 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1445
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446 tcp_initialize_rcv_mss(newsk);
1447
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001448#ifdef CONFIG_TCP_MD5SIG
1449 /* Copy over the MD5 key from the original socket */
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001450 key = tcp_v4_md5_do_lookup(sk, newinet->inet_daddr);
1451 if (key != NULL) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001452 /*
1453 * We're using one, so create a matching key
1454 * on the newsk structure. If we fail to get
1455 * memory, then we end up not copying the key
1456 * across. Shucks.
1457 */
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -02001458 char *newkey = kmemdup(key->key, key->keylen, GFP_ATOMIC);
1459 if (newkey != NULL)
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001460 tcp_v4_md5_do_add(newsk, newinet->inet_daddr,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001461 newkey, key->keylen);
Adam Langley49a72df2008-07-19 00:01:42 -07001462 newsk->sk_route_caps &= ~NETIF_F_GSO_MASK;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001463 }
1464#endif
1465
Eric Dumazet9327f702009-12-04 03:46:54 +00001466 __inet_hash_nolisten(newsk, NULL);
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001467 __inet_inherit_port(sk, newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468
1469 return newsk;
1470
1471exit_overflow:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001472 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473exit:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001474 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475 dst_release(dst);
1476 return NULL;
1477}
1478
1479static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
1480{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001481 struct tcphdr *th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001482 const struct iphdr *iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483 struct sock *nsk;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001484 struct request_sock **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 /* Find possible connection requests. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001486 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
1487 iph->saddr, iph->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488 if (req)
1489 return tcp_check_req(sk, skb, req, prev);
1490
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001491 nsk = inet_lookup_established(sock_net(sk), &tcp_hashinfo, iph->saddr,
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001492 th->source, iph->daddr, th->dest, inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493
1494 if (nsk) {
1495 if (nsk->sk_state != TCP_TIME_WAIT) {
1496 bh_lock_sock(nsk);
1497 return nsk;
1498 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001499 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500 return NULL;
1501 }
1502
1503#ifdef CONFIG_SYN_COOKIES
1504 if (!th->rst && !th->syn && th->ack)
1505 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
1506#endif
1507 return sk;
1508}
1509
Al Virob51655b2006-11-14 21:40:42 -08001510static __sum16 tcp_v4_checksum_init(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001512 const struct iphdr *iph = ip_hdr(skb);
1513
Patrick McHardy84fa7932006-08-29 16:44:56 -07001514 if (skb->ip_summed == CHECKSUM_COMPLETE) {
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001515 if (!tcp_v4_check(skb->len, iph->saddr,
1516 iph->daddr, skb->csum)) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001517 skb->ip_summed = CHECKSUM_UNNECESSARY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518 return 0;
Herbert Xufb286bb2005-11-10 13:01:24 -08001519 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520 }
Herbert Xufb286bb2005-11-10 13:01:24 -08001521
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001522 skb->csum = csum_tcpudp_nofold(iph->saddr, iph->daddr,
Herbert Xufb286bb2005-11-10 13:01:24 -08001523 skb->len, IPPROTO_TCP, 0);
1524
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 if (skb->len <= 76) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001526 return __skb_checksum_complete(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527 }
1528 return 0;
1529}
1530
1531
1532/* The socket must have it's spinlock held when we get
1533 * here.
1534 *
1535 * We have a potential double-lock case here, so even when
1536 * doing backlog processing we use the BH locking scheme.
1537 * This is because we cannot sleep with the original spinlock
1538 * held.
1539 */
1540int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1541{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001542 struct sock *rsk;
1543#ifdef CONFIG_TCP_MD5SIG
1544 /*
1545 * We really want to reject the packet as early as possible
1546 * if:
1547 * o We're expecting an MD5'd packet and this is no MD5 tcp option
1548 * o There is an MD5 option and we're not expecting one
1549 */
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001550 if (tcp_v4_inbound_md5_hash(sk, skb))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001551 goto discard;
1552#endif
1553
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1555 TCP_CHECK_TIMER(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001556 if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001557 rsk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001559 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560 TCP_CHECK_TIMER(sk);
1561 return 0;
1562 }
1563
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07001564 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 goto csum_err;
1566
1567 if (sk->sk_state == TCP_LISTEN) {
1568 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
1569 if (!nsk)
1570 goto discard;
1571
1572 if (nsk != sk) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001573 if (tcp_child_process(sk, nsk, skb)) {
1574 rsk = nsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001576 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577 return 0;
1578 }
1579 }
1580
1581 TCP_CHECK_TIMER(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001582 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001583 rsk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001585 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 TCP_CHECK_TIMER(sk);
1587 return 0;
1588
1589reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001590 tcp_v4_send_reset(rsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591discard:
1592 kfree_skb(skb);
1593 /* Be careful here. If this function gets more complicated and
1594 * gcc suffers from register pressure on the x86, sk (in %ebx)
1595 * might be destroyed here. This current version compiles correctly,
1596 * but you have been warned.
1597 */
1598 return 0;
1599
1600csum_err:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001601 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602 goto discard;
1603}
1604
1605/*
1606 * From tcp_input.c
1607 */
1608
1609int tcp_v4_rcv(struct sk_buff *skb)
1610{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001611 const struct iphdr *iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 struct tcphdr *th;
1613 struct sock *sk;
1614 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001615 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616
1617 if (skb->pkt_type != PACKET_HOST)
1618 goto discard_it;
1619
1620 /* Count it even if it's bad */
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001621 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622
1623 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1624 goto discard_it;
1625
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001626 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627
1628 if (th->doff < sizeof(struct tcphdr) / 4)
1629 goto bad_packet;
1630 if (!pskb_may_pull(skb, th->doff * 4))
1631 goto discard_it;
1632
1633 /* An explanation is required here, I think.
1634 * Packet length and doff are validated by header prediction,
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -08001635 * provided case of th->doff==0 is eliminated.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 * So, we defer the checks. */
Herbert Xu60476372007-04-09 11:59:39 -07001637 if (!skb_csum_unnecessary(skb) && tcp_v4_checksum_init(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638 goto bad_packet;
1639
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001640 th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001641 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1643 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1644 skb->len - th->doff * 4);
1645 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1646 TCP_SKB_CB(skb)->when = 0;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001647 TCP_SKB_CB(skb)->flags = iph->tos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648 TCP_SKB_CB(skb)->sacked = 0;
1649
Arnaldo Carvalho de Melo9a1f27c2008-10-07 11:41:57 -07001650 sk = __inet_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 if (!sk)
1652 goto no_tcp_socket;
1653
Eric Dumazetbb134d52010-03-09 05:55:56 +00001654process:
1655 if (sk->sk_state == TCP_TIME_WAIT)
1656 goto do_time_wait;
1657
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001658 if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
1659 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
Stephen Hemmingerd218d112010-01-11 16:28:01 -08001660 goto discard_and_relse;
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001661 }
Stephen Hemmingerd218d112010-01-11 16:28:01 -08001662
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1664 goto discard_and_relse;
Patrick McHardyb59c2702006-01-06 23:06:10 -08001665 nf_reset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001667 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 goto discard_and_relse;
1669
1670 skb->dev = NULL;
1671
Ingo Molnarc6366182006-07-03 00:25:13 -07001672 bh_lock_sock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673 ret = 0;
1674 if (!sock_owned_by_user(sk)) {
Chris Leech1a2449a2006-05-23 18:05:53 -07001675#ifdef CONFIG_NET_DMA
1676 struct tcp_sock *tp = tcp_sk(sk);
1677 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
Dan Williamsf67b4592009-01-06 11:38:15 -07001678 tp->ucopy.dma_chan = dma_find_channel(DMA_MEMCPY);
Chris Leech1a2449a2006-05-23 18:05:53 -07001679 if (tp->ucopy.dma_chan)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 ret = tcp_v4_do_rcv(sk, skb);
Chris Leech1a2449a2006-05-23 18:05:53 -07001681 else
1682#endif
1683 {
1684 if (!tcp_prequeue(sk, skb))
Shan Weiae8d7f82009-05-05 01:01:29 +00001685 ret = tcp_v4_do_rcv(sk, skb);
Chris Leech1a2449a2006-05-23 18:05:53 -07001686 }
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001687 } else if (unlikely(sk_add_backlog(sk, skb))) {
Zhu Yi6b03a532010-03-04 18:01:41 +00001688 bh_unlock_sock(sk);
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001689 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
Zhu Yi6b03a532010-03-04 18:01:41 +00001690 goto discard_and_relse;
1691 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 bh_unlock_sock(sk);
1693
1694 sock_put(sk);
1695
1696 return ret;
1697
1698no_tcp_socket:
1699 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1700 goto discard_it;
1701
1702 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1703bad_packet:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001704 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001706 tcp_v4_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 }
1708
1709discard_it:
1710 /* Discard frame. */
1711 kfree_skb(skb);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001712 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713
1714discard_and_relse:
1715 sock_put(sk);
1716 goto discard_it;
1717
1718do_time_wait:
1719 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001720 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721 goto discard_it;
1722 }
1723
1724 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001725 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001726 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727 goto discard_it;
1728 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001729 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730 case TCP_TW_SYN: {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001731 struct sock *sk2 = inet_lookup_listener(dev_net(skb->dev),
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001732 &tcp_hashinfo,
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001733 iph->daddr, th->dest,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001734 inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735 if (sk2) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001736 inet_twsk_deschedule(inet_twsk(sk), &tcp_death_row);
1737 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738 sk = sk2;
1739 goto process;
1740 }
1741 /* Fall through to ACK */
1742 }
1743 case TCP_TW_ACK:
1744 tcp_v4_timewait_ack(sk, skb);
1745 break;
1746 case TCP_TW_RST:
1747 goto no_tcp_socket;
1748 case TCP_TW_SUCCESS:;
1749 }
1750 goto discard_it;
1751}
1752
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753/* VJ's idea. Save last timestamp seen from this destination
1754 * and hold it at least for normal timewait interval to use for duplicate
1755 * segment detection in subsequent connections, before they enter synchronized
1756 * state.
1757 */
1758
1759int tcp_v4_remember_stamp(struct sock *sk)
1760{
1761 struct inet_sock *inet = inet_sk(sk);
1762 struct tcp_sock *tp = tcp_sk(sk);
1763 struct rtable *rt = (struct rtable *)__sk_dst_get(sk);
1764 struct inet_peer *peer = NULL;
1765 int release_it = 0;
1766
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001767 if (!rt || rt->rt_dst != inet->inet_daddr) {
1768 peer = inet_getpeer(inet->inet_daddr, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 release_it = 1;
1770 } else {
1771 if (!rt->peer)
1772 rt_bind_peer(rt, 1);
1773 peer = rt->peer;
1774 }
1775
1776 if (peer) {
1777 if ((s32)(peer->tcp_ts - tp->rx_opt.ts_recent) <= 0 ||
Eric Dumazet2c1409a2009-11-12 09:33:09 +00001778 ((u32)get_seconds() - peer->tcp_ts_stamp > TCP_PAWS_MSL &&
1779 peer->tcp_ts_stamp <= (u32)tp->rx_opt.ts_recent_stamp)) {
1780 peer->tcp_ts_stamp = (u32)tp->rx_opt.ts_recent_stamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781 peer->tcp_ts = tp->rx_opt.ts_recent;
1782 }
1783 if (release_it)
1784 inet_putpeer(peer);
1785 return 1;
1786 }
1787
1788 return 0;
1789}
1790
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001791int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001793 struct inet_peer *peer = inet_getpeer(tw->tw_daddr, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794
1795 if (peer) {
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001796 const struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
1797
1798 if ((s32)(peer->tcp_ts - tcptw->tw_ts_recent) <= 0 ||
Eric Dumazet2c1409a2009-11-12 09:33:09 +00001799 ((u32)get_seconds() - peer->tcp_ts_stamp > TCP_PAWS_MSL &&
1800 peer->tcp_ts_stamp <= (u32)tcptw->tw_ts_recent_stamp)) {
1801 peer->tcp_ts_stamp = (u32)tcptw->tw_ts_recent_stamp;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001802 peer->tcp_ts = tcptw->tw_ts_recent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803 }
1804 inet_putpeer(peer);
1805 return 1;
1806 }
1807
1808 return 0;
1809}
1810
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001811const struct inet_connection_sock_af_ops ipv4_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001812 .queue_xmit = ip_queue_xmit,
1813 .send_check = tcp_v4_send_check,
1814 .rebuild_header = inet_sk_rebuild_header,
1815 .conn_request = tcp_v4_conn_request,
1816 .syn_recv_sock = tcp_v4_syn_recv_sock,
1817 .remember_stamp = tcp_v4_remember_stamp,
1818 .net_header_len = sizeof(struct iphdr),
1819 .setsockopt = ip_setsockopt,
1820 .getsockopt = ip_getsockopt,
1821 .addr2sockaddr = inet_csk_addr2sockaddr,
1822 .sockaddr_len = sizeof(struct sockaddr_in),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001823 .bind_conflict = inet_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001824#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001825 .compat_setsockopt = compat_ip_setsockopt,
1826 .compat_getsockopt = compat_ip_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001827#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828};
1829
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001830#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001831static const struct tcp_sock_af_ops tcp_sock_ipv4_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001832 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001833 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001834 .md5_add = tcp_v4_md5_add_func,
1835 .md5_parse = tcp_v4_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001836};
Andrew Mortonb6332e62006-11-30 19:16:28 -08001837#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001838
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839/* NOTE: A lot of things set to zero explicitly by call to
1840 * sk_alloc() so need not be done here.
1841 */
1842static int tcp_v4_init_sock(struct sock *sk)
1843{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001844 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845 struct tcp_sock *tp = tcp_sk(sk);
1846
1847 skb_queue_head_init(&tp->out_of_order_queue);
1848 tcp_init_xmit_timers(sk);
1849 tcp_prequeue_init(tp);
1850
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001851 icsk->icsk_rto = TCP_TIMEOUT_INIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852 tp->mdev = TCP_TIMEOUT_INIT;
1853
1854 /* So many TCP implementations out there (incorrectly) count the
1855 * initial SYN frame in their delayed-ACK and congestion control
1856 * algorithms that we must have the following bandaid to talk
1857 * efficiently to them. -DaveM
1858 */
1859 tp->snd_cwnd = 2;
1860
1861 /* See draft-stevens-tcpca-spec-01 for discussion of the
1862 * initialization of these values.
1863 */
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07001864 tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865 tp->snd_cwnd_clamp = ~0;
William Allen Simpsonbee7ca92009-11-10 09:51:18 +00001866 tp->mss_cache = TCP_MSS_DEFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867
1868 tp->reordering = sysctl_tcp_reordering;
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001869 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870
1871 sk->sk_state = TCP_CLOSE;
1872
1873 sk->sk_write_space = sk_stream_write_space;
1874 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1875
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001876 icsk->icsk_af_ops = &ipv4_specific;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001877 icsk->icsk_sync_mss = tcp_sync_mss;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001878#ifdef CONFIG_TCP_MD5SIG
1879 tp->af_specific = &tcp_sock_ipv4_specific;
1880#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881
William Allen Simpson435cf552009-12-02 18:17:05 +00001882 /* TCP Cookie Transactions */
1883 if (sysctl_tcp_cookie_size > 0) {
1884 /* Default, cookies without s_data_payload. */
1885 tp->cookie_values =
1886 kzalloc(sizeof(*tp->cookie_values),
1887 sk->sk_allocation);
1888 if (tp->cookie_values != NULL)
1889 kref_init(&tp->cookie_values->kref);
1890 }
1891 /* Presumed zeroed, in order of appearance:
1892 * cookie_in_always, cookie_out_never,
1893 * s_data_constant, s_data_in, s_data_out
1894 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1896 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1897
Herbert Xueb4dea52008-12-29 23:04:08 -08001898 local_bh_disable();
Eric Dumazet17483762008-11-25 21:16:35 -08001899 percpu_counter_inc(&tcp_sockets_allocated);
Herbert Xueb4dea52008-12-29 23:04:08 -08001900 local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001901
1902 return 0;
1903}
1904
Brian Haley7d06b2e2008-06-14 17:04:49 -07001905void tcp_v4_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906{
1907 struct tcp_sock *tp = tcp_sk(sk);
1908
1909 tcp_clear_xmit_timers(sk);
1910
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001911 tcp_cleanup_congestion_control(sk);
Stephen Hemminger317a76f2005-06-23 12:19:55 -07001912
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 /* Cleanup up the write buffer. */
David S. Millerfe067e82007-03-07 12:12:44 -08001914 tcp_write_queue_purge(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915
1916 /* Cleans up our, hopefully empty, out_of_order_queue. */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001917 __skb_queue_purge(&tp->out_of_order_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001919#ifdef CONFIG_TCP_MD5SIG
1920 /* Clean up the MD5 key list, if any */
1921 if (tp->md5sig_info) {
1922 tcp_v4_clear_md5_list(sk);
1923 kfree(tp->md5sig_info);
1924 tp->md5sig_info = NULL;
1925 }
1926#endif
1927
Chris Leech1a2449a2006-05-23 18:05:53 -07001928#ifdef CONFIG_NET_DMA
1929 /* Cleans up our sk_async_wait_queue */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001930 __skb_queue_purge(&sk->sk_async_wait_queue);
Chris Leech1a2449a2006-05-23 18:05:53 -07001931#endif
1932
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933 /* Clean prequeue, it must be empty really */
1934 __skb_queue_purge(&tp->ucopy.prequeue);
1935
1936 /* Clean up a referenced TCP bind bucket. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001937 if (inet_csk(sk)->icsk_bind_hash)
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001938 inet_put_port(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939
1940 /*
1941 * If sendmsg cached page exists, toss it.
1942 */
1943 if (sk->sk_sndmsg_page) {
1944 __free_page(sk->sk_sndmsg_page);
1945 sk->sk_sndmsg_page = NULL;
1946 }
1947
William Allen Simpson435cf552009-12-02 18:17:05 +00001948 /* TCP Cookie Transactions */
1949 if (tp->cookie_values != NULL) {
1950 kref_put(&tp->cookie_values->kref,
1951 tcp_cookie_values_release);
1952 tp->cookie_values = NULL;
1953 }
1954
Eric Dumazet17483762008-11-25 21:16:35 -08001955 percpu_counter_dec(&tcp_sockets_allocated);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001956}
1957
1958EXPORT_SYMBOL(tcp_v4_destroy_sock);
1959
1960#ifdef CONFIG_PROC_FS
1961/* Proc filesystem TCP sock list dumping. */
1962
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001963static inline struct inet_timewait_sock *tw_head(struct hlist_nulls_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964{
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001965 return hlist_nulls_empty(head) ? NULL :
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001966 list_entry(head->first, struct inet_timewait_sock, tw_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967}
1968
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001969static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970{
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001971 return !is_a_nulls(tw->tw_node.next) ?
1972 hlist_nulls_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973}
1974
1975static void *listening_get_next(struct seq_file *seq, void *cur)
1976{
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001977 struct inet_connection_sock *icsk;
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08001978 struct hlist_nulls_node *node;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979 struct sock *sk = cur;
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001980 struct inet_listen_hashbucket *ilb;
Jianjun Kong5799de02008-11-03 02:49:10 -08001981 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07001982 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983
1984 if (!sk) {
1985 st->bucket = 0;
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001986 ilb = &tcp_hashinfo.listening_hash[0];
1987 spin_lock_bh(&ilb->lock);
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08001988 sk = sk_nulls_head(&ilb->head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989 goto get_sk;
1990 }
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001991 ilb = &tcp_hashinfo.listening_hash[st->bucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992 ++st->num;
1993
1994 if (st->state == TCP_SEQ_STATE_OPENREQ) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001995 struct request_sock *req = cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001997 icsk = inet_csk(st->syn_wait_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998 req = req->dl_next;
1999 while (1) {
2000 while (req) {
Daniel Lezcanobdccc4c2008-07-19 00:15:13 -07002001 if (req->rsk_ops->family == st->family) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002 cur = req;
2003 goto out;
2004 }
2005 req = req->dl_next;
2006 }
Eric Dumazet72a3eff2006-11-16 02:30:37 -08002007 if (++st->sbucket >= icsk->icsk_accept_queue.listen_opt->nr_table_entries)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008 break;
2009get_req:
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002010 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011 }
2012 sk = sk_next(st->syn_wait_sk);
2013 st->state = TCP_SEQ_STATE_LISTENING;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002014 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015 } else {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002016 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002017 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2018 if (reqsk_queue_len(&icsk->icsk_accept_queue))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019 goto start_req;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002020 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002021 sk = sk_next(sk);
2022 }
2023get_sk:
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08002024 sk_nulls_for_each_from(sk, node) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002025 if (sk->sk_family == st->family && net_eq(sock_net(sk), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026 cur = sk;
2027 goto out;
2028 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002029 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002030 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2031 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002032start_req:
2033 st->uid = sock_i_uid(sk);
2034 st->syn_wait_sk = sk;
2035 st->state = TCP_SEQ_STATE_OPENREQ;
2036 st->sbucket = 0;
2037 goto get_req;
2038 }
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002039 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040 }
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002041 spin_unlock_bh(&ilb->lock);
Arnaldo Carvalho de Melo0f7ff922005-08-09 19:59:44 -07002042 if (++st->bucket < INET_LHTABLE_SIZE) {
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002043 ilb = &tcp_hashinfo.listening_hash[st->bucket];
2044 spin_lock_bh(&ilb->lock);
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08002045 sk = sk_nulls_head(&ilb->head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002046 goto get_sk;
2047 }
2048 cur = NULL;
2049out:
2050 return cur;
2051}
2052
2053static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
2054{
2055 void *rc = listening_get_next(seq, NULL);
2056
2057 while (rc && *pos) {
2058 rc = listening_get_next(seq, rc);
2059 --*pos;
2060 }
2061 return rc;
2062}
2063
Andi Kleen6eac5602008-08-28 01:08:02 -07002064static inline int empty_bucket(struct tcp_iter_state *st)
2065{
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002066 return hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].chain) &&
2067 hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].twchain);
Andi Kleen6eac5602008-08-28 01:08:02 -07002068}
2069
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070static void *established_get_first(struct seq_file *seq)
2071{
Jianjun Kong5799de02008-11-03 02:49:10 -08002072 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002073 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074 void *rc = NULL;
2075
Eric Dumazetf373b532009-10-09 00:16:19 +00002076 for (st->bucket = 0; st->bucket <= tcp_hashinfo.ehash_mask; ++st->bucket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077 struct sock *sk;
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002078 struct hlist_nulls_node *node;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002079 struct inet_timewait_sock *tw;
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002080 spinlock_t *lock = inet_ehash_lockp(&tcp_hashinfo, st->bucket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081
Andi Kleen6eac5602008-08-28 01:08:02 -07002082 /* Lockless fast path for the common case of empty buckets */
2083 if (empty_bucket(st))
2084 continue;
2085
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002086 spin_lock_bh(lock);
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002087 sk_nulls_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002088 if (sk->sk_family != st->family ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002089 !net_eq(sock_net(sk), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002090 continue;
2091 }
2092 rc = sk;
2093 goto out;
2094 }
2095 st->state = TCP_SEQ_STATE_TIME_WAIT;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002096 inet_twsk_for_each(tw, node,
Eric Dumazetdbca9b2752007-02-08 14:16:46 -08002097 &tcp_hashinfo.ehash[st->bucket].twchain) {
Pavel Emelyanov28518fc2008-03-21 15:52:00 -07002098 if (tw->tw_family != st->family ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002099 !net_eq(twsk_net(tw), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002100 continue;
2101 }
2102 rc = tw;
2103 goto out;
2104 }
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002105 spin_unlock_bh(lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106 st->state = TCP_SEQ_STATE_ESTABLISHED;
2107 }
2108out:
2109 return rc;
2110}
2111
2112static void *established_get_next(struct seq_file *seq, void *cur)
2113{
2114 struct sock *sk = cur;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002115 struct inet_timewait_sock *tw;
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002116 struct hlist_nulls_node *node;
Jianjun Kong5799de02008-11-03 02:49:10 -08002117 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002118 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119
2120 ++st->num;
2121
2122 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
2123 tw = cur;
2124 tw = tw_next(tw);
2125get_tw:
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002126 while (tw && (tw->tw_family != st->family || !net_eq(twsk_net(tw), net))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002127 tw = tw_next(tw);
2128 }
2129 if (tw) {
2130 cur = tw;
2131 goto out;
2132 }
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002133 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134 st->state = TCP_SEQ_STATE_ESTABLISHED;
2135
Andi Kleen6eac5602008-08-28 01:08:02 -07002136 /* Look for next non empty bucket */
Eric Dumazetf373b532009-10-09 00:16:19 +00002137 while (++st->bucket <= tcp_hashinfo.ehash_mask &&
Andi Kleen6eac5602008-08-28 01:08:02 -07002138 empty_bucket(st))
2139 ;
Eric Dumazetf373b532009-10-09 00:16:19 +00002140 if (st->bucket > tcp_hashinfo.ehash_mask)
Andi Kleen6eac5602008-08-28 01:08:02 -07002141 return NULL;
2142
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002143 spin_lock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002144 sk = sk_nulls_head(&tcp_hashinfo.ehash[st->bucket].chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145 } else
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002146 sk = sk_nulls_next(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002147
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002148 sk_nulls_for_each_from(sk, node) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002149 if (sk->sk_family == st->family && net_eq(sock_net(sk), net))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002150 goto found;
2151 }
2152
2153 st->state = TCP_SEQ_STATE_TIME_WAIT;
Eric Dumazetdbca9b2752007-02-08 14:16:46 -08002154 tw = tw_head(&tcp_hashinfo.ehash[st->bucket].twchain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002155 goto get_tw;
2156found:
2157 cur = sk;
2158out:
2159 return cur;
2160}
2161
2162static void *established_get_idx(struct seq_file *seq, loff_t pos)
2163{
2164 void *rc = established_get_first(seq);
2165
2166 while (rc && pos) {
2167 rc = established_get_next(seq, rc);
2168 --pos;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002169 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002170 return rc;
2171}
2172
2173static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
2174{
2175 void *rc;
Jianjun Kong5799de02008-11-03 02:49:10 -08002176 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177
Linus Torvalds1da177e2005-04-16 15:20:36 -07002178 st->state = TCP_SEQ_STATE_LISTENING;
2179 rc = listening_get_idx(seq, &pos);
2180
2181 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182 st->state = TCP_SEQ_STATE_ESTABLISHED;
2183 rc = established_get_idx(seq, pos);
2184 }
2185
2186 return rc;
2187}
2188
2189static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
2190{
Jianjun Kong5799de02008-11-03 02:49:10 -08002191 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192 st->state = TCP_SEQ_STATE_LISTENING;
2193 st->num = 0;
2194 return *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2195}
2196
2197static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2198{
2199 void *rc = NULL;
Jianjun Kong5799de02008-11-03 02:49:10 -08002200 struct tcp_iter_state *st;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002201
2202 if (v == SEQ_START_TOKEN) {
2203 rc = tcp_get_idx(seq, 0);
2204 goto out;
2205 }
2206 st = seq->private;
2207
2208 switch (st->state) {
2209 case TCP_SEQ_STATE_OPENREQ:
2210 case TCP_SEQ_STATE_LISTENING:
2211 rc = listening_get_next(seq, v);
2212 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213 st->state = TCP_SEQ_STATE_ESTABLISHED;
2214 rc = established_get_first(seq);
2215 }
2216 break;
2217 case TCP_SEQ_STATE_ESTABLISHED:
2218 case TCP_SEQ_STATE_TIME_WAIT:
2219 rc = established_get_next(seq, v);
2220 break;
2221 }
2222out:
2223 ++*pos;
2224 return rc;
2225}
2226
2227static void tcp_seq_stop(struct seq_file *seq, void *v)
2228{
Jianjun Kong5799de02008-11-03 02:49:10 -08002229 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230
2231 switch (st->state) {
2232 case TCP_SEQ_STATE_OPENREQ:
2233 if (v) {
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002234 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
2235 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236 }
2237 case TCP_SEQ_STATE_LISTENING:
2238 if (v != SEQ_START_TOKEN)
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002239 spin_unlock_bh(&tcp_hashinfo.listening_hash[st->bucket].lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240 break;
2241 case TCP_SEQ_STATE_TIME_WAIT:
2242 case TCP_SEQ_STATE_ESTABLISHED:
2243 if (v)
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002244 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245 break;
2246 }
2247}
2248
2249static int tcp_seq_open(struct inode *inode, struct file *file)
2250{
2251 struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002252 struct tcp_iter_state *s;
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002253 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002254
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002255 err = seq_open_net(inode, file, &afinfo->seq_ops,
2256 sizeof(struct tcp_iter_state));
2257 if (err < 0)
2258 return err;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002259
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002260 s = ((struct seq_file *)file->private_data)->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002261 s->family = afinfo->family;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002262 return 0;
2263}
2264
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002265int tcp_proc_register(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266{
2267 int rc = 0;
2268 struct proc_dir_entry *p;
2269
Denis V. Lunev68fcadd2008-04-13 22:13:30 -07002270 afinfo->seq_fops.open = tcp_seq_open;
2271 afinfo->seq_fops.read = seq_read;
2272 afinfo->seq_fops.llseek = seq_lseek;
2273 afinfo->seq_fops.release = seq_release_net;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002274
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002275 afinfo->seq_ops.start = tcp_seq_start;
2276 afinfo->seq_ops.next = tcp_seq_next;
2277 afinfo->seq_ops.stop = tcp_seq_stop;
2278
Denis V. Lunev84841c32008-05-02 04:10:08 -07002279 p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net,
2280 &afinfo->seq_fops, afinfo);
2281 if (!p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282 rc = -ENOMEM;
2283 return rc;
2284}
2285
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002286void tcp_proc_unregister(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002288 proc_net_remove(net, afinfo->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289}
2290
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002291static void get_openreq4(struct sock *sk, struct request_sock *req,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002292 struct seq_file *f, int i, int uid, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002294 const struct inet_request_sock *ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295 int ttd = req->expires - jiffies;
2296
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002297 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
2298 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p%n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002299 i,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002300 ireq->loc_addr,
Eric Dumazetc720c7e2009-10-15 06:30:45 +00002301 ntohs(inet_sk(sk)->inet_sport),
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002302 ireq->rmt_addr,
2303 ntohs(ireq->rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002304 TCP_SYN_RECV,
2305 0, 0, /* could print option size, but that is af dependent. */
2306 1, /* timers active (only the expire timer) */
2307 jiffies_to_clock_t(ttd),
2308 req->retrans,
2309 uid,
2310 0, /* non standard timer */
2311 0, /* open_requests have no inode */
2312 atomic_read(&sk->sk_refcnt),
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002313 req,
2314 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315}
2316
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002317static void get_tcp4_sock(struct sock *sk, struct seq_file *f, int i, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002318{
2319 int timer_active;
2320 unsigned long timer_expires;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002321 struct tcp_sock *tp = tcp_sk(sk);
2322 const struct inet_connection_sock *icsk = inet_csk(sk);
2323 struct inet_sock *inet = inet_sk(sk);
Eric Dumazetc720c7e2009-10-15 06:30:45 +00002324 __be32 dest = inet->inet_daddr;
2325 __be32 src = inet->inet_rcv_saddr;
2326 __u16 destp = ntohs(inet->inet_dport);
2327 __u16 srcp = ntohs(inet->inet_sport);
Eric Dumazet49d09002009-12-03 16:06:13 -08002328 int rx_queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002330 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002332 timer_expires = icsk->icsk_timeout;
2333 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002334 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002335 timer_expires = icsk->icsk_timeout;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002336 } else if (timer_pending(&sk->sk_timer)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337 timer_active = 2;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002338 timer_expires = sk->sk_timer.expires;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002339 } else {
2340 timer_active = 0;
2341 timer_expires = jiffies;
2342 }
2343
Eric Dumazet49d09002009-12-03 16:06:13 -08002344 if (sk->sk_state == TCP_LISTEN)
2345 rx_queue = sk->sk_ack_backlog;
2346 else
2347 /*
2348 * because we dont lock socket, we might find a transient negative value
2349 */
2350 rx_queue = max_t(int, tp->rcv_nxt - tp->copied_seq, 0);
2351
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002352 seq_printf(f, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
Stephen Hemminger7be87352008-06-27 20:00:19 -07002353 "%08X %5d %8d %lu %d %p %lu %lu %u %u %d%n",
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002354 i, src, srcp, dest, destp, sk->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07002355 tp->write_seq - tp->snd_una,
Eric Dumazet49d09002009-12-03 16:06:13 -08002356 rx_queue,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002357 timer_active,
2358 jiffies_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002359 icsk->icsk_retransmits,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002360 sock_i_uid(sk),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03002361 icsk->icsk_probes_out,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002362 sock_i_ino(sk),
2363 atomic_read(&sk->sk_refcnt), sk,
Stephen Hemminger7be87352008-06-27 20:00:19 -07002364 jiffies_to_clock_t(icsk->icsk_rto),
2365 jiffies_to_clock_t(icsk->icsk_ack.ato),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002366 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002367 tp->snd_cwnd,
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07002368 tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002369 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002370}
2371
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002372static void get_timewait4_sock(struct inet_timewait_sock *tw,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002373 struct seq_file *f, int i, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002374{
Al Viro23f33c22006-09-27 18:43:50 -07002375 __be32 dest, src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002376 __u16 destp, srcp;
2377 int ttd = tw->tw_ttd - jiffies;
2378
2379 if (ttd < 0)
2380 ttd = 0;
2381
2382 dest = tw->tw_daddr;
2383 src = tw->tw_rcv_saddr;
2384 destp = ntohs(tw->tw_dport);
2385 srcp = ntohs(tw->tw_sport);
2386
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002387 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
2388 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p%n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002389 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
2390 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002391 atomic_read(&tw->tw_refcnt), tw, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392}
2393
2394#define TMPSZ 150
2395
2396static int tcp4_seq_show(struct seq_file *seq, void *v)
2397{
Jianjun Kong5799de02008-11-03 02:49:10 -08002398 struct tcp_iter_state *st;
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002399 int len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002400
2401 if (v == SEQ_START_TOKEN) {
2402 seq_printf(seq, "%-*s\n", TMPSZ - 1,
2403 " sl local_address rem_address st tx_queue "
2404 "rx_queue tr tm->when retrnsmt uid timeout "
2405 "inode");
2406 goto out;
2407 }
2408 st = seq->private;
2409
2410 switch (st->state) {
2411 case TCP_SEQ_STATE_LISTENING:
2412 case TCP_SEQ_STATE_ESTABLISHED:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002413 get_tcp4_sock(v, seq, st->num, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002414 break;
2415 case TCP_SEQ_STATE_OPENREQ:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002416 get_openreq4(st->syn_wait_sk, v, seq, st->num, st->uid, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002417 break;
2418 case TCP_SEQ_STATE_TIME_WAIT:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002419 get_timewait4_sock(v, seq, st->num, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002420 break;
2421 }
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002422 seq_printf(seq, "%*s\n", TMPSZ - 1 - len, "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002423out:
2424 return 0;
2425}
2426
Linus Torvalds1da177e2005-04-16 15:20:36 -07002427static struct tcp_seq_afinfo tcp4_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002428 .name = "tcp",
2429 .family = AF_INET,
Denis V. Lunev5f4472c2008-04-13 22:13:53 -07002430 .seq_fops = {
2431 .owner = THIS_MODULE,
2432 },
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002433 .seq_ops = {
2434 .show = tcp4_seq_show,
2435 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002436};
2437
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002438static int __net_init tcp4_proc_init_net(struct net *net)
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002439{
2440 return tcp_proc_register(net, &tcp4_seq_afinfo);
2441}
2442
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002443static void __net_exit tcp4_proc_exit_net(struct net *net)
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002444{
2445 tcp_proc_unregister(net, &tcp4_seq_afinfo);
2446}
2447
2448static struct pernet_operations tcp4_net_ops = {
2449 .init = tcp4_proc_init_net,
2450 .exit = tcp4_proc_exit_net,
2451};
2452
Linus Torvalds1da177e2005-04-16 15:20:36 -07002453int __init tcp4_proc_init(void)
2454{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002455 return register_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002456}
2457
2458void tcp4_proc_exit(void)
2459{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002460 unregister_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002461}
2462#endif /* CONFIG_PROC_FS */
2463
Herbert Xubf296b12008-12-15 23:43:36 -08002464struct sk_buff **tcp4_gro_receive(struct sk_buff **head, struct sk_buff *skb)
2465{
Herbert Xu36e7b1b2009-04-27 05:44:45 -07002466 struct iphdr *iph = skb_gro_network_header(skb);
Herbert Xubf296b12008-12-15 23:43:36 -08002467
2468 switch (skb->ip_summed) {
2469 case CHECKSUM_COMPLETE:
Herbert Xu86911732009-01-29 14:19:50 +00002470 if (!tcp_v4_check(skb_gro_len(skb), iph->saddr, iph->daddr,
Herbert Xubf296b12008-12-15 23:43:36 -08002471 skb->csum)) {
2472 skb->ip_summed = CHECKSUM_UNNECESSARY;
2473 break;
2474 }
2475
2476 /* fall through */
2477 case CHECKSUM_NONE:
2478 NAPI_GRO_CB(skb)->flush = 1;
2479 return NULL;
2480 }
2481
2482 return tcp_gro_receive(head, skb);
2483}
2484EXPORT_SYMBOL(tcp4_gro_receive);
2485
2486int tcp4_gro_complete(struct sk_buff *skb)
2487{
2488 struct iphdr *iph = ip_hdr(skb);
2489 struct tcphdr *th = tcp_hdr(skb);
2490
2491 th->check = ~tcp_v4_check(skb->len - skb_transport_offset(skb),
2492 iph->saddr, iph->daddr, 0);
2493 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV4;
2494
2495 return tcp_gro_complete(skb);
2496}
2497EXPORT_SYMBOL(tcp4_gro_complete);
2498
Linus Torvalds1da177e2005-04-16 15:20:36 -07002499struct proto tcp_prot = {
2500 .name = "TCP",
2501 .owner = THIS_MODULE,
2502 .close = tcp_close,
2503 .connect = tcp_v4_connect,
2504 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002505 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002506 .ioctl = tcp_ioctl,
2507 .init = tcp_v4_init_sock,
2508 .destroy = tcp_v4_destroy_sock,
2509 .shutdown = tcp_shutdown,
2510 .setsockopt = tcp_setsockopt,
2511 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002512 .recvmsg = tcp_recvmsg,
2513 .backlog_rcv = tcp_v4_do_rcv,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08002514 .hash = inet_hash,
2515 .unhash = inet_unhash,
2516 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002517 .enter_memory_pressure = tcp_enter_memory_pressure,
2518 .sockets_allocated = &tcp_sockets_allocated,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07002519 .orphan_count = &tcp_orphan_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002520 .memory_allocated = &tcp_memory_allocated,
2521 .memory_pressure = &tcp_memory_pressure,
2522 .sysctl_mem = sysctl_tcp_mem,
2523 .sysctl_wmem = sysctl_tcp_wmem,
2524 .sysctl_rmem = sysctl_tcp_rmem,
2525 .max_header = MAX_TCP_HEADER,
2526 .obj_size = sizeof(struct tcp_sock),
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002527 .slab_flags = SLAB_DESTROY_BY_RCU,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002528 .twsk_prot = &tcp_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002529 .rsk_prot = &tcp_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07002530 .h.hashinfo = &tcp_hashinfo,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002531#ifdef CONFIG_COMPAT
2532 .compat_setsockopt = compat_tcp_setsockopt,
2533 .compat_getsockopt = compat_tcp_getsockopt,
2534#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002535};
2536
Denis V. Lunev046ee902008-04-03 14:31:33 -07002537
2538static int __net_init tcp_sk_init(struct net *net)
2539{
2540 return inet_ctl_sock_create(&net->ipv4.tcp_sock,
2541 PF_INET, SOCK_RAW, IPPROTO_TCP, net);
2542}
2543
2544static void __net_exit tcp_sk_exit(struct net *net)
2545{
2546 inet_ctl_sock_destroy(net->ipv4.tcp_sock);
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002547}
2548
2549static void __net_exit tcp_sk_exit_batch(struct list_head *net_exit_list)
2550{
2551 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET);
Denis V. Lunev046ee902008-04-03 14:31:33 -07002552}
2553
2554static struct pernet_operations __net_initdata tcp_sk_ops = {
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002555 .init = tcp_sk_init,
2556 .exit = tcp_sk_exit,
2557 .exit_batch = tcp_sk_exit_batch,
Denis V. Lunev046ee902008-04-03 14:31:33 -07002558};
2559
Denis V. Lunev9b0f9762008-02-29 11:13:15 -08002560void __init tcp_v4_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002561{
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002562 inet_hashinfo_init(&tcp_hashinfo);
Eric W. Biederman6a1b3052009-02-22 00:10:18 -08002563 if (register_pernet_subsys(&tcp_sk_ops))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002564 panic("Failed to create the TCP control socket.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002565}
2566
2567EXPORT_SYMBOL(ipv4_specific);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002568EXPORT_SYMBOL(tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002569EXPORT_SYMBOL(tcp_prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002570EXPORT_SYMBOL(tcp_v4_conn_request);
2571EXPORT_SYMBOL(tcp_v4_connect);
2572EXPORT_SYMBOL(tcp_v4_do_rcv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002573EXPORT_SYMBOL(tcp_v4_remember_stamp);
2574EXPORT_SYMBOL(tcp_v4_send_check);
2575EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
2576
2577#ifdef CONFIG_PROC_FS
2578EXPORT_SYMBOL(tcp_proc_register);
2579EXPORT_SYMBOL(tcp_proc_unregister);
2580#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002581EXPORT_SYMBOL(sysctl_tcp_low_latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002582