blob: 69ccbc1dde9cdfed2719e243fd6091cc9781a876 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * Implementation of the Transmission Control Protocol(TCP).
7 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 * IPv4 specific functions
9 *
10 *
11 * code split from:
12 * linux/ipv4/tcp.c
13 * linux/ipv4/tcp_input.c
14 * linux/ipv4/tcp_output.c
15 *
16 * See tcp.c for author information
17 *
18 * This program is free software; you can redistribute it and/or
19 * modify it under the terms of the GNU General Public License
20 * as published by the Free Software Foundation; either version
21 * 2 of the License, or (at your option) any later version.
22 */
23
24/*
25 * Changes:
26 * David S. Miller : New socket lookup architecture.
27 * This code is dedicated to John Dyson.
28 * David S. Miller : Change semantics of established hash,
29 * half is devoted to TIME_WAIT sockets
30 * and the rest go in the other half.
31 * Andi Kleen : Add support for syncookies and fixed
32 * some bugs: ip options weren't passed to
33 * the TCP layer, missed a check for an
34 * ACK bit.
35 * Andi Kleen : Implemented fast path mtu discovery.
36 * Fixed many serious bugs in the
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -070037 * request_sock handling and moved
Linus Torvalds1da177e2005-04-16 15:20:36 -070038 * most of it into the af independent code.
39 * Added tail drop and some other bugfixes.
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -080040 * Added new listen semantics.
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 * Mike McLagan : Routing by source
42 * Juan Jose Ciarlante: ip_dynaddr bits
43 * Andi Kleen: various fixes.
44 * Vitaly E. Lavrov : Transparent proxy revived after year
45 * coma.
46 * Andi Kleen : Fix new listen.
47 * Andi Kleen : Fix accept error reporting.
48 * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which
49 * Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind
50 * a single port at the same time.
51 */
52
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
Herbert Xueb4dea52008-12-29 23:04:08 -080054#include <linux/bottom_half.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070055#include <linux/types.h>
56#include <linux/fcntl.h>
57#include <linux/module.h>
58#include <linux/random.h>
59#include <linux/cache.h>
60#include <linux/jhash.h>
61#include <linux/init.h>
62#include <linux/times.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090063#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070064
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020065#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070066#include <net/icmp.h>
Arnaldo Carvalho de Melo304a1612005-08-09 19:59:20 -070067#include <net/inet_hashtables.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070068#include <net/tcp.h>
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -030069#include <net/transp_v6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070070#include <net/ipv6.h>
71#include <net/inet_common.h>
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -080072#include <net/timewait_sock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070073#include <net/xfrm.h>
Chris Leech1a2449a2006-05-23 18:05:53 -070074#include <net/netdma.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
76#include <linux/inet.h>
77#include <linux/ipv6.h>
78#include <linux/stddef.h>
79#include <linux/proc_fs.h>
80#include <linux/seq_file.h>
81
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080082#include <linux/crypto.h>
83#include <linux/scatterlist.h>
84
Brian Haleyab32ea52006-09-22 14:15:41 -070085int sysctl_tcp_tw_reuse __read_mostly;
86int sysctl_tcp_low_latency __read_mostly;
Eric Dumazet4bc2f182010-07-09 21:22:10 +000087EXPORT_SYMBOL(sysctl_tcp_low_latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080090#ifdef CONFIG_TCP_MD5SIG
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -020091static struct tcp_md5sig_key *tcp_v4_md5_do_lookup(struct sock *sk,
92 __be32 addr);
Adam Langley49a72df2008-07-19 00:01:42 -070093static int tcp_v4_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
94 __be32 daddr, __be32 saddr, struct tcphdr *th);
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +090095#else
96static inline
97struct tcp_md5sig_key *tcp_v4_md5_do_lookup(struct sock *sk, __be32 addr)
98{
99 return NULL;
100}
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800101#endif
102
Eric Dumazet5caea4e2008-11-20 00:40:07 -0800103struct inet_hashinfo tcp_hashinfo;
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000104EXPORT_SYMBOL(tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105
Gerrit Renkera94f7232006-11-10 14:06:49 -0800106static inline __u32 tcp_v4_init_sequence(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700108 return secure_tcp_sequence_number(ip_hdr(skb)->daddr,
109 ip_hdr(skb)->saddr,
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700110 tcp_hdr(skb)->dest,
111 tcp_hdr(skb)->source);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112}
113
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800114int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp)
115{
116 const struct tcp_timewait_sock *tcptw = tcp_twsk(sktw);
117 struct tcp_sock *tp = tcp_sk(sk);
118
119 /* With PAWS, it is safe from the viewpoint
120 of data integrity. Even without PAWS it is safe provided sequence
121 spaces do not overlap i.e. at data rates <= 80Mbit/sec.
122
123 Actually, the idea is close to VJ's one, only timestamp cache is
124 held not per host, but per port pair and TW bucket is used as state
125 holder.
126
127 If TW bucket has been already destroyed we fall back to VJ's scheme
128 and use initial timestamp retrieved from peer table.
129 */
130 if (tcptw->tw_ts_recent_stamp &&
131 (twp == NULL || (sysctl_tcp_tw_reuse &&
James Morris9d729f72007-03-04 16:12:44 -0800132 get_seconds() - tcptw->tw_ts_recent_stamp > 1))) {
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800133 tp->write_seq = tcptw->tw_snd_nxt + 65535 + 2;
134 if (tp->write_seq == 0)
135 tp->write_seq = 1;
136 tp->rx_opt.ts_recent = tcptw->tw_ts_recent;
137 tp->rx_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp;
138 sock_hold(sktw);
139 return 1;
140 }
141
142 return 0;
143}
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800144EXPORT_SYMBOL_GPL(tcp_twsk_unique);
145
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146/* This will initiate an outgoing connection. */
147int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
148{
149 struct inet_sock *inet = inet_sk(sk);
150 struct tcp_sock *tp = tcp_sk(sk);
151 struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
152 struct rtable *rt;
Al Virobada8ad2006-09-26 21:27:15 -0700153 __be32 daddr, nexthop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 int tmp;
155 int err;
156
157 if (addr_len < sizeof(struct sockaddr_in))
158 return -EINVAL;
159
160 if (usin->sin_family != AF_INET)
161 return -EAFNOSUPPORT;
162
163 nexthop = daddr = usin->sin_addr.s_addr;
164 if (inet->opt && inet->opt->srr) {
165 if (!daddr)
166 return -EINVAL;
167 nexthop = inet->opt->faddr;
168 }
169
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000170 tmp = ip_route_connect(&rt, nexthop, inet->inet_saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
172 IPPROTO_TCP,
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000173 inet->inet_sport, usin->sin_port, sk, 1);
Wei Dong584bdf82007-05-31 22:49:28 -0700174 if (tmp < 0) {
175 if (tmp == -ENETUNREACH)
Pavel Emelyanov7c73a6f2008-07-16 20:20:11 -0700176 IP_INC_STATS_BH(sock_net(sk), IPSTATS_MIB_OUTNOROUTES);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 return tmp;
Wei Dong584bdf82007-05-31 22:49:28 -0700178 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179
180 if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
181 ip_rt_put(rt);
182 return -ENETUNREACH;
183 }
184
185 if (!inet->opt || !inet->opt->srr)
186 daddr = rt->rt_dst;
187
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000188 if (!inet->inet_saddr)
189 inet->inet_saddr = rt->rt_src;
190 inet->inet_rcv_saddr = inet->inet_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000192 if (tp->rx_opt.ts_recent_stamp && inet->inet_daddr != daddr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 /* Reset inherited state */
194 tp->rx_opt.ts_recent = 0;
195 tp->rx_opt.ts_recent_stamp = 0;
196 tp->write_seq = 0;
197 }
198
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -0700199 if (tcp_death_row.sysctl_tw_recycle &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 !tp->rx_opt.ts_recent_stamp && rt->rt_dst == daddr) {
201 struct inet_peer *peer = rt_get_peer(rt);
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200202 /*
203 * VJ's idea. We save last timestamp seen from
204 * the destination in peer table, when entering state
205 * TIME-WAIT * and initialize rx_opt.ts_recent from it,
206 * when trying new connection.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 */
Eric Dumazet317fe0e2010-06-16 04:52:13 +0000208 if (peer) {
209 inet_peer_refcheck(peer);
210 if ((u32)get_seconds() - peer->tcp_ts_stamp <= TCP_PAWS_MSL) {
211 tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp;
212 tp->rx_opt.ts_recent = peer->tcp_ts;
213 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 }
215 }
216
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000217 inet->inet_dport = usin->sin_port;
218 inet->inet_daddr = daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800220 inet_csk(sk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 if (inet->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800222 inet_csk(sk)->icsk_ext_hdr_len = inet->opt->optlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223
William Allen Simpsonbee7ca92009-11-10 09:51:18 +0000224 tp->rx_opt.mss_clamp = TCP_MSS_DEFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225
226 /* Socket identity is still unknown (sport may be zero).
227 * However we set state to SYN-SENT and not releasing socket
228 * lock select source port, enter ourselves into the hash tables and
229 * complete initialization after this.
230 */
231 tcp_set_state(sk, TCP_SYN_SENT);
Arnaldo Carvalho de Meloa7f5e7f2005-12-13 23:25:31 -0800232 err = inet_hash_connect(&tcp_death_row, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 if (err)
234 goto failure;
235
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200236 err = ip_route_newports(&rt, IPPROTO_TCP,
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000237 inet->inet_sport, inet->inet_dport, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 if (err)
239 goto failure;
240
241 /* OK, now commit destination to socket. */
Herbert Xubcd76112006-06-30 13:36:35 -0700242 sk->sk_gso_type = SKB_GSO_TCPV4;
Changli Gaod8d1f302010-06-10 23:31:35 -0700243 sk_setup_caps(sk, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
245 if (!tp->write_seq)
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000246 tp->write_seq = secure_tcp_sequence_number(inet->inet_saddr,
247 inet->inet_daddr,
248 inet->inet_sport,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 usin->sin_port);
250
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000251 inet->inet_id = tp->write_seq ^ jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
253 err = tcp_connect(sk);
254 rt = NULL;
255 if (err)
256 goto failure;
257
258 return 0;
259
260failure:
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200261 /*
262 * This unhashes the socket and releases the local port,
263 * if necessary.
264 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 tcp_set_state(sk, TCP_CLOSE);
266 ip_rt_put(rt);
267 sk->sk_route_caps = 0;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000268 inet->inet_dport = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 return err;
270}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000271EXPORT_SYMBOL(tcp_v4_connect);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273/*
274 * This routine does path mtu discovery as defined in RFC1191.
275 */
Stephen Hemminger40efc6f2006-01-03 16:03:49 -0800276static void do_pmtu_discovery(struct sock *sk, struct iphdr *iph, u32 mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277{
278 struct dst_entry *dst;
279 struct inet_sock *inet = inet_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280
281 /* We are not interested in TCP_LISTEN and open_requests (SYN-ACKs
282 * send out by Linux are always <576bytes so they should go through
283 * unfragmented).
284 */
285 if (sk->sk_state == TCP_LISTEN)
286 return;
287
288 /* We don't check in the destentry if pmtu discovery is forbidden
289 * on this route. We just assume that no packet_to_big packets
290 * are send back when pmtu discovery is not active.
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900291 * There is a small race when the user changes this flag in the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 * route, but I think that's acceptable.
293 */
294 if ((dst = __sk_dst_check(sk, 0)) == NULL)
295 return;
296
297 dst->ops->update_pmtu(dst, mtu);
298
299 /* Something is about to be wrong... Remember soft error
300 * for the case, if this connection will not able to recover.
301 */
302 if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
303 sk->sk_err_soft = EMSGSIZE;
304
305 mtu = dst_mtu(dst);
306
307 if (inet->pmtudisc != IP_PMTUDISC_DONT &&
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800308 inet_csk(sk)->icsk_pmtu_cookie > mtu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 tcp_sync_mss(sk, mtu);
310
311 /* Resend the TCP packet because it's
312 * clear that the old packet has been
313 * dropped. This is the new "fast" path mtu
314 * discovery.
315 */
316 tcp_simple_retransmit(sk);
317 } /* else let the usual retransmit timer handle it */
318}
319
320/*
321 * This routine is called by the ICMP module when it gets some
322 * sort of error condition. If err < 0 then the socket should
323 * be closed and the error returned to the user. If err > 0
324 * it's just the icmp type << 8 | icmp code. After adjustment
325 * header points to the first 8 bytes of the tcp header. We need
326 * to find the appropriate port.
327 *
328 * The locking strategy used here is very "optimistic". When
329 * someone else accesses the socket the ICMP is just dropped
330 * and for some paths there is no check at all.
331 * A more general error queue to queue errors for later handling
332 * is probably better.
333 *
334 */
335
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000336void tcp_v4_err(struct sk_buff *icmp_skb, u32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337{
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000338 struct iphdr *iph = (struct iphdr *)icmp_skb->data;
339 struct tcphdr *th = (struct tcphdr *)(icmp_skb->data + (iph->ihl << 2));
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000340 struct inet_connection_sock *icsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 struct tcp_sock *tp;
342 struct inet_sock *inet;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000343 const int type = icmp_hdr(icmp_skb)->type;
344 const int code = icmp_hdr(icmp_skb)->code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 struct sock *sk;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000346 struct sk_buff *skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 __u32 seq;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000348 __u32 remaining;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 int err;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000350 struct net *net = dev_net(icmp_skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000352 if (icmp_skb->len < (iph->ihl << 2) + 8) {
Pavel Emelyanovdcfc23c2008-07-14 23:03:00 -0700353 ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 return;
355 }
356
Pavel Emelyanovfd54d712008-07-14 23:01:40 -0700357 sk = inet_lookup(net, &tcp_hashinfo, iph->daddr, th->dest,
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000358 iph->saddr, th->source, inet_iif(icmp_skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 if (!sk) {
Pavel Emelyanovdcfc23c2008-07-14 23:03:00 -0700360 ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 return;
362 }
363 if (sk->sk_state == TCP_TIME_WAIT) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700364 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 return;
366 }
367
368 bh_lock_sock(sk);
369 /* If too many ICMPs get dropped on busy
370 * servers this needs to be solved differently.
371 */
372 if (sock_owned_by_user(sk))
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700373 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374
375 if (sk->sk_state == TCP_CLOSE)
376 goto out;
377
stephen hemminger97e3ecd12010-03-18 11:27:32 +0000378 if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
379 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
380 goto out;
381 }
382
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000383 icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 tp = tcp_sk(sk);
385 seq = ntohl(th->seq);
386 if (sk->sk_state != TCP_LISTEN &&
387 !between(seq, tp->snd_una, tp->snd_nxt)) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700388 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 goto out;
390 }
391
392 switch (type) {
393 case ICMP_SOURCE_QUENCH:
394 /* Just silently ignore these. */
395 goto out;
396 case ICMP_PARAMETERPROB:
397 err = EPROTO;
398 break;
399 case ICMP_DEST_UNREACH:
400 if (code > NR_ICMP_UNREACH)
401 goto out;
402
403 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
404 if (!sock_owned_by_user(sk))
405 do_pmtu_discovery(sk, iph, info);
406 goto out;
407 }
408
409 err = icmp_err_convert[code].errno;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000410 /* check if icmp_skb allows revert of backoff
411 * (see draft-zimmermann-tcp-lcd) */
412 if (code != ICMP_NET_UNREACH && code != ICMP_HOST_UNREACH)
413 break;
414 if (seq != tp->snd_una || !icsk->icsk_retransmits ||
415 !icsk->icsk_backoff)
416 break;
417
David S. Miller8f49c272010-11-12 13:35:00 -0800418 if (sock_owned_by_user(sk))
419 break;
420
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000421 icsk->icsk_backoff--;
422 inet_csk(sk)->icsk_rto = __tcp_set_rto(tp) <<
423 icsk->icsk_backoff;
424 tcp_bound_rto(sk);
425
426 skb = tcp_write_queue_head(sk);
427 BUG_ON(!skb);
428
429 remaining = icsk->icsk_rto - min(icsk->icsk_rto,
430 tcp_time_stamp - TCP_SKB_CB(skb)->when);
431
432 if (remaining) {
433 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
434 remaining, TCP_RTO_MAX);
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000435 } else {
436 /* RTO revert clocked out retransmission.
437 * Will retransmit now */
438 tcp_retransmit_timer(sk);
439 }
440
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 break;
442 case ICMP_TIME_EXCEEDED:
443 err = EHOSTUNREACH;
444 break;
445 default:
446 goto out;
447 }
448
449 switch (sk->sk_state) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700450 struct request_sock *req, **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 case TCP_LISTEN:
452 if (sock_owned_by_user(sk))
453 goto out;
454
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700455 req = inet_csk_search_req(sk, &prev, th->dest,
456 iph->daddr, iph->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 if (!req)
458 goto out;
459
460 /* ICMPs are not backlogged, hence we cannot get
461 an established socket here.
462 */
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700463 WARN_ON(req->sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700465 if (seq != tcp_rsk(req)->snt_isn) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700466 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 goto out;
468 }
469
470 /*
471 * Still in SYN_RECV, just remove it silently.
472 * There is no good way to pass the error to the newly
473 * created socket, and POSIX does not want network
474 * errors returned from accept().
475 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700476 inet_csk_reqsk_queue_drop(sk, req, prev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 goto out;
478
479 case TCP_SYN_SENT:
480 case TCP_SYN_RECV: /* Cannot happen.
481 It can f.e. if SYNs crossed.
482 */
483 if (!sock_owned_by_user(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 sk->sk_err = err;
485
486 sk->sk_error_report(sk);
487
488 tcp_done(sk);
489 } else {
490 sk->sk_err_soft = err;
491 }
492 goto out;
493 }
494
495 /* If we've already connected we will keep trying
496 * until we time out, or the user gives up.
497 *
498 * rfc1122 4.2.3.9 allows to consider as hard errors
499 * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
500 * but it is obsoleted by pmtu discovery).
501 *
502 * Note, that in modern internet, where routing is unreliable
503 * and in each dark corner broken firewalls sit, sending random
504 * errors ordered by their masters even this two messages finally lose
505 * their original sense (even Linux sends invalid PORT_UNREACHs)
506 *
507 * Now we are in compliance with RFCs.
508 * --ANK (980905)
509 */
510
511 inet = inet_sk(sk);
512 if (!sock_owned_by_user(sk) && inet->recverr) {
513 sk->sk_err = err;
514 sk->sk_error_report(sk);
515 } else { /* Only an error on timeout */
516 sk->sk_err_soft = err;
517 }
518
519out:
520 bh_unlock_sock(sk);
521 sock_put(sk);
522}
523
Herbert Xu419f9f82010-04-11 02:15:53 +0000524static void __tcp_v4_send_check(struct sk_buff *skb,
525 __be32 saddr, __be32 daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700527 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528
Patrick McHardy84fa7932006-08-29 16:44:56 -0700529 if (skb->ip_summed == CHECKSUM_PARTIAL) {
Herbert Xu419f9f82010-04-11 02:15:53 +0000530 th->check = ~tcp_v4_check(skb->len, saddr, daddr, 0);
Herbert Xu663ead32007-04-09 11:59:07 -0700531 skb->csum_start = skb_transport_header(skb) - skb->head;
Al Viroff1dcad2006-11-20 18:07:29 -0800532 skb->csum_offset = offsetof(struct tcphdr, check);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 } else {
Herbert Xu419f9f82010-04-11 02:15:53 +0000534 th->check = tcp_v4_check(skb->len, saddr, daddr,
Joe Perches07f07572008-11-19 15:44:53 -0800535 csum_partial(th,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 th->doff << 2,
537 skb->csum));
538 }
539}
540
Herbert Xu419f9f82010-04-11 02:15:53 +0000541/* This routine computes an IPv4 TCP checksum. */
Herbert Xubb296242010-04-11 02:15:55 +0000542void tcp_v4_send_check(struct sock *sk, struct sk_buff *skb)
Herbert Xu419f9f82010-04-11 02:15:53 +0000543{
544 struct inet_sock *inet = inet_sk(sk);
545
546 __tcp_v4_send_check(skb, inet->inet_saddr, inet->inet_daddr);
547}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000548EXPORT_SYMBOL(tcp_v4_send_check);
Herbert Xu419f9f82010-04-11 02:15:53 +0000549
Herbert Xua430a432006-07-08 13:34:56 -0700550int tcp_v4_gso_send_check(struct sk_buff *skb)
551{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700552 const struct iphdr *iph;
Herbert Xua430a432006-07-08 13:34:56 -0700553 struct tcphdr *th;
554
555 if (!pskb_may_pull(skb, sizeof(*th)))
556 return -EINVAL;
557
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700558 iph = ip_hdr(skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700559 th = tcp_hdr(skb);
Herbert Xua430a432006-07-08 13:34:56 -0700560
561 th->check = 0;
Patrick McHardy84fa7932006-08-29 16:44:56 -0700562 skb->ip_summed = CHECKSUM_PARTIAL;
Herbert Xu419f9f82010-04-11 02:15:53 +0000563 __tcp_v4_send_check(skb, iph->saddr, iph->daddr);
Herbert Xua430a432006-07-08 13:34:56 -0700564 return 0;
565}
566
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567/*
568 * This routine will send an RST to the other tcp.
569 *
570 * Someone asks: why I NEVER use socket parameters (TOS, TTL etc.)
571 * for reset.
572 * Answer: if a packet caused RST, it is not for a socket
573 * existing in our system, if it is matched to a socket,
574 * it is just duplicate segment or bug in other side's TCP.
575 * So that we build reply only basing on parameters
576 * arrived with segment.
577 * Exception: precedence violation. We do not implement it in any case.
578 */
579
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800580static void tcp_v4_send_reset(struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700582 struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800583 struct {
584 struct tcphdr th;
585#ifdef CONFIG_TCP_MD5SIG
Al Viro714e85b2006-11-14 20:51:49 -0800586 __be32 opt[(TCPOLEN_MD5SIG_ALIGNED >> 2)];
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800587#endif
588 } rep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 struct ip_reply_arg arg;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800590#ifdef CONFIG_TCP_MD5SIG
591 struct tcp_md5sig_key *key;
592#endif
Pavel Emelyanova86b1e32008-07-16 20:20:58 -0700593 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594
595 /* Never send a reset in response to a reset. */
596 if (th->rst)
597 return;
598
Eric Dumazet511c3f92009-06-02 05:14:27 +0000599 if (skb_rtable(skb)->rt_type != RTN_LOCAL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 return;
601
602 /* Swap the send and the receive. */
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800603 memset(&rep, 0, sizeof(rep));
604 rep.th.dest = th->source;
605 rep.th.source = th->dest;
606 rep.th.doff = sizeof(struct tcphdr) / 4;
607 rep.th.rst = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608
609 if (th->ack) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800610 rep.th.seq = th->ack_seq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800612 rep.th.ack = 1;
613 rep.th.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
614 skb->len - (th->doff << 2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 }
616
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200617 memset(&arg, 0, sizeof(arg));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800618 arg.iov[0].iov_base = (unsigned char *)&rep;
619 arg.iov[0].iov_len = sizeof(rep.th);
620
621#ifdef CONFIG_TCP_MD5SIG
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700622 key = sk ? tcp_v4_md5_do_lookup(sk, ip_hdr(skb)->daddr) : NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800623 if (key) {
624 rep.opt[0] = htonl((TCPOPT_NOP << 24) |
625 (TCPOPT_NOP << 16) |
626 (TCPOPT_MD5SIG << 8) |
627 TCPOLEN_MD5SIG);
628 /* Update length and the length the header thinks exists */
629 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
630 rep.th.doff = arg.iov[0].iov_len / 4;
631
Adam Langley49a72df2008-07-19 00:01:42 -0700632 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[1],
Ilpo Järvinen78e645cb2008-10-09 14:37:47 -0700633 key, ip_hdr(skb)->saddr,
634 ip_hdr(skb)->daddr, &rep.th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800635 }
636#endif
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700637 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
638 ip_hdr(skb)->saddr, /* XXX */
Ilpo Järvinen52cd5752008-10-08 11:34:06 -0700639 arg.iov[0].iov_len, IPPROTO_TCP, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700641 arg.flags = (sk && inet_sk(sk)->transparent) ? IP_REPLY_ARG_NOSRCCHECK : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642
Eric Dumazetadf30902009-06-02 05:19:30 +0000643 net = dev_net(skb_dst(skb)->dev);
Pavel Emelyanova86b1e32008-07-16 20:20:58 -0700644 ip_send_reply(net->ipv4.tcp_sock, skb,
Denis V. Lunev7feb49c2008-04-03 14:32:00 -0700645 &arg, arg.iov[0].iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646
Pavel Emelyanov63231bd2008-07-16 20:22:25 -0700647 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
648 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649}
650
651/* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
652 outside socket context is ugly, certainly. What can I do?
653 */
654
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900655static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
656 u32 win, u32 ts, int oif,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700657 struct tcp_md5sig_key *key,
658 int reply_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700660 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 struct {
662 struct tcphdr th;
Al Viro714e85b2006-11-14 20:51:49 -0800663 __be32 opt[(TCPOLEN_TSTAMP_ALIGNED >> 2)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800664#ifdef CONFIG_TCP_MD5SIG
Al Viro714e85b2006-11-14 20:51:49 -0800665 + (TCPOLEN_MD5SIG_ALIGNED >> 2)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800666#endif
667 ];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 } rep;
669 struct ip_reply_arg arg;
Eric Dumazetadf30902009-06-02 05:19:30 +0000670 struct net *net = dev_net(skb_dst(skb)->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671
672 memset(&rep.th, 0, sizeof(struct tcphdr));
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200673 memset(&arg, 0, sizeof(arg));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674
675 arg.iov[0].iov_base = (unsigned char *)&rep;
676 arg.iov[0].iov_len = sizeof(rep.th);
677 if (ts) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800678 rep.opt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
679 (TCPOPT_TIMESTAMP << 8) |
680 TCPOLEN_TIMESTAMP);
681 rep.opt[1] = htonl(tcp_time_stamp);
682 rep.opt[2] = htonl(ts);
Craig Schlentercb48cfe2007-01-09 00:11:15 -0800683 arg.iov[0].iov_len += TCPOLEN_TSTAMP_ALIGNED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 }
685
686 /* Swap the send and the receive. */
687 rep.th.dest = th->source;
688 rep.th.source = th->dest;
689 rep.th.doff = arg.iov[0].iov_len / 4;
690 rep.th.seq = htonl(seq);
691 rep.th.ack_seq = htonl(ack);
692 rep.th.ack = 1;
693 rep.th.window = htons(win);
694
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800695#ifdef CONFIG_TCP_MD5SIG
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800696 if (key) {
697 int offset = (ts) ? 3 : 0;
698
699 rep.opt[offset++] = htonl((TCPOPT_NOP << 24) |
700 (TCPOPT_NOP << 16) |
701 (TCPOPT_MD5SIG << 8) |
702 TCPOLEN_MD5SIG);
703 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
704 rep.th.doff = arg.iov[0].iov_len/4;
705
Adam Langley49a72df2008-07-19 00:01:42 -0700706 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[offset],
Adam Langley90b7e112008-07-31 20:49:48 -0700707 key, ip_hdr(skb)->saddr,
708 ip_hdr(skb)->daddr, &rep.th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800709 }
710#endif
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700711 arg.flags = reply_flags;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700712 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
713 ip_hdr(skb)->saddr, /* XXX */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 arg.iov[0].iov_len, IPPROTO_TCP, 0);
715 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900716 if (oif)
717 arg.bound_dev_if = oif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718
Pavel Emelyanova86b1e32008-07-16 20:20:58 -0700719 ip_send_reply(net->ipv4.tcp_sock, skb,
Denis V. Lunev7feb49c2008-04-03 14:32:00 -0700720 &arg, arg.iov[0].iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721
Pavel Emelyanov63231bd2008-07-16 20:22:25 -0700722 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723}
724
725static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
726{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700727 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800728 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900730 tcp_v4_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200731 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900732 tcptw->tw_ts_recent,
733 tw->tw_bound_dev_if,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700734 tcp_twsk_md5_key(tcptw),
735 tw->tw_transparent ? IP_REPLY_ARG_NOSRCCHECK : 0
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900736 );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700738 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739}
740
Gui Jianfeng6edafaa2008-08-06 23:50:04 -0700741static void tcp_v4_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200742 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743{
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900744 tcp_v4_send_ack(skb, tcp_rsk(req)->snt_isn + 1,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800745 tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900746 req->ts_recent,
747 0,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700748 tcp_v4_md5_do_lookup(sk, ip_hdr(skb)->daddr),
749 inet_rsk(req)->no_srccheck ? IP_REPLY_ARG_NOSRCCHECK : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750}
751
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752/*
Kris Katterjohn9bf1d832008-02-17 22:29:19 -0800753 * Send a SYN-ACK after having received a SYN.
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700754 * This still operates on a request_sock only, not on a big
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 * socket.
756 */
Octavian Purdila72659ec2010-01-17 19:09:39 -0800757static int tcp_v4_send_synack(struct sock *sk, struct dst_entry *dst,
758 struct request_sock *req,
759 struct request_values *rvp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700761 const struct inet_request_sock *ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 int err = -1;
763 struct sk_buff * skb;
764
765 /* First, grab a route. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700766 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800767 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000769 skb = tcp_make_synack(sk, dst, req, rvp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770
771 if (skb) {
Herbert Xu419f9f82010-04-11 02:15:53 +0000772 __tcp_v4_send_check(skb, ireq->loc_addr, ireq->rmt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700774 err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,
775 ireq->rmt_addr,
776 ireq->opt);
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200777 err = net_xmit_eval(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 }
779
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 dst_release(dst);
781 return err;
782}
783
Octavian Purdila72659ec2010-01-17 19:09:39 -0800784static int tcp_v4_rtx_synack(struct sock *sk, struct request_sock *req,
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000785 struct request_values *rvp)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800786{
Octavian Purdila72659ec2010-01-17 19:09:39 -0800787 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_RETRANSSEGS);
788 return tcp_v4_send_synack(sk, NULL, req, rvp);
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800789}
790
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700792 * IPv4 request_sock destructor.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 */
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700794static void tcp_v4_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795{
Jesper Juhla51482b2005-11-08 09:41:34 -0800796 kfree(inet_rsk(req)->opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797}
798
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000799static void syn_flood_warning(const struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800{
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000801 const char *msg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000803#ifdef CONFIG_SYN_COOKIES
804 if (sysctl_tcp_syncookies)
805 msg = "Sending cookies";
806 else
Arnaldo Carvalho de Melo80e40da2006-01-04 01:58:06 -0200807#endif
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000808 msg = "Dropping request";
809
810 pr_info("TCP: Possible SYN flooding on port %d. %s.\n",
811 ntohs(tcp_hdr(skb)->dest), msg);
812}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813
814/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700815 * Save and compile IPv4 options into the request_sock if needed.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 */
Stephen Hemminger40efc6f2006-01-03 16:03:49 -0800817static struct ip_options *tcp_v4_save_options(struct sock *sk,
818 struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819{
820 struct ip_options *opt = &(IPCB(skb)->opt);
821 struct ip_options *dopt = NULL;
822
823 if (opt && opt->optlen) {
824 int opt_size = optlength(opt);
825 dopt = kmalloc(opt_size, GFP_ATOMIC);
826 if (dopt) {
827 if (ip_options_echo(dopt, skb)) {
828 kfree(dopt);
829 dopt = NULL;
830 }
831 }
832 }
833 return dopt;
834}
835
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800836#ifdef CONFIG_TCP_MD5SIG
837/*
838 * RFC2385 MD5 checksumming requires a mapping of
839 * IP address->MD5 Key.
840 * We need to maintain these in the sk structure.
841 */
842
843/* Find the Key structure for an address. */
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200844static struct tcp_md5sig_key *
845 tcp_v4_md5_do_lookup(struct sock *sk, __be32 addr)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800846{
847 struct tcp_sock *tp = tcp_sk(sk);
848 int i;
849
850 if (!tp->md5sig_info || !tp->md5sig_info->entries4)
851 return NULL;
852 for (i = 0; i < tp->md5sig_info->entries4; i++) {
853 if (tp->md5sig_info->keys4[i].addr == addr)
David S. Millerf8ab18d2007-09-28 15:18:35 -0700854 return &tp->md5sig_info->keys4[i].base;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800855 }
856 return NULL;
857}
858
859struct tcp_md5sig_key *tcp_v4_md5_lookup(struct sock *sk,
860 struct sock *addr_sk)
861{
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000862 return tcp_v4_md5_do_lookup(sk, inet_sk(addr_sk)->inet_daddr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800863}
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800864EXPORT_SYMBOL(tcp_v4_md5_lookup);
865
Adrian Bunkf5b99bc2006-11-30 17:22:29 -0800866static struct tcp_md5sig_key *tcp_v4_reqsk_md5_lookup(struct sock *sk,
867 struct request_sock *req)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800868{
869 return tcp_v4_md5_do_lookup(sk, inet_rsk(req)->rmt_addr);
870}
871
872/* This can be called on a newly created socket, from other files */
873int tcp_v4_md5_do_add(struct sock *sk, __be32 addr,
874 u8 *newkey, u8 newkeylen)
875{
876 /* Add Key to the list */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700877 struct tcp_md5sig_key *key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800878 struct tcp_sock *tp = tcp_sk(sk);
879 struct tcp4_md5sig_key *keys;
880
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700881 key = tcp_v4_md5_do_lookup(sk, addr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800882 if (key) {
883 /* Pre-existing entry - just update that one. */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700884 kfree(key->key);
885 key->key = newkey;
886 key->keylen = newkeylen;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800887 } else {
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200888 struct tcp_md5sig_info *md5sig;
889
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800890 if (!tp->md5sig_info) {
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200891 tp->md5sig_info = kzalloc(sizeof(*tp->md5sig_info),
892 GFP_ATOMIC);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800893 if (!tp->md5sig_info) {
894 kfree(newkey);
895 return -ENOMEM;
896 }
Eric Dumazeta4654192010-05-16 00:36:33 -0700897 sk_nocaps_add(sk, NETIF_F_GSO_MASK);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800898 }
Wu Fengguangaa133072009-09-02 23:45:45 -0700899 if (tcp_alloc_md5sig_pool(sk) == NULL) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800900 kfree(newkey);
901 return -ENOMEM;
902 }
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200903 md5sig = tp->md5sig_info;
904
905 if (md5sig->alloced4 == md5sig->entries4) {
906 keys = kmalloc((sizeof(*keys) *
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900907 (md5sig->entries4 + 1)), GFP_ATOMIC);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800908 if (!keys) {
909 kfree(newkey);
910 tcp_free_md5sig_pool();
911 return -ENOMEM;
912 }
913
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200914 if (md5sig->entries4)
915 memcpy(keys, md5sig->keys4,
916 sizeof(*keys) * md5sig->entries4);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800917
918 /* Free old key list, and reference new one */
YOSHIFUJI Hideakia80cc202007-11-20 17:30:06 -0800919 kfree(md5sig->keys4);
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200920 md5sig->keys4 = keys;
921 md5sig->alloced4++;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800922 }
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200923 md5sig->entries4++;
David S. Millerf8ab18d2007-09-28 15:18:35 -0700924 md5sig->keys4[md5sig->entries4 - 1].addr = addr;
925 md5sig->keys4[md5sig->entries4 - 1].base.key = newkey;
926 md5sig->keys4[md5sig->entries4 - 1].base.keylen = newkeylen;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800927 }
928 return 0;
929}
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800930EXPORT_SYMBOL(tcp_v4_md5_do_add);
931
932static int tcp_v4_md5_add_func(struct sock *sk, struct sock *addr_sk,
933 u8 *newkey, u8 newkeylen)
934{
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000935 return tcp_v4_md5_do_add(sk, inet_sk(addr_sk)->inet_daddr,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800936 newkey, newkeylen);
937}
938
939int tcp_v4_md5_do_del(struct sock *sk, __be32 addr)
940{
941 struct tcp_sock *tp = tcp_sk(sk);
942 int i;
943
944 for (i = 0; i < tp->md5sig_info->entries4; i++) {
945 if (tp->md5sig_info->keys4[i].addr == addr) {
946 /* Free the key */
David S. Millerf8ab18d2007-09-28 15:18:35 -0700947 kfree(tp->md5sig_info->keys4[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800948 tp->md5sig_info->entries4--;
949
950 if (tp->md5sig_info->entries4 == 0) {
951 kfree(tp->md5sig_info->keys4);
952 tp->md5sig_info->keys4 = NULL;
Leigh Brown8228a18d2006-12-17 17:12:30 -0800953 tp->md5sig_info->alloced4 = 0;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200954 } else if (tp->md5sig_info->entries4 != i) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800955 /* Need to do some manipulation */
YOSHIFUJI Hideaki354faf02007-11-20 17:30:31 -0800956 memmove(&tp->md5sig_info->keys4[i],
957 &tp->md5sig_info->keys4[i+1],
958 (tp->md5sig_info->entries4 - i) *
959 sizeof(struct tcp4_md5sig_key));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800960 }
961 tcp_free_md5sig_pool();
962 return 0;
963 }
964 }
965 return -ENOENT;
966}
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800967EXPORT_SYMBOL(tcp_v4_md5_do_del);
968
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200969static void tcp_v4_clear_md5_list(struct sock *sk)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800970{
971 struct tcp_sock *tp = tcp_sk(sk);
972
973 /* Free each key, then the set of key keys,
974 * the crypto element, and then decrement our
975 * hold on the last resort crypto.
976 */
977 if (tp->md5sig_info->entries4) {
978 int i;
979 for (i = 0; i < tp->md5sig_info->entries4; i++)
David S. Millerf8ab18d2007-09-28 15:18:35 -0700980 kfree(tp->md5sig_info->keys4[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800981 tp->md5sig_info->entries4 = 0;
982 tcp_free_md5sig_pool();
983 }
984 if (tp->md5sig_info->keys4) {
985 kfree(tp->md5sig_info->keys4);
986 tp->md5sig_info->keys4 = NULL;
987 tp->md5sig_info->alloced4 = 0;
988 }
989}
990
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200991static int tcp_v4_parse_md5_keys(struct sock *sk, char __user *optval,
992 int optlen)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800993{
994 struct tcp_md5sig cmd;
995 struct sockaddr_in *sin = (struct sockaddr_in *)&cmd.tcpm_addr;
996 u8 *newkey;
997
998 if (optlen < sizeof(cmd))
999 return -EINVAL;
1000
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001001 if (copy_from_user(&cmd, optval, sizeof(cmd)))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001002 return -EFAULT;
1003
1004 if (sin->sin_family != AF_INET)
1005 return -EINVAL;
1006
1007 if (!cmd.tcpm_key || !cmd.tcpm_keylen) {
1008 if (!tcp_sk(sk)->md5sig_info)
1009 return -ENOENT;
1010 return tcp_v4_md5_do_del(sk, sin->sin_addr.s_addr);
1011 }
1012
1013 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
1014 return -EINVAL;
1015
1016 if (!tcp_sk(sk)->md5sig_info) {
1017 struct tcp_sock *tp = tcp_sk(sk);
Wu Fengguangaa133072009-09-02 23:45:45 -07001018 struct tcp_md5sig_info *p;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001019
Wu Fengguangaa133072009-09-02 23:45:45 -07001020 p = kzalloc(sizeof(*p), sk->sk_allocation);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001021 if (!p)
1022 return -EINVAL;
1023
1024 tp->md5sig_info = p;
Eric Dumazeta4654192010-05-16 00:36:33 -07001025 sk_nocaps_add(sk, NETIF_F_GSO_MASK);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001026 }
1027
Wu Fengguangaa133072009-09-02 23:45:45 -07001028 newkey = kmemdup(cmd.tcpm_key, cmd.tcpm_keylen, sk->sk_allocation);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001029 if (!newkey)
1030 return -ENOMEM;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001031 return tcp_v4_md5_do_add(sk, sin->sin_addr.s_addr,
1032 newkey, cmd.tcpm_keylen);
1033}
1034
Adam Langley49a72df2008-07-19 00:01:42 -07001035static int tcp_v4_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
1036 __be32 daddr, __be32 saddr, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001037{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001038 struct tcp4_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -07001039 struct scatterlist sg;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001040
1041 bp = &hp->md5_blk.ip4;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001042
1043 /*
Adam Langley49a72df2008-07-19 00:01:42 -07001044 * 1. the TCP pseudo-header (in the order: source IP address,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001045 * destination IP address, zero-padded protocol number, and
1046 * segment length)
1047 */
1048 bp->saddr = saddr;
1049 bp->daddr = daddr;
1050 bp->pad = 0;
YOSHIFUJI Hideaki076fb722008-04-17 12:48:12 +09001051 bp->protocol = IPPROTO_TCP;
Adam Langley49a72df2008-07-19 00:01:42 -07001052 bp->len = cpu_to_be16(nbytes);
David S. Millerc7da57a2007-10-26 00:41:21 -07001053
Adam Langley49a72df2008-07-19 00:01:42 -07001054 sg_init_one(&sg, bp, sizeof(*bp));
1055 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
1056}
1057
1058static int tcp_v4_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
1059 __be32 daddr, __be32 saddr, struct tcphdr *th)
1060{
1061 struct tcp_md5sig_pool *hp;
1062 struct hash_desc *desc;
1063
1064 hp = tcp_get_md5sig_pool();
1065 if (!hp)
1066 goto clear_hash_noput;
1067 desc = &hp->md5_desc;
1068
1069 if (crypto_hash_init(desc))
1070 goto clear_hash;
1071 if (tcp_v4_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
1072 goto clear_hash;
1073 if (tcp_md5_hash_header(hp, th))
1074 goto clear_hash;
1075 if (tcp_md5_hash_key(hp, key))
1076 goto clear_hash;
1077 if (crypto_hash_final(desc, md5_hash))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001078 goto clear_hash;
1079
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001080 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001081 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -07001082
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001083clear_hash:
1084 tcp_put_md5sig_pool();
1085clear_hash_noput:
1086 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -07001087 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001088}
1089
Adam Langley49a72df2008-07-19 00:01:42 -07001090int tcp_v4_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
1091 struct sock *sk, struct request_sock *req,
1092 struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001093{
Adam Langley49a72df2008-07-19 00:01:42 -07001094 struct tcp_md5sig_pool *hp;
1095 struct hash_desc *desc;
1096 struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001097 __be32 saddr, daddr;
1098
1099 if (sk) {
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001100 saddr = inet_sk(sk)->inet_saddr;
1101 daddr = inet_sk(sk)->inet_daddr;
Adam Langley49a72df2008-07-19 00:01:42 -07001102 } else if (req) {
1103 saddr = inet_rsk(req)->loc_addr;
1104 daddr = inet_rsk(req)->rmt_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001105 } else {
Adam Langley49a72df2008-07-19 00:01:42 -07001106 const struct iphdr *iph = ip_hdr(skb);
1107 saddr = iph->saddr;
1108 daddr = iph->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001109 }
Adam Langley49a72df2008-07-19 00:01:42 -07001110
1111 hp = tcp_get_md5sig_pool();
1112 if (!hp)
1113 goto clear_hash_noput;
1114 desc = &hp->md5_desc;
1115
1116 if (crypto_hash_init(desc))
1117 goto clear_hash;
1118
1119 if (tcp_v4_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
1120 goto clear_hash;
1121 if (tcp_md5_hash_header(hp, th))
1122 goto clear_hash;
1123 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
1124 goto clear_hash;
1125 if (tcp_md5_hash_key(hp, key))
1126 goto clear_hash;
1127 if (crypto_hash_final(desc, md5_hash))
1128 goto clear_hash;
1129
1130 tcp_put_md5sig_pool();
1131 return 0;
1132
1133clear_hash:
1134 tcp_put_md5sig_pool();
1135clear_hash_noput:
1136 memset(md5_hash, 0, 16);
1137 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001138}
Adam Langley49a72df2008-07-19 00:01:42 -07001139EXPORT_SYMBOL(tcp_v4_md5_hash_skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001140
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001141static int tcp_v4_inbound_md5_hash(struct sock *sk, struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001142{
1143 /*
1144 * This gets called for each TCP segment that arrives
1145 * so we want to be efficient.
1146 * We have 3 drop cases:
1147 * o No MD5 hash and one expected.
1148 * o MD5 hash and we're not expecting one.
1149 * o MD5 hash and its wrong.
1150 */
1151 __u8 *hash_location = NULL;
1152 struct tcp_md5sig_key *hash_expected;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001153 const struct iphdr *iph = ip_hdr(skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001154 struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001155 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001156 unsigned char newhash[16];
1157
1158 hash_expected = tcp_v4_md5_do_lookup(sk, iph->saddr);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +09001159 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001160
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001161 /* We've parsed the options - do we have a hash? */
1162 if (!hash_expected && !hash_location)
1163 return 0;
1164
1165 if (hash_expected && !hash_location) {
David S. Miller785957d2008-07-30 03:03:15 -07001166 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001167 return 1;
1168 }
1169
1170 if (!hash_expected && hash_location) {
David S. Miller785957d2008-07-30 03:03:15 -07001171 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001172 return 1;
1173 }
1174
1175 /* Okay, so this is hash_expected and hash_location -
1176 * so we need to calculate the checksum.
1177 */
Adam Langley49a72df2008-07-19 00:01:42 -07001178 genhash = tcp_v4_md5_hash_skb(newhash,
1179 hash_expected,
1180 NULL, NULL, skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001181
1182 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
1183 if (net_ratelimit()) {
Harvey Harrison673d57e2008-10-31 00:53:57 -07001184 printk(KERN_INFO "MD5 Hash failed for (%pI4, %d)->(%pI4, %d)%s\n",
1185 &iph->saddr, ntohs(th->source),
1186 &iph->daddr, ntohs(th->dest),
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001187 genhash ? " tcp_v4_calc_md5_hash failed" : "");
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001188 }
1189 return 1;
1190 }
1191 return 0;
1192}
1193
1194#endif
1195
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001196struct request_sock_ops tcp_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 .family = PF_INET,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001198 .obj_size = sizeof(struct tcp_request_sock),
Octavian Purdila72659ec2010-01-17 19:09:39 -08001199 .rtx_syn_ack = tcp_v4_rtx_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001200 .send_ack = tcp_v4_reqsk_send_ack,
1201 .destructor = tcp_v4_reqsk_destructor,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 .send_reset = tcp_v4_send_reset,
Octavian Purdila72659ec2010-01-17 19:09:39 -08001203 .syn_ack_timeout = tcp_syn_ack_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204};
1205
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001206#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001207static const struct tcp_request_sock_ops tcp_request_sock_ipv4_ops = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001208 .md5_lookup = tcp_v4_reqsk_md5_lookup,
John Dykstrae3afe7b2009-07-16 05:04:51 +00001209 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001210};
Andrew Mortonb6332e62006-11-30 19:16:28 -08001211#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001212
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08001213static struct timewait_sock_ops tcp_timewait_sock_ops = {
1214 .twsk_obj_size = sizeof(struct tcp_timewait_sock),
1215 .twsk_unique = tcp_twsk_unique,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001216 .twsk_destructor= tcp_twsk_destructor,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08001217};
1218
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1220{
William Allen Simpson4957faade2009-12-02 18:25:27 +00001221 struct tcp_extend_values tmp_ext;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 struct tcp_options_received tmp_opt;
William Allen Simpson4957faade2009-12-02 18:25:27 +00001223 u8 *hash_location;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001224 struct request_sock *req;
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001225 struct inet_request_sock *ireq;
William Allen Simpson4957faade2009-12-02 18:25:27 +00001226 struct tcp_sock *tp = tcp_sk(sk);
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001227 struct dst_entry *dst = NULL;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001228 __be32 saddr = ip_hdr(skb)->saddr;
1229 __be32 daddr = ip_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230 __u32 isn = TCP_SKB_CB(skb)->when;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231#ifdef CONFIG_SYN_COOKIES
1232 int want_cookie = 0;
1233#else
1234#define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */
1235#endif
1236
1237 /* Never answer to SYNs send to broadcast or multicast */
Eric Dumazet511c3f92009-06-02 05:14:27 +00001238 if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 goto drop;
1240
1241 /* TW buckets are converted to open requests without
1242 * limitations, they conserve resources and peer is
1243 * evidently real one.
1244 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001245 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
Florian Westphal2a1d4bd2010-06-03 00:43:12 +00001246 if (net_ratelimit())
1247 syn_flood_warning(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248#ifdef CONFIG_SYN_COOKIES
1249 if (sysctl_tcp_syncookies) {
1250 want_cookie = 1;
1251 } else
1252#endif
1253 goto drop;
1254 }
1255
1256 /* Accept backlog is full. If we have already queued enough
1257 * of warm entries in syn queue, drop request. It is better than
1258 * clogging syn queue with openreqs with exponentially increasing
1259 * timeout.
1260 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001261 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 goto drop;
1263
Arnaldo Carvalho de Meloce4a7d02008-06-10 12:39:35 -07001264 req = inet_reqsk_alloc(&tcp_request_sock_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 if (!req)
1266 goto drop;
1267
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001268#ifdef CONFIG_TCP_MD5SIG
1269 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv4_ops;
1270#endif
1271
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 tcp_clear_options(&tmp_opt);
William Allen Simpsonbee7ca92009-11-10 09:51:18 +00001273 tmp_opt.mss_clamp = TCP_MSS_DEFAULT;
William Allen Simpson4957faade2009-12-02 18:25:27 +00001274 tmp_opt.user_mss = tp->rx_opt.user_mss;
David S. Millerbb5b7c12009-12-15 20:56:42 -08001275 tcp_parse_options(skb, &tmp_opt, &hash_location, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276
William Allen Simpson4957faade2009-12-02 18:25:27 +00001277 if (tmp_opt.cookie_plus > 0 &&
1278 tmp_opt.saw_tstamp &&
1279 !tp->rx_opt.cookie_out_never &&
1280 (sysctl_tcp_cookie_size > 0 ||
1281 (tp->cookie_values != NULL &&
1282 tp->cookie_values->cookie_desired > 0))) {
1283 u8 *c;
1284 u32 *mess = &tmp_ext.cookie_bakery[COOKIE_DIGEST_WORDS];
1285 int l = tmp_opt.cookie_plus - TCPOLEN_COOKIE_BASE;
1286
1287 if (tcp_cookie_generator(&tmp_ext.cookie_bakery[0]) != 0)
1288 goto drop_and_release;
1289
1290 /* Secret recipe starts with IP addresses */
Eric Dumazet0eae88f2010-04-20 19:06:52 -07001291 *mess++ ^= (__force u32)daddr;
1292 *mess++ ^= (__force u32)saddr;
William Allen Simpson4957faade2009-12-02 18:25:27 +00001293
1294 /* plus variable length Initiator Cookie */
1295 c = (u8 *)mess;
1296 while (l-- > 0)
1297 *c++ ^= *hash_location++;
1298
1299#ifdef CONFIG_SYN_COOKIES
1300 want_cookie = 0; /* not our kind of cookie */
1301#endif
1302 tmp_ext.cookie_out_never = 0; /* false */
1303 tmp_ext.cookie_plus = tmp_opt.cookie_plus;
1304 } else if (!tp->rx_opt.cookie_in_always) {
1305 /* redundant indications, but ensure initialization. */
1306 tmp_ext.cookie_out_never = 1; /* true */
1307 tmp_ext.cookie_plus = 0;
1308 } else {
1309 goto drop_and_release;
1310 }
1311 tmp_ext.cookie_in_always = tp->rx_opt.cookie_in_always;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312
Florian Westphal4dfc2812008-04-10 03:12:40 -07001313 if (want_cookie && !tmp_opt.saw_tstamp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 tcp_clear_options(&tmp_opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 tcp_openreq_init(req, &tmp_opt, skb);
1318
David S. Millerbb5b7c12009-12-15 20:56:42 -08001319 ireq = inet_rsk(req);
1320 ireq->loc_addr = daddr;
1321 ireq->rmt_addr = saddr;
1322 ireq->no_srccheck = inet_sk(sk)->transparent;
1323 ireq->opt = tcp_v4_save_options(sk, skb);
1324
Paul Moore284904a2009-03-27 17:10:28 -04001325 if (security_inet_conn_request(sk, skb, req))
David S. Millerbb5b7c12009-12-15 20:56:42 -08001326 goto drop_and_free;
Paul Moore284904a2009-03-27 17:10:28 -04001327
Florian Westphal172d69e2010-06-21 11:48:45 +00001328 if (!want_cookie || tmp_opt.tstamp_ok)
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001329 TCP_ECN_create_request(req, tcp_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330
1331 if (want_cookie) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 isn = cookie_v4_init_sequence(sk, skb, &req->mss);
Florian Westphal172d69e2010-06-21 11:48:45 +00001333 req->cookie_ts = tmp_opt.tstamp_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 } else if (!isn) {
1335 struct inet_peer *peer = NULL;
1336
1337 /* VJ's idea. We save last timestamp seen
1338 * from the destination in peer table, when entering
1339 * state TIME-WAIT, and check against it before
1340 * accepting new connection request.
1341 *
1342 * If "isn" is not zero, this request hit alive
1343 * timewait bucket, so that all the necessary checks
1344 * are made in the function processing timewait state.
1345 */
1346 if (tmp_opt.saw_tstamp &&
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001347 tcp_death_row.sysctl_tw_recycle &&
David S. Millerbb5b7c12009-12-15 20:56:42 -08001348 (dst = inet_csk_route_req(sk, req)) != NULL &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349 (peer = rt_get_peer((struct rtable *)dst)) != NULL &&
1350 peer->v4daddr == saddr) {
Eric Dumazet317fe0e2010-06-16 04:52:13 +00001351 inet_peer_refcheck(peer);
Eric Dumazet2c1409a2009-11-12 09:33:09 +00001352 if ((u32)get_seconds() - peer->tcp_ts_stamp < TCP_PAWS_MSL &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 (s32)(peer->tcp_ts - req->ts_recent) >
1354 TCP_PAWS_WINDOW) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001355 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001356 goto drop_and_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 }
1358 }
1359 /* Kill the following clause, if you dislike this way. */
1360 else if (!sysctl_tcp_syncookies &&
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001361 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 (sysctl_max_syn_backlog >> 2)) &&
1363 (!peer || !peer->tcp_ts_stamp) &&
1364 (!dst || !dst_metric(dst, RTAX_RTT))) {
1365 /* Without syncookies last quarter of
1366 * backlog is filled with destinations,
1367 * proven to be alive.
1368 * It means that we continue to communicate
1369 * to destinations, already remembered
1370 * to the moment of synflood.
1371 */
Harvey Harrison673d57e2008-10-31 00:53:57 -07001372 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open request from %pI4/%u\n",
1373 &saddr, ntohs(tcp_hdr(skb)->source));
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001374 goto drop_and_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375 }
1376
Gerrit Renkera94f7232006-11-10 14:06:49 -08001377 isn = tcp_v4_init_sequence(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378 }
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001379 tcp_rsk(req)->snt_isn = isn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380
Octavian Purdila72659ec2010-01-17 19:09:39 -08001381 if (tcp_v4_send_synack(sk, dst, req,
1382 (struct request_values *)&tmp_ext) ||
William Allen Simpson4957faade2009-12-02 18:25:27 +00001383 want_cookie)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 goto drop_and_free;
1385
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001386 inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 return 0;
1388
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001389drop_and_release:
1390 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391drop_and_free:
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001392 reqsk_free(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393drop:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 return 0;
1395}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001396EXPORT_SYMBOL(tcp_v4_conn_request);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397
1398
1399/*
1400 * The three way handshake has completed - we got a valid synack -
1401 * now create the new socket.
1402 */
1403struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001404 struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 struct dst_entry *dst)
1406{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001407 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 struct inet_sock *newinet;
1409 struct tcp_sock *newtp;
1410 struct sock *newsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001411#ifdef CONFIG_TCP_MD5SIG
1412 struct tcp_md5sig_key *key;
1413#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414
1415 if (sk_acceptq_is_full(sk))
1416 goto exit_overflow;
1417
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001418 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419 goto exit;
1420
1421 newsk = tcp_create_openreq_child(sk, req, skb);
1422 if (!newsk)
Balazs Scheidler093d2822010-10-21 13:06:43 +02001423 goto exit_nonewsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424
Herbert Xubcd76112006-06-30 13:36:35 -07001425 newsk->sk_gso_type = SKB_GSO_TCPV4;
Arnaldo Carvalho de Melo6cbb0df2005-08-09 19:49:02 -07001426 sk_setup_caps(newsk, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427
1428 newtp = tcp_sk(newsk);
1429 newinet = inet_sk(newsk);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001430 ireq = inet_rsk(req);
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001431 newinet->inet_daddr = ireq->rmt_addr;
1432 newinet->inet_rcv_saddr = ireq->loc_addr;
1433 newinet->inet_saddr = ireq->loc_addr;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001434 newinet->opt = ireq->opt;
1435 ireq->opt = NULL;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001436 newinet->mc_index = inet_iif(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001437 newinet->mc_ttl = ip_hdr(skb)->ttl;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001438 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439 if (newinet->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001440 inet_csk(newsk)->icsk_ext_hdr_len = newinet->opt->optlen;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001441 newinet->inet_id = newtp->write_seq ^ jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442
John Heffner5d424d52006-03-20 17:53:41 -08001443 tcp_mtup_init(newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 tcp_sync_mss(newsk, dst_mtu(dst));
1445 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
Tom Quetchenbachf5fff5d2008-09-21 00:21:51 -07001446 if (tcp_sk(sk)->rx_opt.user_mss &&
1447 tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1448 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1449
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 tcp_initialize_rcv_mss(newsk);
1451
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001452#ifdef CONFIG_TCP_MD5SIG
1453 /* Copy over the MD5 key from the original socket */
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001454 key = tcp_v4_md5_do_lookup(sk, newinet->inet_daddr);
1455 if (key != NULL) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001456 /*
1457 * We're using one, so create a matching key
1458 * on the newsk structure. If we fail to get
1459 * memory, then we end up not copying the key
1460 * across. Shucks.
1461 */
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -02001462 char *newkey = kmemdup(key->key, key->keylen, GFP_ATOMIC);
1463 if (newkey != NULL)
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001464 tcp_v4_md5_do_add(newsk, newinet->inet_daddr,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001465 newkey, key->keylen);
Eric Dumazeta4654192010-05-16 00:36:33 -07001466 sk_nocaps_add(newsk, NETIF_F_GSO_MASK);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001467 }
1468#endif
1469
Balazs Scheidler093d2822010-10-21 13:06:43 +02001470 if (__inet_inherit_port(sk, newsk) < 0) {
1471 sock_put(newsk);
1472 goto exit;
1473 }
Eric Dumazet9327f702009-12-04 03:46:54 +00001474 __inet_hash_nolisten(newsk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475
1476 return newsk;
1477
1478exit_overflow:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001479 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001480exit_nonewsk:
1481 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482exit:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001483 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 return NULL;
1485}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001486EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487
1488static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
1489{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001490 struct tcphdr *th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001491 const struct iphdr *iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492 struct sock *nsk;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001493 struct request_sock **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494 /* Find possible connection requests. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001495 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
1496 iph->saddr, iph->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 if (req)
1498 return tcp_check_req(sk, skb, req, prev);
1499
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001500 nsk = inet_lookup_established(sock_net(sk), &tcp_hashinfo, iph->saddr,
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001501 th->source, iph->daddr, th->dest, inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502
1503 if (nsk) {
1504 if (nsk->sk_state != TCP_TIME_WAIT) {
1505 bh_lock_sock(nsk);
1506 return nsk;
1507 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001508 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509 return NULL;
1510 }
1511
1512#ifdef CONFIG_SYN_COOKIES
Florian Westphalaf9b4732010-06-03 00:43:44 +00001513 if (!th->syn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
1515#endif
1516 return sk;
1517}
1518
Al Virob51655b2006-11-14 21:40:42 -08001519static __sum16 tcp_v4_checksum_init(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001521 const struct iphdr *iph = ip_hdr(skb);
1522
Patrick McHardy84fa7932006-08-29 16:44:56 -07001523 if (skb->ip_summed == CHECKSUM_COMPLETE) {
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001524 if (!tcp_v4_check(skb->len, iph->saddr,
1525 iph->daddr, skb->csum)) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001526 skb->ip_summed = CHECKSUM_UNNECESSARY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527 return 0;
Herbert Xufb286bb2005-11-10 13:01:24 -08001528 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 }
Herbert Xufb286bb2005-11-10 13:01:24 -08001530
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001531 skb->csum = csum_tcpudp_nofold(iph->saddr, iph->daddr,
Herbert Xufb286bb2005-11-10 13:01:24 -08001532 skb->len, IPPROTO_TCP, 0);
1533
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534 if (skb->len <= 76) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001535 return __skb_checksum_complete(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536 }
1537 return 0;
1538}
1539
1540
1541/* The socket must have it's spinlock held when we get
1542 * here.
1543 *
1544 * We have a potential double-lock case here, so even when
1545 * doing backlog processing we use the BH locking scheme.
1546 * This is because we cannot sleep with the original spinlock
1547 * held.
1548 */
1549int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1550{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001551 struct sock *rsk;
1552#ifdef CONFIG_TCP_MD5SIG
1553 /*
1554 * We really want to reject the packet as early as possible
1555 * if:
1556 * o We're expecting an MD5'd packet and this is no MD5 tcp option
1557 * o There is an MD5 option and we're not expecting one
1558 */
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001559 if (tcp_v4_inbound_md5_hash(sk, skb))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001560 goto discard;
1561#endif
1562
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
Eric Dumazetca551582010-06-03 09:03:58 +00001564 sock_rps_save_rxhash(sk, skb->rxhash);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 TCP_CHECK_TIMER(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001566 if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001567 rsk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001569 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 TCP_CHECK_TIMER(sk);
1571 return 0;
1572 }
1573
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07001574 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 goto csum_err;
1576
1577 if (sk->sk_state == TCP_LISTEN) {
1578 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
1579 if (!nsk)
1580 goto discard;
1581
1582 if (nsk != sk) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001583 if (tcp_child_process(sk, nsk, skb)) {
1584 rsk = nsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001586 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 return 0;
1588 }
Eric Dumazetca551582010-06-03 09:03:58 +00001589 } else
1590 sock_rps_save_rxhash(sk, skb->rxhash);
1591
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592
1593 TCP_CHECK_TIMER(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001594 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001595 rsk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001597 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598 TCP_CHECK_TIMER(sk);
1599 return 0;
1600
1601reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001602 tcp_v4_send_reset(rsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603discard:
1604 kfree_skb(skb);
1605 /* Be careful here. If this function gets more complicated and
1606 * gcc suffers from register pressure on the x86, sk (in %ebx)
1607 * might be destroyed here. This current version compiles correctly,
1608 * but you have been warned.
1609 */
1610 return 0;
1611
1612csum_err:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001613 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614 goto discard;
1615}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001616EXPORT_SYMBOL(tcp_v4_do_rcv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617
1618/*
1619 * From tcp_input.c
1620 */
1621
1622int tcp_v4_rcv(struct sk_buff *skb)
1623{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001624 const struct iphdr *iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625 struct tcphdr *th;
1626 struct sock *sk;
1627 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001628 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629
1630 if (skb->pkt_type != PACKET_HOST)
1631 goto discard_it;
1632
1633 /* Count it even if it's bad */
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001634 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635
1636 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1637 goto discard_it;
1638
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001639 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640
1641 if (th->doff < sizeof(struct tcphdr) / 4)
1642 goto bad_packet;
1643 if (!pskb_may_pull(skb, th->doff * 4))
1644 goto discard_it;
1645
1646 /* An explanation is required here, I think.
1647 * Packet length and doff are validated by header prediction,
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -08001648 * provided case of th->doff==0 is eliminated.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 * So, we defer the checks. */
Herbert Xu60476372007-04-09 11:59:39 -07001650 if (!skb_csum_unnecessary(skb) && tcp_v4_checksum_init(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 goto bad_packet;
1652
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001653 th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001654 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1656 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1657 skb->len - th->doff * 4);
1658 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1659 TCP_SKB_CB(skb)->when = 0;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001660 TCP_SKB_CB(skb)->flags = iph->tos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 TCP_SKB_CB(skb)->sacked = 0;
1662
Arnaldo Carvalho de Melo9a1f27c2008-10-07 11:41:57 -07001663 sk = __inet_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664 if (!sk)
1665 goto no_tcp_socket;
1666
Eric Dumazetbb134d52010-03-09 05:55:56 +00001667process:
1668 if (sk->sk_state == TCP_TIME_WAIT)
1669 goto do_time_wait;
1670
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001671 if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
1672 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
Stephen Hemmingerd218d112010-01-11 16:28:01 -08001673 goto discard_and_relse;
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001674 }
Stephen Hemmingerd218d112010-01-11 16:28:01 -08001675
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1677 goto discard_and_relse;
Patrick McHardyb59c2702006-01-06 23:06:10 -08001678 nf_reset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001680 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 goto discard_and_relse;
1682
1683 skb->dev = NULL;
1684
Ingo Molnarc6366182006-07-03 00:25:13 -07001685 bh_lock_sock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 ret = 0;
1687 if (!sock_owned_by_user(sk)) {
Chris Leech1a2449a2006-05-23 18:05:53 -07001688#ifdef CONFIG_NET_DMA
1689 struct tcp_sock *tp = tcp_sk(sk);
1690 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
Dan Williamsf67b4592009-01-06 11:38:15 -07001691 tp->ucopy.dma_chan = dma_find_channel(DMA_MEMCPY);
Chris Leech1a2449a2006-05-23 18:05:53 -07001692 if (tp->ucopy.dma_chan)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693 ret = tcp_v4_do_rcv(sk, skb);
Chris Leech1a2449a2006-05-23 18:05:53 -07001694 else
1695#endif
1696 {
1697 if (!tcp_prequeue(sk, skb))
Shan Weiae8d7f82009-05-05 01:01:29 +00001698 ret = tcp_v4_do_rcv(sk, skb);
Chris Leech1a2449a2006-05-23 18:05:53 -07001699 }
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001700 } else if (unlikely(sk_add_backlog(sk, skb))) {
Zhu Yi6b03a532010-03-04 18:01:41 +00001701 bh_unlock_sock(sk);
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001702 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
Zhu Yi6b03a532010-03-04 18:01:41 +00001703 goto discard_and_relse;
1704 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705 bh_unlock_sock(sk);
1706
1707 sock_put(sk);
1708
1709 return ret;
1710
1711no_tcp_socket:
1712 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1713 goto discard_it;
1714
1715 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1716bad_packet:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001717 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001719 tcp_v4_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720 }
1721
1722discard_it:
1723 /* Discard frame. */
1724 kfree_skb(skb);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001725 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726
1727discard_and_relse:
1728 sock_put(sk);
1729 goto discard_it;
1730
1731do_time_wait:
1732 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001733 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734 goto discard_it;
1735 }
1736
1737 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001738 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001739 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740 goto discard_it;
1741 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001742 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743 case TCP_TW_SYN: {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001744 struct sock *sk2 = inet_lookup_listener(dev_net(skb->dev),
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001745 &tcp_hashinfo,
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001746 iph->daddr, th->dest,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001747 inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748 if (sk2) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001749 inet_twsk_deschedule(inet_twsk(sk), &tcp_death_row);
1750 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751 sk = sk2;
1752 goto process;
1753 }
1754 /* Fall through to ACK */
1755 }
1756 case TCP_TW_ACK:
1757 tcp_v4_timewait_ack(sk, skb);
1758 break;
1759 case TCP_TW_RST:
1760 goto no_tcp_socket;
1761 case TCP_TW_SUCCESS:;
1762 }
1763 goto discard_it;
1764}
1765
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766/* VJ's idea. Save last timestamp seen from this destination
1767 * and hold it at least for normal timewait interval to use for duplicate
1768 * segment detection in subsequent connections, before they enter synchronized
1769 * state.
1770 */
1771
1772int tcp_v4_remember_stamp(struct sock *sk)
1773{
1774 struct inet_sock *inet = inet_sk(sk);
1775 struct tcp_sock *tp = tcp_sk(sk);
1776 struct rtable *rt = (struct rtable *)__sk_dst_get(sk);
1777 struct inet_peer *peer = NULL;
1778 int release_it = 0;
1779
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001780 if (!rt || rt->rt_dst != inet->inet_daddr) {
1781 peer = inet_getpeer(inet->inet_daddr, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782 release_it = 1;
1783 } else {
1784 if (!rt->peer)
1785 rt_bind_peer(rt, 1);
1786 peer = rt->peer;
1787 }
1788
1789 if (peer) {
1790 if ((s32)(peer->tcp_ts - tp->rx_opt.ts_recent) <= 0 ||
Eric Dumazet2c1409a2009-11-12 09:33:09 +00001791 ((u32)get_seconds() - peer->tcp_ts_stamp > TCP_PAWS_MSL &&
1792 peer->tcp_ts_stamp <= (u32)tp->rx_opt.ts_recent_stamp)) {
1793 peer->tcp_ts_stamp = (u32)tp->rx_opt.ts_recent_stamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 peer->tcp_ts = tp->rx_opt.ts_recent;
1795 }
1796 if (release_it)
1797 inet_putpeer(peer);
1798 return 1;
1799 }
1800
1801 return 0;
1802}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001803EXPORT_SYMBOL(tcp_v4_remember_stamp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001805int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001807 struct inet_peer *peer = inet_getpeer(tw->tw_daddr, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808
1809 if (peer) {
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001810 const struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
1811
1812 if ((s32)(peer->tcp_ts - tcptw->tw_ts_recent) <= 0 ||
Eric Dumazet2c1409a2009-11-12 09:33:09 +00001813 ((u32)get_seconds() - peer->tcp_ts_stamp > TCP_PAWS_MSL &&
1814 peer->tcp_ts_stamp <= (u32)tcptw->tw_ts_recent_stamp)) {
1815 peer->tcp_ts_stamp = (u32)tcptw->tw_ts_recent_stamp;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001816 peer->tcp_ts = tcptw->tw_ts_recent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 }
1818 inet_putpeer(peer);
1819 return 1;
1820 }
1821
1822 return 0;
1823}
1824
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001825const struct inet_connection_sock_af_ops ipv4_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001826 .queue_xmit = ip_queue_xmit,
1827 .send_check = tcp_v4_send_check,
1828 .rebuild_header = inet_sk_rebuild_header,
1829 .conn_request = tcp_v4_conn_request,
1830 .syn_recv_sock = tcp_v4_syn_recv_sock,
1831 .remember_stamp = tcp_v4_remember_stamp,
1832 .net_header_len = sizeof(struct iphdr),
1833 .setsockopt = ip_setsockopt,
1834 .getsockopt = ip_getsockopt,
1835 .addr2sockaddr = inet_csk_addr2sockaddr,
1836 .sockaddr_len = sizeof(struct sockaddr_in),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001837 .bind_conflict = inet_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001838#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001839 .compat_setsockopt = compat_ip_setsockopt,
1840 .compat_getsockopt = compat_ip_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001841#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842};
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001843EXPORT_SYMBOL(ipv4_specific);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001845#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001846static const struct tcp_sock_af_ops tcp_sock_ipv4_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001847 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001848 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001849 .md5_add = tcp_v4_md5_add_func,
1850 .md5_parse = tcp_v4_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001851};
Andrew Mortonb6332e62006-11-30 19:16:28 -08001852#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001853
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854/* NOTE: A lot of things set to zero explicitly by call to
1855 * sk_alloc() so need not be done here.
1856 */
1857static int tcp_v4_init_sock(struct sock *sk)
1858{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001859 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860 struct tcp_sock *tp = tcp_sk(sk);
1861
1862 skb_queue_head_init(&tp->out_of_order_queue);
1863 tcp_init_xmit_timers(sk);
1864 tcp_prequeue_init(tp);
1865
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001866 icsk->icsk_rto = TCP_TIMEOUT_INIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867 tp->mdev = TCP_TIMEOUT_INIT;
1868
1869 /* So many TCP implementations out there (incorrectly) count the
1870 * initial SYN frame in their delayed-ACK and congestion control
1871 * algorithms that we must have the following bandaid to talk
1872 * efficiently to them. -DaveM
1873 */
1874 tp->snd_cwnd = 2;
1875
1876 /* See draft-stevens-tcpca-spec-01 for discussion of the
1877 * initialization of these values.
1878 */
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07001879 tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880 tp->snd_cwnd_clamp = ~0;
William Allen Simpsonbee7ca92009-11-10 09:51:18 +00001881 tp->mss_cache = TCP_MSS_DEFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882
1883 tp->reordering = sysctl_tcp_reordering;
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001884 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885
1886 sk->sk_state = TCP_CLOSE;
1887
1888 sk->sk_write_space = sk_stream_write_space;
1889 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1890
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001891 icsk->icsk_af_ops = &ipv4_specific;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001892 icsk->icsk_sync_mss = tcp_sync_mss;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001893#ifdef CONFIG_TCP_MD5SIG
1894 tp->af_specific = &tcp_sock_ipv4_specific;
1895#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896
William Allen Simpson435cf552009-12-02 18:17:05 +00001897 /* TCP Cookie Transactions */
1898 if (sysctl_tcp_cookie_size > 0) {
1899 /* Default, cookies without s_data_payload. */
1900 tp->cookie_values =
1901 kzalloc(sizeof(*tp->cookie_values),
1902 sk->sk_allocation);
1903 if (tp->cookie_values != NULL)
1904 kref_init(&tp->cookie_values->kref);
1905 }
1906 /* Presumed zeroed, in order of appearance:
1907 * cookie_in_always, cookie_out_never,
1908 * s_data_constant, s_data_in, s_data_out
1909 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1911 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1912
Herbert Xueb4dea52008-12-29 23:04:08 -08001913 local_bh_disable();
Eric Dumazet17483762008-11-25 21:16:35 -08001914 percpu_counter_inc(&tcp_sockets_allocated);
Herbert Xueb4dea52008-12-29 23:04:08 -08001915 local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916
1917 return 0;
1918}
1919
Brian Haley7d06b2e2008-06-14 17:04:49 -07001920void tcp_v4_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921{
1922 struct tcp_sock *tp = tcp_sk(sk);
1923
1924 tcp_clear_xmit_timers(sk);
1925
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001926 tcp_cleanup_congestion_control(sk);
Stephen Hemminger317a76f2005-06-23 12:19:55 -07001927
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 /* Cleanup up the write buffer. */
David S. Millerfe067e82007-03-07 12:12:44 -08001929 tcp_write_queue_purge(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930
1931 /* Cleans up our, hopefully empty, out_of_order_queue. */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001932 __skb_queue_purge(&tp->out_of_order_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001934#ifdef CONFIG_TCP_MD5SIG
1935 /* Clean up the MD5 key list, if any */
1936 if (tp->md5sig_info) {
1937 tcp_v4_clear_md5_list(sk);
1938 kfree(tp->md5sig_info);
1939 tp->md5sig_info = NULL;
1940 }
1941#endif
1942
Chris Leech1a2449a2006-05-23 18:05:53 -07001943#ifdef CONFIG_NET_DMA
1944 /* Cleans up our sk_async_wait_queue */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001945 __skb_queue_purge(&sk->sk_async_wait_queue);
Chris Leech1a2449a2006-05-23 18:05:53 -07001946#endif
1947
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 /* Clean prequeue, it must be empty really */
1949 __skb_queue_purge(&tp->ucopy.prequeue);
1950
1951 /* Clean up a referenced TCP bind bucket. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001952 if (inet_csk(sk)->icsk_bind_hash)
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001953 inet_put_port(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954
1955 /*
1956 * If sendmsg cached page exists, toss it.
1957 */
1958 if (sk->sk_sndmsg_page) {
1959 __free_page(sk->sk_sndmsg_page);
1960 sk->sk_sndmsg_page = NULL;
1961 }
1962
William Allen Simpson435cf552009-12-02 18:17:05 +00001963 /* TCP Cookie Transactions */
1964 if (tp->cookie_values != NULL) {
1965 kref_put(&tp->cookie_values->kref,
1966 tcp_cookie_values_release);
1967 tp->cookie_values = NULL;
1968 }
1969
Eric Dumazet17483762008-11-25 21:16:35 -08001970 percpu_counter_dec(&tcp_sockets_allocated);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972EXPORT_SYMBOL(tcp_v4_destroy_sock);
1973
1974#ifdef CONFIG_PROC_FS
1975/* Proc filesystem TCP sock list dumping. */
1976
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001977static inline struct inet_timewait_sock *tw_head(struct hlist_nulls_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001978{
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001979 return hlist_nulls_empty(head) ? NULL :
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001980 list_entry(head->first, struct inet_timewait_sock, tw_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981}
1982
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001983static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984{
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001985 return !is_a_nulls(tw->tw_node.next) ?
1986 hlist_nulls_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987}
1988
Tom Herberta8b690f2010-06-07 00:43:42 -07001989/*
1990 * Get next listener socket follow cur. If cur is NULL, get first socket
1991 * starting from bucket given in st->bucket; when st->bucket is zero the
1992 * very first socket in the hash table is returned.
1993 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994static void *listening_get_next(struct seq_file *seq, void *cur)
1995{
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001996 struct inet_connection_sock *icsk;
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08001997 struct hlist_nulls_node *node;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998 struct sock *sk = cur;
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001999 struct inet_listen_hashbucket *ilb;
Jianjun Kong5799de02008-11-03 02:49:10 -08002000 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002001 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002
2003 if (!sk) {
Tom Herberta8b690f2010-06-07 00:43:42 -07002004 ilb = &tcp_hashinfo.listening_hash[st->bucket];
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002005 spin_lock_bh(&ilb->lock);
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08002006 sk = sk_nulls_head(&ilb->head);
Tom Herberta8b690f2010-06-07 00:43:42 -07002007 st->offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008 goto get_sk;
2009 }
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002010 ilb = &tcp_hashinfo.listening_hash[st->bucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011 ++st->num;
Tom Herberta8b690f2010-06-07 00:43:42 -07002012 ++st->offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013
2014 if (st->state == TCP_SEQ_STATE_OPENREQ) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002015 struct request_sock *req = cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016
Eric Dumazet72a3eff2006-11-16 02:30:37 -08002017 icsk = inet_csk(st->syn_wait_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002018 req = req->dl_next;
2019 while (1) {
2020 while (req) {
Daniel Lezcanobdccc4c2008-07-19 00:15:13 -07002021 if (req->rsk_ops->family == st->family) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022 cur = req;
2023 goto out;
2024 }
2025 req = req->dl_next;
2026 }
Tom Herberta8b690f2010-06-07 00:43:42 -07002027 st->offset = 0;
Eric Dumazet72a3eff2006-11-16 02:30:37 -08002028 if (++st->sbucket >= icsk->icsk_accept_queue.listen_opt->nr_table_entries)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029 break;
2030get_req:
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002031 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002032 }
2033 sk = sk_next(st->syn_wait_sk);
2034 st->state = TCP_SEQ_STATE_LISTENING;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002035 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036 } else {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002037 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002038 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2039 if (reqsk_queue_len(&icsk->icsk_accept_queue))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040 goto start_req;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002041 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042 sk = sk_next(sk);
2043 }
2044get_sk:
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08002045 sk_nulls_for_each_from(sk, node) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002046 if (sk->sk_family == st->family && net_eq(sock_net(sk), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002047 cur = sk;
2048 goto out;
2049 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002050 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002051 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2052 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002053start_req:
2054 st->uid = sock_i_uid(sk);
2055 st->syn_wait_sk = sk;
2056 st->state = TCP_SEQ_STATE_OPENREQ;
2057 st->sbucket = 0;
2058 goto get_req;
2059 }
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002060 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002061 }
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002062 spin_unlock_bh(&ilb->lock);
Tom Herberta8b690f2010-06-07 00:43:42 -07002063 st->offset = 0;
Arnaldo Carvalho de Melo0f7ff922005-08-09 19:59:44 -07002064 if (++st->bucket < INET_LHTABLE_SIZE) {
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002065 ilb = &tcp_hashinfo.listening_hash[st->bucket];
2066 spin_lock_bh(&ilb->lock);
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08002067 sk = sk_nulls_head(&ilb->head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002068 goto get_sk;
2069 }
2070 cur = NULL;
2071out:
2072 return cur;
2073}
2074
2075static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
2076{
Tom Herberta8b690f2010-06-07 00:43:42 -07002077 struct tcp_iter_state *st = seq->private;
2078 void *rc;
2079
2080 st->bucket = 0;
2081 st->offset = 0;
2082 rc = listening_get_next(seq, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083
2084 while (rc && *pos) {
2085 rc = listening_get_next(seq, rc);
2086 --*pos;
2087 }
2088 return rc;
2089}
2090
Andi Kleen6eac5602008-08-28 01:08:02 -07002091static inline int empty_bucket(struct tcp_iter_state *st)
2092{
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002093 return hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].chain) &&
2094 hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].twchain);
Andi Kleen6eac5602008-08-28 01:08:02 -07002095}
2096
Tom Herberta8b690f2010-06-07 00:43:42 -07002097/*
2098 * Get first established socket starting from bucket given in st->bucket.
2099 * If st->bucket is zero, the very first socket in the hash is returned.
2100 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002101static void *established_get_first(struct seq_file *seq)
2102{
Jianjun Kong5799de02008-11-03 02:49:10 -08002103 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002104 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002105 void *rc = NULL;
2106
Tom Herberta8b690f2010-06-07 00:43:42 -07002107 st->offset = 0;
2108 for (; st->bucket <= tcp_hashinfo.ehash_mask; ++st->bucket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109 struct sock *sk;
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002110 struct hlist_nulls_node *node;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002111 struct inet_timewait_sock *tw;
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002112 spinlock_t *lock = inet_ehash_lockp(&tcp_hashinfo, st->bucket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113
Andi Kleen6eac5602008-08-28 01:08:02 -07002114 /* Lockless fast path for the common case of empty buckets */
2115 if (empty_bucket(st))
2116 continue;
2117
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002118 spin_lock_bh(lock);
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002119 sk_nulls_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002120 if (sk->sk_family != st->family ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002121 !net_eq(sock_net(sk), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002122 continue;
2123 }
2124 rc = sk;
2125 goto out;
2126 }
2127 st->state = TCP_SEQ_STATE_TIME_WAIT;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002128 inet_twsk_for_each(tw, node,
Eric Dumazetdbca9b2752007-02-08 14:16:46 -08002129 &tcp_hashinfo.ehash[st->bucket].twchain) {
Pavel Emelyanov28518fc2008-03-21 15:52:00 -07002130 if (tw->tw_family != st->family ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002131 !net_eq(twsk_net(tw), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132 continue;
2133 }
2134 rc = tw;
2135 goto out;
2136 }
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002137 spin_unlock_bh(lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138 st->state = TCP_SEQ_STATE_ESTABLISHED;
2139 }
2140out:
2141 return rc;
2142}
2143
2144static void *established_get_next(struct seq_file *seq, void *cur)
2145{
2146 struct sock *sk = cur;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002147 struct inet_timewait_sock *tw;
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002148 struct hlist_nulls_node *node;
Jianjun Kong5799de02008-11-03 02:49:10 -08002149 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002150 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151
2152 ++st->num;
Tom Herberta8b690f2010-06-07 00:43:42 -07002153 ++st->offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002154
2155 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
2156 tw = cur;
2157 tw = tw_next(tw);
2158get_tw:
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002159 while (tw && (tw->tw_family != st->family || !net_eq(twsk_net(tw), net))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002160 tw = tw_next(tw);
2161 }
2162 if (tw) {
2163 cur = tw;
2164 goto out;
2165 }
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002166 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002167 st->state = TCP_SEQ_STATE_ESTABLISHED;
2168
Andi Kleen6eac5602008-08-28 01:08:02 -07002169 /* Look for next non empty bucket */
Tom Herberta8b690f2010-06-07 00:43:42 -07002170 st->offset = 0;
Eric Dumazetf373b532009-10-09 00:16:19 +00002171 while (++st->bucket <= tcp_hashinfo.ehash_mask &&
Andi Kleen6eac5602008-08-28 01:08:02 -07002172 empty_bucket(st))
2173 ;
Eric Dumazetf373b532009-10-09 00:16:19 +00002174 if (st->bucket > tcp_hashinfo.ehash_mask)
Andi Kleen6eac5602008-08-28 01:08:02 -07002175 return NULL;
2176
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002177 spin_lock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002178 sk = sk_nulls_head(&tcp_hashinfo.ehash[st->bucket].chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179 } else
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002180 sk = sk_nulls_next(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002181
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002182 sk_nulls_for_each_from(sk, node) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002183 if (sk->sk_family == st->family && net_eq(sock_net(sk), net))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184 goto found;
2185 }
2186
2187 st->state = TCP_SEQ_STATE_TIME_WAIT;
Eric Dumazetdbca9b2752007-02-08 14:16:46 -08002188 tw = tw_head(&tcp_hashinfo.ehash[st->bucket].twchain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189 goto get_tw;
2190found:
2191 cur = sk;
2192out:
2193 return cur;
2194}
2195
2196static void *established_get_idx(struct seq_file *seq, loff_t pos)
2197{
Tom Herberta8b690f2010-06-07 00:43:42 -07002198 struct tcp_iter_state *st = seq->private;
2199 void *rc;
2200
2201 st->bucket = 0;
2202 rc = established_get_first(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002203
2204 while (rc && pos) {
2205 rc = established_get_next(seq, rc);
2206 --pos;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002207 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208 return rc;
2209}
2210
2211static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
2212{
2213 void *rc;
Jianjun Kong5799de02008-11-03 02:49:10 -08002214 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002215
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216 st->state = TCP_SEQ_STATE_LISTENING;
2217 rc = listening_get_idx(seq, &pos);
2218
2219 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002220 st->state = TCP_SEQ_STATE_ESTABLISHED;
2221 rc = established_get_idx(seq, pos);
2222 }
2223
2224 return rc;
2225}
2226
Tom Herberta8b690f2010-06-07 00:43:42 -07002227static void *tcp_seek_last_pos(struct seq_file *seq)
2228{
2229 struct tcp_iter_state *st = seq->private;
2230 int offset = st->offset;
2231 int orig_num = st->num;
2232 void *rc = NULL;
2233
2234 switch (st->state) {
2235 case TCP_SEQ_STATE_OPENREQ:
2236 case TCP_SEQ_STATE_LISTENING:
2237 if (st->bucket >= INET_LHTABLE_SIZE)
2238 break;
2239 st->state = TCP_SEQ_STATE_LISTENING;
2240 rc = listening_get_next(seq, NULL);
2241 while (offset-- && rc)
2242 rc = listening_get_next(seq, rc);
2243 if (rc)
2244 break;
2245 st->bucket = 0;
2246 /* Fallthrough */
2247 case TCP_SEQ_STATE_ESTABLISHED:
2248 case TCP_SEQ_STATE_TIME_WAIT:
2249 st->state = TCP_SEQ_STATE_ESTABLISHED;
2250 if (st->bucket > tcp_hashinfo.ehash_mask)
2251 break;
2252 rc = established_get_first(seq);
2253 while (offset-- && rc)
2254 rc = established_get_next(seq, rc);
2255 }
2256
2257 st->num = orig_num;
2258
2259 return rc;
2260}
2261
Linus Torvalds1da177e2005-04-16 15:20:36 -07002262static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
2263{
Jianjun Kong5799de02008-11-03 02:49:10 -08002264 struct tcp_iter_state *st = seq->private;
Tom Herberta8b690f2010-06-07 00:43:42 -07002265 void *rc;
2266
2267 if (*pos && *pos == st->last_pos) {
2268 rc = tcp_seek_last_pos(seq);
2269 if (rc)
2270 goto out;
2271 }
2272
Linus Torvalds1da177e2005-04-16 15:20:36 -07002273 st->state = TCP_SEQ_STATE_LISTENING;
2274 st->num = 0;
Tom Herberta8b690f2010-06-07 00:43:42 -07002275 st->bucket = 0;
2276 st->offset = 0;
2277 rc = *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2278
2279out:
2280 st->last_pos = *pos;
2281 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282}
2283
2284static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2285{
Tom Herberta8b690f2010-06-07 00:43:42 -07002286 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287 void *rc = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002288
2289 if (v == SEQ_START_TOKEN) {
2290 rc = tcp_get_idx(seq, 0);
2291 goto out;
2292 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293
2294 switch (st->state) {
2295 case TCP_SEQ_STATE_OPENREQ:
2296 case TCP_SEQ_STATE_LISTENING:
2297 rc = listening_get_next(seq, v);
2298 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002299 st->state = TCP_SEQ_STATE_ESTABLISHED;
Tom Herberta8b690f2010-06-07 00:43:42 -07002300 st->bucket = 0;
2301 st->offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002302 rc = established_get_first(seq);
2303 }
2304 break;
2305 case TCP_SEQ_STATE_ESTABLISHED:
2306 case TCP_SEQ_STATE_TIME_WAIT:
2307 rc = established_get_next(seq, v);
2308 break;
2309 }
2310out:
2311 ++*pos;
Tom Herberta8b690f2010-06-07 00:43:42 -07002312 st->last_pos = *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002313 return rc;
2314}
2315
2316static void tcp_seq_stop(struct seq_file *seq, void *v)
2317{
Jianjun Kong5799de02008-11-03 02:49:10 -08002318 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002319
2320 switch (st->state) {
2321 case TCP_SEQ_STATE_OPENREQ:
2322 if (v) {
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002323 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
2324 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002325 }
2326 case TCP_SEQ_STATE_LISTENING:
2327 if (v != SEQ_START_TOKEN)
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002328 spin_unlock_bh(&tcp_hashinfo.listening_hash[st->bucket].lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329 break;
2330 case TCP_SEQ_STATE_TIME_WAIT:
2331 case TCP_SEQ_STATE_ESTABLISHED:
2332 if (v)
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002333 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002334 break;
2335 }
2336}
2337
2338static int tcp_seq_open(struct inode *inode, struct file *file)
2339{
2340 struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002341 struct tcp_iter_state *s;
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002342 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002343
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002344 err = seq_open_net(inode, file, &afinfo->seq_ops,
2345 sizeof(struct tcp_iter_state));
2346 if (err < 0)
2347 return err;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002348
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002349 s = ((struct seq_file *)file->private_data)->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002350 s->family = afinfo->family;
Tom Herberta8b690f2010-06-07 00:43:42 -07002351 s->last_pos = 0;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002352 return 0;
2353}
2354
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002355int tcp_proc_register(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002356{
2357 int rc = 0;
2358 struct proc_dir_entry *p;
2359
Denis V. Lunev68fcadd2008-04-13 22:13:30 -07002360 afinfo->seq_fops.open = tcp_seq_open;
2361 afinfo->seq_fops.read = seq_read;
2362 afinfo->seq_fops.llseek = seq_lseek;
2363 afinfo->seq_fops.release = seq_release_net;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002364
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002365 afinfo->seq_ops.start = tcp_seq_start;
2366 afinfo->seq_ops.next = tcp_seq_next;
2367 afinfo->seq_ops.stop = tcp_seq_stop;
2368
Denis V. Lunev84841c32008-05-02 04:10:08 -07002369 p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net,
2370 &afinfo->seq_fops, afinfo);
2371 if (!p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002372 rc = -ENOMEM;
2373 return rc;
2374}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002375EXPORT_SYMBOL(tcp_proc_register);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002376
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002377void tcp_proc_unregister(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002378{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002379 proc_net_remove(net, afinfo->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002381EXPORT_SYMBOL(tcp_proc_unregister);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002382
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002383static void get_openreq4(struct sock *sk, struct request_sock *req,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002384 struct seq_file *f, int i, int uid, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002385{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002386 const struct inet_request_sock *ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002387 int ttd = req->expires - jiffies;
2388
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002389 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
2390 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p%n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002391 i,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002392 ireq->loc_addr,
Eric Dumazetc720c7e2009-10-15 06:30:45 +00002393 ntohs(inet_sk(sk)->inet_sport),
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002394 ireq->rmt_addr,
2395 ntohs(ireq->rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002396 TCP_SYN_RECV,
2397 0, 0, /* could print option size, but that is af dependent. */
2398 1, /* timers active (only the expire timer) */
2399 jiffies_to_clock_t(ttd),
2400 req->retrans,
2401 uid,
2402 0, /* non standard timer */
2403 0, /* open_requests have no inode */
2404 atomic_read(&sk->sk_refcnt),
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002405 req,
2406 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002407}
2408
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002409static void get_tcp4_sock(struct sock *sk, struct seq_file *f, int i, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002410{
2411 int timer_active;
2412 unsigned long timer_expires;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002413 struct tcp_sock *tp = tcp_sk(sk);
2414 const struct inet_connection_sock *icsk = inet_csk(sk);
2415 struct inet_sock *inet = inet_sk(sk);
Eric Dumazetc720c7e2009-10-15 06:30:45 +00002416 __be32 dest = inet->inet_daddr;
2417 __be32 src = inet->inet_rcv_saddr;
2418 __u16 destp = ntohs(inet->inet_dport);
2419 __u16 srcp = ntohs(inet->inet_sport);
Eric Dumazet49d09002009-12-03 16:06:13 -08002420 int rx_queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002421
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002422 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002423 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002424 timer_expires = icsk->icsk_timeout;
2425 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002426 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002427 timer_expires = icsk->icsk_timeout;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002428 } else if (timer_pending(&sk->sk_timer)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429 timer_active = 2;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002430 timer_expires = sk->sk_timer.expires;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002431 } else {
2432 timer_active = 0;
2433 timer_expires = jiffies;
2434 }
2435
Eric Dumazet49d09002009-12-03 16:06:13 -08002436 if (sk->sk_state == TCP_LISTEN)
2437 rx_queue = sk->sk_ack_backlog;
2438 else
2439 /*
2440 * because we dont lock socket, we might find a transient negative value
2441 */
2442 rx_queue = max_t(int, tp->rcv_nxt - tp->copied_seq, 0);
2443
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002444 seq_printf(f, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
Stephen Hemminger7be87352008-06-27 20:00:19 -07002445 "%08X %5d %8d %lu %d %p %lu %lu %u %u %d%n",
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002446 i, src, srcp, dest, destp, sk->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07002447 tp->write_seq - tp->snd_una,
Eric Dumazet49d09002009-12-03 16:06:13 -08002448 rx_queue,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002449 timer_active,
2450 jiffies_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002451 icsk->icsk_retransmits,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002452 sock_i_uid(sk),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03002453 icsk->icsk_probes_out,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002454 sock_i_ino(sk),
2455 atomic_read(&sk->sk_refcnt), sk,
Stephen Hemminger7be87352008-06-27 20:00:19 -07002456 jiffies_to_clock_t(icsk->icsk_rto),
2457 jiffies_to_clock_t(icsk->icsk_ack.ato),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002458 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002459 tp->snd_cwnd,
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07002460 tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002461 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002462}
2463
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002464static void get_timewait4_sock(struct inet_timewait_sock *tw,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002465 struct seq_file *f, int i, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002466{
Al Viro23f33c22006-09-27 18:43:50 -07002467 __be32 dest, src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002468 __u16 destp, srcp;
2469 int ttd = tw->tw_ttd - jiffies;
2470
2471 if (ttd < 0)
2472 ttd = 0;
2473
2474 dest = tw->tw_daddr;
2475 src = tw->tw_rcv_saddr;
2476 destp = ntohs(tw->tw_dport);
2477 srcp = ntohs(tw->tw_sport);
2478
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002479 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
2480 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p%n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002481 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
2482 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002483 atomic_read(&tw->tw_refcnt), tw, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002484}
2485
2486#define TMPSZ 150
2487
2488static int tcp4_seq_show(struct seq_file *seq, void *v)
2489{
Jianjun Kong5799de02008-11-03 02:49:10 -08002490 struct tcp_iter_state *st;
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002491 int len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002492
2493 if (v == SEQ_START_TOKEN) {
2494 seq_printf(seq, "%-*s\n", TMPSZ - 1,
2495 " sl local_address rem_address st tx_queue "
2496 "rx_queue tr tm->when retrnsmt uid timeout "
2497 "inode");
2498 goto out;
2499 }
2500 st = seq->private;
2501
2502 switch (st->state) {
2503 case TCP_SEQ_STATE_LISTENING:
2504 case TCP_SEQ_STATE_ESTABLISHED:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002505 get_tcp4_sock(v, seq, st->num, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002506 break;
2507 case TCP_SEQ_STATE_OPENREQ:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002508 get_openreq4(st->syn_wait_sk, v, seq, st->num, st->uid, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002509 break;
2510 case TCP_SEQ_STATE_TIME_WAIT:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002511 get_timewait4_sock(v, seq, st->num, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002512 break;
2513 }
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002514 seq_printf(seq, "%*s\n", TMPSZ - 1 - len, "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002515out:
2516 return 0;
2517}
2518
Linus Torvalds1da177e2005-04-16 15:20:36 -07002519static struct tcp_seq_afinfo tcp4_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002520 .name = "tcp",
2521 .family = AF_INET,
Denis V. Lunev5f4472c2008-04-13 22:13:53 -07002522 .seq_fops = {
2523 .owner = THIS_MODULE,
2524 },
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002525 .seq_ops = {
2526 .show = tcp4_seq_show,
2527 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002528};
2529
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002530static int __net_init tcp4_proc_init_net(struct net *net)
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002531{
2532 return tcp_proc_register(net, &tcp4_seq_afinfo);
2533}
2534
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002535static void __net_exit tcp4_proc_exit_net(struct net *net)
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002536{
2537 tcp_proc_unregister(net, &tcp4_seq_afinfo);
2538}
2539
2540static struct pernet_operations tcp4_net_ops = {
2541 .init = tcp4_proc_init_net,
2542 .exit = tcp4_proc_exit_net,
2543};
2544
Linus Torvalds1da177e2005-04-16 15:20:36 -07002545int __init tcp4_proc_init(void)
2546{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002547 return register_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002548}
2549
2550void tcp4_proc_exit(void)
2551{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002552 unregister_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002553}
2554#endif /* CONFIG_PROC_FS */
2555
Herbert Xubf296b12008-12-15 23:43:36 -08002556struct sk_buff **tcp4_gro_receive(struct sk_buff **head, struct sk_buff *skb)
2557{
Herbert Xu36e7b1b2009-04-27 05:44:45 -07002558 struct iphdr *iph = skb_gro_network_header(skb);
Herbert Xubf296b12008-12-15 23:43:36 -08002559
2560 switch (skb->ip_summed) {
2561 case CHECKSUM_COMPLETE:
Herbert Xu86911732009-01-29 14:19:50 +00002562 if (!tcp_v4_check(skb_gro_len(skb), iph->saddr, iph->daddr,
Herbert Xubf296b12008-12-15 23:43:36 -08002563 skb->csum)) {
2564 skb->ip_summed = CHECKSUM_UNNECESSARY;
2565 break;
2566 }
2567
2568 /* fall through */
2569 case CHECKSUM_NONE:
2570 NAPI_GRO_CB(skb)->flush = 1;
2571 return NULL;
2572 }
2573
2574 return tcp_gro_receive(head, skb);
2575}
Herbert Xubf296b12008-12-15 23:43:36 -08002576
2577int tcp4_gro_complete(struct sk_buff *skb)
2578{
2579 struct iphdr *iph = ip_hdr(skb);
2580 struct tcphdr *th = tcp_hdr(skb);
2581
2582 th->check = ~tcp_v4_check(skb->len - skb_transport_offset(skb),
2583 iph->saddr, iph->daddr, 0);
2584 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV4;
2585
2586 return tcp_gro_complete(skb);
2587}
Herbert Xubf296b12008-12-15 23:43:36 -08002588
Linus Torvalds1da177e2005-04-16 15:20:36 -07002589struct proto tcp_prot = {
2590 .name = "TCP",
2591 .owner = THIS_MODULE,
2592 .close = tcp_close,
2593 .connect = tcp_v4_connect,
2594 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002595 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002596 .ioctl = tcp_ioctl,
2597 .init = tcp_v4_init_sock,
2598 .destroy = tcp_v4_destroy_sock,
2599 .shutdown = tcp_shutdown,
2600 .setsockopt = tcp_setsockopt,
2601 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002602 .recvmsg = tcp_recvmsg,
Changli Gao7ba42912010-07-10 20:41:55 +00002603 .sendmsg = tcp_sendmsg,
2604 .sendpage = tcp_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002605 .backlog_rcv = tcp_v4_do_rcv,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08002606 .hash = inet_hash,
2607 .unhash = inet_unhash,
2608 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002609 .enter_memory_pressure = tcp_enter_memory_pressure,
2610 .sockets_allocated = &tcp_sockets_allocated,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07002611 .orphan_count = &tcp_orphan_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002612 .memory_allocated = &tcp_memory_allocated,
2613 .memory_pressure = &tcp_memory_pressure,
2614 .sysctl_mem = sysctl_tcp_mem,
2615 .sysctl_wmem = sysctl_tcp_wmem,
2616 .sysctl_rmem = sysctl_tcp_rmem,
2617 .max_header = MAX_TCP_HEADER,
2618 .obj_size = sizeof(struct tcp_sock),
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002619 .slab_flags = SLAB_DESTROY_BY_RCU,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002620 .twsk_prot = &tcp_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002621 .rsk_prot = &tcp_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07002622 .h.hashinfo = &tcp_hashinfo,
Changli Gao7ba42912010-07-10 20:41:55 +00002623 .no_autobind = true,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002624#ifdef CONFIG_COMPAT
2625 .compat_setsockopt = compat_tcp_setsockopt,
2626 .compat_getsockopt = compat_tcp_getsockopt,
2627#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002628};
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002629EXPORT_SYMBOL(tcp_prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002630
Denis V. Lunev046ee902008-04-03 14:31:33 -07002631
2632static int __net_init tcp_sk_init(struct net *net)
2633{
2634 return inet_ctl_sock_create(&net->ipv4.tcp_sock,
2635 PF_INET, SOCK_RAW, IPPROTO_TCP, net);
2636}
2637
2638static void __net_exit tcp_sk_exit(struct net *net)
2639{
2640 inet_ctl_sock_destroy(net->ipv4.tcp_sock);
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002641}
2642
2643static void __net_exit tcp_sk_exit_batch(struct list_head *net_exit_list)
2644{
2645 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET);
Denis V. Lunev046ee902008-04-03 14:31:33 -07002646}
2647
2648static struct pernet_operations __net_initdata tcp_sk_ops = {
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002649 .init = tcp_sk_init,
2650 .exit = tcp_sk_exit,
2651 .exit_batch = tcp_sk_exit_batch,
Denis V. Lunev046ee902008-04-03 14:31:33 -07002652};
2653
Denis V. Lunev9b0f9762008-02-29 11:13:15 -08002654void __init tcp_v4_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002655{
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002656 inet_hashinfo_init(&tcp_hashinfo);
Eric W. Biederman6a1b3052009-02-22 00:10:18 -08002657 if (register_pernet_subsys(&tcp_sk_ops))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002658 panic("Failed to create the TCP control socket.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002659}