blob: 7cda24b53f610482dbee6de501334991aba030cb [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
168 tmp = ip_route_connect(&rt, nexthop, inet->saddr,
169 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
170 IPPROTO_TCP,
David S. Miller8eb90862007-02-08 02:09:21 -0800171 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
186 if (!inet->saddr)
187 inet->saddr = rt->rt_src;
188 inet->rcv_saddr = inet->saddr;
189
190 if (tp->rx_opt.ts_recent_stamp && inet->daddr != daddr) {
191 /* 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 &&
James Morris9d729f72007-03-04 16:12:44 -0800207 peer->tcp_ts_stamp + TCP_PAWS_MSL >= get_seconds()) {
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
213 inet->dport = usin->sin_port;
214 inet->daddr = daddr;
215
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
220 tp->rx_opt.mss_clamp = 536;
221
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,
233 inet->sport, 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)
242 tp->write_seq = secure_tcp_sequence_number(inet->saddr,
243 inet->daddr,
244 inet->sport,
245 usin->sin_port);
246
247 inet->id = tp->write_seq ^ jiffies;
248
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;
264 inet->dport = 0;
265 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) {
Frederik Deweerdtba7808e2007-02-04 20:15:27 -0800523 th->check = ~tcp_v4_check(len, inet->saddr,
524 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 {
Frederik Deweerdtba7808e2007-02-04 20:15:27 -0800528 th->check = tcp_v4_check(len, inet->saddr, inet->daddr,
Joe Perches07f07572008-11-19 15:44:53 -0800529 csum_partial(th,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 th->doff << 2,
531 skb->csum));
532 }
533}
534
Herbert Xua430a432006-07-08 13:34:56 -0700535int tcp_v4_gso_send_check(struct sk_buff *skb)
536{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700537 const struct iphdr *iph;
Herbert Xua430a432006-07-08 13:34:56 -0700538 struct tcphdr *th;
539
540 if (!pskb_may_pull(skb, sizeof(*th)))
541 return -EINVAL;
542
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700543 iph = ip_hdr(skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700544 th = tcp_hdr(skb);
Herbert Xua430a432006-07-08 13:34:56 -0700545
546 th->check = 0;
Frederik Deweerdtba7808e2007-02-04 20:15:27 -0800547 th->check = ~tcp_v4_check(skb->len, iph->saddr, iph->daddr, 0);
Herbert Xu663ead32007-04-09 11:59:07 -0700548 skb->csum_start = skb_transport_header(skb) - skb->head;
Al Viroff1dcad2006-11-20 18:07:29 -0800549 skb->csum_offset = offsetof(struct tcphdr, check);
Patrick McHardy84fa7932006-08-29 16:44:56 -0700550 skb->ip_summed = CHECKSUM_PARTIAL;
Herbert Xua430a432006-07-08 13:34:56 -0700551 return 0;
552}
553
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554/*
555 * This routine will send an RST to the other tcp.
556 *
557 * Someone asks: why I NEVER use socket parameters (TOS, TTL etc.)
558 * for reset.
559 * Answer: if a packet caused RST, it is not for a socket
560 * existing in our system, if it is matched to a socket,
561 * it is just duplicate segment or bug in other side's TCP.
562 * So that we build reply only basing on parameters
563 * arrived with segment.
564 * Exception: precedence violation. We do not implement it in any case.
565 */
566
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800567static void tcp_v4_send_reset(struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700569 struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800570 struct {
571 struct tcphdr th;
572#ifdef CONFIG_TCP_MD5SIG
Al Viro714e85b2006-11-14 20:51:49 -0800573 __be32 opt[(TCPOLEN_MD5SIG_ALIGNED >> 2)];
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800574#endif
575 } rep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 struct ip_reply_arg arg;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800577#ifdef CONFIG_TCP_MD5SIG
578 struct tcp_md5sig_key *key;
579#endif
Pavel Emelyanova86b1e32008-07-16 20:20:58 -0700580 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581
582 /* Never send a reset in response to a reset. */
583 if (th->rst)
584 return;
585
Eric Dumazet511c3f92009-06-02 05:14:27 +0000586 if (skb_rtable(skb)->rt_type != RTN_LOCAL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 return;
588
589 /* Swap the send and the receive. */
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800590 memset(&rep, 0, sizeof(rep));
591 rep.th.dest = th->source;
592 rep.th.source = th->dest;
593 rep.th.doff = sizeof(struct tcphdr) / 4;
594 rep.th.rst = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
596 if (th->ack) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800597 rep.th.seq = th->ack_seq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800599 rep.th.ack = 1;
600 rep.th.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
601 skb->len - (th->doff << 2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 }
603
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200604 memset(&arg, 0, sizeof(arg));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800605 arg.iov[0].iov_base = (unsigned char *)&rep;
606 arg.iov[0].iov_len = sizeof(rep.th);
607
608#ifdef CONFIG_TCP_MD5SIG
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700609 key = sk ? tcp_v4_md5_do_lookup(sk, ip_hdr(skb)->daddr) : NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800610 if (key) {
611 rep.opt[0] = htonl((TCPOPT_NOP << 24) |
612 (TCPOPT_NOP << 16) |
613 (TCPOPT_MD5SIG << 8) |
614 TCPOLEN_MD5SIG);
615 /* Update length and the length the header thinks exists */
616 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
617 rep.th.doff = arg.iov[0].iov_len / 4;
618
Adam Langley49a72df2008-07-19 00:01:42 -0700619 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[1],
Ilpo Järvinen78e645cb2008-10-09 14:37:47 -0700620 key, ip_hdr(skb)->saddr,
621 ip_hdr(skb)->daddr, &rep.th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800622 }
623#endif
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700624 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
625 ip_hdr(skb)->saddr, /* XXX */
Ilpo Järvinen52cd5752008-10-08 11:34:06 -0700626 arg.iov[0].iov_len, IPPROTO_TCP, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700628 arg.flags = (sk && inet_sk(sk)->transparent) ? IP_REPLY_ARG_NOSRCCHECK : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629
Eric Dumazetadf30902009-06-02 05:19:30 +0000630 net = dev_net(skb_dst(skb)->dev);
Pavel Emelyanova86b1e32008-07-16 20:20:58 -0700631 ip_send_reply(net->ipv4.tcp_sock, skb,
Denis V. Lunev7feb49c2008-04-03 14:32:00 -0700632 &arg, arg.iov[0].iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633
Pavel Emelyanov63231bd2008-07-16 20:22:25 -0700634 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
635 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636}
637
638/* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
639 outside socket context is ugly, certainly. What can I do?
640 */
641
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900642static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
643 u32 win, u32 ts, int oif,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700644 struct tcp_md5sig_key *key,
645 int reply_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700647 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 struct {
649 struct tcphdr th;
Al Viro714e85b2006-11-14 20:51:49 -0800650 __be32 opt[(TCPOLEN_TSTAMP_ALIGNED >> 2)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800651#ifdef CONFIG_TCP_MD5SIG
Al Viro714e85b2006-11-14 20:51:49 -0800652 + (TCPOLEN_MD5SIG_ALIGNED >> 2)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800653#endif
654 ];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 } rep;
656 struct ip_reply_arg arg;
Eric Dumazetadf30902009-06-02 05:19:30 +0000657 struct net *net = dev_net(skb_dst(skb)->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658
659 memset(&rep.th, 0, sizeof(struct tcphdr));
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200660 memset(&arg, 0, sizeof(arg));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661
662 arg.iov[0].iov_base = (unsigned char *)&rep;
663 arg.iov[0].iov_len = sizeof(rep.th);
664 if (ts) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800665 rep.opt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
666 (TCPOPT_TIMESTAMP << 8) |
667 TCPOLEN_TIMESTAMP);
668 rep.opt[1] = htonl(tcp_time_stamp);
669 rep.opt[2] = htonl(ts);
Craig Schlentercb48cfe2007-01-09 00:11:15 -0800670 arg.iov[0].iov_len += TCPOLEN_TSTAMP_ALIGNED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 }
672
673 /* Swap the send and the receive. */
674 rep.th.dest = th->source;
675 rep.th.source = th->dest;
676 rep.th.doff = arg.iov[0].iov_len / 4;
677 rep.th.seq = htonl(seq);
678 rep.th.ack_seq = htonl(ack);
679 rep.th.ack = 1;
680 rep.th.window = htons(win);
681
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800682#ifdef CONFIG_TCP_MD5SIG
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800683 if (key) {
684 int offset = (ts) ? 3 : 0;
685
686 rep.opt[offset++] = htonl((TCPOPT_NOP << 24) |
687 (TCPOPT_NOP << 16) |
688 (TCPOPT_MD5SIG << 8) |
689 TCPOLEN_MD5SIG);
690 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
691 rep.th.doff = arg.iov[0].iov_len/4;
692
Adam Langley49a72df2008-07-19 00:01:42 -0700693 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[offset],
Adam Langley90b7e112008-07-31 20:49:48 -0700694 key, ip_hdr(skb)->saddr,
695 ip_hdr(skb)->daddr, &rep.th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800696 }
697#endif
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700698 arg.flags = reply_flags;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700699 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
700 ip_hdr(skb)->saddr, /* XXX */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 arg.iov[0].iov_len, IPPROTO_TCP, 0);
702 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900703 if (oif)
704 arg.bound_dev_if = oif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705
Pavel Emelyanova86b1e32008-07-16 20:20:58 -0700706 ip_send_reply(net->ipv4.tcp_sock, skb,
Denis V. Lunev7feb49c2008-04-03 14:32:00 -0700707 &arg, arg.iov[0].iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708
Pavel Emelyanov63231bd2008-07-16 20:22:25 -0700709 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710}
711
712static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
713{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700714 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800715 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900717 tcp_v4_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200718 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900719 tcptw->tw_ts_recent,
720 tw->tw_bound_dev_if,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700721 tcp_twsk_md5_key(tcptw),
722 tw->tw_transparent ? IP_REPLY_ARG_NOSRCCHECK : 0
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900723 );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700725 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726}
727
Gui Jianfeng6edafaa2008-08-06 23:50:04 -0700728static void tcp_v4_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200729 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730{
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900731 tcp_v4_send_ack(skb, tcp_rsk(req)->snt_isn + 1,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800732 tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900733 req->ts_recent,
734 0,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700735 tcp_v4_md5_do_lookup(sk, ip_hdr(skb)->daddr),
736 inet_rsk(req)->no_srccheck ? IP_REPLY_ARG_NOSRCCHECK : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737}
738
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739/*
Kris Katterjohn9bf1d832008-02-17 22:29:19 -0800740 * Send a SYN-ACK after having received a SYN.
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700741 * This still operates on a request_sock only, not on a big
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 * socket.
743 */
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800744static int __tcp_v4_send_synack(struct sock *sk, struct request_sock *req,
745 struct dst_entry *dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700747 const struct inet_request_sock *ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 int err = -1;
749 struct sk_buff * skb;
750
751 /* First, grab a route. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700752 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800753 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754
755 skb = tcp_make_synack(sk, dst, req);
756
757 if (skb) {
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700758 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759
Frederik Deweerdtba7808e2007-02-04 20:15:27 -0800760 th->check = tcp_v4_check(skb->len,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700761 ireq->loc_addr,
762 ireq->rmt_addr,
Joe Perches07f07572008-11-19 15:44:53 -0800763 csum_partial(th, skb->len,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 skb->csum));
765
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700766 err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,
767 ireq->rmt_addr,
768 ireq->opt);
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200769 err = net_xmit_eval(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 }
771
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 dst_release(dst);
773 return err;
774}
775
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800776static int tcp_v4_send_synack(struct sock *sk, struct request_sock *req)
777{
778 return __tcp_v4_send_synack(sk, req, NULL);
779}
780
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700782 * IPv4 request_sock destructor.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 */
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700784static void tcp_v4_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785{
Jesper Juhla51482b2005-11-08 09:41:34 -0800786 kfree(inet_rsk(req)->opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787}
788
Arnaldo Carvalho de Melo80e40da2006-01-04 01:58:06 -0200789#ifdef CONFIG_SYN_COOKIES
Stephen Hemminger40efc6f2006-01-03 16:03:49 -0800790static void syn_flood_warning(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791{
792 static unsigned long warntime;
793
794 if (time_after(jiffies, (warntime + HZ * 60))) {
795 warntime = jiffies;
796 printk(KERN_INFO
797 "possible SYN flooding on port %d. Sending cookies.\n",
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700798 ntohs(tcp_hdr(skb)->dest));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 }
800}
Arnaldo Carvalho de Melo80e40da2006-01-04 01:58:06 -0200801#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802
803/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700804 * Save and compile IPv4 options into the request_sock if needed.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 */
Stephen Hemminger40efc6f2006-01-03 16:03:49 -0800806static struct ip_options *tcp_v4_save_options(struct sock *sk,
807 struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808{
809 struct ip_options *opt = &(IPCB(skb)->opt);
810 struct ip_options *dopt = NULL;
811
812 if (opt && opt->optlen) {
813 int opt_size = optlength(opt);
814 dopt = kmalloc(opt_size, GFP_ATOMIC);
815 if (dopt) {
816 if (ip_options_echo(dopt, skb)) {
817 kfree(dopt);
818 dopt = NULL;
819 }
820 }
821 }
822 return dopt;
823}
824
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800825#ifdef CONFIG_TCP_MD5SIG
826/*
827 * RFC2385 MD5 checksumming requires a mapping of
828 * IP address->MD5 Key.
829 * We need to maintain these in the sk structure.
830 */
831
832/* Find the Key structure for an address. */
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200833static struct tcp_md5sig_key *
834 tcp_v4_md5_do_lookup(struct sock *sk, __be32 addr)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800835{
836 struct tcp_sock *tp = tcp_sk(sk);
837 int i;
838
839 if (!tp->md5sig_info || !tp->md5sig_info->entries4)
840 return NULL;
841 for (i = 0; i < tp->md5sig_info->entries4; i++) {
842 if (tp->md5sig_info->keys4[i].addr == addr)
David S. Millerf8ab18d2007-09-28 15:18:35 -0700843 return &tp->md5sig_info->keys4[i].base;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800844 }
845 return NULL;
846}
847
848struct tcp_md5sig_key *tcp_v4_md5_lookup(struct sock *sk,
849 struct sock *addr_sk)
850{
851 return tcp_v4_md5_do_lookup(sk, inet_sk(addr_sk)->daddr);
852}
853
854EXPORT_SYMBOL(tcp_v4_md5_lookup);
855
Adrian Bunkf5b99bc2006-11-30 17:22:29 -0800856static struct tcp_md5sig_key *tcp_v4_reqsk_md5_lookup(struct sock *sk,
857 struct request_sock *req)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800858{
859 return tcp_v4_md5_do_lookup(sk, inet_rsk(req)->rmt_addr);
860}
861
862/* This can be called on a newly created socket, from other files */
863int tcp_v4_md5_do_add(struct sock *sk, __be32 addr,
864 u8 *newkey, u8 newkeylen)
865{
866 /* Add Key to the list */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700867 struct tcp_md5sig_key *key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800868 struct tcp_sock *tp = tcp_sk(sk);
869 struct tcp4_md5sig_key *keys;
870
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700871 key = tcp_v4_md5_do_lookup(sk, addr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800872 if (key) {
873 /* Pre-existing entry - just update that one. */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700874 kfree(key->key);
875 key->key = newkey;
876 key->keylen = newkeylen;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800877 } else {
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200878 struct tcp_md5sig_info *md5sig;
879
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800880 if (!tp->md5sig_info) {
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200881 tp->md5sig_info = kzalloc(sizeof(*tp->md5sig_info),
882 GFP_ATOMIC);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800883 if (!tp->md5sig_info) {
884 kfree(newkey);
885 return -ENOMEM;
886 }
David S. Miller3d7dbea2007-06-12 14:36:42 -0700887 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800888 }
Wu Fengguangaa133072009-09-02 23:45:45 -0700889 if (tcp_alloc_md5sig_pool(sk) == NULL) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800890 kfree(newkey);
891 return -ENOMEM;
892 }
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200893 md5sig = tp->md5sig_info;
894
895 if (md5sig->alloced4 == md5sig->entries4) {
896 keys = kmalloc((sizeof(*keys) *
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900897 (md5sig->entries4 + 1)), GFP_ATOMIC);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800898 if (!keys) {
899 kfree(newkey);
900 tcp_free_md5sig_pool();
901 return -ENOMEM;
902 }
903
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200904 if (md5sig->entries4)
905 memcpy(keys, md5sig->keys4,
906 sizeof(*keys) * md5sig->entries4);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800907
908 /* Free old key list, and reference new one */
YOSHIFUJI Hideakia80cc202007-11-20 17:30:06 -0800909 kfree(md5sig->keys4);
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200910 md5sig->keys4 = keys;
911 md5sig->alloced4++;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800912 }
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200913 md5sig->entries4++;
David S. Millerf8ab18d2007-09-28 15:18:35 -0700914 md5sig->keys4[md5sig->entries4 - 1].addr = addr;
915 md5sig->keys4[md5sig->entries4 - 1].base.key = newkey;
916 md5sig->keys4[md5sig->entries4 - 1].base.keylen = newkeylen;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800917 }
918 return 0;
919}
920
921EXPORT_SYMBOL(tcp_v4_md5_do_add);
922
923static int tcp_v4_md5_add_func(struct sock *sk, struct sock *addr_sk,
924 u8 *newkey, u8 newkeylen)
925{
926 return tcp_v4_md5_do_add(sk, inet_sk(addr_sk)->daddr,
927 newkey, newkeylen);
928}
929
930int tcp_v4_md5_do_del(struct sock *sk, __be32 addr)
931{
932 struct tcp_sock *tp = tcp_sk(sk);
933 int i;
934
935 for (i = 0; i < tp->md5sig_info->entries4; i++) {
936 if (tp->md5sig_info->keys4[i].addr == addr) {
937 /* Free the key */
David S. Millerf8ab18d2007-09-28 15:18:35 -0700938 kfree(tp->md5sig_info->keys4[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800939 tp->md5sig_info->entries4--;
940
941 if (tp->md5sig_info->entries4 == 0) {
942 kfree(tp->md5sig_info->keys4);
943 tp->md5sig_info->keys4 = NULL;
Leigh Brown8228a18d2006-12-17 17:12:30 -0800944 tp->md5sig_info->alloced4 = 0;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200945 } else if (tp->md5sig_info->entries4 != i) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800946 /* Need to do some manipulation */
YOSHIFUJI Hideaki354faf02007-11-20 17:30:31 -0800947 memmove(&tp->md5sig_info->keys4[i],
948 &tp->md5sig_info->keys4[i+1],
949 (tp->md5sig_info->entries4 - i) *
950 sizeof(struct tcp4_md5sig_key));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800951 }
952 tcp_free_md5sig_pool();
953 return 0;
954 }
955 }
956 return -ENOENT;
957}
958
959EXPORT_SYMBOL(tcp_v4_md5_do_del);
960
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200961static void tcp_v4_clear_md5_list(struct sock *sk)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800962{
963 struct tcp_sock *tp = tcp_sk(sk);
964
965 /* Free each key, then the set of key keys,
966 * the crypto element, and then decrement our
967 * hold on the last resort crypto.
968 */
969 if (tp->md5sig_info->entries4) {
970 int i;
971 for (i = 0; i < tp->md5sig_info->entries4; i++)
David S. Millerf8ab18d2007-09-28 15:18:35 -0700972 kfree(tp->md5sig_info->keys4[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800973 tp->md5sig_info->entries4 = 0;
974 tcp_free_md5sig_pool();
975 }
976 if (tp->md5sig_info->keys4) {
977 kfree(tp->md5sig_info->keys4);
978 tp->md5sig_info->keys4 = NULL;
979 tp->md5sig_info->alloced4 = 0;
980 }
981}
982
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200983static int tcp_v4_parse_md5_keys(struct sock *sk, char __user *optval,
984 int optlen)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800985{
986 struct tcp_md5sig cmd;
987 struct sockaddr_in *sin = (struct sockaddr_in *)&cmd.tcpm_addr;
988 u8 *newkey;
989
990 if (optlen < sizeof(cmd))
991 return -EINVAL;
992
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200993 if (copy_from_user(&cmd, optval, sizeof(cmd)))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800994 return -EFAULT;
995
996 if (sin->sin_family != AF_INET)
997 return -EINVAL;
998
999 if (!cmd.tcpm_key || !cmd.tcpm_keylen) {
1000 if (!tcp_sk(sk)->md5sig_info)
1001 return -ENOENT;
1002 return tcp_v4_md5_do_del(sk, sin->sin_addr.s_addr);
1003 }
1004
1005 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
1006 return -EINVAL;
1007
1008 if (!tcp_sk(sk)->md5sig_info) {
1009 struct tcp_sock *tp = tcp_sk(sk);
Wu Fengguangaa133072009-09-02 23:45:45 -07001010 struct tcp_md5sig_info *p;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001011
Wu Fengguangaa133072009-09-02 23:45:45 -07001012 p = kzalloc(sizeof(*p), sk->sk_allocation);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001013 if (!p)
1014 return -EINVAL;
1015
1016 tp->md5sig_info = p;
David S. Miller3d7dbea2007-06-12 14:36:42 -07001017 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001018 }
1019
Wu Fengguangaa133072009-09-02 23:45:45 -07001020 newkey = kmemdup(cmd.tcpm_key, cmd.tcpm_keylen, sk->sk_allocation);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001021 if (!newkey)
1022 return -ENOMEM;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001023 return tcp_v4_md5_do_add(sk, sin->sin_addr.s_addr,
1024 newkey, cmd.tcpm_keylen);
1025}
1026
Adam Langley49a72df2008-07-19 00:01:42 -07001027static int tcp_v4_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
1028 __be32 daddr, __be32 saddr, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001029{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001030 struct tcp4_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -07001031 struct scatterlist sg;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001032
1033 bp = &hp->md5_blk.ip4;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001034
1035 /*
Adam Langley49a72df2008-07-19 00:01:42 -07001036 * 1. the TCP pseudo-header (in the order: source IP address,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001037 * destination IP address, zero-padded protocol number, and
1038 * segment length)
1039 */
1040 bp->saddr = saddr;
1041 bp->daddr = daddr;
1042 bp->pad = 0;
YOSHIFUJI Hideaki076fb722008-04-17 12:48:12 +09001043 bp->protocol = IPPROTO_TCP;
Adam Langley49a72df2008-07-19 00:01:42 -07001044 bp->len = cpu_to_be16(nbytes);
David S. Millerc7da57a2007-10-26 00:41:21 -07001045
Adam Langley49a72df2008-07-19 00:01:42 -07001046 sg_init_one(&sg, bp, sizeof(*bp));
1047 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
1048}
1049
1050static int tcp_v4_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
1051 __be32 daddr, __be32 saddr, struct tcphdr *th)
1052{
1053 struct tcp_md5sig_pool *hp;
1054 struct hash_desc *desc;
1055
1056 hp = tcp_get_md5sig_pool();
1057 if (!hp)
1058 goto clear_hash_noput;
1059 desc = &hp->md5_desc;
1060
1061 if (crypto_hash_init(desc))
1062 goto clear_hash;
1063 if (tcp_v4_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
1064 goto clear_hash;
1065 if (tcp_md5_hash_header(hp, th))
1066 goto clear_hash;
1067 if (tcp_md5_hash_key(hp, key))
1068 goto clear_hash;
1069 if (crypto_hash_final(desc, md5_hash))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001070 goto clear_hash;
1071
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001072 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001073 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -07001074
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001075clear_hash:
1076 tcp_put_md5sig_pool();
1077clear_hash_noput:
1078 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -07001079 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001080}
1081
Adam Langley49a72df2008-07-19 00:01:42 -07001082int tcp_v4_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
1083 struct sock *sk, struct request_sock *req,
1084 struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001085{
Adam Langley49a72df2008-07-19 00:01:42 -07001086 struct tcp_md5sig_pool *hp;
1087 struct hash_desc *desc;
1088 struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001089 __be32 saddr, daddr;
1090
1091 if (sk) {
1092 saddr = inet_sk(sk)->saddr;
1093 daddr = inet_sk(sk)->daddr;
Adam Langley49a72df2008-07-19 00:01:42 -07001094 } else if (req) {
1095 saddr = inet_rsk(req)->loc_addr;
1096 daddr = inet_rsk(req)->rmt_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001097 } else {
Adam Langley49a72df2008-07-19 00:01:42 -07001098 const struct iphdr *iph = ip_hdr(skb);
1099 saddr = iph->saddr;
1100 daddr = iph->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001101 }
Adam Langley49a72df2008-07-19 00:01:42 -07001102
1103 hp = tcp_get_md5sig_pool();
1104 if (!hp)
1105 goto clear_hash_noput;
1106 desc = &hp->md5_desc;
1107
1108 if (crypto_hash_init(desc))
1109 goto clear_hash;
1110
1111 if (tcp_v4_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
1112 goto clear_hash;
1113 if (tcp_md5_hash_header(hp, th))
1114 goto clear_hash;
1115 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
1116 goto clear_hash;
1117 if (tcp_md5_hash_key(hp, key))
1118 goto clear_hash;
1119 if (crypto_hash_final(desc, md5_hash))
1120 goto clear_hash;
1121
1122 tcp_put_md5sig_pool();
1123 return 0;
1124
1125clear_hash:
1126 tcp_put_md5sig_pool();
1127clear_hash_noput:
1128 memset(md5_hash, 0, 16);
1129 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001130}
1131
Adam Langley49a72df2008-07-19 00:01:42 -07001132EXPORT_SYMBOL(tcp_v4_md5_hash_skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001133
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001134static int tcp_v4_inbound_md5_hash(struct sock *sk, struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001135{
1136 /*
1137 * This gets called for each TCP segment that arrives
1138 * so we want to be efficient.
1139 * We have 3 drop cases:
1140 * o No MD5 hash and one expected.
1141 * o MD5 hash and we're not expecting one.
1142 * o MD5 hash and its wrong.
1143 */
1144 __u8 *hash_location = NULL;
1145 struct tcp_md5sig_key *hash_expected;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001146 const struct iphdr *iph = ip_hdr(skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001147 struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001148 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001149 unsigned char newhash[16];
1150
1151 hash_expected = tcp_v4_md5_do_lookup(sk, iph->saddr);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +09001152 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001153
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001154 /* We've parsed the options - do we have a hash? */
1155 if (!hash_expected && !hash_location)
1156 return 0;
1157
1158 if (hash_expected && !hash_location) {
David S. Miller785957d2008-07-30 03:03:15 -07001159 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001160 return 1;
1161 }
1162
1163 if (!hash_expected && hash_location) {
David S. Miller785957d2008-07-30 03:03:15 -07001164 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001165 return 1;
1166 }
1167
1168 /* Okay, so this is hash_expected and hash_location -
1169 * so we need to calculate the checksum.
1170 */
Adam Langley49a72df2008-07-19 00:01:42 -07001171 genhash = tcp_v4_md5_hash_skb(newhash,
1172 hash_expected,
1173 NULL, NULL, skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001174
1175 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
1176 if (net_ratelimit()) {
Harvey Harrison673d57e2008-10-31 00:53:57 -07001177 printk(KERN_INFO "MD5 Hash failed for (%pI4, %d)->(%pI4, %d)%s\n",
1178 &iph->saddr, ntohs(th->source),
1179 &iph->daddr, ntohs(th->dest),
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001180 genhash ? " tcp_v4_calc_md5_hash failed" : "");
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001181 }
1182 return 1;
1183 }
1184 return 0;
1185}
1186
1187#endif
1188
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001189struct request_sock_ops tcp_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 .family = PF_INET,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001191 .obj_size = sizeof(struct tcp_request_sock),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 .rtx_syn_ack = tcp_v4_send_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001193 .send_ack = tcp_v4_reqsk_send_ack,
1194 .destructor = tcp_v4_reqsk_destructor,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 .send_reset = tcp_v4_send_reset,
1196};
1197
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001198#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001199static const struct tcp_request_sock_ops tcp_request_sock_ipv4_ops = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001200 .md5_lookup = tcp_v4_reqsk_md5_lookup,
John Dykstrae3afe7b2009-07-16 05:04:51 +00001201 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001202};
Andrew Mortonb6332e62006-11-30 19:16:28 -08001203#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001204
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08001205static struct timewait_sock_ops tcp_timewait_sock_ops = {
1206 .twsk_obj_size = sizeof(struct tcp_timewait_sock),
1207 .twsk_unique = tcp_twsk_unique,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001208 .twsk_destructor= tcp_twsk_destructor,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08001209};
1210
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1212{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001213 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214 struct tcp_options_received tmp_opt;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001215 struct request_sock *req;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001216 __be32 saddr = ip_hdr(skb)->saddr;
1217 __be32 daddr = ip_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218 __u32 isn = TCP_SKB_CB(skb)->when;
1219 struct dst_entry *dst = NULL;
1220#ifdef CONFIG_SYN_COOKIES
1221 int want_cookie = 0;
1222#else
1223#define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */
1224#endif
1225
1226 /* Never answer to SYNs send to broadcast or multicast */
Eric Dumazet511c3f92009-06-02 05:14:27 +00001227 if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 goto drop;
1229
1230 /* TW buckets are converted to open requests without
1231 * limitations, they conserve resources and peer is
1232 * evidently real one.
1233 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001234 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235#ifdef CONFIG_SYN_COOKIES
1236 if (sysctl_tcp_syncookies) {
1237 want_cookie = 1;
1238 } else
1239#endif
1240 goto drop;
1241 }
1242
1243 /* Accept backlog is full. If we have already queued enough
1244 * of warm entries in syn queue, drop request. It is better than
1245 * clogging syn queue with openreqs with exponentially increasing
1246 * timeout.
1247 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001248 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249 goto drop;
1250
Arnaldo Carvalho de Meloce4a7d02008-06-10 12:39:35 -07001251 req = inet_reqsk_alloc(&tcp_request_sock_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 if (!req)
1253 goto drop;
1254
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001255#ifdef CONFIG_TCP_MD5SIG
1256 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv4_ops;
1257#endif
1258
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 tcp_clear_options(&tmp_opt);
1260 tmp_opt.mss_clamp = 536;
1261 tmp_opt.user_mss = tcp_sk(sk)->rx_opt.user_mss;
1262
1263 tcp_parse_options(skb, &tmp_opt, 0);
1264
Florian Westphal4dfc2812008-04-10 03:12:40 -07001265 if (want_cookie && !tmp_opt.saw_tstamp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 tcp_clear_options(&tmp_opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
1269
1270 tcp_openreq_init(req, &tmp_opt, skb);
1271
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001272 ireq = inet_rsk(req);
1273 ireq->loc_addr = daddr;
1274 ireq->rmt_addr = saddr;
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -07001275 ireq->no_srccheck = inet_sk(sk)->transparent;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001276 ireq->opt = tcp_v4_save_options(sk, skb);
Paul Moore284904a2009-03-27 17:10:28 -04001277
1278 if (security_inet_conn_request(sk, skb, req))
1279 goto drop_and_free;
1280
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 if (!want_cookie)
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001282 TCP_ECN_create_request(req, tcp_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283
1284 if (want_cookie) {
1285#ifdef CONFIG_SYN_COOKIES
1286 syn_flood_warning(skb);
Florian Westphal4dfc2812008-04-10 03:12:40 -07001287 req->cookie_ts = tmp_opt.tstamp_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288#endif
1289 isn = cookie_v4_init_sequence(sk, skb, &req->mss);
1290 } else if (!isn) {
1291 struct inet_peer *peer = NULL;
1292
1293 /* VJ's idea. We save last timestamp seen
1294 * from the destination in peer table, when entering
1295 * state TIME-WAIT, and check against it before
1296 * accepting new connection request.
1297 *
1298 * If "isn" is not zero, this request hit alive
1299 * timewait bucket, so that all the necessary checks
1300 * are made in the function processing timewait state.
1301 */
1302 if (tmp_opt.saw_tstamp &&
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001303 tcp_death_row.sysctl_tw_recycle &&
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001304 (dst = inet_csk_route_req(sk, req)) != NULL &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 (peer = rt_get_peer((struct rtable *)dst)) != NULL &&
1306 peer->v4daddr == saddr) {
James Morris9d729f72007-03-04 16:12:44 -08001307 if (get_seconds() < peer->tcp_ts_stamp + TCP_PAWS_MSL &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 (s32)(peer->tcp_ts - req->ts_recent) >
1309 TCP_PAWS_WINDOW) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001310 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001311 goto drop_and_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 }
1313 }
1314 /* Kill the following clause, if you dislike this way. */
1315 else if (!sysctl_tcp_syncookies &&
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001316 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 (sysctl_max_syn_backlog >> 2)) &&
1318 (!peer || !peer->tcp_ts_stamp) &&
1319 (!dst || !dst_metric(dst, RTAX_RTT))) {
1320 /* Without syncookies last quarter of
1321 * backlog is filled with destinations,
1322 * proven to be alive.
1323 * It means that we continue to communicate
1324 * to destinations, already remembered
1325 * to the moment of synflood.
1326 */
Harvey Harrison673d57e2008-10-31 00:53:57 -07001327 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open request from %pI4/%u\n",
1328 &saddr, ntohs(tcp_hdr(skb)->source));
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001329 goto drop_and_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330 }
1331
Gerrit Renkera94f7232006-11-10 14:06:49 -08001332 isn = tcp_v4_init_sequence(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 }
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001334 tcp_rsk(req)->snt_isn = isn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001336 if (__tcp_v4_send_synack(sk, req, dst) || want_cookie)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 goto drop_and_free;
1338
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001339 inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340 return 0;
1341
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001342drop_and_release:
1343 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344drop_and_free:
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001345 reqsk_free(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346drop:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 return 0;
1348}
1349
1350
1351/*
1352 * The three way handshake has completed - we got a valid synack -
1353 * now create the new socket.
1354 */
1355struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001356 struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 struct dst_entry *dst)
1358{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001359 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 struct inet_sock *newinet;
1361 struct tcp_sock *newtp;
1362 struct sock *newsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001363#ifdef CONFIG_TCP_MD5SIG
1364 struct tcp_md5sig_key *key;
1365#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366
1367 if (sk_acceptq_is_full(sk))
1368 goto exit_overflow;
1369
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001370 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 goto exit;
1372
1373 newsk = tcp_create_openreq_child(sk, req, skb);
1374 if (!newsk)
1375 goto exit;
1376
Herbert Xubcd76112006-06-30 13:36:35 -07001377 newsk->sk_gso_type = SKB_GSO_TCPV4;
Arnaldo Carvalho de Melo6cbb0df2005-08-09 19:49:02 -07001378 sk_setup_caps(newsk, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379
1380 newtp = tcp_sk(newsk);
1381 newinet = inet_sk(newsk);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001382 ireq = inet_rsk(req);
1383 newinet->daddr = ireq->rmt_addr;
1384 newinet->rcv_saddr = ireq->loc_addr;
1385 newinet->saddr = ireq->loc_addr;
1386 newinet->opt = ireq->opt;
1387 ireq->opt = NULL;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001388 newinet->mc_index = inet_iif(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001389 newinet->mc_ttl = ip_hdr(skb)->ttl;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001390 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391 if (newinet->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001392 inet_csk(newsk)->icsk_ext_hdr_len = newinet->opt->optlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393 newinet->id = newtp->write_seq ^ jiffies;
1394
John Heffner5d424d52006-03-20 17:53:41 -08001395 tcp_mtup_init(newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396 tcp_sync_mss(newsk, dst_mtu(dst));
1397 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
Tom Quetchenbachf5fff5d2008-09-21 00:21:51 -07001398 if (tcp_sk(sk)->rx_opt.user_mss &&
1399 tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1400 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1401
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 tcp_initialize_rcv_mss(newsk);
1403
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001404#ifdef CONFIG_TCP_MD5SIG
1405 /* Copy over the MD5 key from the original socket */
1406 if ((key = tcp_v4_md5_do_lookup(sk, newinet->daddr)) != NULL) {
1407 /*
1408 * We're using one, so create a matching key
1409 * on the newsk structure. If we fail to get
1410 * memory, then we end up not copying the key
1411 * across. Shucks.
1412 */
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -02001413 char *newkey = kmemdup(key->key, key->keylen, GFP_ATOMIC);
1414 if (newkey != NULL)
John Dykstrae547bc12009-07-17 09:23:22 +00001415 tcp_v4_md5_do_add(newsk, newinet->daddr,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001416 newkey, key->keylen);
Adam Langley49a72df2008-07-19 00:01:42 -07001417 newsk->sk_route_caps &= ~NETIF_F_GSO_MASK;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001418 }
1419#endif
1420
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001421 __inet_hash_nolisten(newsk);
1422 __inet_inherit_port(sk, newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423
1424 return newsk;
1425
1426exit_overflow:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001427 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428exit:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001429 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 dst_release(dst);
1431 return NULL;
1432}
1433
1434static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
1435{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001436 struct tcphdr *th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001437 const struct iphdr *iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 struct sock *nsk;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001439 struct request_sock **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440 /* Find possible connection requests. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001441 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
1442 iph->saddr, iph->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443 if (req)
1444 return tcp_check_req(sk, skb, req, prev);
1445
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001446 nsk = inet_lookup_established(sock_net(sk), &tcp_hashinfo, iph->saddr,
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001447 th->source, iph->daddr, th->dest, inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448
1449 if (nsk) {
1450 if (nsk->sk_state != TCP_TIME_WAIT) {
1451 bh_lock_sock(nsk);
1452 return nsk;
1453 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001454 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 return NULL;
1456 }
1457
1458#ifdef CONFIG_SYN_COOKIES
1459 if (!th->rst && !th->syn && th->ack)
1460 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
1461#endif
1462 return sk;
1463}
1464
Al Virob51655b2006-11-14 21:40:42 -08001465static __sum16 tcp_v4_checksum_init(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001467 const struct iphdr *iph = ip_hdr(skb);
1468
Patrick McHardy84fa7932006-08-29 16:44:56 -07001469 if (skb->ip_summed == CHECKSUM_COMPLETE) {
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001470 if (!tcp_v4_check(skb->len, iph->saddr,
1471 iph->daddr, skb->csum)) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001472 skb->ip_summed = CHECKSUM_UNNECESSARY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 return 0;
Herbert Xufb286bb2005-11-10 13:01:24 -08001474 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475 }
Herbert Xufb286bb2005-11-10 13:01:24 -08001476
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001477 skb->csum = csum_tcpudp_nofold(iph->saddr, iph->daddr,
Herbert Xufb286bb2005-11-10 13:01:24 -08001478 skb->len, IPPROTO_TCP, 0);
1479
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480 if (skb->len <= 76) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001481 return __skb_checksum_complete(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482 }
1483 return 0;
1484}
1485
1486
1487/* The socket must have it's spinlock held when we get
1488 * here.
1489 *
1490 * We have a potential double-lock case here, so even when
1491 * doing backlog processing we use the BH locking scheme.
1492 * This is because we cannot sleep with the original spinlock
1493 * held.
1494 */
1495int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1496{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001497 struct sock *rsk;
1498#ifdef CONFIG_TCP_MD5SIG
1499 /*
1500 * We really want to reject the packet as early as possible
1501 * if:
1502 * o We're expecting an MD5'd packet and this is no MD5 tcp option
1503 * o There is an MD5 option and we're not expecting one
1504 */
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001505 if (tcp_v4_inbound_md5_hash(sk, skb))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001506 goto discard;
1507#endif
1508
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1510 TCP_CHECK_TIMER(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001511 if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001512 rsk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001514 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515 TCP_CHECK_TIMER(sk);
1516 return 0;
1517 }
1518
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07001519 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520 goto csum_err;
1521
1522 if (sk->sk_state == TCP_LISTEN) {
1523 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
1524 if (!nsk)
1525 goto discard;
1526
1527 if (nsk != sk) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001528 if (tcp_child_process(sk, nsk, skb)) {
1529 rsk = nsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001531 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532 return 0;
1533 }
1534 }
1535
1536 TCP_CHECK_TIMER(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001537 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001538 rsk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001540 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541 TCP_CHECK_TIMER(sk);
1542 return 0;
1543
1544reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001545 tcp_v4_send_reset(rsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546discard:
1547 kfree_skb(skb);
1548 /* Be careful here. If this function gets more complicated and
1549 * gcc suffers from register pressure on the x86, sk (in %ebx)
1550 * might be destroyed here. This current version compiles correctly,
1551 * but you have been warned.
1552 */
1553 return 0;
1554
1555csum_err:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001556 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557 goto discard;
1558}
1559
1560/*
1561 * From tcp_input.c
1562 */
1563
1564int tcp_v4_rcv(struct sk_buff *skb)
1565{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001566 const struct iphdr *iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567 struct tcphdr *th;
1568 struct sock *sk;
1569 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001570 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571
1572 if (skb->pkt_type != PACKET_HOST)
1573 goto discard_it;
1574
1575 /* Count it even if it's bad */
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001576 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577
1578 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1579 goto discard_it;
1580
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001581 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582
1583 if (th->doff < sizeof(struct tcphdr) / 4)
1584 goto bad_packet;
1585 if (!pskb_may_pull(skb, th->doff * 4))
1586 goto discard_it;
1587
1588 /* An explanation is required here, I think.
1589 * Packet length and doff are validated by header prediction,
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -08001590 * provided case of th->doff==0 is eliminated.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 * So, we defer the checks. */
Herbert Xu60476372007-04-09 11:59:39 -07001592 if (!skb_csum_unnecessary(skb) && tcp_v4_checksum_init(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593 goto bad_packet;
1594
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001595 th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001596 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1598 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1599 skb->len - th->doff * 4);
1600 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1601 TCP_SKB_CB(skb)->when = 0;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001602 TCP_SKB_CB(skb)->flags = iph->tos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603 TCP_SKB_CB(skb)->sacked = 0;
1604
Arnaldo Carvalho de Melo9a1f27c2008-10-07 11:41:57 -07001605 sk = __inet_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 if (!sk)
1607 goto no_tcp_socket;
1608
1609process:
1610 if (sk->sk_state == TCP_TIME_WAIT)
1611 goto do_time_wait;
1612
1613 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1614 goto discard_and_relse;
Patrick McHardyb59c2702006-01-06 23:06:10 -08001615 nf_reset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001617 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618 goto discard_and_relse;
1619
1620 skb->dev = NULL;
1621
Ingo Molnarc6366182006-07-03 00:25:13 -07001622 bh_lock_sock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 ret = 0;
1624 if (!sock_owned_by_user(sk)) {
Chris Leech1a2449a2006-05-23 18:05:53 -07001625#ifdef CONFIG_NET_DMA
1626 struct tcp_sock *tp = tcp_sk(sk);
1627 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
Dan Williamsf67b4592009-01-06 11:38:15 -07001628 tp->ucopy.dma_chan = dma_find_channel(DMA_MEMCPY);
Chris Leech1a2449a2006-05-23 18:05:53 -07001629 if (tp->ucopy.dma_chan)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630 ret = tcp_v4_do_rcv(sk, skb);
Chris Leech1a2449a2006-05-23 18:05:53 -07001631 else
1632#endif
1633 {
1634 if (!tcp_prequeue(sk, skb))
Shan Weiae8d7f82009-05-05 01:01:29 +00001635 ret = tcp_v4_do_rcv(sk, skb);
Chris Leech1a2449a2006-05-23 18:05:53 -07001636 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637 } else
1638 sk_add_backlog(sk, skb);
1639 bh_unlock_sock(sk);
1640
1641 sock_put(sk);
1642
1643 return ret;
1644
1645no_tcp_socket:
1646 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1647 goto discard_it;
1648
1649 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1650bad_packet:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001651 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001653 tcp_v4_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654 }
1655
1656discard_it:
1657 /* Discard frame. */
1658 kfree_skb(skb);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001659 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660
1661discard_and_relse:
1662 sock_put(sk);
1663 goto discard_it;
1664
1665do_time_wait:
1666 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001667 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 goto discard_it;
1669 }
1670
1671 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001672 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001673 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 goto discard_it;
1675 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001676 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677 case TCP_TW_SYN: {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001678 struct sock *sk2 = inet_lookup_listener(dev_net(skb->dev),
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001679 &tcp_hashinfo,
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001680 iph->daddr, th->dest,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001681 inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 if (sk2) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001683 inet_twsk_deschedule(inet_twsk(sk), &tcp_death_row);
1684 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685 sk = sk2;
1686 goto process;
1687 }
1688 /* Fall through to ACK */
1689 }
1690 case TCP_TW_ACK:
1691 tcp_v4_timewait_ack(sk, skb);
1692 break;
1693 case TCP_TW_RST:
1694 goto no_tcp_socket;
1695 case TCP_TW_SUCCESS:;
1696 }
1697 goto discard_it;
1698}
1699
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700/* VJ's idea. Save last timestamp seen from this destination
1701 * and hold it at least for normal timewait interval to use for duplicate
1702 * segment detection in subsequent connections, before they enter synchronized
1703 * state.
1704 */
1705
1706int tcp_v4_remember_stamp(struct sock *sk)
1707{
1708 struct inet_sock *inet = inet_sk(sk);
1709 struct tcp_sock *tp = tcp_sk(sk);
1710 struct rtable *rt = (struct rtable *)__sk_dst_get(sk);
1711 struct inet_peer *peer = NULL;
1712 int release_it = 0;
1713
1714 if (!rt || rt->rt_dst != inet->daddr) {
1715 peer = inet_getpeer(inet->daddr, 1);
1716 release_it = 1;
1717 } else {
1718 if (!rt->peer)
1719 rt_bind_peer(rt, 1);
1720 peer = rt->peer;
1721 }
1722
1723 if (peer) {
1724 if ((s32)(peer->tcp_ts - tp->rx_opt.ts_recent) <= 0 ||
James Morris9d729f72007-03-04 16:12:44 -08001725 (peer->tcp_ts_stamp + TCP_PAWS_MSL < get_seconds() &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726 peer->tcp_ts_stamp <= tp->rx_opt.ts_recent_stamp)) {
1727 peer->tcp_ts_stamp = tp->rx_opt.ts_recent_stamp;
1728 peer->tcp_ts = tp->rx_opt.ts_recent;
1729 }
1730 if (release_it)
1731 inet_putpeer(peer);
1732 return 1;
1733 }
1734
1735 return 0;
1736}
1737
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001738int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001740 struct inet_peer *peer = inet_getpeer(tw->tw_daddr, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741
1742 if (peer) {
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001743 const struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
1744
1745 if ((s32)(peer->tcp_ts - tcptw->tw_ts_recent) <= 0 ||
James Morris9d729f72007-03-04 16:12:44 -08001746 (peer->tcp_ts_stamp + TCP_PAWS_MSL < get_seconds() &&
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001747 peer->tcp_ts_stamp <= tcptw->tw_ts_recent_stamp)) {
1748 peer->tcp_ts_stamp = tcptw->tw_ts_recent_stamp;
1749 peer->tcp_ts = tcptw->tw_ts_recent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750 }
1751 inet_putpeer(peer);
1752 return 1;
1753 }
1754
1755 return 0;
1756}
1757
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001758const struct inet_connection_sock_af_ops ipv4_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001759 .queue_xmit = ip_queue_xmit,
1760 .send_check = tcp_v4_send_check,
1761 .rebuild_header = inet_sk_rebuild_header,
1762 .conn_request = tcp_v4_conn_request,
1763 .syn_recv_sock = tcp_v4_syn_recv_sock,
1764 .remember_stamp = tcp_v4_remember_stamp,
1765 .net_header_len = sizeof(struct iphdr),
1766 .setsockopt = ip_setsockopt,
1767 .getsockopt = ip_getsockopt,
1768 .addr2sockaddr = inet_csk_addr2sockaddr,
1769 .sockaddr_len = sizeof(struct sockaddr_in),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001770 .bind_conflict = inet_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001771#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001772 .compat_setsockopt = compat_ip_setsockopt,
1773 .compat_getsockopt = compat_ip_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001774#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775};
1776
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001777#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001778static const struct tcp_sock_af_ops tcp_sock_ipv4_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001779 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001780 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001781 .md5_add = tcp_v4_md5_add_func,
1782 .md5_parse = tcp_v4_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001783};
Andrew Mortonb6332e62006-11-30 19:16:28 -08001784#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001785
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786/* NOTE: A lot of things set to zero explicitly by call to
1787 * sk_alloc() so need not be done here.
1788 */
1789static int tcp_v4_init_sock(struct sock *sk)
1790{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001791 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792 struct tcp_sock *tp = tcp_sk(sk);
1793
1794 skb_queue_head_init(&tp->out_of_order_queue);
1795 tcp_init_xmit_timers(sk);
1796 tcp_prequeue_init(tp);
1797
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001798 icsk->icsk_rto = TCP_TIMEOUT_INIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799 tp->mdev = TCP_TIMEOUT_INIT;
1800
1801 /* So many TCP implementations out there (incorrectly) count the
1802 * initial SYN frame in their delayed-ACK and congestion control
1803 * algorithms that we must have the following bandaid to talk
1804 * efficiently to them. -DaveM
1805 */
1806 tp->snd_cwnd = 2;
1807
1808 /* See draft-stevens-tcpca-spec-01 for discussion of the
1809 * initialization of these values.
1810 */
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07001811 tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812 tp->snd_cwnd_clamp = ~0;
David S. Millerc1b4a7e2005-07-05 15:24:38 -07001813 tp->mss_cache = 536;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814
1815 tp->reordering = sysctl_tcp_reordering;
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001816 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817
1818 sk->sk_state = TCP_CLOSE;
1819
1820 sk->sk_write_space = sk_stream_write_space;
1821 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1822
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001823 icsk->icsk_af_ops = &ipv4_specific;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001824 icsk->icsk_sync_mss = tcp_sync_mss;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001825#ifdef CONFIG_TCP_MD5SIG
1826 tp->af_specific = &tcp_sock_ipv4_specific;
1827#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828
1829 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1830 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1831
Herbert Xueb4dea52008-12-29 23:04:08 -08001832 local_bh_disable();
Eric Dumazet17483762008-11-25 21:16:35 -08001833 percpu_counter_inc(&tcp_sockets_allocated);
Herbert Xueb4dea52008-12-29 23:04:08 -08001834 local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835
1836 return 0;
1837}
1838
Brian Haley7d06b2e2008-06-14 17:04:49 -07001839void tcp_v4_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840{
1841 struct tcp_sock *tp = tcp_sk(sk);
1842
1843 tcp_clear_xmit_timers(sk);
1844
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001845 tcp_cleanup_congestion_control(sk);
Stephen Hemminger317a76f2005-06-23 12:19:55 -07001846
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847 /* Cleanup up the write buffer. */
David S. Millerfe067e82007-03-07 12:12:44 -08001848 tcp_write_queue_purge(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849
1850 /* Cleans up our, hopefully empty, out_of_order_queue. */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001851 __skb_queue_purge(&tp->out_of_order_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001853#ifdef CONFIG_TCP_MD5SIG
1854 /* Clean up the MD5 key list, if any */
1855 if (tp->md5sig_info) {
1856 tcp_v4_clear_md5_list(sk);
1857 kfree(tp->md5sig_info);
1858 tp->md5sig_info = NULL;
1859 }
1860#endif
1861
Chris Leech1a2449a2006-05-23 18:05:53 -07001862#ifdef CONFIG_NET_DMA
1863 /* Cleans up our sk_async_wait_queue */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001864 __skb_queue_purge(&sk->sk_async_wait_queue);
Chris Leech1a2449a2006-05-23 18:05:53 -07001865#endif
1866
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867 /* Clean prequeue, it must be empty really */
1868 __skb_queue_purge(&tp->ucopy.prequeue);
1869
1870 /* Clean up a referenced TCP bind bucket. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001871 if (inet_csk(sk)->icsk_bind_hash)
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001872 inet_put_port(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873
1874 /*
1875 * If sendmsg cached page exists, toss it.
1876 */
1877 if (sk->sk_sndmsg_page) {
1878 __free_page(sk->sk_sndmsg_page);
1879 sk->sk_sndmsg_page = NULL;
1880 }
1881
Eric Dumazet17483762008-11-25 21:16:35 -08001882 percpu_counter_dec(&tcp_sockets_allocated);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883}
1884
1885EXPORT_SYMBOL(tcp_v4_destroy_sock);
1886
1887#ifdef CONFIG_PROC_FS
1888/* Proc filesystem TCP sock list dumping. */
1889
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001890static inline struct inet_timewait_sock *tw_head(struct hlist_nulls_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891{
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001892 return hlist_nulls_empty(head) ? NULL :
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001893 list_entry(head->first, struct inet_timewait_sock, tw_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894}
1895
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001896static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897{
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001898 return !is_a_nulls(tw->tw_node.next) ?
1899 hlist_nulls_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900}
1901
1902static void *listening_get_next(struct seq_file *seq, void *cur)
1903{
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001904 struct inet_connection_sock *icsk;
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08001905 struct hlist_nulls_node *node;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906 struct sock *sk = cur;
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001907 struct inet_listen_hashbucket *ilb;
Jianjun Kong5799de02008-11-03 02:49:10 -08001908 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07001909 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910
1911 if (!sk) {
1912 st->bucket = 0;
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001913 ilb = &tcp_hashinfo.listening_hash[0];
1914 spin_lock_bh(&ilb->lock);
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08001915 sk = sk_nulls_head(&ilb->head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 goto get_sk;
1917 }
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001918 ilb = &tcp_hashinfo.listening_hash[st->bucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919 ++st->num;
1920
1921 if (st->state == TCP_SEQ_STATE_OPENREQ) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001922 struct request_sock *req = cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001924 icsk = inet_csk(st->syn_wait_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 req = req->dl_next;
1926 while (1) {
1927 while (req) {
Daniel Lezcanobdccc4c2008-07-19 00:15:13 -07001928 if (req->rsk_ops->family == st->family) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929 cur = req;
1930 goto out;
1931 }
1932 req = req->dl_next;
1933 }
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001934 if (++st->sbucket >= icsk->icsk_accept_queue.listen_opt->nr_table_entries)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935 break;
1936get_req:
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001937 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938 }
1939 sk = sk_next(st->syn_wait_sk);
1940 st->state = TCP_SEQ_STATE_LISTENING;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001941 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942 } else {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001943 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001944 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1945 if (reqsk_queue_len(&icsk->icsk_accept_queue))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946 goto start_req;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001947 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 sk = sk_next(sk);
1949 }
1950get_sk:
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08001951 sk_nulls_for_each_from(sk, node) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09001952 if (sk->sk_family == st->family && net_eq(sock_net(sk), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953 cur = sk;
1954 goto out;
1955 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001956 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001957 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1958 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959start_req:
1960 st->uid = sock_i_uid(sk);
1961 st->syn_wait_sk = sk;
1962 st->state = TCP_SEQ_STATE_OPENREQ;
1963 st->sbucket = 0;
1964 goto get_req;
1965 }
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001966 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967 }
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001968 spin_unlock_bh(&ilb->lock);
Arnaldo Carvalho de Melo0f7ff922005-08-09 19:59:44 -07001969 if (++st->bucket < INET_LHTABLE_SIZE) {
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001970 ilb = &tcp_hashinfo.listening_hash[st->bucket];
1971 spin_lock_bh(&ilb->lock);
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08001972 sk = sk_nulls_head(&ilb->head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973 goto get_sk;
1974 }
1975 cur = NULL;
1976out:
1977 return cur;
1978}
1979
1980static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
1981{
1982 void *rc = listening_get_next(seq, NULL);
1983
1984 while (rc && *pos) {
1985 rc = listening_get_next(seq, rc);
1986 --*pos;
1987 }
1988 return rc;
1989}
1990
Andi Kleen6eac5602008-08-28 01:08:02 -07001991static inline int empty_bucket(struct tcp_iter_state *st)
1992{
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001993 return hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].chain) &&
1994 hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].twchain);
Andi Kleen6eac5602008-08-28 01:08:02 -07001995}
1996
Linus Torvalds1da177e2005-04-16 15:20:36 -07001997static void *established_get_first(struct seq_file *seq)
1998{
Jianjun Kong5799de02008-11-03 02:49:10 -08001999 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002000 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002001 void *rc = NULL;
2002
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07002003 for (st->bucket = 0; st->bucket < tcp_hashinfo.ehash_size; ++st->bucket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004 struct sock *sk;
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002005 struct hlist_nulls_node *node;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002006 struct inet_timewait_sock *tw;
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002007 spinlock_t *lock = inet_ehash_lockp(&tcp_hashinfo, st->bucket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008
Andi Kleen6eac5602008-08-28 01:08:02 -07002009 /* Lockless fast path for the common case of empty buckets */
2010 if (empty_bucket(st))
2011 continue;
2012
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002013 spin_lock_bh(lock);
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002014 sk_nulls_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002015 if (sk->sk_family != st->family ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002016 !net_eq(sock_net(sk), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017 continue;
2018 }
2019 rc = sk;
2020 goto out;
2021 }
2022 st->state = TCP_SEQ_STATE_TIME_WAIT;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002023 inet_twsk_for_each(tw, node,
Eric Dumazetdbca9b2752007-02-08 14:16:46 -08002024 &tcp_hashinfo.ehash[st->bucket].twchain) {
Pavel Emelyanov28518fc2008-03-21 15:52:00 -07002025 if (tw->tw_family != st->family ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002026 !net_eq(twsk_net(tw), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027 continue;
2028 }
2029 rc = tw;
2030 goto out;
2031 }
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002032 spin_unlock_bh(lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033 st->state = TCP_SEQ_STATE_ESTABLISHED;
2034 }
2035out:
2036 return rc;
2037}
2038
2039static void *established_get_next(struct seq_file *seq, void *cur)
2040{
2041 struct sock *sk = cur;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002042 struct inet_timewait_sock *tw;
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002043 struct hlist_nulls_node *node;
Jianjun Kong5799de02008-11-03 02:49:10 -08002044 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002045 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002046
2047 ++st->num;
2048
2049 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
2050 tw = cur;
2051 tw = tw_next(tw);
2052get_tw:
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002053 while (tw && (tw->tw_family != st->family || !net_eq(twsk_net(tw), net))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054 tw = tw_next(tw);
2055 }
2056 if (tw) {
2057 cur = tw;
2058 goto out;
2059 }
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002060 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002061 st->state = TCP_SEQ_STATE_ESTABLISHED;
2062
Andi Kleen6eac5602008-08-28 01:08:02 -07002063 /* Look for next non empty bucket */
2064 while (++st->bucket < tcp_hashinfo.ehash_size &&
2065 empty_bucket(st))
2066 ;
2067 if (st->bucket >= tcp_hashinfo.ehash_size)
2068 return NULL;
2069
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002070 spin_lock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002071 sk = sk_nulls_head(&tcp_hashinfo.ehash[st->bucket].chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002072 } else
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002073 sk = sk_nulls_next(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002075 sk_nulls_for_each_from(sk, node) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002076 if (sk->sk_family == st->family && net_eq(sock_net(sk), net))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077 goto found;
2078 }
2079
2080 st->state = TCP_SEQ_STATE_TIME_WAIT;
Eric Dumazetdbca9b2752007-02-08 14:16:46 -08002081 tw = tw_head(&tcp_hashinfo.ehash[st->bucket].twchain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082 goto get_tw;
2083found:
2084 cur = sk;
2085out:
2086 return cur;
2087}
2088
2089static void *established_get_idx(struct seq_file *seq, loff_t pos)
2090{
2091 void *rc = established_get_first(seq);
2092
2093 while (rc && pos) {
2094 rc = established_get_next(seq, rc);
2095 --pos;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002096 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097 return rc;
2098}
2099
2100static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
2101{
2102 void *rc;
Jianjun Kong5799de02008-11-03 02:49:10 -08002103 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104
Linus Torvalds1da177e2005-04-16 15:20:36 -07002105 st->state = TCP_SEQ_STATE_LISTENING;
2106 rc = listening_get_idx(seq, &pos);
2107
2108 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109 st->state = TCP_SEQ_STATE_ESTABLISHED;
2110 rc = established_get_idx(seq, pos);
2111 }
2112
2113 return rc;
2114}
2115
2116static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
2117{
Jianjun Kong5799de02008-11-03 02:49:10 -08002118 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119 st->state = TCP_SEQ_STATE_LISTENING;
2120 st->num = 0;
2121 return *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2122}
2123
2124static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2125{
2126 void *rc = NULL;
Jianjun Kong5799de02008-11-03 02:49:10 -08002127 struct tcp_iter_state *st;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128
2129 if (v == SEQ_START_TOKEN) {
2130 rc = tcp_get_idx(seq, 0);
2131 goto out;
2132 }
2133 st = seq->private;
2134
2135 switch (st->state) {
2136 case TCP_SEQ_STATE_OPENREQ:
2137 case TCP_SEQ_STATE_LISTENING:
2138 rc = listening_get_next(seq, v);
2139 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140 st->state = TCP_SEQ_STATE_ESTABLISHED;
2141 rc = established_get_first(seq);
2142 }
2143 break;
2144 case TCP_SEQ_STATE_ESTABLISHED:
2145 case TCP_SEQ_STATE_TIME_WAIT:
2146 rc = established_get_next(seq, v);
2147 break;
2148 }
2149out:
2150 ++*pos;
2151 return rc;
2152}
2153
2154static void tcp_seq_stop(struct seq_file *seq, void *v)
2155{
Jianjun Kong5799de02008-11-03 02:49:10 -08002156 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002157
2158 switch (st->state) {
2159 case TCP_SEQ_STATE_OPENREQ:
2160 if (v) {
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002161 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
2162 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163 }
2164 case TCP_SEQ_STATE_LISTENING:
2165 if (v != SEQ_START_TOKEN)
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002166 spin_unlock_bh(&tcp_hashinfo.listening_hash[st->bucket].lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002167 break;
2168 case TCP_SEQ_STATE_TIME_WAIT:
2169 case TCP_SEQ_STATE_ESTABLISHED:
2170 if (v)
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002171 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002172 break;
2173 }
2174}
2175
2176static int tcp_seq_open(struct inode *inode, struct file *file)
2177{
2178 struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179 struct tcp_iter_state *s;
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002180 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002181
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002182 err = seq_open_net(inode, file, &afinfo->seq_ops,
2183 sizeof(struct tcp_iter_state));
2184 if (err < 0)
2185 return err;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002186
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002187 s = ((struct seq_file *)file->private_data)->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188 s->family = afinfo->family;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002189 return 0;
2190}
2191
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002192int tcp_proc_register(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193{
2194 int rc = 0;
2195 struct proc_dir_entry *p;
2196
Denis V. Lunev68fcadd2008-04-13 22:13:30 -07002197 afinfo->seq_fops.open = tcp_seq_open;
2198 afinfo->seq_fops.read = seq_read;
2199 afinfo->seq_fops.llseek = seq_lseek;
2200 afinfo->seq_fops.release = seq_release_net;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002201
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002202 afinfo->seq_ops.start = tcp_seq_start;
2203 afinfo->seq_ops.next = tcp_seq_next;
2204 afinfo->seq_ops.stop = tcp_seq_stop;
2205
Denis V. Lunev84841c32008-05-02 04:10:08 -07002206 p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net,
2207 &afinfo->seq_fops, afinfo);
2208 if (!p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209 rc = -ENOMEM;
2210 return rc;
2211}
2212
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002213void tcp_proc_unregister(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002214{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002215 proc_net_remove(net, afinfo->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216}
2217
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002218static void get_openreq4(struct sock *sk, struct request_sock *req,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002219 struct seq_file *f, int i, int uid, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002220{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002221 const struct inet_request_sock *ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002222 int ttd = req->expires - jiffies;
2223
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002224 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
2225 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p%n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226 i,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002227 ireq->loc_addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228 ntohs(inet_sk(sk)->sport),
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002229 ireq->rmt_addr,
2230 ntohs(ireq->rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002231 TCP_SYN_RECV,
2232 0, 0, /* could print option size, but that is af dependent. */
2233 1, /* timers active (only the expire timer) */
2234 jiffies_to_clock_t(ttd),
2235 req->retrans,
2236 uid,
2237 0, /* non standard timer */
2238 0, /* open_requests have no inode */
2239 atomic_read(&sk->sk_refcnt),
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002240 req,
2241 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242}
2243
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002244static void get_tcp4_sock(struct sock *sk, struct seq_file *f, int i, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245{
2246 int timer_active;
2247 unsigned long timer_expires;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002248 struct tcp_sock *tp = tcp_sk(sk);
2249 const struct inet_connection_sock *icsk = inet_csk(sk);
2250 struct inet_sock *inet = inet_sk(sk);
Al Viro714e85b2006-11-14 20:51:49 -08002251 __be32 dest = inet->daddr;
2252 __be32 src = inet->rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002253 __u16 destp = ntohs(inet->dport);
2254 __u16 srcp = ntohs(inet->sport);
2255
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002256 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002257 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002258 timer_expires = icsk->icsk_timeout;
2259 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002261 timer_expires = icsk->icsk_timeout;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002262 } else if (timer_pending(&sk->sk_timer)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002263 timer_active = 2;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002264 timer_expires = sk->sk_timer.expires;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265 } else {
2266 timer_active = 0;
2267 timer_expires = jiffies;
2268 }
2269
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002270 seq_printf(f, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
Stephen Hemminger7be87352008-06-27 20:00:19 -07002271 "%08X %5d %8d %lu %d %p %lu %lu %u %u %d%n",
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002272 i, src, srcp, dest, destp, sk->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07002273 tp->write_seq - tp->snd_una,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002274 sk->sk_state == TCP_LISTEN ? sk->sk_ack_backlog :
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002275 (tp->rcv_nxt - tp->copied_seq),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002276 timer_active,
2277 jiffies_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002278 icsk->icsk_retransmits,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002279 sock_i_uid(sk),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03002280 icsk->icsk_probes_out,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002281 sock_i_ino(sk),
2282 atomic_read(&sk->sk_refcnt), sk,
Stephen Hemminger7be87352008-06-27 20:00:19 -07002283 jiffies_to_clock_t(icsk->icsk_rto),
2284 jiffies_to_clock_t(icsk->icsk_ack.ato),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002285 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002286 tp->snd_cwnd,
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07002287 tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002288 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289}
2290
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002291static void get_timewait4_sock(struct inet_timewait_sock *tw,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002292 struct seq_file *f, int i, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293{
Al Viro23f33c22006-09-27 18:43:50 -07002294 __be32 dest, src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295 __u16 destp, srcp;
2296 int ttd = tw->tw_ttd - jiffies;
2297
2298 if (ttd < 0)
2299 ttd = 0;
2300
2301 dest = tw->tw_daddr;
2302 src = tw->tw_rcv_saddr;
2303 destp = ntohs(tw->tw_dport);
2304 srcp = ntohs(tw->tw_sport);
2305
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002306 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
2307 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p%n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002308 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
2309 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002310 atomic_read(&tw->tw_refcnt), tw, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311}
2312
2313#define TMPSZ 150
2314
2315static int tcp4_seq_show(struct seq_file *seq, void *v)
2316{
Jianjun Kong5799de02008-11-03 02:49:10 -08002317 struct tcp_iter_state *st;
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002318 int len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002319
2320 if (v == SEQ_START_TOKEN) {
2321 seq_printf(seq, "%-*s\n", TMPSZ - 1,
2322 " sl local_address rem_address st tx_queue "
2323 "rx_queue tr tm->when retrnsmt uid timeout "
2324 "inode");
2325 goto out;
2326 }
2327 st = seq->private;
2328
2329 switch (st->state) {
2330 case TCP_SEQ_STATE_LISTENING:
2331 case TCP_SEQ_STATE_ESTABLISHED:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002332 get_tcp4_sock(v, seq, st->num, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333 break;
2334 case TCP_SEQ_STATE_OPENREQ:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002335 get_openreq4(st->syn_wait_sk, v, seq, st->num, st->uid, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336 break;
2337 case TCP_SEQ_STATE_TIME_WAIT:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002338 get_timewait4_sock(v, seq, st->num, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002339 break;
2340 }
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002341 seq_printf(seq, "%*s\n", TMPSZ - 1 - len, "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002342out:
2343 return 0;
2344}
2345
Linus Torvalds1da177e2005-04-16 15:20:36 -07002346static struct tcp_seq_afinfo tcp4_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002347 .name = "tcp",
2348 .family = AF_INET,
Denis V. Lunev5f4472c2008-04-13 22:13:53 -07002349 .seq_fops = {
2350 .owner = THIS_MODULE,
2351 },
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002352 .seq_ops = {
2353 .show = tcp4_seq_show,
2354 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002355};
2356
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002357static int tcp4_proc_init_net(struct net *net)
2358{
2359 return tcp_proc_register(net, &tcp4_seq_afinfo);
2360}
2361
2362static void tcp4_proc_exit_net(struct net *net)
2363{
2364 tcp_proc_unregister(net, &tcp4_seq_afinfo);
2365}
2366
2367static struct pernet_operations tcp4_net_ops = {
2368 .init = tcp4_proc_init_net,
2369 .exit = tcp4_proc_exit_net,
2370};
2371
Linus Torvalds1da177e2005-04-16 15:20:36 -07002372int __init tcp4_proc_init(void)
2373{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002374 return register_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002375}
2376
2377void tcp4_proc_exit(void)
2378{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002379 unregister_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380}
2381#endif /* CONFIG_PROC_FS */
2382
Herbert Xubf296b12008-12-15 23:43:36 -08002383struct sk_buff **tcp4_gro_receive(struct sk_buff **head, struct sk_buff *skb)
2384{
Herbert Xu36e7b1b2009-04-27 05:44:45 -07002385 struct iphdr *iph = skb_gro_network_header(skb);
Herbert Xubf296b12008-12-15 23:43:36 -08002386
2387 switch (skb->ip_summed) {
2388 case CHECKSUM_COMPLETE:
Herbert Xu86911732009-01-29 14:19:50 +00002389 if (!tcp_v4_check(skb_gro_len(skb), iph->saddr, iph->daddr,
Herbert Xubf296b12008-12-15 23:43:36 -08002390 skb->csum)) {
2391 skb->ip_summed = CHECKSUM_UNNECESSARY;
2392 break;
2393 }
2394
2395 /* fall through */
2396 case CHECKSUM_NONE:
2397 NAPI_GRO_CB(skb)->flush = 1;
2398 return NULL;
2399 }
2400
2401 return tcp_gro_receive(head, skb);
2402}
2403EXPORT_SYMBOL(tcp4_gro_receive);
2404
2405int tcp4_gro_complete(struct sk_buff *skb)
2406{
2407 struct iphdr *iph = ip_hdr(skb);
2408 struct tcphdr *th = tcp_hdr(skb);
2409
2410 th->check = ~tcp_v4_check(skb->len - skb_transport_offset(skb),
2411 iph->saddr, iph->daddr, 0);
2412 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV4;
2413
2414 return tcp_gro_complete(skb);
2415}
2416EXPORT_SYMBOL(tcp4_gro_complete);
2417
Linus Torvalds1da177e2005-04-16 15:20:36 -07002418struct proto tcp_prot = {
2419 .name = "TCP",
2420 .owner = THIS_MODULE,
2421 .close = tcp_close,
2422 .connect = tcp_v4_connect,
2423 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002424 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002425 .ioctl = tcp_ioctl,
2426 .init = tcp_v4_init_sock,
2427 .destroy = tcp_v4_destroy_sock,
2428 .shutdown = tcp_shutdown,
2429 .setsockopt = tcp_setsockopt,
2430 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002431 .recvmsg = tcp_recvmsg,
2432 .backlog_rcv = tcp_v4_do_rcv,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08002433 .hash = inet_hash,
2434 .unhash = inet_unhash,
2435 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002436 .enter_memory_pressure = tcp_enter_memory_pressure,
2437 .sockets_allocated = &tcp_sockets_allocated,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07002438 .orphan_count = &tcp_orphan_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002439 .memory_allocated = &tcp_memory_allocated,
2440 .memory_pressure = &tcp_memory_pressure,
2441 .sysctl_mem = sysctl_tcp_mem,
2442 .sysctl_wmem = sysctl_tcp_wmem,
2443 .sysctl_rmem = sysctl_tcp_rmem,
2444 .max_header = MAX_TCP_HEADER,
2445 .obj_size = sizeof(struct tcp_sock),
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002446 .slab_flags = SLAB_DESTROY_BY_RCU,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002447 .twsk_prot = &tcp_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002448 .rsk_prot = &tcp_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07002449 .h.hashinfo = &tcp_hashinfo,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002450#ifdef CONFIG_COMPAT
2451 .compat_setsockopt = compat_tcp_setsockopt,
2452 .compat_getsockopt = compat_tcp_getsockopt,
2453#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002454};
2455
Denis V. Lunev046ee902008-04-03 14:31:33 -07002456
2457static int __net_init tcp_sk_init(struct net *net)
2458{
2459 return inet_ctl_sock_create(&net->ipv4.tcp_sock,
2460 PF_INET, SOCK_RAW, IPPROTO_TCP, net);
2461}
2462
2463static void __net_exit tcp_sk_exit(struct net *net)
2464{
2465 inet_ctl_sock_destroy(net->ipv4.tcp_sock);
Daniel Lezcanod3154922008-09-08 13:17:27 -07002466 inet_twsk_purge(net, &tcp_hashinfo, &tcp_death_row, AF_INET);
Denis V. Lunev046ee902008-04-03 14:31:33 -07002467}
2468
2469static struct pernet_operations __net_initdata tcp_sk_ops = {
2470 .init = tcp_sk_init,
2471 .exit = tcp_sk_exit,
2472};
2473
Denis V. Lunev9b0f9762008-02-29 11:13:15 -08002474void __init tcp_v4_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475{
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002476 inet_hashinfo_init(&tcp_hashinfo);
Eric W. Biederman6a1b3052009-02-22 00:10:18 -08002477 if (register_pernet_subsys(&tcp_sk_ops))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002478 panic("Failed to create the TCP control socket.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002479}
2480
2481EXPORT_SYMBOL(ipv4_specific);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002482EXPORT_SYMBOL(tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002483EXPORT_SYMBOL(tcp_prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002484EXPORT_SYMBOL(tcp_v4_conn_request);
2485EXPORT_SYMBOL(tcp_v4_connect);
2486EXPORT_SYMBOL(tcp_v4_do_rcv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002487EXPORT_SYMBOL(tcp_v4_remember_stamp);
2488EXPORT_SYMBOL(tcp_v4_send_check);
2489EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
2490
2491#ifdef CONFIG_PROC_FS
2492EXPORT_SYMBOL(tcp_proc_register);
2493EXPORT_SYMBOL(tcp_proc_unregister);
2494#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002495EXPORT_SYMBOL(sysctl_tcp_low_latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002496