blob: a7d6671e33b8a6e46aba0b352ad083736d1b421b [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{
David S. Miller2d7192d2011-04-26 13:28:44 -0700149 struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 struct inet_sock *inet = inet_sk(sk);
151 struct tcp_sock *tp = tcp_sk(sk);
David S. Millerdca8b082011-02-24 13:38:12 -0800152 __be16 orig_sport, orig_dport;
Al Virobada8ad2006-09-26 21:27:15 -0700153 __be32 daddr, nexthop;
David S. Millerda905bd2011-05-06 16:11:19 -0700154 struct flowi4 *fl4;
David S. Miller2d7192d2011-04-26 13:28:44 -0700155 struct rtable *rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 int err;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000157 struct ip_options_rcu *inet_opt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158
159 if (addr_len < sizeof(struct sockaddr_in))
160 return -EINVAL;
161
162 if (usin->sin_family != AF_INET)
163 return -EAFNOSUPPORT;
164
165 nexthop = daddr = usin->sin_addr.s_addr;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000166 inet_opt = rcu_dereference_protected(inet->inet_opt,
167 sock_owned_by_user(sk));
168 if (inet_opt && inet_opt->opt.srr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 if (!daddr)
170 return -EINVAL;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000171 nexthop = inet_opt->opt.faddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 }
173
David S. Millerdca8b082011-02-24 13:38:12 -0800174 orig_sport = inet->inet_sport;
175 orig_dport = usin->sin_port;
David S. Millerda905bd2011-05-06 16:11:19 -0700176 fl4 = &inet->cork.fl.u.ip4;
177 rt = ip_route_connect(fl4, nexthop, inet->inet_saddr,
David S. Millerb23dd4f2011-03-02 14:31:35 -0800178 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
179 IPPROTO_TCP,
180 orig_sport, orig_dport, sk, true);
181 if (IS_ERR(rt)) {
182 err = PTR_ERR(rt);
183 if (err == -ENETUNREACH)
Pavel Emelyanov7c73a6f2008-07-16 20:20:11 -0700184 IP_INC_STATS_BH(sock_net(sk), IPSTATS_MIB_OUTNOROUTES);
David S. Millerb23dd4f2011-03-02 14:31:35 -0800185 return err;
Wei Dong584bdf82007-05-31 22:49:28 -0700186 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
188 if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
189 ip_rt_put(rt);
190 return -ENETUNREACH;
191 }
192
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000193 if (!inet_opt || !inet_opt->opt.srr)
David S. Millerda905bd2011-05-06 16:11:19 -0700194 daddr = fl4->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000196 if (!inet->inet_saddr)
David S. Millerda905bd2011-05-06 16:11:19 -0700197 inet->inet_saddr = fl4->saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000198 inet->inet_rcv_saddr = inet->inet_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000200 if (tp->rx_opt.ts_recent_stamp && inet->inet_daddr != daddr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 /* Reset inherited state */
202 tp->rx_opt.ts_recent = 0;
203 tp->rx_opt.ts_recent_stamp = 0;
204 tp->write_seq = 0;
205 }
206
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -0700207 if (tcp_death_row.sysctl_tw_recycle &&
David S. Millerda905bd2011-05-06 16:11:19 -0700208 !tp->rx_opt.ts_recent_stamp && fl4->daddr == daddr) {
David S. Millered2361e2011-05-18 18:38:54 -0400209 struct inet_peer *peer = rt_get_peer(rt, fl4->daddr);
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200210 /*
211 * VJ's idea. We save last timestamp seen from
212 * the destination in peer table, when entering state
213 * TIME-WAIT * and initialize rx_opt.ts_recent from it,
214 * when trying new connection.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 */
Eric Dumazet317fe0e2010-06-16 04:52:13 +0000216 if (peer) {
217 inet_peer_refcheck(peer);
218 if ((u32)get_seconds() - peer->tcp_ts_stamp <= TCP_PAWS_MSL) {
219 tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp;
220 tp->rx_opt.ts_recent = peer->tcp_ts;
221 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 }
223 }
224
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000225 inet->inet_dport = usin->sin_port;
226 inet->inet_daddr = daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800228 inet_csk(sk)->icsk_ext_hdr_len = 0;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000229 if (inet_opt)
230 inet_csk(sk)->icsk_ext_hdr_len = inet_opt->opt.optlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231
William Allen Simpsonbee7ca92009-11-10 09:51:18 +0000232 tp->rx_opt.mss_clamp = TCP_MSS_DEFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233
234 /* Socket identity is still unknown (sport may be zero).
235 * However we set state to SYN-SENT and not releasing socket
236 * lock select source port, enter ourselves into the hash tables and
237 * complete initialization after this.
238 */
239 tcp_set_state(sk, TCP_SYN_SENT);
Arnaldo Carvalho de Meloa7f5e7f2005-12-13 23:25:31 -0800240 err = inet_hash_connect(&tcp_death_row, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 if (err)
242 goto failure;
243
David S. Millerda905bd2011-05-06 16:11:19 -0700244 rt = ip_route_newports(fl4, rt, orig_sport, orig_dport,
David S. Millerb23dd4f2011-03-02 14:31:35 -0800245 inet->inet_sport, inet->inet_dport, sk);
246 if (IS_ERR(rt)) {
247 err = PTR_ERR(rt);
248 rt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 goto failure;
David S. Millerb23dd4f2011-03-02 14:31:35 -0800250 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 /* OK, now commit destination to socket. */
Herbert Xubcd76112006-06-30 13:36:35 -0700252 sk->sk_gso_type = SKB_GSO_TCPV4;
Changli Gaod8d1f302010-06-10 23:31:35 -0700253 sk_setup_caps(sk, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
255 if (!tp->write_seq)
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000256 tp->write_seq = secure_tcp_sequence_number(inet->inet_saddr,
257 inet->inet_daddr,
258 inet->inet_sport,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 usin->sin_port);
260
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000261 inet->inet_id = tp->write_seq ^ jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262
263 err = tcp_connect(sk);
264 rt = NULL;
265 if (err)
266 goto failure;
267
268 return 0;
269
270failure:
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200271 /*
272 * This unhashes the socket and releases the local port,
273 * if necessary.
274 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 tcp_set_state(sk, TCP_CLOSE);
276 ip_rt_put(rt);
277 sk->sk_route_caps = 0;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000278 inet->inet_dport = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 return err;
280}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000281EXPORT_SYMBOL(tcp_v4_connect);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283/*
284 * This routine does path mtu discovery as defined in RFC1191.
285 */
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000286static void do_pmtu_discovery(struct sock *sk, const struct iphdr *iph, u32 mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287{
288 struct dst_entry *dst;
289 struct inet_sock *inet = inet_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290
291 /* We are not interested in TCP_LISTEN and open_requests (SYN-ACKs
292 * send out by Linux are always <576bytes so they should go through
293 * unfragmented).
294 */
295 if (sk->sk_state == TCP_LISTEN)
296 return;
297
298 /* We don't check in the destentry if pmtu discovery is forbidden
299 * on this route. We just assume that no packet_to_big packets
300 * are send back when pmtu discovery is not active.
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900301 * There is a small race when the user changes this flag in the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 * route, but I think that's acceptable.
303 */
304 if ((dst = __sk_dst_check(sk, 0)) == NULL)
305 return;
306
307 dst->ops->update_pmtu(dst, mtu);
308
309 /* Something is about to be wrong... Remember soft error
310 * for the case, if this connection will not able to recover.
311 */
312 if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
313 sk->sk_err_soft = EMSGSIZE;
314
315 mtu = dst_mtu(dst);
316
317 if (inet->pmtudisc != IP_PMTUDISC_DONT &&
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800318 inet_csk(sk)->icsk_pmtu_cookie > mtu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 tcp_sync_mss(sk, mtu);
320
321 /* Resend the TCP packet because it's
322 * clear that the old packet has been
323 * dropped. This is the new "fast" path mtu
324 * discovery.
325 */
326 tcp_simple_retransmit(sk);
327 } /* else let the usual retransmit timer handle it */
328}
329
330/*
331 * This routine is called by the ICMP module when it gets some
332 * sort of error condition. If err < 0 then the socket should
333 * be closed and the error returned to the user. If err > 0
334 * it's just the icmp type << 8 | icmp code. After adjustment
335 * header points to the first 8 bytes of the tcp header. We need
336 * to find the appropriate port.
337 *
338 * The locking strategy used here is very "optimistic". When
339 * someone else accesses the socket the ICMP is just dropped
340 * and for some paths there is no check at all.
341 * A more general error queue to queue errors for later handling
342 * is probably better.
343 *
344 */
345
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000346void tcp_v4_err(struct sk_buff *icmp_skb, u32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000348 const struct iphdr *iph = (const struct iphdr *)icmp_skb->data;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000349 struct tcphdr *th = (struct tcphdr *)(icmp_skb->data + (iph->ihl << 2));
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000350 struct inet_connection_sock *icsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 struct tcp_sock *tp;
352 struct inet_sock *inet;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000353 const int type = icmp_hdr(icmp_skb)->type;
354 const int code = icmp_hdr(icmp_skb)->code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 struct sock *sk;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000356 struct sk_buff *skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 __u32 seq;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000358 __u32 remaining;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 int err;
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000360 struct net *net = dev_net(icmp_skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000362 if (icmp_skb->len < (iph->ihl << 2) + 8) {
Pavel Emelyanovdcfc23c2008-07-14 23:03:00 -0700363 ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 return;
365 }
366
Pavel Emelyanovfd54d712008-07-14 23:01:40 -0700367 sk = inet_lookup(net, &tcp_hashinfo, iph->daddr, th->dest,
Damian Lukowski4d1a2d92009-08-26 00:16:27 +0000368 iph->saddr, th->source, inet_iif(icmp_skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 if (!sk) {
Pavel Emelyanovdcfc23c2008-07-14 23:03:00 -0700370 ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 return;
372 }
373 if (sk->sk_state == TCP_TIME_WAIT) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700374 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 return;
376 }
377
378 bh_lock_sock(sk);
379 /* If too many ICMPs get dropped on busy
380 * servers this needs to be solved differently.
381 */
382 if (sock_owned_by_user(sk))
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700383 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384
385 if (sk->sk_state == TCP_CLOSE)
386 goto out;
387
stephen hemminger97e3ecd2010-03-18 11:27:32 +0000388 if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
389 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
390 goto out;
391 }
392
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000393 icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 tp = tcp_sk(sk);
395 seq = ntohl(th->seq);
396 if (sk->sk_state != TCP_LISTEN &&
397 !between(seq, tp->snd_una, tp->snd_nxt)) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700398 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 goto out;
400 }
401
402 switch (type) {
403 case ICMP_SOURCE_QUENCH:
404 /* Just silently ignore these. */
405 goto out;
406 case ICMP_PARAMETERPROB:
407 err = EPROTO;
408 break;
409 case ICMP_DEST_UNREACH:
410 if (code > NR_ICMP_UNREACH)
411 goto out;
412
413 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
414 if (!sock_owned_by_user(sk))
415 do_pmtu_discovery(sk, iph, info);
416 goto out;
417 }
418
419 err = icmp_err_convert[code].errno;
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000420 /* check if icmp_skb allows revert of backoff
421 * (see draft-zimmermann-tcp-lcd) */
422 if (code != ICMP_NET_UNREACH && code != ICMP_HOST_UNREACH)
423 break;
424 if (seq != tp->snd_una || !icsk->icsk_retransmits ||
425 !icsk->icsk_backoff)
426 break;
427
David S. Miller8f49c272010-11-12 13:35:00 -0800428 if (sock_owned_by_user(sk))
429 break;
430
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000431 icsk->icsk_backoff--;
432 inet_csk(sk)->icsk_rto = __tcp_set_rto(tp) <<
433 icsk->icsk_backoff;
434 tcp_bound_rto(sk);
435
436 skb = tcp_write_queue_head(sk);
437 BUG_ON(!skb);
438
439 remaining = icsk->icsk_rto - min(icsk->icsk_rto,
440 tcp_time_stamp - TCP_SKB_CB(skb)->when);
441
442 if (remaining) {
443 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
444 remaining, TCP_RTO_MAX);
Damian Lukowskif1ecd5d2009-08-26 00:16:31 +0000445 } else {
446 /* RTO revert clocked out retransmission.
447 * Will retransmit now */
448 tcp_retransmit_timer(sk);
449 }
450
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 break;
452 case ICMP_TIME_EXCEEDED:
453 err = EHOSTUNREACH;
454 break;
455 default:
456 goto out;
457 }
458
459 switch (sk->sk_state) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700460 struct request_sock *req, **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 case TCP_LISTEN:
462 if (sock_owned_by_user(sk))
463 goto out;
464
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700465 req = inet_csk_search_req(sk, &prev, th->dest,
466 iph->daddr, iph->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 if (!req)
468 goto out;
469
470 /* ICMPs are not backlogged, hence we cannot get
471 an established socket here.
472 */
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700473 WARN_ON(req->sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700475 if (seq != tcp_rsk(req)->snt_isn) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700476 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 goto out;
478 }
479
480 /*
481 * Still in SYN_RECV, just remove it silently.
482 * There is no good way to pass the error to the newly
483 * created socket, and POSIX does not want network
484 * errors returned from accept().
485 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700486 inet_csk_reqsk_queue_drop(sk, req, prev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 goto out;
488
489 case TCP_SYN_SENT:
490 case TCP_SYN_RECV: /* Cannot happen.
491 It can f.e. if SYNs crossed.
492 */
493 if (!sock_owned_by_user(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 sk->sk_err = err;
495
496 sk->sk_error_report(sk);
497
498 tcp_done(sk);
499 } else {
500 sk->sk_err_soft = err;
501 }
502 goto out;
503 }
504
505 /* If we've already connected we will keep trying
506 * until we time out, or the user gives up.
507 *
508 * rfc1122 4.2.3.9 allows to consider as hard errors
509 * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
510 * but it is obsoleted by pmtu discovery).
511 *
512 * Note, that in modern internet, where routing is unreliable
513 * and in each dark corner broken firewalls sit, sending random
514 * errors ordered by their masters even this two messages finally lose
515 * their original sense (even Linux sends invalid PORT_UNREACHs)
516 *
517 * Now we are in compliance with RFCs.
518 * --ANK (980905)
519 */
520
521 inet = inet_sk(sk);
522 if (!sock_owned_by_user(sk) && inet->recverr) {
523 sk->sk_err = err;
524 sk->sk_error_report(sk);
525 } else { /* Only an error on timeout */
526 sk->sk_err_soft = err;
527 }
528
529out:
530 bh_unlock_sock(sk);
531 sock_put(sk);
532}
533
Herbert Xu419f9f82010-04-11 02:15:53 +0000534static void __tcp_v4_send_check(struct sk_buff *skb,
535 __be32 saddr, __be32 daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700537 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538
Patrick McHardy84fa7932006-08-29 16:44:56 -0700539 if (skb->ip_summed == CHECKSUM_PARTIAL) {
Herbert Xu419f9f82010-04-11 02:15:53 +0000540 th->check = ~tcp_v4_check(skb->len, saddr, daddr, 0);
Herbert Xu663ead32007-04-09 11:59:07 -0700541 skb->csum_start = skb_transport_header(skb) - skb->head;
Al Viroff1dcad2006-11-20 18:07:29 -0800542 skb->csum_offset = offsetof(struct tcphdr, check);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 } else {
Herbert Xu419f9f82010-04-11 02:15:53 +0000544 th->check = tcp_v4_check(skb->len, saddr, daddr,
Joe Perches07f07572008-11-19 15:44:53 -0800545 csum_partial(th,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 th->doff << 2,
547 skb->csum));
548 }
549}
550
Herbert Xu419f9f82010-04-11 02:15:53 +0000551/* This routine computes an IPv4 TCP checksum. */
Herbert Xubb296242010-04-11 02:15:55 +0000552void tcp_v4_send_check(struct sock *sk, struct sk_buff *skb)
Herbert Xu419f9f82010-04-11 02:15:53 +0000553{
554 struct inet_sock *inet = inet_sk(sk);
555
556 __tcp_v4_send_check(skb, inet->inet_saddr, inet->inet_daddr);
557}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000558EXPORT_SYMBOL(tcp_v4_send_check);
Herbert Xu419f9f82010-04-11 02:15:53 +0000559
Herbert Xua430a432006-07-08 13:34:56 -0700560int tcp_v4_gso_send_check(struct sk_buff *skb)
561{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700562 const struct iphdr *iph;
Herbert Xua430a432006-07-08 13:34:56 -0700563 struct tcphdr *th;
564
565 if (!pskb_may_pull(skb, sizeof(*th)))
566 return -EINVAL;
567
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700568 iph = ip_hdr(skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700569 th = tcp_hdr(skb);
Herbert Xua430a432006-07-08 13:34:56 -0700570
571 th->check = 0;
Patrick McHardy84fa7932006-08-29 16:44:56 -0700572 skb->ip_summed = CHECKSUM_PARTIAL;
Herbert Xu419f9f82010-04-11 02:15:53 +0000573 __tcp_v4_send_check(skb, iph->saddr, iph->daddr);
Herbert Xua430a432006-07-08 13:34:56 -0700574 return 0;
575}
576
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577/*
578 * This routine will send an RST to the other tcp.
579 *
580 * Someone asks: why I NEVER use socket parameters (TOS, TTL etc.)
581 * for reset.
582 * Answer: if a packet caused RST, it is not for a socket
583 * existing in our system, if it is matched to a socket,
584 * it is just duplicate segment or bug in other side's TCP.
585 * So that we build reply only basing on parameters
586 * arrived with segment.
587 * Exception: precedence violation. We do not implement it in any case.
588 */
589
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800590static void tcp_v4_send_reset(struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700592 struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800593 struct {
594 struct tcphdr th;
595#ifdef CONFIG_TCP_MD5SIG
Al Viro714e85b2006-11-14 20:51:49 -0800596 __be32 opt[(TCPOLEN_MD5SIG_ALIGNED >> 2)];
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800597#endif
598 } rep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 struct ip_reply_arg arg;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800600#ifdef CONFIG_TCP_MD5SIG
601 struct tcp_md5sig_key *key;
602#endif
Pavel Emelyanova86b1e32008-07-16 20:20:58 -0700603 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604
605 /* Never send a reset in response to a reset. */
606 if (th->rst)
607 return;
608
Eric Dumazet511c3f92009-06-02 05:14:27 +0000609 if (skb_rtable(skb)->rt_type != RTN_LOCAL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 return;
611
612 /* Swap the send and the receive. */
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800613 memset(&rep, 0, sizeof(rep));
614 rep.th.dest = th->source;
615 rep.th.source = th->dest;
616 rep.th.doff = sizeof(struct tcphdr) / 4;
617 rep.th.rst = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618
619 if (th->ack) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800620 rep.th.seq = th->ack_seq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800622 rep.th.ack = 1;
623 rep.th.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
624 skb->len - (th->doff << 2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 }
626
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200627 memset(&arg, 0, sizeof(arg));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800628 arg.iov[0].iov_base = (unsigned char *)&rep;
629 arg.iov[0].iov_len = sizeof(rep.th);
630
631#ifdef CONFIG_TCP_MD5SIG
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700632 key = sk ? tcp_v4_md5_do_lookup(sk, ip_hdr(skb)->daddr) : NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800633 if (key) {
634 rep.opt[0] = htonl((TCPOPT_NOP << 24) |
635 (TCPOPT_NOP << 16) |
636 (TCPOPT_MD5SIG << 8) |
637 TCPOLEN_MD5SIG);
638 /* Update length and the length the header thinks exists */
639 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
640 rep.th.doff = arg.iov[0].iov_len / 4;
641
Adam Langley49a72df2008-07-19 00:01:42 -0700642 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[1],
Ilpo Järvinen78e645c2008-10-09 14:37:47 -0700643 key, ip_hdr(skb)->saddr,
644 ip_hdr(skb)->daddr, &rep.th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800645 }
646#endif
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700647 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
648 ip_hdr(skb)->saddr, /* XXX */
Ilpo Järvinen52cd5752008-10-08 11:34:06 -0700649 arg.iov[0].iov_len, IPPROTO_TCP, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700651 arg.flags = (sk && inet_sk(sk)->transparent) ? IP_REPLY_ARG_NOSRCCHECK : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652
Eric Dumazetadf30902009-06-02 05:19:30 +0000653 net = dev_net(skb_dst(skb)->dev);
David S. Miller0a5ebb82011-05-09 13:22:43 -0700654 ip_send_reply(net->ipv4.tcp_sock, skb, ip_hdr(skb)->saddr,
Denis V. Lunev7feb49c2008-04-03 14:32:00 -0700655 &arg, arg.iov[0].iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656
Pavel Emelyanov63231bd2008-07-16 20:22:25 -0700657 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
658 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659}
660
661/* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
662 outside socket context is ugly, certainly. What can I do?
663 */
664
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900665static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
666 u32 win, u32 ts, int oif,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700667 struct tcp_md5sig_key *key,
668 int reply_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700670 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 struct {
672 struct tcphdr th;
Al Viro714e85b2006-11-14 20:51:49 -0800673 __be32 opt[(TCPOLEN_TSTAMP_ALIGNED >> 2)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800674#ifdef CONFIG_TCP_MD5SIG
Al Viro714e85b2006-11-14 20:51:49 -0800675 + (TCPOLEN_MD5SIG_ALIGNED >> 2)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800676#endif
677 ];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 } rep;
679 struct ip_reply_arg arg;
Eric Dumazetadf30902009-06-02 05:19:30 +0000680 struct net *net = dev_net(skb_dst(skb)->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681
682 memset(&rep.th, 0, sizeof(struct tcphdr));
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200683 memset(&arg, 0, sizeof(arg));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684
685 arg.iov[0].iov_base = (unsigned char *)&rep;
686 arg.iov[0].iov_len = sizeof(rep.th);
687 if (ts) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800688 rep.opt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
689 (TCPOPT_TIMESTAMP << 8) |
690 TCPOLEN_TIMESTAMP);
691 rep.opt[1] = htonl(tcp_time_stamp);
692 rep.opt[2] = htonl(ts);
Craig Schlentercb48cfe2007-01-09 00:11:15 -0800693 arg.iov[0].iov_len += TCPOLEN_TSTAMP_ALIGNED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 }
695
696 /* Swap the send and the receive. */
697 rep.th.dest = th->source;
698 rep.th.source = th->dest;
699 rep.th.doff = arg.iov[0].iov_len / 4;
700 rep.th.seq = htonl(seq);
701 rep.th.ack_seq = htonl(ack);
702 rep.th.ack = 1;
703 rep.th.window = htons(win);
704
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800705#ifdef CONFIG_TCP_MD5SIG
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800706 if (key) {
707 int offset = (ts) ? 3 : 0;
708
709 rep.opt[offset++] = htonl((TCPOPT_NOP << 24) |
710 (TCPOPT_NOP << 16) |
711 (TCPOPT_MD5SIG << 8) |
712 TCPOLEN_MD5SIG);
713 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
714 rep.th.doff = arg.iov[0].iov_len/4;
715
Adam Langley49a72df2008-07-19 00:01:42 -0700716 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[offset],
Adam Langley90b7e112008-07-31 20:49:48 -0700717 key, ip_hdr(skb)->saddr,
718 ip_hdr(skb)->daddr, &rep.th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800719 }
720#endif
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700721 arg.flags = reply_flags;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700722 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
723 ip_hdr(skb)->saddr, /* XXX */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 arg.iov[0].iov_len, IPPROTO_TCP, 0);
725 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900726 if (oif)
727 arg.bound_dev_if = oif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728
David S. Miller0a5ebb82011-05-09 13:22:43 -0700729 ip_send_reply(net->ipv4.tcp_sock, skb, ip_hdr(skb)->saddr,
Denis V. Lunev7feb49c2008-04-03 14:32:00 -0700730 &arg, arg.iov[0].iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731
Pavel Emelyanov63231bd2008-07-16 20:22:25 -0700732 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733}
734
735static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
736{
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700737 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800738 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900740 tcp_v4_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200741 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900742 tcptw->tw_ts_recent,
743 tw->tw_bound_dev_if,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700744 tcp_twsk_md5_key(tcptw),
745 tw->tw_transparent ? IP_REPLY_ARG_NOSRCCHECK : 0
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900746 );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700748 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749}
750
Gui Jianfeng6edafaa2008-08-06 23:50:04 -0700751static void tcp_v4_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200752 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753{
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900754 tcp_v4_send_ack(skb, tcp_rsk(req)->snt_isn + 1,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800755 tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900756 req->ts_recent,
757 0,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700758 tcp_v4_md5_do_lookup(sk, ip_hdr(skb)->daddr),
759 inet_rsk(req)->no_srccheck ? IP_REPLY_ARG_NOSRCCHECK : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760}
761
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762/*
Kris Katterjohn9bf1d832008-02-17 22:29:19 -0800763 * Send a SYN-ACK after having received a SYN.
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700764 * This still operates on a request_sock only, not on a big
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 * socket.
766 */
Octavian Purdila72659ec2010-01-17 19:09:39 -0800767static int tcp_v4_send_synack(struct sock *sk, struct dst_entry *dst,
768 struct request_sock *req,
769 struct request_values *rvp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700771 const struct inet_request_sock *ireq = inet_rsk(req);
David S. Miller6bd023f2011-05-18 18:32:03 -0400772 struct flowi4 fl4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 int err = -1;
774 struct sk_buff * skb;
775
776 /* First, grab a route. */
David S. Miller6bd023f2011-05-18 18:32:03 -0400777 if (!dst && (dst = inet_csk_route_req(sk, &fl4, req)) == NULL)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800778 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000780 skb = tcp_make_synack(sk, dst, req, rvp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781
782 if (skb) {
Herbert Xu419f9f82010-04-11 02:15:53 +0000783 __tcp_v4_send_check(skb, ireq->loc_addr, ireq->rmt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700785 err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,
786 ireq->rmt_addr,
787 ireq->opt);
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200788 err = net_xmit_eval(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 }
790
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 dst_release(dst);
792 return err;
793}
794
Octavian Purdila72659ec2010-01-17 19:09:39 -0800795static int tcp_v4_rtx_synack(struct sock *sk, struct request_sock *req,
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000796 struct request_values *rvp)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800797{
Octavian Purdila72659ec2010-01-17 19:09:39 -0800798 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_RETRANSSEGS);
799 return tcp_v4_send_synack(sk, NULL, req, rvp);
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800800}
801
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700803 * IPv4 request_sock destructor.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 */
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700805static void tcp_v4_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806{
Jesper Juhla51482b2005-11-08 09:41:34 -0800807 kfree(inet_rsk(req)->opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808}
809
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000810static void syn_flood_warning(const struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811{
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000812 const char *msg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000814#ifdef CONFIG_SYN_COOKIES
815 if (sysctl_tcp_syncookies)
816 msg = "Sending cookies";
817 else
Arnaldo Carvalho de Melo80e40da2006-01-04 01:58:06 -0200818#endif
Florian Westphal2a1d4bd2010-06-03 00:43:12 +0000819 msg = "Dropping request";
820
821 pr_info("TCP: Possible SYN flooding on port %d. %s.\n",
822 ntohs(tcp_hdr(skb)->dest), msg);
823}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824
825/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700826 * Save and compile IPv4 options into the request_sock if needed.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 */
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000828static struct ip_options_rcu *tcp_v4_save_options(struct sock *sk,
829 struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830{
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000831 const struct ip_options *opt = &(IPCB(skb)->opt);
832 struct ip_options_rcu *dopt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833
834 if (opt && opt->optlen) {
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000835 int opt_size = sizeof(*dopt) + opt->optlen;
836
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 dopt = kmalloc(opt_size, GFP_ATOMIC);
838 if (dopt) {
Eric Dumazetf6d8bd02011-04-21 09:45:37 +0000839 if (ip_options_echo(&dopt->opt, skb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 kfree(dopt);
841 dopt = NULL;
842 }
843 }
844 }
845 return dopt;
846}
847
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800848#ifdef CONFIG_TCP_MD5SIG
849/*
850 * RFC2385 MD5 checksumming requires a mapping of
851 * IP address->MD5 Key.
852 * We need to maintain these in the sk structure.
853 */
854
855/* Find the Key structure for an address. */
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200856static struct tcp_md5sig_key *
857 tcp_v4_md5_do_lookup(struct sock *sk, __be32 addr)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800858{
859 struct tcp_sock *tp = tcp_sk(sk);
860 int i;
861
862 if (!tp->md5sig_info || !tp->md5sig_info->entries4)
863 return NULL;
864 for (i = 0; i < tp->md5sig_info->entries4; i++) {
865 if (tp->md5sig_info->keys4[i].addr == addr)
David S. Millerf8ab18d2007-09-28 15:18:35 -0700866 return &tp->md5sig_info->keys4[i].base;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800867 }
868 return NULL;
869}
870
871struct tcp_md5sig_key *tcp_v4_md5_lookup(struct sock *sk,
872 struct sock *addr_sk)
873{
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000874 return tcp_v4_md5_do_lookup(sk, inet_sk(addr_sk)->inet_daddr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800875}
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800876EXPORT_SYMBOL(tcp_v4_md5_lookup);
877
Adrian Bunkf5b99bc2006-11-30 17:22:29 -0800878static struct tcp_md5sig_key *tcp_v4_reqsk_md5_lookup(struct sock *sk,
879 struct request_sock *req)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800880{
881 return tcp_v4_md5_do_lookup(sk, inet_rsk(req)->rmt_addr);
882}
883
884/* This can be called on a newly created socket, from other files */
885int tcp_v4_md5_do_add(struct sock *sk, __be32 addr,
886 u8 *newkey, u8 newkeylen)
887{
888 /* Add Key to the list */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700889 struct tcp_md5sig_key *key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800890 struct tcp_sock *tp = tcp_sk(sk);
891 struct tcp4_md5sig_key *keys;
892
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700893 key = tcp_v4_md5_do_lookup(sk, addr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800894 if (key) {
895 /* Pre-existing entry - just update that one. */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700896 kfree(key->key);
897 key->key = newkey;
898 key->keylen = newkeylen;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800899 } else {
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200900 struct tcp_md5sig_info *md5sig;
901
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800902 if (!tp->md5sig_info) {
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200903 tp->md5sig_info = kzalloc(sizeof(*tp->md5sig_info),
904 GFP_ATOMIC);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800905 if (!tp->md5sig_info) {
906 kfree(newkey);
907 return -ENOMEM;
908 }
Eric Dumazeta4654192010-05-16 00:36:33 -0700909 sk_nocaps_add(sk, NETIF_F_GSO_MASK);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800910 }
Wu Fengguangaa133072009-09-02 23:45:45 -0700911 if (tcp_alloc_md5sig_pool(sk) == NULL) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800912 kfree(newkey);
913 return -ENOMEM;
914 }
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200915 md5sig = tp->md5sig_info;
916
917 if (md5sig->alloced4 == md5sig->entries4) {
918 keys = kmalloc((sizeof(*keys) *
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900919 (md5sig->entries4 + 1)), GFP_ATOMIC);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800920 if (!keys) {
921 kfree(newkey);
922 tcp_free_md5sig_pool();
923 return -ENOMEM;
924 }
925
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200926 if (md5sig->entries4)
927 memcpy(keys, md5sig->keys4,
928 sizeof(*keys) * md5sig->entries4);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800929
930 /* Free old key list, and reference new one */
YOSHIFUJI Hideakia80cc202007-11-20 17:30:06 -0800931 kfree(md5sig->keys4);
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200932 md5sig->keys4 = keys;
933 md5sig->alloced4++;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800934 }
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200935 md5sig->entries4++;
David S. Millerf8ab18d2007-09-28 15:18:35 -0700936 md5sig->keys4[md5sig->entries4 - 1].addr = addr;
937 md5sig->keys4[md5sig->entries4 - 1].base.key = newkey;
938 md5sig->keys4[md5sig->entries4 - 1].base.keylen = newkeylen;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800939 }
940 return 0;
941}
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800942EXPORT_SYMBOL(tcp_v4_md5_do_add);
943
944static int tcp_v4_md5_add_func(struct sock *sk, struct sock *addr_sk,
945 u8 *newkey, u8 newkeylen)
946{
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000947 return tcp_v4_md5_do_add(sk, inet_sk(addr_sk)->inet_daddr,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800948 newkey, newkeylen);
949}
950
951int tcp_v4_md5_do_del(struct sock *sk, __be32 addr)
952{
953 struct tcp_sock *tp = tcp_sk(sk);
954 int i;
955
956 for (i = 0; i < tp->md5sig_info->entries4; i++) {
957 if (tp->md5sig_info->keys4[i].addr == addr) {
958 /* Free the key */
David S. Millerf8ab18d2007-09-28 15:18:35 -0700959 kfree(tp->md5sig_info->keys4[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800960 tp->md5sig_info->entries4--;
961
962 if (tp->md5sig_info->entries4 == 0) {
963 kfree(tp->md5sig_info->keys4);
964 tp->md5sig_info->keys4 = NULL;
Leigh Brown8228a18d2006-12-17 17:12:30 -0800965 tp->md5sig_info->alloced4 = 0;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200966 } else if (tp->md5sig_info->entries4 != i) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800967 /* Need to do some manipulation */
YOSHIFUJI Hideaki354faf02007-11-20 17:30:31 -0800968 memmove(&tp->md5sig_info->keys4[i],
969 &tp->md5sig_info->keys4[i+1],
970 (tp->md5sig_info->entries4 - i) *
971 sizeof(struct tcp4_md5sig_key));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800972 }
973 tcp_free_md5sig_pool();
974 return 0;
975 }
976 }
977 return -ENOENT;
978}
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800979EXPORT_SYMBOL(tcp_v4_md5_do_del);
980
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200981static void tcp_v4_clear_md5_list(struct sock *sk)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800982{
983 struct tcp_sock *tp = tcp_sk(sk);
984
985 /* Free each key, then the set of key keys,
986 * the crypto element, and then decrement our
987 * hold on the last resort crypto.
988 */
989 if (tp->md5sig_info->entries4) {
990 int i;
991 for (i = 0; i < tp->md5sig_info->entries4; i++)
David S. Millerf8ab18d2007-09-28 15:18:35 -0700992 kfree(tp->md5sig_info->keys4[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800993 tp->md5sig_info->entries4 = 0;
994 tcp_free_md5sig_pool();
995 }
996 if (tp->md5sig_info->keys4) {
997 kfree(tp->md5sig_info->keys4);
998 tp->md5sig_info->keys4 = NULL;
999 tp->md5sig_info->alloced4 = 0;
1000 }
1001}
1002
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001003static int tcp_v4_parse_md5_keys(struct sock *sk, char __user *optval,
1004 int optlen)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001005{
1006 struct tcp_md5sig cmd;
1007 struct sockaddr_in *sin = (struct sockaddr_in *)&cmd.tcpm_addr;
1008 u8 *newkey;
1009
1010 if (optlen < sizeof(cmd))
1011 return -EINVAL;
1012
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001013 if (copy_from_user(&cmd, optval, sizeof(cmd)))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001014 return -EFAULT;
1015
1016 if (sin->sin_family != AF_INET)
1017 return -EINVAL;
1018
1019 if (!cmd.tcpm_key || !cmd.tcpm_keylen) {
1020 if (!tcp_sk(sk)->md5sig_info)
1021 return -ENOENT;
1022 return tcp_v4_md5_do_del(sk, sin->sin_addr.s_addr);
1023 }
1024
1025 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
1026 return -EINVAL;
1027
1028 if (!tcp_sk(sk)->md5sig_info) {
1029 struct tcp_sock *tp = tcp_sk(sk);
Wu Fengguangaa133072009-09-02 23:45:45 -07001030 struct tcp_md5sig_info *p;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001031
Wu Fengguangaa133072009-09-02 23:45:45 -07001032 p = kzalloc(sizeof(*p), sk->sk_allocation);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001033 if (!p)
1034 return -EINVAL;
1035
1036 tp->md5sig_info = p;
Eric Dumazeta4654192010-05-16 00:36:33 -07001037 sk_nocaps_add(sk, NETIF_F_GSO_MASK);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001038 }
1039
Wu Fengguangaa133072009-09-02 23:45:45 -07001040 newkey = kmemdup(cmd.tcpm_key, cmd.tcpm_keylen, sk->sk_allocation);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001041 if (!newkey)
1042 return -ENOMEM;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001043 return tcp_v4_md5_do_add(sk, sin->sin_addr.s_addr,
1044 newkey, cmd.tcpm_keylen);
1045}
1046
Adam Langley49a72df2008-07-19 00:01:42 -07001047static int tcp_v4_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
1048 __be32 daddr, __be32 saddr, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001049{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001050 struct tcp4_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -07001051 struct scatterlist sg;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001052
1053 bp = &hp->md5_blk.ip4;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001054
1055 /*
Adam Langley49a72df2008-07-19 00:01:42 -07001056 * 1. the TCP pseudo-header (in the order: source IP address,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001057 * destination IP address, zero-padded protocol number, and
1058 * segment length)
1059 */
1060 bp->saddr = saddr;
1061 bp->daddr = daddr;
1062 bp->pad = 0;
YOSHIFUJI Hideaki076fb722008-04-17 12:48:12 +09001063 bp->protocol = IPPROTO_TCP;
Adam Langley49a72df2008-07-19 00:01:42 -07001064 bp->len = cpu_to_be16(nbytes);
David S. Millerc7da57a2007-10-26 00:41:21 -07001065
Adam Langley49a72df2008-07-19 00:01:42 -07001066 sg_init_one(&sg, bp, sizeof(*bp));
1067 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
1068}
1069
1070static int tcp_v4_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
1071 __be32 daddr, __be32 saddr, struct tcphdr *th)
1072{
1073 struct tcp_md5sig_pool *hp;
1074 struct hash_desc *desc;
1075
1076 hp = tcp_get_md5sig_pool();
1077 if (!hp)
1078 goto clear_hash_noput;
1079 desc = &hp->md5_desc;
1080
1081 if (crypto_hash_init(desc))
1082 goto clear_hash;
1083 if (tcp_v4_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
1084 goto clear_hash;
1085 if (tcp_md5_hash_header(hp, th))
1086 goto clear_hash;
1087 if (tcp_md5_hash_key(hp, key))
1088 goto clear_hash;
1089 if (crypto_hash_final(desc, md5_hash))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001090 goto clear_hash;
1091
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001092 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001093 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -07001094
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001095clear_hash:
1096 tcp_put_md5sig_pool();
1097clear_hash_noput:
1098 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -07001099 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001100}
1101
Adam Langley49a72df2008-07-19 00:01:42 -07001102int tcp_v4_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
1103 struct sock *sk, struct request_sock *req,
1104 struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001105{
Adam Langley49a72df2008-07-19 00:01:42 -07001106 struct tcp_md5sig_pool *hp;
1107 struct hash_desc *desc;
1108 struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001109 __be32 saddr, daddr;
1110
1111 if (sk) {
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001112 saddr = inet_sk(sk)->inet_saddr;
1113 daddr = inet_sk(sk)->inet_daddr;
Adam Langley49a72df2008-07-19 00:01:42 -07001114 } else if (req) {
1115 saddr = inet_rsk(req)->loc_addr;
1116 daddr = inet_rsk(req)->rmt_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001117 } else {
Adam Langley49a72df2008-07-19 00:01:42 -07001118 const struct iphdr *iph = ip_hdr(skb);
1119 saddr = iph->saddr;
1120 daddr = iph->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001121 }
Adam Langley49a72df2008-07-19 00:01:42 -07001122
1123 hp = tcp_get_md5sig_pool();
1124 if (!hp)
1125 goto clear_hash_noput;
1126 desc = &hp->md5_desc;
1127
1128 if (crypto_hash_init(desc))
1129 goto clear_hash;
1130
1131 if (tcp_v4_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
1132 goto clear_hash;
1133 if (tcp_md5_hash_header(hp, th))
1134 goto clear_hash;
1135 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
1136 goto clear_hash;
1137 if (tcp_md5_hash_key(hp, key))
1138 goto clear_hash;
1139 if (crypto_hash_final(desc, md5_hash))
1140 goto clear_hash;
1141
1142 tcp_put_md5sig_pool();
1143 return 0;
1144
1145clear_hash:
1146 tcp_put_md5sig_pool();
1147clear_hash_noput:
1148 memset(md5_hash, 0, 16);
1149 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001150}
Adam Langley49a72df2008-07-19 00:01:42 -07001151EXPORT_SYMBOL(tcp_v4_md5_hash_skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001152
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001153static int tcp_v4_inbound_md5_hash(struct sock *sk, struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001154{
1155 /*
1156 * This gets called for each TCP segment that arrives
1157 * so we want to be efficient.
1158 * We have 3 drop cases:
1159 * o No MD5 hash and one expected.
1160 * o MD5 hash and we're not expecting one.
1161 * o MD5 hash and its wrong.
1162 */
1163 __u8 *hash_location = NULL;
1164 struct tcp_md5sig_key *hash_expected;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001165 const struct iphdr *iph = ip_hdr(skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001166 struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001167 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001168 unsigned char newhash[16];
1169
1170 hash_expected = tcp_v4_md5_do_lookup(sk, iph->saddr);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +09001171 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001172
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001173 /* We've parsed the options - do we have a hash? */
1174 if (!hash_expected && !hash_location)
1175 return 0;
1176
1177 if (hash_expected && !hash_location) {
David S. Miller785957d2008-07-30 03:03:15 -07001178 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001179 return 1;
1180 }
1181
1182 if (!hash_expected && hash_location) {
David S. Miller785957d2008-07-30 03:03:15 -07001183 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001184 return 1;
1185 }
1186
1187 /* Okay, so this is hash_expected and hash_location -
1188 * so we need to calculate the checksum.
1189 */
Adam Langley49a72df2008-07-19 00:01:42 -07001190 genhash = tcp_v4_md5_hash_skb(newhash,
1191 hash_expected,
1192 NULL, NULL, skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001193
1194 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
1195 if (net_ratelimit()) {
Harvey Harrison673d57e2008-10-31 00:53:57 -07001196 printk(KERN_INFO "MD5 Hash failed for (%pI4, %d)->(%pI4, %d)%s\n",
1197 &iph->saddr, ntohs(th->source),
1198 &iph->daddr, ntohs(th->dest),
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001199 genhash ? " tcp_v4_calc_md5_hash failed" : "");
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001200 }
1201 return 1;
1202 }
1203 return 0;
1204}
1205
1206#endif
1207
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001208struct request_sock_ops tcp_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209 .family = PF_INET,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001210 .obj_size = sizeof(struct tcp_request_sock),
Octavian Purdila72659ec2010-01-17 19:09:39 -08001211 .rtx_syn_ack = tcp_v4_rtx_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001212 .send_ack = tcp_v4_reqsk_send_ack,
1213 .destructor = tcp_v4_reqsk_destructor,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214 .send_reset = tcp_v4_send_reset,
Octavian Purdila72659ec2010-01-17 19:09:39 -08001215 .syn_ack_timeout = tcp_syn_ack_timeout,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216};
1217
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001218#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001219static const struct tcp_request_sock_ops tcp_request_sock_ipv4_ops = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001220 .md5_lookup = tcp_v4_reqsk_md5_lookup,
John Dykstrae3afe7b2009-07-16 05:04:51 +00001221 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001222};
Andrew Mortonb6332e62006-11-30 19:16:28 -08001223#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001224
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1226{
William Allen Simpson4957faa2009-12-02 18:25:27 +00001227 struct tcp_extend_values tmp_ext;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 struct tcp_options_received tmp_opt;
William Allen Simpson4957faa2009-12-02 18:25:27 +00001229 u8 *hash_location;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001230 struct request_sock *req;
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001231 struct inet_request_sock *ireq;
William Allen Simpson4957faa2009-12-02 18:25:27 +00001232 struct tcp_sock *tp = tcp_sk(sk);
William Allen Simpsone6b4d112009-12-02 18:07:39 +00001233 struct dst_entry *dst = NULL;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001234 __be32 saddr = ip_hdr(skb)->saddr;
1235 __be32 daddr = ip_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236 __u32 isn = TCP_SKB_CB(skb)->when;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237#ifdef CONFIG_SYN_COOKIES
1238 int want_cookie = 0;
1239#else
1240#define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */
1241#endif
1242
1243 /* Never answer to SYNs send to broadcast or multicast */
Eric Dumazet511c3f92009-06-02 05:14:27 +00001244 if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 goto drop;
1246
1247 /* TW buckets are converted to open requests without
1248 * limitations, they conserve resources and peer is
1249 * evidently real one.
1250 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001251 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
Florian Westphal2a1d4bd2010-06-03 00:43:12 +00001252 if (net_ratelimit())
1253 syn_flood_warning(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254#ifdef CONFIG_SYN_COOKIES
1255 if (sysctl_tcp_syncookies) {
1256 want_cookie = 1;
1257 } else
1258#endif
1259 goto drop;
1260 }
1261
1262 /* Accept backlog is full. If we have already queued enough
1263 * of warm entries in syn queue, drop request. It is better than
1264 * clogging syn queue with openreqs with exponentially increasing
1265 * timeout.
1266 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001267 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 goto drop;
1269
Arnaldo Carvalho de Meloce4a7d02008-06-10 12:39:35 -07001270 req = inet_reqsk_alloc(&tcp_request_sock_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271 if (!req)
1272 goto drop;
1273
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001274#ifdef CONFIG_TCP_MD5SIG
1275 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv4_ops;
1276#endif
1277
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 tcp_clear_options(&tmp_opt);
William Allen Simpsonbee7ca92009-11-10 09:51:18 +00001279 tmp_opt.mss_clamp = TCP_MSS_DEFAULT;
William Allen Simpson4957faa2009-12-02 18:25:27 +00001280 tmp_opt.user_mss = tp->rx_opt.user_mss;
David S. Millerbb5b7c12009-12-15 20:56:42 -08001281 tcp_parse_options(skb, &tmp_opt, &hash_location, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282
William Allen Simpson4957faa2009-12-02 18:25:27 +00001283 if (tmp_opt.cookie_plus > 0 &&
1284 tmp_opt.saw_tstamp &&
1285 !tp->rx_opt.cookie_out_never &&
1286 (sysctl_tcp_cookie_size > 0 ||
1287 (tp->cookie_values != NULL &&
1288 tp->cookie_values->cookie_desired > 0))) {
1289 u8 *c;
1290 u32 *mess = &tmp_ext.cookie_bakery[COOKIE_DIGEST_WORDS];
1291 int l = tmp_opt.cookie_plus - TCPOLEN_COOKIE_BASE;
1292
1293 if (tcp_cookie_generator(&tmp_ext.cookie_bakery[0]) != 0)
1294 goto drop_and_release;
1295
1296 /* Secret recipe starts with IP addresses */
Eric Dumazet0eae88f2010-04-20 19:06:52 -07001297 *mess++ ^= (__force u32)daddr;
1298 *mess++ ^= (__force u32)saddr;
William Allen Simpson4957faa2009-12-02 18:25:27 +00001299
1300 /* plus variable length Initiator Cookie */
1301 c = (u8 *)mess;
1302 while (l-- > 0)
1303 *c++ ^= *hash_location++;
1304
1305#ifdef CONFIG_SYN_COOKIES
1306 want_cookie = 0; /* not our kind of cookie */
1307#endif
1308 tmp_ext.cookie_out_never = 0; /* false */
1309 tmp_ext.cookie_plus = tmp_opt.cookie_plus;
1310 } else if (!tp->rx_opt.cookie_in_always) {
1311 /* redundant indications, but ensure initialization. */
1312 tmp_ext.cookie_out_never = 1; /* true */
1313 tmp_ext.cookie_plus = 0;
1314 } else {
1315 goto drop_and_release;
1316 }
1317 tmp_ext.cookie_in_always = tp->rx_opt.cookie_in_always;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318
Florian Westphal4dfc2812008-04-10 03:12:40 -07001319 if (want_cookie && !tmp_opt.saw_tstamp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 tcp_clear_options(&tmp_opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323 tcp_openreq_init(req, &tmp_opt, skb);
1324
David S. Millerbb5b7c12009-12-15 20:56:42 -08001325 ireq = inet_rsk(req);
1326 ireq->loc_addr = daddr;
1327 ireq->rmt_addr = saddr;
1328 ireq->no_srccheck = inet_sk(sk)->transparent;
1329 ireq->opt = tcp_v4_save_options(sk, skb);
1330
Paul Moore284904a2009-03-27 17:10:28 -04001331 if (security_inet_conn_request(sk, skb, req))
David S. Millerbb5b7c12009-12-15 20:56:42 -08001332 goto drop_and_free;
Paul Moore284904a2009-03-27 17:10:28 -04001333
Florian Westphal172d69e2010-06-21 11:48:45 +00001334 if (!want_cookie || tmp_opt.tstamp_ok)
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001335 TCP_ECN_create_request(req, tcp_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336
1337 if (want_cookie) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 isn = cookie_v4_init_sequence(sk, skb, &req->mss);
Florian Westphal172d69e2010-06-21 11:48:45 +00001339 req->cookie_ts = tmp_opt.tstamp_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340 } else if (!isn) {
1341 struct inet_peer *peer = NULL;
David S. Miller6bd023f2011-05-18 18:32:03 -04001342 struct flowi4 fl4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343
1344 /* VJ's idea. We save last timestamp seen
1345 * from the destination in peer table, when entering
1346 * state TIME-WAIT, and check against it before
1347 * accepting new connection request.
1348 *
1349 * If "isn" is not zero, this request hit alive
1350 * timewait bucket, so that all the necessary checks
1351 * are made in the function processing timewait state.
1352 */
1353 if (tmp_opt.saw_tstamp &&
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001354 tcp_death_row.sysctl_tw_recycle &&
David S. Miller6bd023f2011-05-18 18:32:03 -04001355 (dst = inet_csk_route_req(sk, &fl4, req)) != NULL &&
David S. Millered2361e2011-05-18 18:38:54 -04001356 fl4.daddr == saddr &&
1357 (peer = rt_get_peer((struct rtable *)dst, fl4.daddr)) != NULL) {
Eric Dumazet317fe0e2010-06-16 04:52:13 +00001358 inet_peer_refcheck(peer);
Eric Dumazet2c1409a2009-11-12 09:33:09 +00001359 if ((u32)get_seconds() - peer->tcp_ts_stamp < TCP_PAWS_MSL &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 (s32)(peer->tcp_ts - req->ts_recent) >
1361 TCP_PAWS_WINDOW) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001362 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001363 goto drop_and_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 }
1365 }
1366 /* Kill the following clause, if you dislike this way. */
1367 else if (!sysctl_tcp_syncookies &&
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001368 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 (sysctl_max_syn_backlog >> 2)) &&
1370 (!peer || !peer->tcp_ts_stamp) &&
1371 (!dst || !dst_metric(dst, RTAX_RTT))) {
1372 /* Without syncookies last quarter of
1373 * backlog is filled with destinations,
1374 * proven to be alive.
1375 * It means that we continue to communicate
1376 * to destinations, already remembered
1377 * to the moment of synflood.
1378 */
Harvey Harrison673d57e2008-10-31 00:53:57 -07001379 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open request from %pI4/%u\n",
1380 &saddr, ntohs(tcp_hdr(skb)->source));
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001381 goto drop_and_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 }
1383
Gerrit Renkera94f7232006-11-10 14:06:49 -08001384 isn = tcp_v4_init_sequence(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 }
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001386 tcp_rsk(req)->snt_isn = isn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387
Octavian Purdila72659ec2010-01-17 19:09:39 -08001388 if (tcp_v4_send_synack(sk, dst, req,
1389 (struct request_values *)&tmp_ext) ||
William Allen Simpson4957faa2009-12-02 18:25:27 +00001390 want_cookie)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391 goto drop_and_free;
1392
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001393 inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 return 0;
1395
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001396drop_and_release:
1397 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398drop_and_free:
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001399 reqsk_free(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400drop:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401 return 0;
1402}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001403EXPORT_SYMBOL(tcp_v4_conn_request);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404
1405
1406/*
1407 * The three way handshake has completed - we got a valid synack -
1408 * now create the new socket.
1409 */
1410struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001411 struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412 struct dst_entry *dst)
1413{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001414 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415 struct inet_sock *newinet;
1416 struct tcp_sock *newtp;
1417 struct sock *newsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001418#ifdef CONFIG_TCP_MD5SIG
1419 struct tcp_md5sig_key *key;
1420#endif
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001421 struct ip_options_rcu *inet_opt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422
1423 if (sk_acceptq_is_full(sk))
1424 goto exit_overflow;
1425
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 newsk = tcp_create_openreq_child(sk, req, skb);
1427 if (!newsk)
Balazs Scheidler093d2822010-10-21 13:06:43 +02001428 goto exit_nonewsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429
Herbert Xubcd76112006-06-30 13:36:35 -07001430 newsk->sk_gso_type = SKB_GSO_TCPV4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431
1432 newtp = tcp_sk(newsk);
1433 newinet = inet_sk(newsk);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001434 ireq = inet_rsk(req);
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001435 newinet->inet_daddr = ireq->rmt_addr;
1436 newinet->inet_rcv_saddr = ireq->loc_addr;
1437 newinet->inet_saddr = ireq->loc_addr;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001438 inet_opt = ireq->opt;
1439 rcu_assign_pointer(newinet->inet_opt, inet_opt);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001440 ireq->opt = NULL;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001441 newinet->mc_index = inet_iif(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001442 newinet->mc_ttl = ip_hdr(skb)->ttl;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001443 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Eric Dumazetf6d8bd02011-04-21 09:45:37 +00001444 if (inet_opt)
1445 inet_csk(newsk)->icsk_ext_hdr_len = inet_opt->opt.optlen;
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001446 newinet->inet_id = newtp->write_seq ^ jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447
David S. Miller0e734412011-05-08 15:28:03 -07001448 if (!dst && (dst = inet_csk_route_child_sock(sk, newsk, req)) == NULL)
1449 goto put_and_exit;
1450
1451 sk_setup_caps(newsk, dst);
1452
John Heffner5d424d52006-03-20 17:53:41 -08001453 tcp_mtup_init(newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454 tcp_sync_mss(newsk, dst_mtu(dst));
David S. Miller0dbaee32010-12-13 12:52:14 -08001455 newtp->advmss = dst_metric_advmss(dst);
Tom Quetchenbachf5fff5d2008-09-21 00:21:51 -07001456 if (tcp_sk(sk)->rx_opt.user_mss &&
1457 tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1458 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1459
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 tcp_initialize_rcv_mss(newsk);
1461
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001462#ifdef CONFIG_TCP_MD5SIG
1463 /* Copy over the MD5 key from the original socket */
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001464 key = tcp_v4_md5_do_lookup(sk, newinet->inet_daddr);
1465 if (key != NULL) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001466 /*
1467 * We're using one, so create a matching key
1468 * on the newsk structure. If we fail to get
1469 * memory, then we end up not copying the key
1470 * across. Shucks.
1471 */
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -02001472 char *newkey = kmemdup(key->key, key->keylen, GFP_ATOMIC);
1473 if (newkey != NULL)
Eric Dumazetc720c7e2009-10-15 06:30:45 +00001474 tcp_v4_md5_do_add(newsk, newinet->inet_daddr,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001475 newkey, key->keylen);
Eric Dumazeta4654192010-05-16 00:36:33 -07001476 sk_nocaps_add(newsk, NETIF_F_GSO_MASK);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001477 }
1478#endif
1479
David S. Miller0e734412011-05-08 15:28:03 -07001480 if (__inet_inherit_port(sk, newsk) < 0)
1481 goto put_and_exit;
Eric Dumazet9327f702009-12-04 03:46:54 +00001482 __inet_hash_nolisten(newsk, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483
1484 return newsk;
1485
1486exit_overflow:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001487 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Balazs Scheidler093d2822010-10-21 13:06:43 +02001488exit_nonewsk:
1489 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490exit:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001491 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492 return NULL;
David S. Miller0e734412011-05-08 15:28:03 -07001493put_and_exit:
1494 sock_put(newsk);
1495 goto exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001497EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498
1499static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
1500{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001501 struct tcphdr *th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001502 const struct iphdr *iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503 struct sock *nsk;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001504 struct request_sock **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505 /* Find possible connection requests. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001506 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
1507 iph->saddr, iph->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 if (req)
1509 return tcp_check_req(sk, skb, req, prev);
1510
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001511 nsk = inet_lookup_established(sock_net(sk), &tcp_hashinfo, iph->saddr,
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001512 th->source, iph->daddr, th->dest, inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513
1514 if (nsk) {
1515 if (nsk->sk_state != TCP_TIME_WAIT) {
1516 bh_lock_sock(nsk);
1517 return nsk;
1518 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001519 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520 return NULL;
1521 }
1522
1523#ifdef CONFIG_SYN_COOKIES
Florian Westphalaf9b4732010-06-03 00:43:44 +00001524 if (!th->syn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
1526#endif
1527 return sk;
1528}
1529
Al Virob51655b2006-11-14 21:40:42 -08001530static __sum16 tcp_v4_checksum_init(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001532 const struct iphdr *iph = ip_hdr(skb);
1533
Patrick McHardy84fa7932006-08-29 16:44:56 -07001534 if (skb->ip_summed == CHECKSUM_COMPLETE) {
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001535 if (!tcp_v4_check(skb->len, iph->saddr,
1536 iph->daddr, skb->csum)) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001537 skb->ip_summed = CHECKSUM_UNNECESSARY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 return 0;
Herbert Xufb286bb2005-11-10 13:01:24 -08001539 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540 }
Herbert Xufb286bb2005-11-10 13:01:24 -08001541
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001542 skb->csum = csum_tcpudp_nofold(iph->saddr, iph->daddr,
Herbert Xufb286bb2005-11-10 13:01:24 -08001543 skb->len, IPPROTO_TCP, 0);
1544
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545 if (skb->len <= 76) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001546 return __skb_checksum_complete(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547 }
1548 return 0;
1549}
1550
1551
1552/* The socket must have it's spinlock held when we get
1553 * here.
1554 *
1555 * We have a potential double-lock case here, so even when
1556 * doing backlog processing we use the BH locking scheme.
1557 * This is because we cannot sleep with the original spinlock
1558 * held.
1559 */
1560int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1561{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001562 struct sock *rsk;
1563#ifdef CONFIG_TCP_MD5SIG
1564 /*
1565 * We really want to reject the packet as early as possible
1566 * if:
1567 * o We're expecting an MD5'd packet and this is no MD5 tcp option
1568 * o There is an MD5 option and we're not expecting one
1569 */
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001570 if (tcp_v4_inbound_md5_hash(sk, skb))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001571 goto discard;
1572#endif
1573
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
Eric Dumazetca551582010-06-03 09:03:58 +00001575 sock_rps_save_rxhash(sk, skb->rxhash);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001576 if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001577 rsk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001579 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 return 0;
1581 }
1582
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07001583 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 goto csum_err;
1585
1586 if (sk->sk_state == TCP_LISTEN) {
1587 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
1588 if (!nsk)
1589 goto discard;
1590
1591 if (nsk != sk) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001592 if (tcp_child_process(sk, nsk, skb)) {
1593 rsk = nsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001595 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596 return 0;
1597 }
Eric Dumazetca551582010-06-03 09:03:58 +00001598 } else
1599 sock_rps_save_rxhash(sk, skb->rxhash);
1600
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001601 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001602 rsk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001604 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605 return 0;
1606
1607reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001608 tcp_v4_send_reset(rsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609discard:
1610 kfree_skb(skb);
1611 /* Be careful here. If this function gets more complicated and
1612 * gcc suffers from register pressure on the x86, sk (in %ebx)
1613 * might be destroyed here. This current version compiles correctly,
1614 * but you have been warned.
1615 */
1616 return 0;
1617
1618csum_err:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001619 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 goto discard;
1621}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001622EXPORT_SYMBOL(tcp_v4_do_rcv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623
1624/*
1625 * From tcp_input.c
1626 */
1627
1628int tcp_v4_rcv(struct sk_buff *skb)
1629{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001630 const struct iphdr *iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 struct tcphdr *th;
1632 struct sock *sk;
1633 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001634 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635
1636 if (skb->pkt_type != PACKET_HOST)
1637 goto discard_it;
1638
1639 /* Count it even if it's bad */
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001640 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641
1642 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1643 goto discard_it;
1644
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001645 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646
1647 if (th->doff < sizeof(struct tcphdr) / 4)
1648 goto bad_packet;
1649 if (!pskb_may_pull(skb, th->doff * 4))
1650 goto discard_it;
1651
1652 /* An explanation is required here, I think.
1653 * Packet length and doff are validated by header prediction,
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -08001654 * provided case of th->doff==0 is eliminated.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655 * So, we defer the checks. */
Herbert Xu60476372007-04-09 11:59:39 -07001656 if (!skb_csum_unnecessary(skb) && tcp_v4_checksum_init(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657 goto bad_packet;
1658
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001659 th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001660 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1662 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1663 skb->len - th->doff * 4);
1664 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1665 TCP_SKB_CB(skb)->when = 0;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001666 TCP_SKB_CB(skb)->flags = iph->tos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 TCP_SKB_CB(skb)->sacked = 0;
1668
Arnaldo Carvalho de Melo9a1f27c2008-10-07 11:41:57 -07001669 sk = __inet_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 if (!sk)
1671 goto no_tcp_socket;
1672
Eric Dumazetbb134d52010-03-09 05:55:56 +00001673process:
1674 if (sk->sk_state == TCP_TIME_WAIT)
1675 goto do_time_wait;
1676
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001677 if (unlikely(iph->ttl < inet_sk(sk)->min_ttl)) {
1678 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
Stephen Hemmingerd218d112010-01-11 16:28:01 -08001679 goto discard_and_relse;
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001680 }
Stephen Hemmingerd218d112010-01-11 16:28:01 -08001681
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1683 goto discard_and_relse;
Patrick McHardyb59c2702006-01-06 23:06:10 -08001684 nf_reset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001686 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687 goto discard_and_relse;
1688
1689 skb->dev = NULL;
1690
Ingo Molnarc6366182006-07-03 00:25:13 -07001691 bh_lock_sock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 ret = 0;
1693 if (!sock_owned_by_user(sk)) {
Chris Leech1a2449a2006-05-23 18:05:53 -07001694#ifdef CONFIG_NET_DMA
1695 struct tcp_sock *tp = tcp_sk(sk);
1696 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
Dan Williamsf67b4592009-01-06 11:38:15 -07001697 tp->ucopy.dma_chan = dma_find_channel(DMA_MEMCPY);
Chris Leech1a2449a2006-05-23 18:05:53 -07001698 if (tp->ucopy.dma_chan)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 ret = tcp_v4_do_rcv(sk, skb);
Chris Leech1a2449a2006-05-23 18:05:53 -07001700 else
1701#endif
1702 {
1703 if (!tcp_prequeue(sk, skb))
Shan Weiae8d7f82009-05-05 01:01:29 +00001704 ret = tcp_v4_do_rcv(sk, skb);
Chris Leech1a2449a2006-05-23 18:05:53 -07001705 }
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001706 } else if (unlikely(sk_add_backlog(sk, skb))) {
Zhu Yi6b03a532010-03-04 18:01:41 +00001707 bh_unlock_sock(sk);
Eric Dumazet6cce09f2010-03-07 23:21:57 +00001708 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
Zhu Yi6b03a532010-03-04 18:01:41 +00001709 goto discard_and_relse;
1710 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711 bh_unlock_sock(sk);
1712
1713 sock_put(sk);
1714
1715 return ret;
1716
1717no_tcp_socket:
1718 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1719 goto discard_it;
1720
1721 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1722bad_packet:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001723 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001725 tcp_v4_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726 }
1727
1728discard_it:
1729 /* Discard frame. */
1730 kfree_skb(skb);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001731 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732
1733discard_and_relse:
1734 sock_put(sk);
1735 goto discard_it;
1736
1737do_time_wait:
1738 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001739 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740 goto discard_it;
1741 }
1742
1743 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001744 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001745 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746 goto discard_it;
1747 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001748 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749 case TCP_TW_SYN: {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001750 struct sock *sk2 = inet_lookup_listener(dev_net(skb->dev),
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001751 &tcp_hashinfo,
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001752 iph->daddr, th->dest,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001753 inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754 if (sk2) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001755 inet_twsk_deschedule(inet_twsk(sk), &tcp_death_row);
1756 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 sk = sk2;
1758 goto process;
1759 }
1760 /* Fall through to ACK */
1761 }
1762 case TCP_TW_ACK:
1763 tcp_v4_timewait_ack(sk, skb);
1764 break;
1765 case TCP_TW_RST:
1766 goto no_tcp_socket;
1767 case TCP_TW_SUCCESS:;
1768 }
1769 goto discard_it;
1770}
1771
David S. Miller3f419d22010-11-29 13:37:14 -08001772struct inet_peer *tcp_v4_get_peer(struct sock *sk, bool *release_it)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773{
David S. Miller3f419d22010-11-29 13:37:14 -08001774 struct rtable *rt = (struct rtable *) __sk_dst_get(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775 struct inet_sock *inet = inet_sk(sk);
David S. Miller3f419d22010-11-29 13:37:14 -08001776 struct inet_peer *peer;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777
David S. Millerc5216cc2011-05-06 22:36:30 -07001778 if (!rt ||
1779 inet->cork.fl.u.ip4.daddr != inet->inet_daddr) {
David S. Millerb534ecf2010-11-30 11:54:19 -08001780 peer = inet_getpeer_v4(inet->inet_daddr, 1);
David S. Miller3f419d22010-11-29 13:37:14 -08001781 *release_it = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782 } else {
1783 if (!rt->peer)
David S. Millera48eff12011-05-18 18:42:43 -04001784 rt_bind_peer(rt, inet->inet_daddr, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 peer = rt->peer;
David S. Miller3f419d22010-11-29 13:37:14 -08001786 *release_it = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787 }
1788
David S. Miller3f419d22010-11-29 13:37:14 -08001789 return peer;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790}
David S. Miller3f419d22010-11-29 13:37:14 -08001791EXPORT_SYMBOL(tcp_v4_get_peer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792
David S. Millerccb7c412010-12-01 18:09:13 -08001793void *tcp_v4_tw_get_peer(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794{
David S. Millerccb7c412010-12-01 18:09:13 -08001795 struct inet_timewait_sock *tw = inet_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796
David S. Millerccb7c412010-12-01 18:09:13 -08001797 return inet_getpeer_v4(tw->tw_daddr, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798}
David S. Millerccb7c412010-12-01 18:09:13 -08001799EXPORT_SYMBOL(tcp_v4_tw_get_peer);
1800
1801static struct timewait_sock_ops tcp_timewait_sock_ops = {
1802 .twsk_obj_size = sizeof(struct tcp_timewait_sock),
1803 .twsk_unique = tcp_twsk_unique,
1804 .twsk_destructor= tcp_twsk_destructor,
1805 .twsk_getpeer = tcp_v4_tw_get_peer,
1806};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807
Stephen Hemminger3b401a82009-09-01 19:25:04 +00001808const struct inet_connection_sock_af_ops ipv4_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001809 .queue_xmit = ip_queue_xmit,
1810 .send_check = tcp_v4_send_check,
1811 .rebuild_header = inet_sk_rebuild_header,
1812 .conn_request = tcp_v4_conn_request,
1813 .syn_recv_sock = tcp_v4_syn_recv_sock,
David S. Miller3f419d22010-11-29 13:37:14 -08001814 .get_peer = tcp_v4_get_peer,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001815 .net_header_len = sizeof(struct iphdr),
1816 .setsockopt = ip_setsockopt,
1817 .getsockopt = ip_getsockopt,
1818 .addr2sockaddr = inet_csk_addr2sockaddr,
1819 .sockaddr_len = sizeof(struct sockaddr_in),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001820 .bind_conflict = inet_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001821#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001822 .compat_setsockopt = compat_ip_setsockopt,
1823 .compat_getsockopt = compat_ip_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001824#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825};
Eric Dumazet4bc2f182010-07-09 21:22:10 +00001826EXPORT_SYMBOL(ipv4_specific);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001828#ifdef CONFIG_TCP_MD5SIG
Stephen Hemmingerb2e4b3d2009-09-01 19:25:03 +00001829static const struct tcp_sock_af_ops tcp_sock_ipv4_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001830 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001831 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001832 .md5_add = tcp_v4_md5_add_func,
1833 .md5_parse = tcp_v4_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001834};
Andrew Mortonb6332e62006-11-30 19:16:28 -08001835#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001836
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837/* NOTE: A lot of things set to zero explicitly by call to
1838 * sk_alloc() so need not be done here.
1839 */
1840static int tcp_v4_init_sock(struct sock *sk)
1841{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001842 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843 struct tcp_sock *tp = tcp_sk(sk);
1844
1845 skb_queue_head_init(&tp->out_of_order_queue);
1846 tcp_init_xmit_timers(sk);
1847 tcp_prequeue_init(tp);
1848
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001849 icsk->icsk_rto = TCP_TIMEOUT_INIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850 tp->mdev = TCP_TIMEOUT_INIT;
1851
1852 /* So many TCP implementations out there (incorrectly) count the
1853 * initial SYN frame in their delayed-ACK and congestion control
1854 * algorithms that we must have the following bandaid to talk
1855 * efficiently to them. -DaveM
1856 */
1857 tp->snd_cwnd = 2;
1858
1859 /* See draft-stevens-tcpca-spec-01 for discussion of the
1860 * initialization of these values.
1861 */
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07001862 tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001863 tp->snd_cwnd_clamp = ~0;
William Allen Simpsonbee7ca92009-11-10 09:51:18 +00001864 tp->mss_cache = TCP_MSS_DEFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865
1866 tp->reordering = sysctl_tcp_reordering;
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001867 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868
1869 sk->sk_state = TCP_CLOSE;
1870
1871 sk->sk_write_space = sk_stream_write_space;
1872 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1873
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001874 icsk->icsk_af_ops = &ipv4_specific;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001875 icsk->icsk_sync_mss = tcp_sync_mss;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001876#ifdef CONFIG_TCP_MD5SIG
1877 tp->af_specific = &tcp_sock_ipv4_specific;
1878#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879
William Allen Simpson435cf552009-12-02 18:17:05 +00001880 /* TCP Cookie Transactions */
1881 if (sysctl_tcp_cookie_size > 0) {
1882 /* Default, cookies without s_data_payload. */
1883 tp->cookie_values =
1884 kzalloc(sizeof(*tp->cookie_values),
1885 sk->sk_allocation);
1886 if (tp->cookie_values != NULL)
1887 kref_init(&tp->cookie_values->kref);
1888 }
1889 /* Presumed zeroed, in order of appearance:
1890 * cookie_in_always, cookie_out_never,
1891 * s_data_constant, s_data_in, s_data_out
1892 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1894 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1895
Herbert Xueb4dea52008-12-29 23:04:08 -08001896 local_bh_disable();
Eric Dumazet17483762008-11-25 21:16:35 -08001897 percpu_counter_inc(&tcp_sockets_allocated);
Herbert Xueb4dea52008-12-29 23:04:08 -08001898 local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899
1900 return 0;
1901}
1902
Brian Haley7d06b2e2008-06-14 17:04:49 -07001903void tcp_v4_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904{
1905 struct tcp_sock *tp = tcp_sk(sk);
1906
1907 tcp_clear_xmit_timers(sk);
1908
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001909 tcp_cleanup_congestion_control(sk);
Stephen Hemminger317a76f2005-06-23 12:19:55 -07001910
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911 /* Cleanup up the write buffer. */
David S. Millerfe067e82007-03-07 12:12:44 -08001912 tcp_write_queue_purge(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913
1914 /* Cleans up our, hopefully empty, out_of_order_queue. */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001915 __skb_queue_purge(&tp->out_of_order_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001917#ifdef CONFIG_TCP_MD5SIG
1918 /* Clean up the MD5 key list, if any */
1919 if (tp->md5sig_info) {
1920 tcp_v4_clear_md5_list(sk);
1921 kfree(tp->md5sig_info);
1922 tp->md5sig_info = NULL;
1923 }
1924#endif
1925
Chris Leech1a2449a2006-05-23 18:05:53 -07001926#ifdef CONFIG_NET_DMA
1927 /* Cleans up our sk_async_wait_queue */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001928 __skb_queue_purge(&sk->sk_async_wait_queue);
Chris Leech1a2449a2006-05-23 18:05:53 -07001929#endif
1930
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931 /* Clean prequeue, it must be empty really */
1932 __skb_queue_purge(&tp->ucopy.prequeue);
1933
1934 /* Clean up a referenced TCP bind bucket. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001935 if (inet_csk(sk)->icsk_bind_hash)
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001936 inet_put_port(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937
1938 /*
1939 * If sendmsg cached page exists, toss it.
1940 */
1941 if (sk->sk_sndmsg_page) {
1942 __free_page(sk->sk_sndmsg_page);
1943 sk->sk_sndmsg_page = NULL;
1944 }
1945
William Allen Simpson435cf552009-12-02 18:17:05 +00001946 /* TCP Cookie Transactions */
1947 if (tp->cookie_values != NULL) {
1948 kref_put(&tp->cookie_values->kref,
1949 tcp_cookie_values_release);
1950 tp->cookie_values = NULL;
1951 }
1952
Eric Dumazet17483762008-11-25 21:16:35 -08001953 percpu_counter_dec(&tcp_sockets_allocated);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955EXPORT_SYMBOL(tcp_v4_destroy_sock);
1956
1957#ifdef CONFIG_PROC_FS
1958/* Proc filesystem TCP sock list dumping. */
1959
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001960static inline struct inet_timewait_sock *tw_head(struct hlist_nulls_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961{
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001962 return hlist_nulls_empty(head) ? NULL :
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -07001963 list_entry(head->first, struct inet_timewait_sock, tw_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964}
1965
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -07001966static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967{
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08001968 return !is_a_nulls(tw->tw_node.next) ?
1969 hlist_nulls_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970}
1971
Tom Herberta8b690f2010-06-07 00:43:42 -07001972/*
1973 * Get next listener socket follow cur. If cur is NULL, get first socket
1974 * starting from bucket given in st->bucket; when st->bucket is zero the
1975 * very first socket in the hash table is returned.
1976 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977static void *listening_get_next(struct seq_file *seq, void *cur)
1978{
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001979 struct inet_connection_sock *icsk;
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08001980 struct hlist_nulls_node *node;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 struct sock *sk = cur;
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001982 struct inet_listen_hashbucket *ilb;
Jianjun Kong5799de02008-11-03 02:49:10 -08001983 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07001984 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985
1986 if (!sk) {
Tom Herberta8b690f2010-06-07 00:43:42 -07001987 ilb = &tcp_hashinfo.listening_hash[st->bucket];
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001988 spin_lock_bh(&ilb->lock);
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08001989 sk = sk_nulls_head(&ilb->head);
Tom Herberta8b690f2010-06-07 00:43:42 -07001990 st->offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991 goto get_sk;
1992 }
Eric Dumazet5caea4e2008-11-20 00:40:07 -08001993 ilb = &tcp_hashinfo.listening_hash[st->bucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994 ++st->num;
Tom Herberta8b690f2010-06-07 00:43:42 -07001995 ++st->offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996
1997 if (st->state == TCP_SEQ_STATE_OPENREQ) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001998 struct request_sock *req = cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999
Eric Dumazet72a3eff2006-11-16 02:30:37 -08002000 icsk = inet_csk(st->syn_wait_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002001 req = req->dl_next;
2002 while (1) {
2003 while (req) {
Daniel Lezcanobdccc4c2008-07-19 00:15:13 -07002004 if (req->rsk_ops->family == st->family) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005 cur = req;
2006 goto out;
2007 }
2008 req = req->dl_next;
2009 }
Eric Dumazet72a3eff2006-11-16 02:30:37 -08002010 if (++st->sbucket >= icsk->icsk_accept_queue.listen_opt->nr_table_entries)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011 break;
2012get_req:
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002013 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002014 }
Eric Dumazet1bde5ac2010-12-23 09:32:46 -08002015 sk = sk_nulls_next(st->syn_wait_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016 st->state = TCP_SEQ_STATE_LISTENING;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002017 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002018 } else {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002019 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002020 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2021 if (reqsk_queue_len(&icsk->icsk_accept_queue))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022 goto start_req;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002023 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Eric Dumazet1bde5ac2010-12-23 09:32:46 -08002024 sk = sk_nulls_next(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002025 }
2026get_sk:
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08002027 sk_nulls_for_each_from(sk, node) {
Pavel Emelyanov8475ef92010-11-22 03:26:12 +00002028 if (!net_eq(sock_net(sk), net))
2029 continue;
2030 if (sk->sk_family == st->family) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031 cur = sk;
2032 goto out;
2033 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002034 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002035 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2036 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002037start_req:
2038 st->uid = sock_i_uid(sk);
2039 st->syn_wait_sk = sk;
2040 st->state = TCP_SEQ_STATE_OPENREQ;
2041 st->sbucket = 0;
2042 goto get_req;
2043 }
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002044 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002045 }
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002046 spin_unlock_bh(&ilb->lock);
Tom Herberta8b690f2010-06-07 00:43:42 -07002047 st->offset = 0;
Arnaldo Carvalho de Melo0f7ff922005-08-09 19:59:44 -07002048 if (++st->bucket < INET_LHTABLE_SIZE) {
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002049 ilb = &tcp_hashinfo.listening_hash[st->bucket];
2050 spin_lock_bh(&ilb->lock);
Eric Dumazetc25eb3b2008-11-23 17:22:55 -08002051 sk = sk_nulls_head(&ilb->head);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002052 goto get_sk;
2053 }
2054 cur = NULL;
2055out:
2056 return cur;
2057}
2058
2059static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
2060{
Tom Herberta8b690f2010-06-07 00:43:42 -07002061 struct tcp_iter_state *st = seq->private;
2062 void *rc;
2063
2064 st->bucket = 0;
2065 st->offset = 0;
2066 rc = listening_get_next(seq, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067
2068 while (rc && *pos) {
2069 rc = listening_get_next(seq, rc);
2070 --*pos;
2071 }
2072 return rc;
2073}
2074
Andi Kleen6eac5602008-08-28 01:08:02 -07002075static inline int empty_bucket(struct tcp_iter_state *st)
2076{
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002077 return hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].chain) &&
2078 hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].twchain);
Andi Kleen6eac5602008-08-28 01:08:02 -07002079}
2080
Tom Herberta8b690f2010-06-07 00:43:42 -07002081/*
2082 * Get first established socket starting from bucket given in st->bucket.
2083 * If st->bucket is zero, the very first socket in the hash is returned.
2084 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085static void *established_get_first(struct seq_file *seq)
2086{
Jianjun Kong5799de02008-11-03 02:49:10 -08002087 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002088 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089 void *rc = NULL;
2090
Tom Herberta8b690f2010-06-07 00:43:42 -07002091 st->offset = 0;
2092 for (; st->bucket <= tcp_hashinfo.ehash_mask; ++st->bucket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093 struct sock *sk;
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002094 struct hlist_nulls_node *node;
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -07002095 struct inet_timewait_sock *tw;
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002096 spinlock_t *lock = inet_ehash_lockp(&tcp_hashinfo, st->bucket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097
Andi Kleen6eac5602008-08-28 01:08:02 -07002098 /* Lockless fast path for the common case of empty buckets */
2099 if (empty_bucket(st))
2100 continue;
2101
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002102 spin_lock_bh(lock);
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002103 sk_nulls_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002104 if (sk->sk_family != st->family ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002105 !net_eq(sock_net(sk), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106 continue;
2107 }
2108 rc = sk;
2109 goto out;
2110 }
2111 st->state = TCP_SEQ_STATE_TIME_WAIT;
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -07002112 inet_twsk_for_each(tw, node,
Eric Dumazetdbca9b2752007-02-08 14:16:46 -08002113 &tcp_hashinfo.ehash[st->bucket].twchain) {
Pavel Emelyanov28518fc2008-03-21 15:52:00 -07002114 if (tw->tw_family != st->family ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002115 !net_eq(twsk_net(tw), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002116 continue;
2117 }
2118 rc = tw;
2119 goto out;
2120 }
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002121 spin_unlock_bh(lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002122 st->state = TCP_SEQ_STATE_ESTABLISHED;
2123 }
2124out:
2125 return rc;
2126}
2127
2128static void *established_get_next(struct seq_file *seq, void *cur)
2129{
2130 struct sock *sk = cur;
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -07002131 struct inet_timewait_sock *tw;
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002132 struct hlist_nulls_node *node;
Jianjun Kong5799de02008-11-03 02:49:10 -08002133 struct tcp_iter_state *st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002134 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002135
2136 ++st->num;
Tom Herberta8b690f2010-06-07 00:43:42 -07002137 ++st->offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138
2139 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
2140 tw = cur;
2141 tw = tw_next(tw);
2142get_tw:
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002143 while (tw && (tw->tw_family != st->family || !net_eq(twsk_net(tw), net))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144 tw = tw_next(tw);
2145 }
2146 if (tw) {
2147 cur = tw;
2148 goto out;
2149 }
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002150 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151 st->state = TCP_SEQ_STATE_ESTABLISHED;
2152
Andi Kleen6eac5602008-08-28 01:08:02 -07002153 /* Look for next non empty bucket */
Tom Herberta8b690f2010-06-07 00:43:42 -07002154 st->offset = 0;
Eric Dumazetf373b532009-10-09 00:16:19 +00002155 while (++st->bucket <= tcp_hashinfo.ehash_mask &&
Andi Kleen6eac5602008-08-28 01:08:02 -07002156 empty_bucket(st))
2157 ;
Eric Dumazetf373b532009-10-09 00:16:19 +00002158 if (st->bucket > tcp_hashinfo.ehash_mask)
Andi Kleen6eac5602008-08-28 01:08:02 -07002159 return NULL;
2160
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002161 spin_lock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002162 sk = sk_nulls_head(&tcp_hashinfo.ehash[st->bucket].chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163 } else
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002164 sk = sk_nulls_next(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002165
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002166 sk_nulls_for_each_from(sk, node) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002167 if (sk->sk_family == st->family && net_eq(sock_net(sk), net))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168 goto found;
2169 }
2170
2171 st->state = TCP_SEQ_STATE_TIME_WAIT;
Eric Dumazetdbca9b2752007-02-08 14:16:46 -08002172 tw = tw_head(&tcp_hashinfo.ehash[st->bucket].twchain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173 goto get_tw;
2174found:
2175 cur = sk;
2176out:
2177 return cur;
2178}
2179
2180static void *established_get_idx(struct seq_file *seq, loff_t pos)
2181{
Tom Herberta8b690f2010-06-07 00:43:42 -07002182 struct tcp_iter_state *st = seq->private;
2183 void *rc;
2184
2185 st->bucket = 0;
2186 rc = established_get_first(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187
2188 while (rc && pos) {
2189 rc = established_get_next(seq, rc);
2190 --pos;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002191 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192 return rc;
2193}
2194
2195static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
2196{
2197 void *rc;
Jianjun Kong5799de02008-11-03 02:49:10 -08002198 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002199
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200 st->state = TCP_SEQ_STATE_LISTENING;
2201 rc = listening_get_idx(seq, &pos);
2202
2203 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002204 st->state = TCP_SEQ_STATE_ESTABLISHED;
2205 rc = established_get_idx(seq, pos);
2206 }
2207
2208 return rc;
2209}
2210
Tom Herberta8b690f2010-06-07 00:43:42 -07002211static void *tcp_seek_last_pos(struct seq_file *seq)
2212{
2213 struct tcp_iter_state *st = seq->private;
2214 int offset = st->offset;
2215 int orig_num = st->num;
2216 void *rc = NULL;
2217
2218 switch (st->state) {
2219 case TCP_SEQ_STATE_OPENREQ:
2220 case TCP_SEQ_STATE_LISTENING:
2221 if (st->bucket >= INET_LHTABLE_SIZE)
2222 break;
2223 st->state = TCP_SEQ_STATE_LISTENING;
2224 rc = listening_get_next(seq, NULL);
2225 while (offset-- && rc)
2226 rc = listening_get_next(seq, rc);
2227 if (rc)
2228 break;
2229 st->bucket = 0;
2230 /* Fallthrough */
2231 case TCP_SEQ_STATE_ESTABLISHED:
2232 case TCP_SEQ_STATE_TIME_WAIT:
2233 st->state = TCP_SEQ_STATE_ESTABLISHED;
2234 if (st->bucket > tcp_hashinfo.ehash_mask)
2235 break;
2236 rc = established_get_first(seq);
2237 while (offset-- && rc)
2238 rc = established_get_next(seq, rc);
2239 }
2240
2241 st->num = orig_num;
2242
2243 return rc;
2244}
2245
Linus Torvalds1da177e2005-04-16 15:20:36 -07002246static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
2247{
Jianjun Kong5799de02008-11-03 02:49:10 -08002248 struct tcp_iter_state *st = seq->private;
Tom Herberta8b690f2010-06-07 00:43:42 -07002249 void *rc;
2250
2251 if (*pos && *pos == st->last_pos) {
2252 rc = tcp_seek_last_pos(seq);
2253 if (rc)
2254 goto out;
2255 }
2256
Linus Torvalds1da177e2005-04-16 15:20:36 -07002257 st->state = TCP_SEQ_STATE_LISTENING;
2258 st->num = 0;
Tom Herberta8b690f2010-06-07 00:43:42 -07002259 st->bucket = 0;
2260 st->offset = 0;
2261 rc = *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2262
2263out:
2264 st->last_pos = *pos;
2265 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266}
2267
2268static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2269{
Tom Herberta8b690f2010-06-07 00:43:42 -07002270 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002271 void *rc = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272
2273 if (v == SEQ_START_TOKEN) {
2274 rc = tcp_get_idx(seq, 0);
2275 goto out;
2276 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002277
2278 switch (st->state) {
2279 case TCP_SEQ_STATE_OPENREQ:
2280 case TCP_SEQ_STATE_LISTENING:
2281 rc = listening_get_next(seq, v);
2282 if (!rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283 st->state = TCP_SEQ_STATE_ESTABLISHED;
Tom Herberta8b690f2010-06-07 00:43:42 -07002284 st->bucket = 0;
2285 st->offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002286 rc = established_get_first(seq);
2287 }
2288 break;
2289 case TCP_SEQ_STATE_ESTABLISHED:
2290 case TCP_SEQ_STATE_TIME_WAIT:
2291 rc = established_get_next(seq, v);
2292 break;
2293 }
2294out:
2295 ++*pos;
Tom Herberta8b690f2010-06-07 00:43:42 -07002296 st->last_pos = *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002297 return rc;
2298}
2299
2300static void tcp_seq_stop(struct seq_file *seq, void *v)
2301{
Jianjun Kong5799de02008-11-03 02:49:10 -08002302 struct tcp_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002303
2304 switch (st->state) {
2305 case TCP_SEQ_STATE_OPENREQ:
2306 if (v) {
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002307 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
2308 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309 }
2310 case TCP_SEQ_STATE_LISTENING:
2311 if (v != SEQ_START_TOKEN)
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002312 spin_unlock_bh(&tcp_hashinfo.listening_hash[st->bucket].lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002313 break;
2314 case TCP_SEQ_STATE_TIME_WAIT:
2315 case TCP_SEQ_STATE_ESTABLISHED:
2316 if (v)
Eric Dumazet9db66bd2008-11-20 20:39:09 -08002317 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002318 break;
2319 }
2320}
2321
2322static int tcp_seq_open(struct inode *inode, struct file *file)
2323{
2324 struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002325 struct tcp_iter_state *s;
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002326 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002327
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002328 err = seq_open_net(inode, file, &afinfo->seq_ops,
2329 sizeof(struct tcp_iter_state));
2330 if (err < 0)
2331 return err;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002332
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002333 s = ((struct seq_file *)file->private_data)->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002334 s->family = afinfo->family;
Tom Herberta8b690f2010-06-07 00:43:42 -07002335 s->last_pos = 0;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002336 return 0;
2337}
2338
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002339int tcp_proc_register(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002340{
2341 int rc = 0;
2342 struct proc_dir_entry *p;
2343
Denis V. Lunev68fcadd2008-04-13 22:13:30 -07002344 afinfo->seq_fops.open = tcp_seq_open;
2345 afinfo->seq_fops.read = seq_read;
2346 afinfo->seq_fops.llseek = seq_lseek;
2347 afinfo->seq_fops.release = seq_release_net;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002348
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002349 afinfo->seq_ops.start = tcp_seq_start;
2350 afinfo->seq_ops.next = tcp_seq_next;
2351 afinfo->seq_ops.stop = tcp_seq_stop;
2352
Denis V. Lunev84841c32008-05-02 04:10:08 -07002353 p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net,
2354 &afinfo->seq_fops, afinfo);
2355 if (!p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002356 rc = -ENOMEM;
2357 return rc;
2358}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002359EXPORT_SYMBOL(tcp_proc_register);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002360
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002361void tcp_proc_unregister(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002362{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002363 proc_net_remove(net, afinfo->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002364}
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002365EXPORT_SYMBOL(tcp_proc_unregister);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002367static void get_openreq4(struct sock *sk, struct request_sock *req,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002368 struct seq_file *f, int i, int uid, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002369{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002370 const struct inet_request_sock *ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371 int ttd = req->expires - jiffies;
2372
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002373 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
Dan Rosenberg71338aa2011-05-23 12:17:35 +00002374 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %pK%n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002375 i,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002376 ireq->loc_addr,
Eric Dumazetc720c7e2009-10-15 06:30:45 +00002377 ntohs(inet_sk(sk)->inet_sport),
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002378 ireq->rmt_addr,
2379 ntohs(ireq->rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380 TCP_SYN_RECV,
2381 0, 0, /* could print option size, but that is af dependent. */
2382 1, /* timers active (only the expire timer) */
2383 jiffies_to_clock_t(ttd),
2384 req->retrans,
2385 uid,
2386 0, /* non standard timer */
2387 0, /* open_requests have no inode */
2388 atomic_read(&sk->sk_refcnt),
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002389 req,
2390 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002391}
2392
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002393static void get_tcp4_sock(struct sock *sk, struct seq_file *f, int i, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002394{
2395 int timer_active;
2396 unsigned long timer_expires;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002397 struct tcp_sock *tp = tcp_sk(sk);
2398 const struct inet_connection_sock *icsk = inet_csk(sk);
2399 struct inet_sock *inet = inet_sk(sk);
Eric Dumazetc720c7e2009-10-15 06:30:45 +00002400 __be32 dest = inet->inet_daddr;
2401 __be32 src = inet->inet_rcv_saddr;
2402 __u16 destp = ntohs(inet->inet_dport);
2403 __u16 srcp = ntohs(inet->inet_sport);
Eric Dumazet49d09002009-12-03 16:06:13 -08002404 int rx_queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002405
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002406 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002407 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002408 timer_expires = icsk->icsk_timeout;
2409 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002410 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002411 timer_expires = icsk->icsk_timeout;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002412 } else if (timer_pending(&sk->sk_timer)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002413 timer_active = 2;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002414 timer_expires = sk->sk_timer.expires;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002415 } else {
2416 timer_active = 0;
2417 timer_expires = jiffies;
2418 }
2419
Eric Dumazet49d09002009-12-03 16:06:13 -08002420 if (sk->sk_state == TCP_LISTEN)
2421 rx_queue = sk->sk_ack_backlog;
2422 else
2423 /*
2424 * because we dont lock socket, we might find a transient negative value
2425 */
2426 rx_queue = max_t(int, tp->rcv_nxt - tp->copied_seq, 0);
2427
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002428 seq_printf(f, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
Dan Rosenberg71338aa2011-05-23 12:17:35 +00002429 "%08X %5d %8d %lu %d %pK %lu %lu %u %u %d%n",
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002430 i, src, srcp, dest, destp, sk->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07002431 tp->write_seq - tp->snd_una,
Eric Dumazet49d09002009-12-03 16:06:13 -08002432 rx_queue,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433 timer_active,
2434 jiffies_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002435 icsk->icsk_retransmits,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002436 sock_i_uid(sk),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03002437 icsk->icsk_probes_out,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002438 sock_i_ino(sk),
2439 atomic_read(&sk->sk_refcnt), sk,
Stephen Hemminger7be87352008-06-27 20:00:19 -07002440 jiffies_to_clock_t(icsk->icsk_rto),
2441 jiffies_to_clock_t(icsk->icsk_ack.ato),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002442 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002443 tp->snd_cwnd,
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -07002444 tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002445 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002446}
2447
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002448static void get_timewait4_sock(struct inet_timewait_sock *tw,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002449 struct seq_file *f, int i, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002450{
Al Viro23f33c22006-09-27 18:43:50 -07002451 __be32 dest, src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002452 __u16 destp, srcp;
2453 int ttd = tw->tw_ttd - jiffies;
2454
2455 if (ttd < 0)
2456 ttd = 0;
2457
2458 dest = tw->tw_daddr;
2459 src = tw->tw_rcv_saddr;
2460 destp = ntohs(tw->tw_dport);
2461 srcp = ntohs(tw->tw_sport);
2462
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002463 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
Dan Rosenberg71338aa2011-05-23 12:17:35 +00002464 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK%n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
2466 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002467 atomic_read(&tw->tw_refcnt), tw, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002468}
2469
2470#define TMPSZ 150
2471
2472static int tcp4_seq_show(struct seq_file *seq, void *v)
2473{
Jianjun Kong5799de02008-11-03 02:49:10 -08002474 struct tcp_iter_state *st;
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002475 int len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002476
2477 if (v == SEQ_START_TOKEN) {
2478 seq_printf(seq, "%-*s\n", TMPSZ - 1,
2479 " sl local_address rem_address st tx_queue "
2480 "rx_queue tr tm->when retrnsmt uid timeout "
2481 "inode");
2482 goto out;
2483 }
2484 st = seq->private;
2485
2486 switch (st->state) {
2487 case TCP_SEQ_STATE_LISTENING:
2488 case TCP_SEQ_STATE_ESTABLISHED:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002489 get_tcp4_sock(v, seq, st->num, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002490 break;
2491 case TCP_SEQ_STATE_OPENREQ:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002492 get_openreq4(st->syn_wait_sk, v, seq, st->num, st->uid, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002493 break;
2494 case TCP_SEQ_STATE_TIME_WAIT:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002495 get_timewait4_sock(v, seq, st->num, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002496 break;
2497 }
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002498 seq_printf(seq, "%*s\n", TMPSZ - 1 - len, "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002499out:
2500 return 0;
2501}
2502
Linus Torvalds1da177e2005-04-16 15:20:36 -07002503static struct tcp_seq_afinfo tcp4_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002504 .name = "tcp",
2505 .family = AF_INET,
Denis V. Lunev5f4472c2008-04-13 22:13:53 -07002506 .seq_fops = {
2507 .owner = THIS_MODULE,
2508 },
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002509 .seq_ops = {
2510 .show = tcp4_seq_show,
2511 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002512};
2513
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002514static int __net_init tcp4_proc_init_net(struct net *net)
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002515{
2516 return tcp_proc_register(net, &tcp4_seq_afinfo);
2517}
2518
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00002519static void __net_exit tcp4_proc_exit_net(struct net *net)
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002520{
2521 tcp_proc_unregister(net, &tcp4_seq_afinfo);
2522}
2523
2524static struct pernet_operations tcp4_net_ops = {
2525 .init = tcp4_proc_init_net,
2526 .exit = tcp4_proc_exit_net,
2527};
2528
Linus Torvalds1da177e2005-04-16 15:20:36 -07002529int __init tcp4_proc_init(void)
2530{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002531 return register_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002532}
2533
2534void tcp4_proc_exit(void)
2535{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002536 unregister_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002537}
2538#endif /* CONFIG_PROC_FS */
2539
Herbert Xubf296b12008-12-15 23:43:36 -08002540struct sk_buff **tcp4_gro_receive(struct sk_buff **head, struct sk_buff *skb)
2541{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00002542 const struct iphdr *iph = skb_gro_network_header(skb);
Herbert Xubf296b12008-12-15 23:43:36 -08002543
2544 switch (skb->ip_summed) {
2545 case CHECKSUM_COMPLETE:
Herbert Xu86911732009-01-29 14:19:50 +00002546 if (!tcp_v4_check(skb_gro_len(skb), iph->saddr, iph->daddr,
Herbert Xubf296b12008-12-15 23:43:36 -08002547 skb->csum)) {
2548 skb->ip_summed = CHECKSUM_UNNECESSARY;
2549 break;
2550 }
2551
2552 /* fall through */
2553 case CHECKSUM_NONE:
2554 NAPI_GRO_CB(skb)->flush = 1;
2555 return NULL;
2556 }
2557
2558 return tcp_gro_receive(head, skb);
2559}
Herbert Xubf296b12008-12-15 23:43:36 -08002560
2561int tcp4_gro_complete(struct sk_buff *skb)
2562{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00002563 const struct iphdr *iph = ip_hdr(skb);
Herbert Xubf296b12008-12-15 23:43:36 -08002564 struct tcphdr *th = tcp_hdr(skb);
2565
2566 th->check = ~tcp_v4_check(skb->len - skb_transport_offset(skb),
2567 iph->saddr, iph->daddr, 0);
2568 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV4;
2569
2570 return tcp_gro_complete(skb);
2571}
Herbert Xubf296b12008-12-15 23:43:36 -08002572
Linus Torvalds1da177e2005-04-16 15:20:36 -07002573struct proto tcp_prot = {
2574 .name = "TCP",
2575 .owner = THIS_MODULE,
2576 .close = tcp_close,
2577 .connect = tcp_v4_connect,
2578 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002579 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002580 .ioctl = tcp_ioctl,
2581 .init = tcp_v4_init_sock,
2582 .destroy = tcp_v4_destroy_sock,
2583 .shutdown = tcp_shutdown,
2584 .setsockopt = tcp_setsockopt,
2585 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002586 .recvmsg = tcp_recvmsg,
Changli Gao7ba42912010-07-10 20:41:55 +00002587 .sendmsg = tcp_sendmsg,
2588 .sendpage = tcp_sendpage,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002589 .backlog_rcv = tcp_v4_do_rcv,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08002590 .hash = inet_hash,
2591 .unhash = inet_unhash,
2592 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002593 .enter_memory_pressure = tcp_enter_memory_pressure,
2594 .sockets_allocated = &tcp_sockets_allocated,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07002595 .orphan_count = &tcp_orphan_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002596 .memory_allocated = &tcp_memory_allocated,
2597 .memory_pressure = &tcp_memory_pressure,
2598 .sysctl_mem = sysctl_tcp_mem,
2599 .sysctl_wmem = sysctl_tcp_wmem,
2600 .sysctl_rmem = sysctl_tcp_rmem,
2601 .max_header = MAX_TCP_HEADER,
2602 .obj_size = sizeof(struct tcp_sock),
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002603 .slab_flags = SLAB_DESTROY_BY_RCU,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002604 .twsk_prot = &tcp_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002605 .rsk_prot = &tcp_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07002606 .h.hashinfo = &tcp_hashinfo,
Changli Gao7ba42912010-07-10 20:41:55 +00002607 .no_autobind = true,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002608#ifdef CONFIG_COMPAT
2609 .compat_setsockopt = compat_tcp_setsockopt,
2610 .compat_getsockopt = compat_tcp_getsockopt,
2611#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002612};
Eric Dumazet4bc2f182010-07-09 21:22:10 +00002613EXPORT_SYMBOL(tcp_prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002614
Denis V. Lunev046ee902008-04-03 14:31:33 -07002615
2616static int __net_init tcp_sk_init(struct net *net)
2617{
2618 return inet_ctl_sock_create(&net->ipv4.tcp_sock,
2619 PF_INET, SOCK_RAW, IPPROTO_TCP, net);
2620}
2621
2622static void __net_exit tcp_sk_exit(struct net *net)
2623{
2624 inet_ctl_sock_destroy(net->ipv4.tcp_sock);
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002625}
2626
2627static void __net_exit tcp_sk_exit_batch(struct list_head *net_exit_list)
2628{
2629 inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET);
Denis V. Lunev046ee902008-04-03 14:31:33 -07002630}
2631
2632static struct pernet_operations __net_initdata tcp_sk_ops = {
Eric W. Biedermanb099ce22009-12-03 02:29:09 +00002633 .init = tcp_sk_init,
2634 .exit = tcp_sk_exit,
2635 .exit_batch = tcp_sk_exit_batch,
Denis V. Lunev046ee902008-04-03 14:31:33 -07002636};
2637
Denis V. Lunev9b0f9762008-02-29 11:13:15 -08002638void __init tcp_v4_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002639{
Eric Dumazet5caea4e2008-11-20 00:40:07 -08002640 inet_hashinfo_init(&tcp_hashinfo);
Eric W. Biederman6a1b3052009-02-22 00:10:18 -08002641 if (register_pernet_subsys(&tcp_sk_ops))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002642 panic("Failed to create the TCP control socket.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002643}