blob: 856f68466d49a8e0d01d03bf66748bd3ad218a1c [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
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1214{
William Allen Simpson4957faade2009-12-02 18:25:27 +00001215 struct tcp_extend_values tmp_ext;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216 struct tcp_options_received tmp_opt;
William Allen Simpson4957faade2009-12-02 18:25:27 +00001217 u8 *hash_location;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001218 struct request_sock *req;
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001219 struct inet_request_sock *ireq;
William Allen Simpson4957faade2009-12-02 18:25:27 +00001220 struct tcp_sock *tp = tcp_sk(sk);
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001221 struct dst_entry *dst = NULL;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001222 __be32 saddr = ip_hdr(skb)->saddr;
1223 __be32 daddr = ip_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 __u32 isn = TCP_SKB_CB(skb)->when;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225#ifdef CONFIG_SYN_COOKIES
1226 int want_cookie = 0;
1227#else
1228#define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */
1229#endif
1230
1231 /* Never answer to SYNs send to broadcast or multicast */
Eric Dumazet511c3f92009-06-02 05:14:27 +00001232 if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 goto drop;
1234
1235 /* TW buckets are converted to open requests without
1236 * limitations, they conserve resources and peer is
1237 * evidently real one.
1238 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001239 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
Florian Westphal2a1d4bd2010-06-03 00:43:12 +00001240 if (net_ratelimit())
1241 syn_flood_warning(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242#ifdef CONFIG_SYN_COOKIES
1243 if (sysctl_tcp_syncookies) {
1244 want_cookie = 1;
1245 } else
1246#endif
1247 goto drop;
1248 }
1249
1250 /* Accept backlog is full. If we have already queued enough
1251 * of warm entries in syn queue, drop request. It is better than
1252 * clogging syn queue with openreqs with exponentially increasing
1253 * timeout.
1254 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001255 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256 goto drop;
1257
Arnaldo Carvalho de Meloce4a7d02008-06-10 12:39:35 -07001258 req = inet_reqsk_alloc(&tcp_request_sock_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 if (!req)
1260 goto drop;
1261
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001262#ifdef CONFIG_TCP_MD5SIG
1263 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv4_ops;
1264#endif
1265
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 tcp_clear_options(&tmp_opt);
William Allen Simpsonbee7ca92009-11-10 09:51:18 +00001267 tmp_opt.mss_clamp = TCP_MSS_DEFAULT;
William Allen Simpson4957faade2009-12-02 18:25:27 +00001268 tmp_opt.user_mss = tp->rx_opt.user_mss;
David S. Millerbb5b7c12009-12-15 20:56:42 -08001269 tcp_parse_options(skb, &tmp_opt, &hash_location, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270
William Allen Simpson4957faade2009-12-02 18:25:27 +00001271 if (tmp_opt.cookie_plus > 0 &&
1272 tmp_opt.saw_tstamp &&
1273 !tp->rx_opt.cookie_out_never &&
1274 (sysctl_tcp_cookie_size > 0 ||
1275 (tp->cookie_values != NULL &&
1276 tp->cookie_values->cookie_desired > 0))) {
1277 u8 *c;
1278 u32 *mess = &tmp_ext.cookie_bakery[COOKIE_DIGEST_WORDS];
1279 int l = tmp_opt.cookie_plus - TCPOLEN_COOKIE_BASE;
1280
1281 if (tcp_cookie_generator(&tmp_ext.cookie_bakery[0]) != 0)
1282 goto drop_and_release;
1283
1284 /* Secret recipe starts with IP addresses */
Eric Dumazet0eae88f2010-04-20 19:06:52 -07001285 *mess++ ^= (__force u32)daddr;
1286 *mess++ ^= (__force u32)saddr;
William Allen Simpson4957faade2009-12-02 18:25:27 +00001287
1288 /* plus variable length Initiator Cookie */
1289 c = (u8 *)mess;
1290 while (l-- > 0)
1291 *c++ ^= *hash_location++;
1292
1293#ifdef CONFIG_SYN_COOKIES
1294 want_cookie = 0; /* not our kind of cookie */
1295#endif
1296 tmp_ext.cookie_out_never = 0; /* false */
1297 tmp_ext.cookie_plus = tmp_opt.cookie_plus;
1298 } else if (!tp->rx_opt.cookie_in_always) {
1299 /* redundant indications, but ensure initialization. */
1300 tmp_ext.cookie_out_never = 1; /* true */
1301 tmp_ext.cookie_plus = 0;
1302 } else {
1303 goto drop_and_release;
1304 }
1305 tmp_ext.cookie_in_always = tp->rx_opt.cookie_in_always;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306
Florian Westphal4dfc2812008-04-10 03:12:40 -07001307 if (want_cookie && !tmp_opt.saw_tstamp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 tcp_clear_options(&tmp_opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311 tcp_openreq_init(req, &tmp_opt, skb);
1312
David S. Millerbb5b7c12009-12-15 20:56:42 -08001313 ireq = inet_rsk(req);
1314 ireq->loc_addr = daddr;
1315 ireq->rmt_addr = saddr;
1316 ireq->no_srccheck = inet_sk(sk)->transparent;
1317 ireq->opt = tcp_v4_save_options(sk, skb);
1318
Paul Moore284904a2009-03-27 17:10:28 -04001319 if (security_inet_conn_request(sk, skb, req))
David S. Millerbb5b7c12009-12-15 20:56:42 -08001320 goto drop_and_free;
Paul Moore284904a2009-03-27 17:10:28 -04001321
Florian Westphal172d69e2010-06-21 11:48:45 +00001322 if (!want_cookie || tmp_opt.tstamp_ok)
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001323 TCP_ECN_create_request(req, tcp_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324
1325 if (want_cookie) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 isn = cookie_v4_init_sequence(sk, skb, &req->mss);
Florian Westphal172d69e2010-06-21 11:48:45 +00001327 req->cookie_ts = tmp_opt.tstamp_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328 } else if (!isn) {
1329 struct inet_peer *peer = NULL;
1330
1331 /* VJ's idea. We save last timestamp seen
1332 * from the destination in peer table, when entering
1333 * state TIME-WAIT, and check against it before
1334 * accepting new connection request.
1335 *
1336 * If "isn" is not zero, this request hit alive
1337 * timewait bucket, so that all the necessary checks
1338 * are made in the function processing timewait state.
1339 */
1340 if (tmp_opt.saw_tstamp &&
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001341 tcp_death_row.sysctl_tw_recycle &&
David S. Millerbb5b7c12009-12-15 20:56:42 -08001342 (dst = inet_csk_route_req(sk, req)) != NULL &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 (peer = rt_get_peer((struct rtable *)dst)) != NULL &&
David S. Miller582a72d2010-11-30 11:53:55 -08001344 peer->daddr.a4 == saddr) {
Eric Dumazet317fe0e2010-06-16 04:52:13 +00001345 inet_peer_refcheck(peer);
Eric Dumazet2c1409a2009-11-12 09:33:09 +00001346 if ((u32)get_seconds() - peer->tcp_ts_stamp < TCP_PAWS_MSL &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 (s32)(peer->tcp_ts - req->ts_recent) >
1348 TCP_PAWS_WINDOW) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001349 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001350 goto drop_and_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 }
1352 }
1353 /* Kill the following clause, if you dislike this way. */
1354 else if (!sysctl_tcp_syncookies &&
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001355 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 (sysctl_max_syn_backlog >> 2)) &&
1357 (!peer || !peer->tcp_ts_stamp) &&
1358 (!dst || !dst_metric(dst, RTAX_RTT))) {
1359 /* Without syncookies last quarter of
1360 * backlog is filled with destinations,
1361 * proven to be alive.
1362 * It means that we continue to communicate
1363 * to destinations, already remembered
1364 * to the moment of synflood.
1365 */
Harvey Harrison673d57e2008-10-31 00:53:57 -07001366 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open request from %pI4/%u\n",
1367 &saddr, ntohs(tcp_hdr(skb)->source));
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001368 goto drop_and_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 }
1370
Gerrit Renkera94f7232006-11-10 14:06:49 -08001371 isn = tcp_v4_init_sequence(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 }
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001373 tcp_rsk(req)->snt_isn = isn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374
Octavian Purdila72659ec2010-01-17 19:09:39 -08001375 if (tcp_v4_send_synack(sk, dst, req,
1376 (struct request_values *)&tmp_ext) ||
William Allen Simpson4957faade2009-12-02 18:25:27 +00001377 want_cookie)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378 goto drop_and_free;
1379
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001380 inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 return 0;
1382
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001383drop_and_release:
1384 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385drop_and_free:
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001386 reqsk_free(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387drop:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 return 0;
1389}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001390EXPORT_SYMBOL(tcp_v4_conn_request);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391
1392
1393/*
1394 * The three way handshake has completed - we got a valid synack -
1395 * now create the new socket.
1396 */
1397struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001398 struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 struct dst_entry *dst)
1400{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001401 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 struct inet_sock *newinet;
1403 struct tcp_sock *newtp;
1404 struct sock *newsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001405#ifdef CONFIG_TCP_MD5SIG
1406 struct tcp_md5sig_key *key;
1407#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408
1409 if (sk_acceptq_is_full(sk))
1410 goto exit_overflow;
1411
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001412 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 goto exit;
1414
1415 newsk = tcp_create_openreq_child(sk, req, skb);
1416 if (!newsk)
Balazs Scheidler093d2822010-10-21 13:06:43 +02001417 goto exit_nonewsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418
Herbert Xubcd76112006-06-30 13:36:35 -07001419 newsk->sk_gso_type = SKB_GSO_TCPV4;
Arnaldo Carvalho de Melo6cbb0df2005-08-09 19:49:02 -07001420 sk_setup_caps(newsk, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421
1422 newtp = tcp_sk(newsk);
1423 newinet = inet_sk(newsk);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001424 ireq = inet_rsk(req);
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001425 newinet->inet_daddr = ireq->rmt_addr;
1426 newinet->inet_rcv_saddr = ireq->loc_addr;
1427 newinet->inet_saddr = ireq->loc_addr;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001428 newinet->opt = ireq->opt;
1429 ireq->opt = NULL;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001430 newinet->mc_index = inet_iif(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001431 newinet->mc_ttl = ip_hdr(skb)->ttl;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001432 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433 if (newinet->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001434 inet_csk(newsk)->icsk_ext_hdr_len = newinet->opt->optlen;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001435 newinet->inet_id = newtp->write_seq ^ jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436
John Heffner5d424d52006-03-20 17:53:41 -08001437 tcp_mtup_init(newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 tcp_sync_mss(newsk, dst_mtu(dst));
David S. Miller0dbaee32010-12-13 12:52:14 -08001439 newtp->advmss = dst_metric_advmss(dst);
Tom Quetchenbachf5fff5d2008-09-21 00:21:51 -07001440 if (tcp_sk(sk)->rx_opt.user_mss &&
1441 tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1442 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1443
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 tcp_initialize_rcv_mss(newsk);
1445
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001446#ifdef CONFIG_TCP_MD5SIG
1447 /* Copy over the MD5 key from the original socket */
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001448 key = tcp_v4_md5_do_lookup(sk, newinet->inet_daddr);
1449 if (key != NULL) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001450 /*
1451 * We're using one, so create a matching key
1452 * on the newsk structure. If we fail to get
1453 * memory, then we end up not copying the key
1454 * across. Shucks.
1455 */
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -02001456 char *newkey = kmemdup(key->key, key->keylen, GFP_ATOMIC);
1457 if (newkey != NULL)
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001458 tcp_v4_md5_do_add(newsk, newinet->inet_daddr,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001459 newkey, key->keylen);
Eric Dumazeta4654192010-05-16 00:36:33 -07001460 sk_nocaps_add(newsk, NETIF_F_GSO_MASK);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001461 }
1462#endif
1463
Balazs Scheidler093d2822010-10-21 13:06:43 +02001464 if (__inet_inherit_port(sk, newsk) < 0) {
1465 sock_put(newsk);
1466 goto exit;
1467 }
Eric Dumazet9327f702009-12-04 03:46:54 +00001468 __inet_hash_nolisten(newsk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469
1470 return newsk;
1471
1472exit_overflow:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001473 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001474exit_nonewsk:
1475 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476exit:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001477 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 return NULL;
1479}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001480EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481
1482static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
1483{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001484 struct tcphdr *th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001485 const struct iphdr *iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 struct sock *nsk;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001487 struct request_sock **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488 /* Find possible connection requests. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001489 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
1490 iph->saddr, iph->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491 if (req)
1492 return tcp_check_req(sk, skb, req, prev);
1493
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001494 nsk = inet_lookup_established(sock_net(sk), &tcp_hashinfo, iph->saddr,
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001495 th->source, iph->daddr, th->dest, inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496
1497 if (nsk) {
1498 if (nsk->sk_state != TCP_TIME_WAIT) {
1499 bh_lock_sock(nsk);
1500 return nsk;
1501 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001502 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503 return NULL;
1504 }
1505
1506#ifdef CONFIG_SYN_COOKIES
Florian Westphalaf9b4732010-06-03 00:43:44 +00001507 if (!th->syn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
1509#endif
1510 return sk;
1511}
1512
Al Virob51655b2006-11-14 21:40:42 -08001513static __sum16 tcp_v4_checksum_init(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001515 const struct iphdr *iph = ip_hdr(skb);
1516
Patrick McHardy84fa7932006-08-29 16:44:56 -07001517 if (skb->ip_summed == CHECKSUM_COMPLETE) {
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001518 if (!tcp_v4_check(skb->len, iph->saddr,
1519 iph->daddr, skb->csum)) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001520 skb->ip_summed = CHECKSUM_UNNECESSARY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521 return 0;
Herbert Xufb286bb2005-11-10 13:01:24 -08001522 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523 }
Herbert Xufb286bb2005-11-10 13:01:24 -08001524
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001525 skb->csum = csum_tcpudp_nofold(iph->saddr, iph->daddr,
Herbert Xufb286bb2005-11-10 13:01:24 -08001526 skb->len, IPPROTO_TCP, 0);
1527
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528 if (skb->len <= 76) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001529 return __skb_checksum_complete(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530 }
1531 return 0;
1532}
1533
1534
1535/* The socket must have it's spinlock held when we get
1536 * here.
1537 *
1538 * We have a potential double-lock case here, so even when
1539 * doing backlog processing we use the BH locking scheme.
1540 * This is because we cannot sleep with the original spinlock
1541 * held.
1542 */
1543int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1544{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001545 struct sock *rsk;
1546#ifdef CONFIG_TCP_MD5SIG
1547 /*
1548 * We really want to reject the packet as early as possible
1549 * if:
1550 * o We're expecting an MD5'd packet and this is no MD5 tcp option
1551 * o There is an MD5 option and we're not expecting one
1552 */
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001553 if (tcp_v4_inbound_md5_hash(sk, skb))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001554 goto discard;
1555#endif
1556
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
Eric Dumazetca551582010-06-03 09:03:58 +00001558 sock_rps_save_rxhash(sk, skb->rxhash);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 TCP_CHECK_TIMER(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001560 if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001561 rsk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001563 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 TCP_CHECK_TIMER(sk);
1565 return 0;
1566 }
1567
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07001568 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569 goto csum_err;
1570
1571 if (sk->sk_state == TCP_LISTEN) {
1572 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
1573 if (!nsk)
1574 goto discard;
1575
1576 if (nsk != sk) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001577 if (tcp_child_process(sk, nsk, skb)) {
1578 rsk = nsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001580 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581 return 0;
1582 }
Eric Dumazetca551582010-06-03 09:03:58 +00001583 } else
1584 sock_rps_save_rxhash(sk, skb->rxhash);
1585
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586
1587 TCP_CHECK_TIMER(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001588 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001589 rsk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001591 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592 TCP_CHECK_TIMER(sk);
1593 return 0;
1594
1595reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001596 tcp_v4_send_reset(rsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597discard:
1598 kfree_skb(skb);
1599 /* Be careful here. If this function gets more complicated and
1600 * gcc suffers from register pressure on the x86, sk (in %ebx)
1601 * might be destroyed here. This current version compiles correctly,
1602 * but you have been warned.
1603 */
1604 return 0;
1605
1606csum_err:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001607 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608 goto discard;
1609}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001610EXPORT_SYMBOL(tcp_v4_do_rcv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611
1612/*
1613 * From tcp_input.c
1614 */
1615
1616int tcp_v4_rcv(struct sk_buff *skb)
1617{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001618 const struct iphdr *iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619 struct tcphdr *th;
1620 struct sock *sk;
1621 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001622 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623
1624 if (skb->pkt_type != PACKET_HOST)
1625 goto discard_it;
1626
1627 /* Count it even if it's bad */
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001628 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629
1630 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1631 goto discard_it;
1632
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001633 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634
1635 if (th->doff < sizeof(struct tcphdr) / 4)
1636 goto bad_packet;
1637 if (!pskb_may_pull(skb, th->doff * 4))
1638 goto discard_it;
1639
1640 /* An explanation is required here, I think.
1641 * Packet length and doff are validated by header prediction,
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -08001642 * provided case of th->doff==0 is eliminated.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 * So, we defer the checks. */
Herbert Xu60476372007-04-09 11:59:39 -07001644 if (!skb_csum_unnecessary(skb) && tcp_v4_checksum_init(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 goto bad_packet;
1646
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001647 th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001648 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1650 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1651 skb->len - th->doff * 4);
1652 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1653 TCP_SKB_CB(skb)->when = 0;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001654 TCP_SKB_CB(skb)->flags = iph->tos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655 TCP_SKB_CB(skb)->sacked = 0;
1656
Arnaldo Carvalho de Melo9a1f27c2008-10-07 11:41:57 -07001657 sk = __inet_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 if (!sk)
1659 goto no_tcp_socket;
1660
Eric Dumazetbb134d52010-03-09 05:55:56 +00001661process:
1662 if (sk->sk_state == TCP_TIME_WAIT)
1663 goto do_time_wait;
1664
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001665 if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
1666 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
Stephen Hemmingerd218d112010-01-11 16:28:01 -08001667 goto discard_and_relse;
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001668 }
Stephen Hemmingerd218d112010-01-11 16:28:01 -08001669
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1671 goto discard_and_relse;
Patrick McHardyb59c2702006-01-06 23:06:10 -08001672 nf_reset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001674 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675 goto discard_and_relse;
1676
1677 skb->dev = NULL;
1678
Ingo Molnarc6366182006-07-03 00:25:13 -07001679 bh_lock_sock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 ret = 0;
1681 if (!sock_owned_by_user(sk)) {
Chris Leech1a2449a2006-05-23 18:05:53 -07001682#ifdef CONFIG_NET_DMA
1683 struct tcp_sock *tp = tcp_sk(sk);
1684 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
Dan Williamsf67b4592009-01-06 11:38:15 -07001685 tp->ucopy.dma_chan = dma_find_channel(DMA_MEMCPY);
Chris Leech1a2449a2006-05-23 18:05:53 -07001686 if (tp->ucopy.dma_chan)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687 ret = tcp_v4_do_rcv(sk, skb);
Chris Leech1a2449a2006-05-23 18:05:53 -07001688 else
1689#endif
1690 {
1691 if (!tcp_prequeue(sk, skb))
Shan Weiae8d7f82009-05-05 01:01:29 +00001692 ret = tcp_v4_do_rcv(sk, skb);
Chris Leech1a2449a2006-05-23 18:05:53 -07001693 }
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001694 } else if (unlikely(sk_add_backlog(sk, skb))) {
Zhu Yi6b03a532010-03-04 18:01:41 +00001695 bh_unlock_sock(sk);
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001696 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
Zhu Yi6b03a532010-03-04 18:01:41 +00001697 goto discard_and_relse;
1698 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 bh_unlock_sock(sk);
1700
1701 sock_put(sk);
1702
1703 return ret;
1704
1705no_tcp_socket:
1706 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1707 goto discard_it;
1708
1709 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1710bad_packet:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001711 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001713 tcp_v4_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714 }
1715
1716discard_it:
1717 /* Discard frame. */
1718 kfree_skb(skb);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001719 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720
1721discard_and_relse:
1722 sock_put(sk);
1723 goto discard_it;
1724
1725do_time_wait:
1726 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001727 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728 goto discard_it;
1729 }
1730
1731 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001732 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
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 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001736 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737 case TCP_TW_SYN: {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001738 struct sock *sk2 = inet_lookup_listener(dev_net(skb->dev),
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001739 &tcp_hashinfo,
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001740 iph->daddr, th->dest,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001741 inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742 if (sk2) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001743 inet_twsk_deschedule(inet_twsk(sk), &tcp_death_row);
1744 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745 sk = sk2;
1746 goto process;
1747 }
1748 /* Fall through to ACK */
1749 }
1750 case TCP_TW_ACK:
1751 tcp_v4_timewait_ack(sk, skb);
1752 break;
1753 case TCP_TW_RST:
1754 goto no_tcp_socket;
1755 case TCP_TW_SUCCESS:;
1756 }
1757 goto discard_it;
1758}
1759
David S. Miller3f419d22010-11-29 13:37:14 -08001760struct inet_peer *tcp_v4_get_peer(struct sock *sk, bool *release_it)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761{
David S. Miller3f419d22010-11-29 13:37:14 -08001762 struct rtable *rt = (struct rtable *) __sk_dst_get(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001763 struct inet_sock *inet = inet_sk(sk);
David S. Miller3f419d22010-11-29 13:37:14 -08001764 struct inet_peer *peer;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001766 if (!rt || rt->rt_dst != inet->inet_daddr) {
David S. Millerb534ecf2010-11-30 11:54:19 -08001767 peer = inet_getpeer_v4(inet->inet_daddr, 1);
David S. Miller3f419d22010-11-29 13:37:14 -08001768 *release_it = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 } else {
1770 if (!rt->peer)
1771 rt_bind_peer(rt, 1);
1772 peer = rt->peer;
David S. Miller3f419d22010-11-29 13:37:14 -08001773 *release_it = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774 }
1775
David S. Miller3f419d22010-11-29 13:37:14 -08001776 return peer;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777}
David S. Miller3f419d22010-11-29 13:37:14 -08001778EXPORT_SYMBOL(tcp_v4_get_peer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779
David S. Millerccb7c412010-12-01 18:09:13 -08001780void *tcp_v4_tw_get_peer(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781{
David S. Millerccb7c412010-12-01 18:09:13 -08001782 struct inet_timewait_sock *tw = inet_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783
David S. Millerccb7c412010-12-01 18:09:13 -08001784 return inet_getpeer_v4(tw->tw_daddr, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785}
David S. Millerccb7c412010-12-01 18:09:13 -08001786EXPORT_SYMBOL(tcp_v4_tw_get_peer);
1787
1788static struct timewait_sock_ops tcp_timewait_sock_ops = {
1789 .twsk_obj_size = sizeof(struct tcp_timewait_sock),
1790 .twsk_unique = tcp_twsk_unique,
1791 .twsk_destructor= tcp_twsk_destructor,
1792 .twsk_getpeer = tcp_v4_tw_get_peer,
1793};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001795const struct inet_connection_sock_af_ops ipv4_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001796 .queue_xmit = ip_queue_xmit,
1797 .send_check = tcp_v4_send_check,
1798 .rebuild_header = inet_sk_rebuild_header,
1799 .conn_request = tcp_v4_conn_request,
1800 .syn_recv_sock = tcp_v4_syn_recv_sock,
David S. Miller3f419d22010-11-29 13:37:14 -08001801 .get_peer = tcp_v4_get_peer,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001802 .net_header_len = sizeof(struct iphdr),
1803 .setsockopt = ip_setsockopt,
1804 .getsockopt = ip_getsockopt,
1805 .addr2sockaddr = inet_csk_addr2sockaddr,
1806 .sockaddr_len = sizeof(struct sockaddr_in),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001807 .bind_conflict = inet_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001808#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001809 .compat_setsockopt = compat_ip_setsockopt,
1810 .compat_getsockopt = compat_ip_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001811#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812};
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001813EXPORT_SYMBOL(ipv4_specific);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001815#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001816static const struct tcp_sock_af_ops tcp_sock_ipv4_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001817 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001818 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001819 .md5_add = tcp_v4_md5_add_func,
1820 .md5_parse = tcp_v4_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001821};
Andrew Mortonb6332e62006-11-30 19:16:28 -08001822#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001823
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824/* NOTE: A lot of things set to zero explicitly by call to
1825 * sk_alloc() so need not be done here.
1826 */
1827static int tcp_v4_init_sock(struct sock *sk)
1828{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001829 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830 struct tcp_sock *tp = tcp_sk(sk);
1831
1832 skb_queue_head_init(&tp->out_of_order_queue);
1833 tcp_init_xmit_timers(sk);
1834 tcp_prequeue_init(tp);
1835
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001836 icsk->icsk_rto = TCP_TIMEOUT_INIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837 tp->mdev = TCP_TIMEOUT_INIT;
1838
1839 /* So many TCP implementations out there (incorrectly) count the
1840 * initial SYN frame in their delayed-ACK and congestion control
1841 * algorithms that we must have the following bandaid to talk
1842 * efficiently to them. -DaveM
1843 */
1844 tp->snd_cwnd = 2;
1845
1846 /* See draft-stevens-tcpca-spec-01 for discussion of the
1847 * initialization of these values.
1848 */
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07001849 tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850 tp->snd_cwnd_clamp = ~0;
William Allen Simpsonbee7ca92009-11-10 09:51:18 +00001851 tp->mss_cache = TCP_MSS_DEFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852
1853 tp->reordering = sysctl_tcp_reordering;
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001854 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855
1856 sk->sk_state = TCP_CLOSE;
1857
1858 sk->sk_write_space = sk_stream_write_space;
1859 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1860
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001861 icsk->icsk_af_ops = &ipv4_specific;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001862 icsk->icsk_sync_mss = tcp_sync_mss;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001863#ifdef CONFIG_TCP_MD5SIG
1864 tp->af_specific = &tcp_sock_ipv4_specific;
1865#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866
William Allen Simpson435cf552009-12-02 18:17:05 +00001867 /* TCP Cookie Transactions */
1868 if (sysctl_tcp_cookie_size > 0) {
1869 /* Default, cookies without s_data_payload. */
1870 tp->cookie_values =
1871 kzalloc(sizeof(*tp->cookie_values),
1872 sk->sk_allocation);
1873 if (tp->cookie_values != NULL)
1874 kref_init(&tp->cookie_values->kref);
1875 }
1876 /* Presumed zeroed, in order of appearance:
1877 * cookie_in_always, cookie_out_never,
1878 * s_data_constant, s_data_in, s_data_out
1879 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1881 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1882
Herbert Xueb4dea52008-12-29 23:04:08 -08001883 local_bh_disable();
Eric Dumazet17483762008-11-25 21:16:35 -08001884 percpu_counter_inc(&tcp_sockets_allocated);
Herbert Xueb4dea52008-12-29 23:04:08 -08001885 local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001886
1887 return 0;
1888}
1889
Brian Haley7d06b2e2008-06-14 17:04:49 -07001890void tcp_v4_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891{
1892 struct tcp_sock *tp = tcp_sk(sk);
1893
1894 tcp_clear_xmit_timers(sk);
1895
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001896 tcp_cleanup_congestion_control(sk);
Stephen Hemminger317a76f2005-06-23 12:19:55 -07001897
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898 /* Cleanup up the write buffer. */
David S. Millerfe067e82007-03-07 12:12:44 -08001899 tcp_write_queue_purge(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900
1901 /* Cleans up our, hopefully empty, out_of_order_queue. */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001902 __skb_queue_purge(&tp->out_of_order_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001904#ifdef CONFIG_TCP_MD5SIG
1905 /* Clean up the MD5 key list, if any */
1906 if (tp->md5sig_info) {
1907 tcp_v4_clear_md5_list(sk);
1908 kfree(tp->md5sig_info);
1909 tp->md5sig_info = NULL;
1910 }
1911#endif
1912
Chris Leech1a2449a2006-05-23 18:05:53 -07001913#ifdef CONFIG_NET_DMA
1914 /* Cleans up our sk_async_wait_queue */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001915 __skb_queue_purge(&sk->sk_async_wait_queue);
Chris Leech1a2449a2006-05-23 18:05:53 -07001916#endif
1917
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 /* Clean prequeue, it must be empty really */
1919 __skb_queue_purge(&tp->ucopy.prequeue);
1920
1921 /* Clean up a referenced TCP bind bucket. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001922 if (inet_csk(sk)->icsk_bind_hash)
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001923 inet_put_port(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924
1925 /*
1926 * If sendmsg cached page exists, toss it.
1927 */
1928 if (sk->sk_sndmsg_page) {
1929 __free_page(sk->sk_sndmsg_page);
1930 sk->sk_sndmsg_page = NULL;
1931 }
1932
William Allen Simpson435cf552009-12-02 18:17:05 +00001933 /* TCP Cookie Transactions */
1934 if (tp->cookie_values != NULL) {
1935 kref_put(&tp->cookie_values->kref,
1936 tcp_cookie_values_release);
1937 tp->cookie_values = NULL;
1938 }
1939
Eric Dumazet17483762008-11-25 21:16:35 -08001940 percpu_counter_dec(&tcp_sockets_allocated);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942EXPORT_SYMBOL(tcp_v4_destroy_sock);
1943
1944#ifdef CONFIG_PROC_FS
1945/* Proc filesystem TCP sock list dumping. */
1946
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001947static inline struct inet_timewait_sock *tw_head(struct hlist_nulls_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948{
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001949 return hlist_nulls_empty(head) ? NULL :
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001950 list_entry(head->first, struct inet_timewait_sock, tw_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951}
1952
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001953static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954{
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001955 return !is_a_nulls(tw->tw_node.next) ?
1956 hlist_nulls_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957}
1958
Tom Herberta8b690f2010-06-07 00:43:42 -07001959/*
1960 * Get next listener socket follow cur. If cur is NULL, get first socket
1961 * starting from bucket given in st->bucket; when st->bucket is zero the
1962 * very first socket in the hash table is returned.
1963 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964static void *listening_get_next(struct seq_file *seq, void *cur)
1965{
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001966 struct inet_connection_sock *icsk;
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08001967 struct hlist_nulls_node *node;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968 struct sock *sk = cur;
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001969 struct inet_listen_hashbucket *ilb;
Jianjun Kong5799de02008-11-03 02:49:10 -08001970 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07001971 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972
1973 if (!sk) {
Tom Herberta8b690f2010-06-07 00:43:42 -07001974 ilb = &tcp_hashinfo.listening_hash[st->bucket];
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001975 spin_lock_bh(&ilb->lock);
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08001976 sk = sk_nulls_head(&ilb->head);
Tom Herberta8b690f2010-06-07 00:43:42 -07001977 st->offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001978 goto get_sk;
1979 }
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001980 ilb = &tcp_hashinfo.listening_hash[st->bucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 ++st->num;
Tom Herberta8b690f2010-06-07 00:43:42 -07001982 ++st->offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983
1984 if (st->state == TCP_SEQ_STATE_OPENREQ) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001985 struct request_sock *req = cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001987 icsk = inet_csk(st->syn_wait_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988 req = req->dl_next;
1989 while (1) {
1990 while (req) {
Daniel Lezcanobdccc4c2008-07-19 00:15:13 -07001991 if (req->rsk_ops->family == st->family) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992 cur = req;
1993 goto out;
1994 }
1995 req = req->dl_next;
1996 }
Tom Herberta8b690f2010-06-07 00:43:42 -07001997 st->offset = 0;
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001998 if (++st->sbucket >= icsk->icsk_accept_queue.listen_opt->nr_table_entries)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999 break;
2000get_req:
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002001 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002 }
Eric Dumazet1bde5ac2010-12-23 09:32:46 -08002003 sk = sk_nulls_next(st->syn_wait_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004 st->state = TCP_SEQ_STATE_LISTENING;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002005 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006 } else {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002007 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002008 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2009 if (reqsk_queue_len(&icsk->icsk_accept_queue))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002010 goto start_req;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002011 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Eric Dumazet1bde5ac2010-12-23 09:32:46 -08002012 sk = sk_nulls_next(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013 }
2014get_sk:
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08002015 sk_nulls_for_each_from(sk, node) {
Pavel Emelyanov8475ef92010-11-22 03:26:12 +00002016 if (!net_eq(sock_net(sk), net))
2017 continue;
2018 if (sk->sk_family == st->family) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019 cur = sk;
2020 goto out;
2021 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002022 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002023 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2024 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002025start_req:
2026 st->uid = sock_i_uid(sk);
2027 st->syn_wait_sk = sk;
2028 st->state = TCP_SEQ_STATE_OPENREQ;
2029 st->sbucket = 0;
2030 goto get_req;
2031 }
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002032 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033 }
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002034 spin_unlock_bh(&ilb->lock);
Tom Herberta8b690f2010-06-07 00:43:42 -07002035 st->offset = 0;
Arnaldo Carvalho de Melo0f7ff922005-08-09 19:59:44 -07002036 if (++st->bucket < INET_LHTABLE_SIZE) {
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002037 ilb = &tcp_hashinfo.listening_hash[st->bucket];
2038 spin_lock_bh(&ilb->lock);
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08002039 sk = sk_nulls_head(&ilb->head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040 goto get_sk;
2041 }
2042 cur = NULL;
2043out:
2044 return cur;
2045}
2046
2047static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
2048{
Tom Herberta8b690f2010-06-07 00:43:42 -07002049 struct tcp_iter_state *st = seq->private;
2050 void *rc;
2051
2052 st->bucket = 0;
2053 st->offset = 0;
2054 rc = listening_get_next(seq, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055
2056 while (rc && *pos) {
2057 rc = listening_get_next(seq, rc);
2058 --*pos;
2059 }
2060 return rc;
2061}
2062
Andi Kleen6eac5602008-08-28 01:08:02 -07002063static inline int empty_bucket(struct tcp_iter_state *st)
2064{
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002065 return hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].chain) &&
2066 hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].twchain);
Andi Kleen6eac5602008-08-28 01:08:02 -07002067}
2068
Tom Herberta8b690f2010-06-07 00:43:42 -07002069/*
2070 * Get first established socket starting from bucket given in st->bucket.
2071 * If st->bucket is zero, the very first socket in the hash is returned.
2072 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073static void *established_get_first(struct seq_file *seq)
2074{
Jianjun Kong5799de02008-11-03 02:49:10 -08002075 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002076 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077 void *rc = NULL;
2078
Tom Herberta8b690f2010-06-07 00:43:42 -07002079 st->offset = 0;
2080 for (; st->bucket <= tcp_hashinfo.ehash_mask; ++st->bucket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081 struct sock *sk;
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002082 struct hlist_nulls_node *node;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002083 struct inet_timewait_sock *tw;
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002084 spinlock_t *lock = inet_ehash_lockp(&tcp_hashinfo, st->bucket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085
Andi Kleen6eac5602008-08-28 01:08:02 -07002086 /* Lockless fast path for the common case of empty buckets */
2087 if (empty_bucket(st))
2088 continue;
2089
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002090 spin_lock_bh(lock);
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002091 sk_nulls_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002092 if (sk->sk_family != st->family ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002093 !net_eq(sock_net(sk), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094 continue;
2095 }
2096 rc = sk;
2097 goto out;
2098 }
2099 st->state = TCP_SEQ_STATE_TIME_WAIT;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002100 inet_twsk_for_each(tw, node,
Eric Dumazetdbca9b2752007-02-08 14:16:46 -08002101 &tcp_hashinfo.ehash[st->bucket].twchain) {
Pavel Emelyanov28518fc2008-03-21 15:52:00 -07002102 if (tw->tw_family != st->family ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002103 !net_eq(twsk_net(tw), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104 continue;
2105 }
2106 rc = tw;
2107 goto out;
2108 }
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002109 spin_unlock_bh(lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002110 st->state = TCP_SEQ_STATE_ESTABLISHED;
2111 }
2112out:
2113 return rc;
2114}
2115
2116static void *established_get_next(struct seq_file *seq, void *cur)
2117{
2118 struct sock *sk = cur;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002119 struct inet_timewait_sock *tw;
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002120 struct hlist_nulls_node *node;
Jianjun Kong5799de02008-11-03 02:49:10 -08002121 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002122 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123
2124 ++st->num;
Tom Herberta8b690f2010-06-07 00:43:42 -07002125 ++st->offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002126
2127 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
2128 tw = cur;
2129 tw = tw_next(tw);
2130get_tw:
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002131 while (tw && (tw->tw_family != st->family || !net_eq(twsk_net(tw), net))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132 tw = tw_next(tw);
2133 }
2134 if (tw) {
2135 cur = tw;
2136 goto out;
2137 }
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002138 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139 st->state = TCP_SEQ_STATE_ESTABLISHED;
2140
Andi Kleen6eac5602008-08-28 01:08:02 -07002141 /* Look for next non empty bucket */
Tom Herberta8b690f2010-06-07 00:43:42 -07002142 st->offset = 0;
Eric Dumazetf373b532009-10-09 00:16:19 +00002143 while (++st->bucket <= tcp_hashinfo.ehash_mask &&
Andi Kleen6eac5602008-08-28 01:08:02 -07002144 empty_bucket(st))
2145 ;
Eric Dumazetf373b532009-10-09 00:16:19 +00002146 if (st->bucket > tcp_hashinfo.ehash_mask)
Andi Kleen6eac5602008-08-28 01:08:02 -07002147 return NULL;
2148
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002149 spin_lock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002150 sk = sk_nulls_head(&tcp_hashinfo.ehash[st->bucket].chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151 } else
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002152 sk = sk_nulls_next(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002154 sk_nulls_for_each_from(sk, node) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002155 if (sk->sk_family == st->family && net_eq(sock_net(sk), net))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156 goto found;
2157 }
2158
2159 st->state = TCP_SEQ_STATE_TIME_WAIT;
Eric Dumazetdbca9b2752007-02-08 14:16:46 -08002160 tw = tw_head(&tcp_hashinfo.ehash[st->bucket].twchain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002161 goto get_tw;
2162found:
2163 cur = sk;
2164out:
2165 return cur;
2166}
2167
2168static void *established_get_idx(struct seq_file *seq, loff_t pos)
2169{
Tom Herberta8b690f2010-06-07 00:43:42 -07002170 struct tcp_iter_state *st = seq->private;
2171 void *rc;
2172
2173 st->bucket = 0;
2174 rc = established_get_first(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002175
2176 while (rc && pos) {
2177 rc = established_get_next(seq, rc);
2178 --pos;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002179 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180 return rc;
2181}
2182
2183static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
2184{
2185 void *rc;
Jianjun Kong5799de02008-11-03 02:49:10 -08002186 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188 st->state = TCP_SEQ_STATE_LISTENING;
2189 rc = listening_get_idx(seq, &pos);
2190
2191 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192 st->state = TCP_SEQ_STATE_ESTABLISHED;
2193 rc = established_get_idx(seq, pos);
2194 }
2195
2196 return rc;
2197}
2198
Tom Herberta8b690f2010-06-07 00:43:42 -07002199static void *tcp_seek_last_pos(struct seq_file *seq)
2200{
2201 struct tcp_iter_state *st = seq->private;
2202 int offset = st->offset;
2203 int orig_num = st->num;
2204 void *rc = NULL;
2205
2206 switch (st->state) {
2207 case TCP_SEQ_STATE_OPENREQ:
2208 case TCP_SEQ_STATE_LISTENING:
2209 if (st->bucket >= INET_LHTABLE_SIZE)
2210 break;
2211 st->state = TCP_SEQ_STATE_LISTENING;
2212 rc = listening_get_next(seq, NULL);
2213 while (offset-- && rc)
2214 rc = listening_get_next(seq, rc);
2215 if (rc)
2216 break;
2217 st->bucket = 0;
2218 /* Fallthrough */
2219 case TCP_SEQ_STATE_ESTABLISHED:
2220 case TCP_SEQ_STATE_TIME_WAIT:
2221 st->state = TCP_SEQ_STATE_ESTABLISHED;
2222 if (st->bucket > tcp_hashinfo.ehash_mask)
2223 break;
2224 rc = established_get_first(seq);
2225 while (offset-- && rc)
2226 rc = established_get_next(seq, rc);
2227 }
2228
2229 st->num = orig_num;
2230
2231 return rc;
2232}
2233
Linus Torvalds1da177e2005-04-16 15:20:36 -07002234static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
2235{
Jianjun Kong5799de02008-11-03 02:49:10 -08002236 struct tcp_iter_state *st = seq->private;
Tom Herberta8b690f2010-06-07 00:43:42 -07002237 void *rc;
2238
2239 if (*pos && *pos == st->last_pos) {
2240 rc = tcp_seek_last_pos(seq);
2241 if (rc)
2242 goto out;
2243 }
2244
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245 st->state = TCP_SEQ_STATE_LISTENING;
2246 st->num = 0;
Tom Herberta8b690f2010-06-07 00:43:42 -07002247 st->bucket = 0;
2248 st->offset = 0;
2249 rc = *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2250
2251out:
2252 st->last_pos = *pos;
2253 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002254}
2255
2256static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2257{
Tom Herberta8b690f2010-06-07 00:43:42 -07002258 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259 void *rc = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260
2261 if (v == SEQ_START_TOKEN) {
2262 rc = tcp_get_idx(seq, 0);
2263 goto out;
2264 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265
2266 switch (st->state) {
2267 case TCP_SEQ_STATE_OPENREQ:
2268 case TCP_SEQ_STATE_LISTENING:
2269 rc = listening_get_next(seq, v);
2270 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002271 st->state = TCP_SEQ_STATE_ESTABLISHED;
Tom Herberta8b690f2010-06-07 00:43:42 -07002272 st->bucket = 0;
2273 st->offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002274 rc = established_get_first(seq);
2275 }
2276 break;
2277 case TCP_SEQ_STATE_ESTABLISHED:
2278 case TCP_SEQ_STATE_TIME_WAIT:
2279 rc = established_get_next(seq, v);
2280 break;
2281 }
2282out:
2283 ++*pos;
Tom Herberta8b690f2010-06-07 00:43:42 -07002284 st->last_pos = *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002285 return rc;
2286}
2287
2288static void tcp_seq_stop(struct seq_file *seq, void *v)
2289{
Jianjun Kong5799de02008-11-03 02:49:10 -08002290 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002291
2292 switch (st->state) {
2293 case TCP_SEQ_STATE_OPENREQ:
2294 if (v) {
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002295 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
2296 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002297 }
2298 case TCP_SEQ_STATE_LISTENING:
2299 if (v != SEQ_START_TOKEN)
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002300 spin_unlock_bh(&tcp_hashinfo.listening_hash[st->bucket].lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002301 break;
2302 case TCP_SEQ_STATE_TIME_WAIT:
2303 case TCP_SEQ_STATE_ESTABLISHED:
2304 if (v)
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002305 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002306 break;
2307 }
2308}
2309
2310static int tcp_seq_open(struct inode *inode, struct file *file)
2311{
2312 struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002313 struct tcp_iter_state *s;
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002314 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002316 err = seq_open_net(inode, file, &afinfo->seq_ops,
2317 sizeof(struct tcp_iter_state));
2318 if (err < 0)
2319 return err;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002320
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002321 s = ((struct seq_file *)file->private_data)->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322 s->family = afinfo->family;
Tom Herberta8b690f2010-06-07 00:43:42 -07002323 s->last_pos = 0;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002324 return 0;
2325}
2326
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002327int tcp_proc_register(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002328{
2329 int rc = 0;
2330 struct proc_dir_entry *p;
2331
Denis V. Lunev68fcadd2008-04-13 22:13:30 -07002332 afinfo->seq_fops.open = tcp_seq_open;
2333 afinfo->seq_fops.read = seq_read;
2334 afinfo->seq_fops.llseek = seq_lseek;
2335 afinfo->seq_fops.release = seq_release_net;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002336
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002337 afinfo->seq_ops.start = tcp_seq_start;
2338 afinfo->seq_ops.next = tcp_seq_next;
2339 afinfo->seq_ops.stop = tcp_seq_stop;
2340
Denis V. Lunev84841c32008-05-02 04:10:08 -07002341 p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net,
2342 &afinfo->seq_fops, afinfo);
2343 if (!p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002344 rc = -ENOMEM;
2345 return rc;
2346}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002347EXPORT_SYMBOL(tcp_proc_register);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002349void tcp_proc_unregister(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002350{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002351 proc_net_remove(net, afinfo->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002352}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002353EXPORT_SYMBOL(tcp_proc_unregister);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002354
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002355static void get_openreq4(struct sock *sk, struct request_sock *req,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002356 struct seq_file *f, int i, int uid, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002357{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002358 const struct inet_request_sock *ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002359 int ttd = req->expires - jiffies;
2360
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002361 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
2362 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p%n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002363 i,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002364 ireq->loc_addr,
Eric Dumazetc720c7e2009-10-15 06:30:45 +00002365 ntohs(inet_sk(sk)->inet_sport),
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002366 ireq->rmt_addr,
2367 ntohs(ireq->rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002368 TCP_SYN_RECV,
2369 0, 0, /* could print option size, but that is af dependent. */
2370 1, /* timers active (only the expire timer) */
2371 jiffies_to_clock_t(ttd),
2372 req->retrans,
2373 uid,
2374 0, /* non standard timer */
2375 0, /* open_requests have no inode */
2376 atomic_read(&sk->sk_refcnt),
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002377 req,
2378 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002379}
2380
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002381static void get_tcp4_sock(struct sock *sk, struct seq_file *f, int i, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002382{
2383 int timer_active;
2384 unsigned long timer_expires;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002385 struct tcp_sock *tp = tcp_sk(sk);
2386 const struct inet_connection_sock *icsk = inet_csk(sk);
2387 struct inet_sock *inet = inet_sk(sk);
Eric Dumazetc720c7e2009-10-15 06:30:45 +00002388 __be32 dest = inet->inet_daddr;
2389 __be32 src = inet->inet_rcv_saddr;
2390 __u16 destp = ntohs(inet->inet_dport);
2391 __u16 srcp = ntohs(inet->inet_sport);
Eric Dumazet49d09002009-12-03 16:06:13 -08002392 int rx_queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002393
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002394 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002395 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002396 timer_expires = icsk->icsk_timeout;
2397 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002398 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002399 timer_expires = icsk->icsk_timeout;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002400 } else if (timer_pending(&sk->sk_timer)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002401 timer_active = 2;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002402 timer_expires = sk->sk_timer.expires;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002403 } else {
2404 timer_active = 0;
2405 timer_expires = jiffies;
2406 }
2407
Eric Dumazet49d09002009-12-03 16:06:13 -08002408 if (sk->sk_state == TCP_LISTEN)
2409 rx_queue = sk->sk_ack_backlog;
2410 else
2411 /*
2412 * because we dont lock socket, we might find a transient negative value
2413 */
2414 rx_queue = max_t(int, tp->rcv_nxt - tp->copied_seq, 0);
2415
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002416 seq_printf(f, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
Stephen Hemminger7be87352008-06-27 20:00:19 -07002417 "%08X %5d %8d %lu %d %p %lu %lu %u %u %d%n",
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002418 i, src, srcp, dest, destp, sk->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07002419 tp->write_seq - tp->snd_una,
Eric Dumazet49d09002009-12-03 16:06:13 -08002420 rx_queue,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002421 timer_active,
2422 jiffies_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002423 icsk->icsk_retransmits,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002424 sock_i_uid(sk),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03002425 icsk->icsk_probes_out,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002426 sock_i_ino(sk),
2427 atomic_read(&sk->sk_refcnt), sk,
Stephen Hemminger7be87352008-06-27 20:00:19 -07002428 jiffies_to_clock_t(icsk->icsk_rto),
2429 jiffies_to_clock_t(icsk->icsk_ack.ato),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002430 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002431 tp->snd_cwnd,
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07002432 tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002433 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002434}
2435
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002436static void get_timewait4_sock(struct inet_timewait_sock *tw,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002437 struct seq_file *f, int i, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002438{
Al Viro23f33c22006-09-27 18:43:50 -07002439 __be32 dest, src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002440 __u16 destp, srcp;
2441 int ttd = tw->tw_ttd - jiffies;
2442
2443 if (ttd < 0)
2444 ttd = 0;
2445
2446 dest = tw->tw_daddr;
2447 src = tw->tw_rcv_saddr;
2448 destp = ntohs(tw->tw_dport);
2449 srcp = ntohs(tw->tw_sport);
2450
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002451 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
2452 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p%n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002453 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
2454 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002455 atomic_read(&tw->tw_refcnt), tw, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002456}
2457
2458#define TMPSZ 150
2459
2460static int tcp4_seq_show(struct seq_file *seq, void *v)
2461{
Jianjun Kong5799de02008-11-03 02:49:10 -08002462 struct tcp_iter_state *st;
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002463 int len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002464
2465 if (v == SEQ_START_TOKEN) {
2466 seq_printf(seq, "%-*s\n", TMPSZ - 1,
2467 " sl local_address rem_address st tx_queue "
2468 "rx_queue tr tm->when retrnsmt uid timeout "
2469 "inode");
2470 goto out;
2471 }
2472 st = seq->private;
2473
2474 switch (st->state) {
2475 case TCP_SEQ_STATE_LISTENING:
2476 case TCP_SEQ_STATE_ESTABLISHED:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002477 get_tcp4_sock(v, seq, st->num, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002478 break;
2479 case TCP_SEQ_STATE_OPENREQ:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002480 get_openreq4(st->syn_wait_sk, v, seq, st->num, st->uid, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002481 break;
2482 case TCP_SEQ_STATE_TIME_WAIT:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002483 get_timewait4_sock(v, seq, st->num, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002484 break;
2485 }
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002486 seq_printf(seq, "%*s\n", TMPSZ - 1 - len, "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002487out:
2488 return 0;
2489}
2490
Linus Torvalds1da177e2005-04-16 15:20:36 -07002491static struct tcp_seq_afinfo tcp4_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002492 .name = "tcp",
2493 .family = AF_INET,
Denis V. Lunev5f4472c2008-04-13 22:13:53 -07002494 .seq_fops = {
2495 .owner = THIS_MODULE,
2496 },
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002497 .seq_ops = {
2498 .show = tcp4_seq_show,
2499 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002500};
2501
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002502static int __net_init tcp4_proc_init_net(struct net *net)
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002503{
2504 return tcp_proc_register(net, &tcp4_seq_afinfo);
2505}
2506
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002507static void __net_exit tcp4_proc_exit_net(struct net *net)
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002508{
2509 tcp_proc_unregister(net, &tcp4_seq_afinfo);
2510}
2511
2512static struct pernet_operations tcp4_net_ops = {
2513 .init = tcp4_proc_init_net,
2514 .exit = tcp4_proc_exit_net,
2515};
2516
Linus Torvalds1da177e2005-04-16 15:20:36 -07002517int __init tcp4_proc_init(void)
2518{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002519 return register_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002520}
2521
2522void tcp4_proc_exit(void)
2523{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002524 unregister_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002525}
2526#endif /* CONFIG_PROC_FS */
2527
Herbert Xubf296b12008-12-15 23:43:36 -08002528struct sk_buff **tcp4_gro_receive(struct sk_buff **head, struct sk_buff *skb)
2529{
Herbert Xu36e7b1b2009-04-27 05:44:45 -07002530 struct iphdr *iph = skb_gro_network_header(skb);
Herbert Xubf296b12008-12-15 23:43:36 -08002531
2532 switch (skb->ip_summed) {
2533 case CHECKSUM_COMPLETE:
Herbert Xu86911732009-01-29 14:19:50 +00002534 if (!tcp_v4_check(skb_gro_len(skb), iph->saddr, iph->daddr,
Herbert Xubf296b12008-12-15 23:43:36 -08002535 skb->csum)) {
2536 skb->ip_summed = CHECKSUM_UNNECESSARY;
2537 break;
2538 }
2539
2540 /* fall through */
2541 case CHECKSUM_NONE:
2542 NAPI_GRO_CB(skb)->flush = 1;
2543 return NULL;
2544 }
2545
2546 return tcp_gro_receive(head, skb);
2547}
Herbert Xubf296b12008-12-15 23:43:36 -08002548
2549int tcp4_gro_complete(struct sk_buff *skb)
2550{
2551 struct iphdr *iph = ip_hdr(skb);
2552 struct tcphdr *th = tcp_hdr(skb);
2553
2554 th->check = ~tcp_v4_check(skb->len - skb_transport_offset(skb),
2555 iph->saddr, iph->daddr, 0);
2556 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV4;
2557
2558 return tcp_gro_complete(skb);
2559}
Herbert Xubf296b12008-12-15 23:43:36 -08002560
Linus Torvalds1da177e2005-04-16 15:20:36 -07002561struct proto tcp_prot = {
2562 .name = "TCP",
2563 .owner = THIS_MODULE,
2564 .close = tcp_close,
2565 .connect = tcp_v4_connect,
2566 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002567 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002568 .ioctl = tcp_ioctl,
2569 .init = tcp_v4_init_sock,
2570 .destroy = tcp_v4_destroy_sock,
2571 .shutdown = tcp_shutdown,
2572 .setsockopt = tcp_setsockopt,
2573 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002574 .recvmsg = tcp_recvmsg,
Changli Gao7ba42912010-07-10 20:41:55 +00002575 .sendmsg = tcp_sendmsg,
2576 .sendpage = tcp_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002577 .backlog_rcv = tcp_v4_do_rcv,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08002578 .hash = inet_hash,
2579 .unhash = inet_unhash,
2580 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002581 .enter_memory_pressure = tcp_enter_memory_pressure,
2582 .sockets_allocated = &tcp_sockets_allocated,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07002583 .orphan_count = &tcp_orphan_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002584 .memory_allocated = &tcp_memory_allocated,
2585 .memory_pressure = &tcp_memory_pressure,
2586 .sysctl_mem = sysctl_tcp_mem,
2587 .sysctl_wmem = sysctl_tcp_wmem,
2588 .sysctl_rmem = sysctl_tcp_rmem,
2589 .max_header = MAX_TCP_HEADER,
2590 .obj_size = sizeof(struct tcp_sock),
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002591 .slab_flags = SLAB_DESTROY_BY_RCU,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002592 .twsk_prot = &tcp_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002593 .rsk_prot = &tcp_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07002594 .h.hashinfo = &tcp_hashinfo,
Changli Gao7ba42912010-07-10 20:41:55 +00002595 .no_autobind = true,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002596#ifdef CONFIG_COMPAT
2597 .compat_setsockopt = compat_tcp_setsockopt,
2598 .compat_getsockopt = compat_tcp_getsockopt,
2599#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002600};
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002601EXPORT_SYMBOL(tcp_prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002602
Denis V. Lunev046ee902008-04-03 14:31:33 -07002603
2604static int __net_init tcp_sk_init(struct net *net)
2605{
2606 return inet_ctl_sock_create(&net->ipv4.tcp_sock,
2607 PF_INET, SOCK_RAW, IPPROTO_TCP, net);
2608}
2609
2610static void __net_exit tcp_sk_exit(struct net *net)
2611{
2612 inet_ctl_sock_destroy(net->ipv4.tcp_sock);
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002613}
2614
2615static void __net_exit tcp_sk_exit_batch(struct list_head *net_exit_list)
2616{
2617 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET);
Denis V. Lunev046ee902008-04-03 14:31:33 -07002618}
2619
2620static struct pernet_operations __net_initdata tcp_sk_ops = {
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002621 .init = tcp_sk_init,
2622 .exit = tcp_sk_exit,
2623 .exit_batch = tcp_sk_exit_batch,
Denis V. Lunev046ee902008-04-03 14:31:33 -07002624};
2625
Denis V. Lunev9b0f9762008-02-29 11:13:15 -08002626void __init tcp_v4_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002627{
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002628 inet_hashinfo_init(&tcp_hashinfo);
Eric W. Biederman6a1b3052009-02-22 00:10:18 -08002629 if (register_pernet_subsys(&tcp_sk_ops))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002630 panic("Failed to create the TCP control socket.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002631}