blob: ba46769c6e97ead6e0c24cf127b20d72b87dc461 [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
54#include <linux/types.h>
55#include <linux/fcntl.h>
56#include <linux/module.h>
57#include <linux/random.h>
58#include <linux/cache.h>
59#include <linux/jhash.h>
60#include <linux/init.h>
61#include <linux/times.h>
62
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020063#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070064#include <net/icmp.h>
Arnaldo Carvalho de Melo304a1612005-08-09 19:59:20 -070065#include <net/inet_hashtables.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070066#include <net/tcp.h>
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -030067#include <net/transp_v6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070068#include <net/ipv6.h>
69#include <net/inet_common.h>
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -080070#include <net/timewait_sock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070071#include <net/xfrm.h>
Chris Leech1a2449a2006-05-23 18:05:53 -070072#include <net/netdma.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
74#include <linux/inet.h>
75#include <linux/ipv6.h>
76#include <linux/stddef.h>
77#include <linux/proc_fs.h>
78#include <linux/seq_file.h>
79
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080080#include <linux/crypto.h>
81#include <linux/scatterlist.h>
82
Brian Haleyab32ea52006-09-22 14:15:41 -070083int sysctl_tcp_tw_reuse __read_mostly;
84int sysctl_tcp_low_latency __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080087#ifdef CONFIG_TCP_MD5SIG
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -020088static struct tcp_md5sig_key *tcp_v4_md5_do_lookup(struct sock *sk,
89 __be32 addr);
Adam Langley49a72df2008-07-19 00:01:42 -070090static int tcp_v4_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
91 __be32 daddr, __be32 saddr, struct tcphdr *th);
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +090092#else
93static inline
94struct tcp_md5sig_key *tcp_v4_md5_do_lookup(struct sock *sk, __be32 addr)
95{
96 return NULL;
97}
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080098#endif
99
Arnaldo Carvalho de Melo0f7ff922005-08-09 19:59:44 -0700100struct inet_hashinfo __cacheline_aligned tcp_hashinfo = {
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200101 .lhash_lock = __RW_LOCK_UNLOCKED(tcp_hashinfo.lhash_lock),
102 .lhash_users = ATOMIC_INIT(0),
103 .lhash_wait = __WAIT_QUEUE_HEAD_INITIALIZER(tcp_hashinfo.lhash_wait),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104};
105
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}
144
145EXPORT_SYMBOL_GPL(tcp_twsk_unique);
146
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147/* This will initiate an outgoing connection. */
148int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
149{
150 struct inet_sock *inet = inet_sk(sk);
151 struct tcp_sock *tp = tcp_sk(sk);
152 struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
153 struct rtable *rt;
Al Virobada8ad2006-09-26 21:27:15 -0700154 __be32 daddr, nexthop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 int tmp;
156 int err;
157
158 if (addr_len < sizeof(struct sockaddr_in))
159 return -EINVAL;
160
161 if (usin->sin_family != AF_INET)
162 return -EAFNOSUPPORT;
163
164 nexthop = daddr = usin->sin_addr.s_addr;
165 if (inet->opt && inet->opt->srr) {
166 if (!daddr)
167 return -EINVAL;
168 nexthop = inet->opt->faddr;
169 }
170
171 tmp = ip_route_connect(&rt, nexthop, inet->saddr,
172 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
173 IPPROTO_TCP,
David S. Miller8eb90862007-02-08 02:09:21 -0800174 inet->sport, usin->sin_port, sk, 1);
Wei Dong584bdf82007-05-31 22:49:28 -0700175 if (tmp < 0) {
176 if (tmp == -ENETUNREACH)
Pavel Emelyanov7c73a6f2008-07-16 20:20:11 -0700177 IP_INC_STATS_BH(sock_net(sk), IPSTATS_MIB_OUTNOROUTES);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 return tmp;
Wei Dong584bdf82007-05-31 22:49:28 -0700179 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180
181 if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
182 ip_rt_put(rt);
183 return -ENETUNREACH;
184 }
185
186 if (!inet->opt || !inet->opt->srr)
187 daddr = rt->rt_dst;
188
189 if (!inet->saddr)
190 inet->saddr = rt->rt_src;
191 inet->rcv_saddr = inet->saddr;
192
193 if (tp->rx_opt.ts_recent_stamp && inet->daddr != daddr) {
194 /* Reset inherited state */
195 tp->rx_opt.ts_recent = 0;
196 tp->rx_opt.ts_recent_stamp = 0;
197 tp->write_seq = 0;
198 }
199
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -0700200 if (tcp_death_row.sysctl_tw_recycle &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 !tp->rx_opt.ts_recent_stamp && rt->rt_dst == daddr) {
202 struct inet_peer *peer = rt_get_peer(rt);
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200203 /*
204 * VJ's idea. We save last timestamp seen from
205 * the destination in peer table, when entering state
206 * TIME-WAIT * and initialize rx_opt.ts_recent from it,
207 * when trying new connection.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 */
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200209 if (peer != NULL &&
James Morris9d729f72007-03-04 16:12:44 -0800210 peer->tcp_ts_stamp + TCP_PAWS_MSL >= get_seconds()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp;
212 tp->rx_opt.ts_recent = peer->tcp_ts;
213 }
214 }
215
216 inet->dport = usin->sin_port;
217 inet->daddr = daddr;
218
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800219 inet_csk(sk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 if (inet->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800221 inet_csk(sk)->icsk_ext_hdr_len = inet->opt->optlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222
223 tp->rx_opt.mss_clamp = 536;
224
225 /* Socket identity is still unknown (sport may be zero).
226 * However we set state to SYN-SENT and not releasing socket
227 * lock select source port, enter ourselves into the hash tables and
228 * complete initialization after this.
229 */
230 tcp_set_state(sk, TCP_SYN_SENT);
Arnaldo Carvalho de Meloa7f5e7f2005-12-13 23:25:31 -0800231 err = inet_hash_connect(&tcp_death_row, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 if (err)
233 goto failure;
234
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200235 err = ip_route_newports(&rt, IPPROTO_TCP,
236 inet->sport, inet->dport, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 if (err)
238 goto failure;
239
240 /* OK, now commit destination to socket. */
Herbert Xubcd76112006-06-30 13:36:35 -0700241 sk->sk_gso_type = SKB_GSO_TCPV4;
Arnaldo Carvalho de Melo6cbb0df2005-08-09 19:49:02 -0700242 sk_setup_caps(sk, &rt->u.dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
244 if (!tp->write_seq)
245 tp->write_seq = secure_tcp_sequence_number(inet->saddr,
246 inet->daddr,
247 inet->sport,
248 usin->sin_port);
249
250 inet->id = tp->write_seq ^ jiffies;
251
252 err = tcp_connect(sk);
253 rt = NULL;
254 if (err)
255 goto failure;
256
257 return 0;
258
259failure:
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200260 /*
261 * This unhashes the socket and releases the local port,
262 * if necessary.
263 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 tcp_set_state(sk, TCP_CLOSE);
265 ip_rt_put(rt);
266 sk->sk_route_caps = 0;
267 inet->dport = 0;
268 return err;
269}
270
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271/*
272 * This routine does path mtu discovery as defined in RFC1191.
273 */
Stephen Hemminger40efc6f2006-01-03 16:03:49 -0800274static void do_pmtu_discovery(struct sock *sk, struct iphdr *iph, u32 mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275{
276 struct dst_entry *dst;
277 struct inet_sock *inet = inet_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278
279 /* We are not interested in TCP_LISTEN and open_requests (SYN-ACKs
280 * send out by Linux are always <576bytes so they should go through
281 * unfragmented).
282 */
283 if (sk->sk_state == TCP_LISTEN)
284 return;
285
286 /* We don't check in the destentry if pmtu discovery is forbidden
287 * on this route. We just assume that no packet_to_big packets
288 * are send back when pmtu discovery is not active.
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900289 * There is a small race when the user changes this flag in the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 * route, but I think that's acceptable.
291 */
292 if ((dst = __sk_dst_check(sk, 0)) == NULL)
293 return;
294
295 dst->ops->update_pmtu(dst, mtu);
296
297 /* Something is about to be wrong... Remember soft error
298 * for the case, if this connection will not able to recover.
299 */
300 if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
301 sk->sk_err_soft = EMSGSIZE;
302
303 mtu = dst_mtu(dst);
304
305 if (inet->pmtudisc != IP_PMTUDISC_DONT &&
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800306 inet_csk(sk)->icsk_pmtu_cookie > mtu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 tcp_sync_mss(sk, mtu);
308
309 /* Resend the TCP packet because it's
310 * clear that the old packet has been
311 * dropped. This is the new "fast" path mtu
312 * discovery.
313 */
314 tcp_simple_retransmit(sk);
315 } /* else let the usual retransmit timer handle it */
316}
317
318/*
319 * This routine is called by the ICMP module when it gets some
320 * sort of error condition. If err < 0 then the socket should
321 * be closed and the error returned to the user. If err > 0
322 * it's just the icmp type << 8 | icmp code. After adjustment
323 * header points to the first 8 bytes of the tcp header. We need
324 * to find the appropriate port.
325 *
326 * The locking strategy used here is very "optimistic". When
327 * someone else accesses the socket the ICMP is just dropped
328 * and for some paths there is no check at all.
329 * A more general error queue to queue errors for later handling
330 * is probably better.
331 *
332 */
333
334void tcp_v4_err(struct sk_buff *skb, u32 info)
335{
336 struct iphdr *iph = (struct iphdr *)skb->data;
337 struct tcphdr *th = (struct tcphdr *)(skb->data + (iph->ihl << 2));
338 struct tcp_sock *tp;
339 struct inet_sock *inet;
Arnaldo Carvalho de Melo88c76642007-03-13 14:43:18 -0300340 const int type = icmp_hdr(skb)->type;
341 const int code = icmp_hdr(skb)->code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 struct sock *sk;
343 __u32 seq;
344 int err;
Pavel Emelyanovfd54d712008-07-14 23:01:40 -0700345 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346
347 if (skb->len < (iph->ihl << 2) + 8) {
Pavel Emelyanovdcfc23c2008-07-14 23:03:00 -0700348 ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 return;
350 }
351
Pavel Emelyanovfd54d712008-07-14 23:01:40 -0700352 sk = inet_lookup(net, &tcp_hashinfo, iph->daddr, th->dest,
Pavel Emelyanovc67499c2008-01-31 05:06:40 -0800353 iph->saddr, th->source, inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 if (!sk) {
Pavel Emelyanovdcfc23c2008-07-14 23:03:00 -0700355 ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 return;
357 }
358 if (sk->sk_state == TCP_TIME_WAIT) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -0700359 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 return;
361 }
362
363 bh_lock_sock(sk);
364 /* If too many ICMPs get dropped on busy
365 * servers this needs to be solved differently.
366 */
367 if (sock_owned_by_user(sk))
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700368 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369
370 if (sk->sk_state == TCP_CLOSE)
371 goto out;
372
373 tp = tcp_sk(sk);
374 seq = ntohl(th->seq);
375 if (sk->sk_state != TCP_LISTEN &&
376 !between(seq, tp->snd_una, tp->snd_nxt)) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700377 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 goto out;
379 }
380
381 switch (type) {
382 case ICMP_SOURCE_QUENCH:
383 /* Just silently ignore these. */
384 goto out;
385 case ICMP_PARAMETERPROB:
386 err = EPROTO;
387 break;
388 case ICMP_DEST_UNREACH:
389 if (code > NR_ICMP_UNREACH)
390 goto out;
391
392 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
393 if (!sock_owned_by_user(sk))
394 do_pmtu_discovery(sk, iph, info);
395 goto out;
396 }
397
398 err = icmp_err_convert[code].errno;
399 break;
400 case ICMP_TIME_EXCEEDED:
401 err = EHOSTUNREACH;
402 break;
403 default:
404 goto out;
405 }
406
407 switch (sk->sk_state) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700408 struct request_sock *req, **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 case TCP_LISTEN:
410 if (sock_owned_by_user(sk))
411 goto out;
412
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700413 req = inet_csk_search_req(sk, &prev, th->dest,
414 iph->daddr, iph->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 if (!req)
416 goto out;
417
418 /* ICMPs are not backlogged, hence we cannot get
419 an established socket here.
420 */
Ilpo Järvinen547b7922008-07-25 21:43:18 -0700421 WARN_ON(req->sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700423 if (seq != tcp_rsk(req)->snt_isn) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700424 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 goto out;
426 }
427
428 /*
429 * Still in SYN_RECV, just remove it silently.
430 * There is no good way to pass the error to the newly
431 * created socket, and POSIX does not want network
432 * errors returned from accept().
433 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700434 inet_csk_reqsk_queue_drop(sk, req, prev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 goto out;
436
437 case TCP_SYN_SENT:
438 case TCP_SYN_RECV: /* Cannot happen.
439 It can f.e. if SYNs crossed.
440 */
441 if (!sock_owned_by_user(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 sk->sk_err = err;
443
444 sk->sk_error_report(sk);
445
446 tcp_done(sk);
447 } else {
448 sk->sk_err_soft = err;
449 }
450 goto out;
451 }
452
453 /* If we've already connected we will keep trying
454 * until we time out, or the user gives up.
455 *
456 * rfc1122 4.2.3.9 allows to consider as hard errors
457 * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
458 * but it is obsoleted by pmtu discovery).
459 *
460 * Note, that in modern internet, where routing is unreliable
461 * and in each dark corner broken firewalls sit, sending random
462 * errors ordered by their masters even this two messages finally lose
463 * their original sense (even Linux sends invalid PORT_UNREACHs)
464 *
465 * Now we are in compliance with RFCs.
466 * --ANK (980905)
467 */
468
469 inet = inet_sk(sk);
470 if (!sock_owned_by_user(sk) && inet->recverr) {
471 sk->sk_err = err;
472 sk->sk_error_report(sk);
473 } else { /* Only an error on timeout */
474 sk->sk_err_soft = err;
475 }
476
477out:
478 bh_unlock_sock(sk);
479 sock_put(sk);
480}
481
482/* This routine computes an IPv4 TCP checksum. */
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -0800483void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484{
485 struct inet_sock *inet = inet_sk(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700486 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487
Patrick McHardy84fa7932006-08-29 16:44:56 -0700488 if (skb->ip_summed == CHECKSUM_PARTIAL) {
Frederik Deweerdtba7808e2007-02-04 20:15:27 -0800489 th->check = ~tcp_v4_check(len, inet->saddr,
490 inet->daddr, 0);
Herbert Xu663ead32007-04-09 11:59:07 -0700491 skb->csum_start = skb_transport_header(skb) - skb->head;
Al Viroff1dcad2006-11-20 18:07:29 -0800492 skb->csum_offset = offsetof(struct tcphdr, check);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 } else {
Frederik Deweerdtba7808e2007-02-04 20:15:27 -0800494 th->check = tcp_v4_check(len, inet->saddr, inet->daddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 csum_partial((char *)th,
496 th->doff << 2,
497 skb->csum));
498 }
499}
500
Herbert Xua430a432006-07-08 13:34:56 -0700501int tcp_v4_gso_send_check(struct sk_buff *skb)
502{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700503 const struct iphdr *iph;
Herbert Xua430a432006-07-08 13:34:56 -0700504 struct tcphdr *th;
505
506 if (!pskb_may_pull(skb, sizeof(*th)))
507 return -EINVAL;
508
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700509 iph = ip_hdr(skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700510 th = tcp_hdr(skb);
Herbert Xua430a432006-07-08 13:34:56 -0700511
512 th->check = 0;
Frederik Deweerdtba7808e2007-02-04 20:15:27 -0800513 th->check = ~tcp_v4_check(skb->len, iph->saddr, iph->daddr, 0);
Herbert Xu663ead32007-04-09 11:59:07 -0700514 skb->csum_start = skb_transport_header(skb) - skb->head;
Al Viroff1dcad2006-11-20 18:07:29 -0800515 skb->csum_offset = offsetof(struct tcphdr, check);
Patrick McHardy84fa7932006-08-29 16:44:56 -0700516 skb->ip_summed = CHECKSUM_PARTIAL;
Herbert Xua430a432006-07-08 13:34:56 -0700517 return 0;
518}
519
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520/*
521 * This routine will send an RST to the other tcp.
522 *
523 * Someone asks: why I NEVER use socket parameters (TOS, TTL etc.)
524 * for reset.
525 * Answer: if a packet caused RST, it is not for a socket
526 * existing in our system, if it is matched to a socket,
527 * it is just duplicate segment or bug in other side's TCP.
528 * So that we build reply only basing on parameters
529 * arrived with segment.
530 * Exception: precedence violation. We do not implement it in any case.
531 */
532
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800533static void tcp_v4_send_reset(struct sock *sk, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700535 struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800536 struct {
537 struct tcphdr th;
538#ifdef CONFIG_TCP_MD5SIG
Al Viro714e85b2006-11-14 20:51:49 -0800539 __be32 opt[(TCPOLEN_MD5SIG_ALIGNED >> 2)];
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800540#endif
541 } rep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 struct ip_reply_arg arg;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800543#ifdef CONFIG_TCP_MD5SIG
544 struct tcp_md5sig_key *key;
545#endif
Pavel Emelyanova86b1e32008-07-16 20:20:58 -0700546 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547
548 /* Never send a reset in response to a reset. */
549 if (th->rst)
550 return;
551
Eric Dumazetee6b9672008-03-05 18:30:47 -0800552 if (skb->rtable->rt_type != RTN_LOCAL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 return;
554
555 /* Swap the send and the receive. */
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800556 memset(&rep, 0, sizeof(rep));
557 rep.th.dest = th->source;
558 rep.th.source = th->dest;
559 rep.th.doff = sizeof(struct tcphdr) / 4;
560 rep.th.rst = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561
562 if (th->ack) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800563 rep.th.seq = th->ack_seq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800565 rep.th.ack = 1;
566 rep.th.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
567 skb->len - (th->doff << 2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 }
569
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200570 memset(&arg, 0, sizeof(arg));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800571 arg.iov[0].iov_base = (unsigned char *)&rep;
572 arg.iov[0].iov_len = sizeof(rep.th);
573
574#ifdef CONFIG_TCP_MD5SIG
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700575 key = sk ? tcp_v4_md5_do_lookup(sk, ip_hdr(skb)->daddr) : NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800576 if (key) {
577 rep.opt[0] = htonl((TCPOPT_NOP << 24) |
578 (TCPOPT_NOP << 16) |
579 (TCPOPT_MD5SIG << 8) |
580 TCPOLEN_MD5SIG);
581 /* Update length and the length the header thinks exists */
582 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
583 rep.th.doff = arg.iov[0].iov_len / 4;
584
Adam Langley49a72df2008-07-19 00:01:42 -0700585 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[1],
586 key, ip_hdr(skb)->daddr,
587 ip_hdr(skb)->saddr, &rep.th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800588 }
589#endif
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700590 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
591 ip_hdr(skb)->saddr, /* XXX */
Ilpo Järvinen52cd5752008-10-08 11:34:06 -0700592 arg.iov[0].iov_len, IPPROTO_TCP, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700594 arg.flags = (sk && inet_sk(sk)->transparent) ? IP_REPLY_ARG_NOSRCCHECK : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
Pavel Emelyanova86b1e32008-07-16 20:20:58 -0700596 net = dev_net(skb->dst->dev);
597 ip_send_reply(net->ipv4.tcp_sock, skb,
Denis V. Lunev7feb49c2008-04-03 14:32:00 -0700598 &arg, arg.iov[0].iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599
Pavel Emelyanov63231bd2008-07-16 20:22:25 -0700600 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
601 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602}
603
604/* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
605 outside socket context is ugly, certainly. What can I do?
606 */
607
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900608static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
609 u32 win, u32 ts, int oif,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700610 struct tcp_md5sig_key *key,
611 int reply_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700613 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 struct {
615 struct tcphdr th;
Al Viro714e85b2006-11-14 20:51:49 -0800616 __be32 opt[(TCPOLEN_TSTAMP_ALIGNED >> 2)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800617#ifdef CONFIG_TCP_MD5SIG
Al Viro714e85b2006-11-14 20:51:49 -0800618 + (TCPOLEN_MD5SIG_ALIGNED >> 2)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800619#endif
620 ];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 } rep;
622 struct ip_reply_arg arg;
Vitaliy Gusev4dd79722008-10-01 01:51:39 -0700623 struct net *net = dev_net(skb->dst->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624
625 memset(&rep.th, 0, sizeof(struct tcphdr));
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200626 memset(&arg, 0, sizeof(arg));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627
628 arg.iov[0].iov_base = (unsigned char *)&rep;
629 arg.iov[0].iov_len = sizeof(rep.th);
630 if (ts) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800631 rep.opt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
632 (TCPOPT_TIMESTAMP << 8) |
633 TCPOLEN_TIMESTAMP);
634 rep.opt[1] = htonl(tcp_time_stamp);
635 rep.opt[2] = htonl(ts);
Craig Schlentercb48cfe2007-01-09 00:11:15 -0800636 arg.iov[0].iov_len += TCPOLEN_TSTAMP_ALIGNED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 }
638
639 /* Swap the send and the receive. */
640 rep.th.dest = th->source;
641 rep.th.source = th->dest;
642 rep.th.doff = arg.iov[0].iov_len / 4;
643 rep.th.seq = htonl(seq);
644 rep.th.ack_seq = htonl(ack);
645 rep.th.ack = 1;
646 rep.th.window = htons(win);
647
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800648#ifdef CONFIG_TCP_MD5SIG
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800649 if (key) {
650 int offset = (ts) ? 3 : 0;
651
652 rep.opt[offset++] = htonl((TCPOPT_NOP << 24) |
653 (TCPOPT_NOP << 16) |
654 (TCPOPT_MD5SIG << 8) |
655 TCPOLEN_MD5SIG);
656 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
657 rep.th.doff = arg.iov[0].iov_len/4;
658
Adam Langley49a72df2008-07-19 00:01:42 -0700659 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[offset],
Adam Langley90b7e112008-07-31 20:49:48 -0700660 key, ip_hdr(skb)->saddr,
661 ip_hdr(skb)->daddr, &rep.th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800662 }
663#endif
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700664 arg.flags = reply_flags;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700665 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
666 ip_hdr(skb)->saddr, /* XXX */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 arg.iov[0].iov_len, IPPROTO_TCP, 0);
668 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900669 if (oif)
670 arg.bound_dev_if = oif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671
Pavel Emelyanova86b1e32008-07-16 20:20:58 -0700672 ip_send_reply(net->ipv4.tcp_sock, skb,
Denis V. Lunev7feb49c2008-04-03 14:32:00 -0700673 &arg, arg.iov[0].iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674
Pavel Emelyanov63231bd2008-07-16 20:22:25 -0700675 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676}
677
678static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
679{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700680 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800681 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900683 tcp_v4_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200684 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900685 tcptw->tw_ts_recent,
686 tw->tw_bound_dev_if,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700687 tcp_twsk_md5_key(tcptw),
688 tw->tw_transparent ? IP_REPLY_ARG_NOSRCCHECK : 0
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900689 );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700691 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692}
693
Gui Jianfeng6edafaa2008-08-06 23:50:04 -0700694static void tcp_v4_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200695 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696{
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900697 tcp_v4_send_ack(skb, tcp_rsk(req)->snt_isn + 1,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800698 tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd,
YOSHIFUJI Hideaki9501f972008-04-18 12:45:16 +0900699 req->ts_recent,
700 0,
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -0700701 tcp_v4_md5_do_lookup(sk, ip_hdr(skb)->daddr),
702 inet_rsk(req)->no_srccheck ? IP_REPLY_ARG_NOSRCCHECK : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703}
704
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705/*
Kris Katterjohn9bf1d832008-02-17 22:29:19 -0800706 * Send a SYN-ACK after having received a SYN.
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700707 * This still operates on a request_sock only, not on a big
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 * socket.
709 */
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800710static int __tcp_v4_send_synack(struct sock *sk, struct request_sock *req,
711 struct dst_entry *dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700713 const struct inet_request_sock *ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 int err = -1;
715 struct sk_buff * skb;
716
717 /* First, grab a route. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700718 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800719 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720
721 skb = tcp_make_synack(sk, dst, req);
722
723 if (skb) {
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700724 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725
Frederik Deweerdtba7808e2007-02-04 20:15:27 -0800726 th->check = tcp_v4_check(skb->len,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700727 ireq->loc_addr,
728 ireq->rmt_addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 csum_partial((char *)th, skb->len,
730 skb->csum));
731
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700732 err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,
733 ireq->rmt_addr,
734 ireq->opt);
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200735 err = net_xmit_eval(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 }
737
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 dst_release(dst);
739 return err;
740}
741
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800742static int tcp_v4_send_synack(struct sock *sk, struct request_sock *req)
743{
744 return __tcp_v4_send_synack(sk, req, NULL);
745}
746
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700748 * IPv4 request_sock destructor.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 */
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700750static void tcp_v4_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751{
Jesper Juhla51482b2005-11-08 09:41:34 -0800752 kfree(inet_rsk(req)->opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753}
754
Arnaldo Carvalho de Melo80e40da2006-01-04 01:58:06 -0200755#ifdef CONFIG_SYN_COOKIES
Stephen Hemminger40efc6f2006-01-03 16:03:49 -0800756static void syn_flood_warning(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757{
758 static unsigned long warntime;
759
760 if (time_after(jiffies, (warntime + HZ * 60))) {
761 warntime = jiffies;
762 printk(KERN_INFO
763 "possible SYN flooding on port %d. Sending cookies.\n",
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700764 ntohs(tcp_hdr(skb)->dest));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 }
766}
Arnaldo Carvalho de Melo80e40da2006-01-04 01:58:06 -0200767#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768
769/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700770 * Save and compile IPv4 options into the request_sock if needed.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 */
Stephen Hemminger40efc6f2006-01-03 16:03:49 -0800772static struct ip_options *tcp_v4_save_options(struct sock *sk,
773 struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774{
775 struct ip_options *opt = &(IPCB(skb)->opt);
776 struct ip_options *dopt = NULL;
777
778 if (opt && opt->optlen) {
779 int opt_size = optlength(opt);
780 dopt = kmalloc(opt_size, GFP_ATOMIC);
781 if (dopt) {
782 if (ip_options_echo(dopt, skb)) {
783 kfree(dopt);
784 dopt = NULL;
785 }
786 }
787 }
788 return dopt;
789}
790
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800791#ifdef CONFIG_TCP_MD5SIG
792/*
793 * RFC2385 MD5 checksumming requires a mapping of
794 * IP address->MD5 Key.
795 * We need to maintain these in the sk structure.
796 */
797
798/* Find the Key structure for an address. */
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200799static struct tcp_md5sig_key *
800 tcp_v4_md5_do_lookup(struct sock *sk, __be32 addr)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800801{
802 struct tcp_sock *tp = tcp_sk(sk);
803 int i;
804
805 if (!tp->md5sig_info || !tp->md5sig_info->entries4)
806 return NULL;
807 for (i = 0; i < tp->md5sig_info->entries4; i++) {
808 if (tp->md5sig_info->keys4[i].addr == addr)
David S. Millerf8ab18d2007-09-28 15:18:35 -0700809 return &tp->md5sig_info->keys4[i].base;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800810 }
811 return NULL;
812}
813
814struct tcp_md5sig_key *tcp_v4_md5_lookup(struct sock *sk,
815 struct sock *addr_sk)
816{
817 return tcp_v4_md5_do_lookup(sk, inet_sk(addr_sk)->daddr);
818}
819
820EXPORT_SYMBOL(tcp_v4_md5_lookup);
821
Adrian Bunkf5b99bc2006-11-30 17:22:29 -0800822static struct tcp_md5sig_key *tcp_v4_reqsk_md5_lookup(struct sock *sk,
823 struct request_sock *req)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800824{
825 return tcp_v4_md5_do_lookup(sk, inet_rsk(req)->rmt_addr);
826}
827
828/* This can be called on a newly created socket, from other files */
829int tcp_v4_md5_do_add(struct sock *sk, __be32 addr,
830 u8 *newkey, u8 newkeylen)
831{
832 /* Add Key to the list */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700833 struct tcp_md5sig_key *key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800834 struct tcp_sock *tp = tcp_sk(sk);
835 struct tcp4_md5sig_key *keys;
836
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700837 key = tcp_v4_md5_do_lookup(sk, addr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800838 if (key) {
839 /* Pre-existing entry - just update that one. */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700840 kfree(key->key);
841 key->key = newkey;
842 key->keylen = newkeylen;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800843 } else {
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200844 struct tcp_md5sig_info *md5sig;
845
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800846 if (!tp->md5sig_info) {
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200847 tp->md5sig_info = kzalloc(sizeof(*tp->md5sig_info),
848 GFP_ATOMIC);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800849 if (!tp->md5sig_info) {
850 kfree(newkey);
851 return -ENOMEM;
852 }
David S. Miller3d7dbea2007-06-12 14:36:42 -0700853 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800854 }
855 if (tcp_alloc_md5sig_pool() == NULL) {
856 kfree(newkey);
857 return -ENOMEM;
858 }
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200859 md5sig = tp->md5sig_info;
860
861 if (md5sig->alloced4 == md5sig->entries4) {
862 keys = kmalloc((sizeof(*keys) *
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900863 (md5sig->entries4 + 1)), GFP_ATOMIC);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800864 if (!keys) {
865 kfree(newkey);
866 tcp_free_md5sig_pool();
867 return -ENOMEM;
868 }
869
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200870 if (md5sig->entries4)
871 memcpy(keys, md5sig->keys4,
872 sizeof(*keys) * md5sig->entries4);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800873
874 /* Free old key list, and reference new one */
YOSHIFUJI Hideakia80cc202007-11-20 17:30:06 -0800875 kfree(md5sig->keys4);
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200876 md5sig->keys4 = keys;
877 md5sig->alloced4++;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800878 }
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200879 md5sig->entries4++;
David S. Millerf8ab18d2007-09-28 15:18:35 -0700880 md5sig->keys4[md5sig->entries4 - 1].addr = addr;
881 md5sig->keys4[md5sig->entries4 - 1].base.key = newkey;
882 md5sig->keys4[md5sig->entries4 - 1].base.keylen = newkeylen;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800883 }
884 return 0;
885}
886
887EXPORT_SYMBOL(tcp_v4_md5_do_add);
888
889static int tcp_v4_md5_add_func(struct sock *sk, struct sock *addr_sk,
890 u8 *newkey, u8 newkeylen)
891{
892 return tcp_v4_md5_do_add(sk, inet_sk(addr_sk)->daddr,
893 newkey, newkeylen);
894}
895
896int tcp_v4_md5_do_del(struct sock *sk, __be32 addr)
897{
898 struct tcp_sock *tp = tcp_sk(sk);
899 int i;
900
901 for (i = 0; i < tp->md5sig_info->entries4; i++) {
902 if (tp->md5sig_info->keys4[i].addr == addr) {
903 /* Free the key */
David S. Millerf8ab18d2007-09-28 15:18:35 -0700904 kfree(tp->md5sig_info->keys4[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800905 tp->md5sig_info->entries4--;
906
907 if (tp->md5sig_info->entries4 == 0) {
908 kfree(tp->md5sig_info->keys4);
909 tp->md5sig_info->keys4 = NULL;
Leigh Brown8228a18d2006-12-17 17:12:30 -0800910 tp->md5sig_info->alloced4 = 0;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200911 } else if (tp->md5sig_info->entries4 != i) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800912 /* Need to do some manipulation */
YOSHIFUJI Hideaki354faf02007-11-20 17:30:31 -0800913 memmove(&tp->md5sig_info->keys4[i],
914 &tp->md5sig_info->keys4[i+1],
915 (tp->md5sig_info->entries4 - i) *
916 sizeof(struct tcp4_md5sig_key));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800917 }
918 tcp_free_md5sig_pool();
919 return 0;
920 }
921 }
922 return -ENOENT;
923}
924
925EXPORT_SYMBOL(tcp_v4_md5_do_del);
926
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200927static void tcp_v4_clear_md5_list(struct sock *sk)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800928{
929 struct tcp_sock *tp = tcp_sk(sk);
930
931 /* Free each key, then the set of key keys,
932 * the crypto element, and then decrement our
933 * hold on the last resort crypto.
934 */
935 if (tp->md5sig_info->entries4) {
936 int i;
937 for (i = 0; i < tp->md5sig_info->entries4; i++)
David S. Millerf8ab18d2007-09-28 15:18:35 -0700938 kfree(tp->md5sig_info->keys4[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800939 tp->md5sig_info->entries4 = 0;
940 tcp_free_md5sig_pool();
941 }
942 if (tp->md5sig_info->keys4) {
943 kfree(tp->md5sig_info->keys4);
944 tp->md5sig_info->keys4 = NULL;
945 tp->md5sig_info->alloced4 = 0;
946 }
947}
948
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200949static int tcp_v4_parse_md5_keys(struct sock *sk, char __user *optval,
950 int optlen)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800951{
952 struct tcp_md5sig cmd;
953 struct sockaddr_in *sin = (struct sockaddr_in *)&cmd.tcpm_addr;
954 u8 *newkey;
955
956 if (optlen < sizeof(cmd))
957 return -EINVAL;
958
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200959 if (copy_from_user(&cmd, optval, sizeof(cmd)))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800960 return -EFAULT;
961
962 if (sin->sin_family != AF_INET)
963 return -EINVAL;
964
965 if (!cmd.tcpm_key || !cmd.tcpm_keylen) {
966 if (!tcp_sk(sk)->md5sig_info)
967 return -ENOENT;
968 return tcp_v4_md5_do_del(sk, sin->sin_addr.s_addr);
969 }
970
971 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
972 return -EINVAL;
973
974 if (!tcp_sk(sk)->md5sig_info) {
975 struct tcp_sock *tp = tcp_sk(sk);
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200976 struct tcp_md5sig_info *p = kzalloc(sizeof(*p), GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800977
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800978 if (!p)
979 return -EINVAL;
980
981 tp->md5sig_info = p;
David S. Miller3d7dbea2007-06-12 14:36:42 -0700982 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800983 }
984
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200985 newkey = kmemdup(cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800986 if (!newkey)
987 return -ENOMEM;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800988 return tcp_v4_md5_do_add(sk, sin->sin_addr.s_addr,
989 newkey, cmd.tcpm_keylen);
990}
991
Adam Langley49a72df2008-07-19 00:01:42 -0700992static int tcp_v4_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
993 __be32 daddr, __be32 saddr, int nbytes)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800994{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800995 struct tcp4_pseudohdr *bp;
Adam Langley49a72df2008-07-19 00:01:42 -0700996 struct scatterlist sg;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800997
998 bp = &hp->md5_blk.ip4;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800999
1000 /*
Adam Langley49a72df2008-07-19 00:01:42 -07001001 * 1. the TCP pseudo-header (in the order: source IP address,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001002 * destination IP address, zero-padded protocol number, and
1003 * segment length)
1004 */
1005 bp->saddr = saddr;
1006 bp->daddr = daddr;
1007 bp->pad = 0;
YOSHIFUJI Hideaki076fb722008-04-17 12:48:12 +09001008 bp->protocol = IPPROTO_TCP;
Adam Langley49a72df2008-07-19 00:01:42 -07001009 bp->len = cpu_to_be16(nbytes);
David S. Millerc7da57a2007-10-26 00:41:21 -07001010
Adam Langley49a72df2008-07-19 00:01:42 -07001011 sg_init_one(&sg, bp, sizeof(*bp));
1012 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
1013}
1014
1015static int tcp_v4_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
1016 __be32 daddr, __be32 saddr, struct tcphdr *th)
1017{
1018 struct tcp_md5sig_pool *hp;
1019 struct hash_desc *desc;
1020
1021 hp = tcp_get_md5sig_pool();
1022 if (!hp)
1023 goto clear_hash_noput;
1024 desc = &hp->md5_desc;
1025
1026 if (crypto_hash_init(desc))
1027 goto clear_hash;
1028 if (tcp_v4_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
1029 goto clear_hash;
1030 if (tcp_md5_hash_header(hp, th))
1031 goto clear_hash;
1032 if (tcp_md5_hash_key(hp, key))
1033 goto clear_hash;
1034 if (crypto_hash_final(desc, md5_hash))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001035 goto clear_hash;
1036
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001037 tcp_put_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001038 return 0;
Adam Langley49a72df2008-07-19 00:01:42 -07001039
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001040clear_hash:
1041 tcp_put_md5sig_pool();
1042clear_hash_noput:
1043 memset(md5_hash, 0, 16);
Adam Langley49a72df2008-07-19 00:01:42 -07001044 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001045}
1046
Adam Langley49a72df2008-07-19 00:01:42 -07001047int tcp_v4_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
1048 struct sock *sk, struct request_sock *req,
1049 struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001050{
Adam Langley49a72df2008-07-19 00:01:42 -07001051 struct tcp_md5sig_pool *hp;
1052 struct hash_desc *desc;
1053 struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001054 __be32 saddr, daddr;
1055
1056 if (sk) {
1057 saddr = inet_sk(sk)->saddr;
1058 daddr = inet_sk(sk)->daddr;
Adam Langley49a72df2008-07-19 00:01:42 -07001059 } else if (req) {
1060 saddr = inet_rsk(req)->loc_addr;
1061 daddr = inet_rsk(req)->rmt_addr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001062 } else {
Adam Langley49a72df2008-07-19 00:01:42 -07001063 const struct iphdr *iph = ip_hdr(skb);
1064 saddr = iph->saddr;
1065 daddr = iph->daddr;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001066 }
Adam Langley49a72df2008-07-19 00:01:42 -07001067
1068 hp = tcp_get_md5sig_pool();
1069 if (!hp)
1070 goto clear_hash_noput;
1071 desc = &hp->md5_desc;
1072
1073 if (crypto_hash_init(desc))
1074 goto clear_hash;
1075
1076 if (tcp_v4_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
1077 goto clear_hash;
1078 if (tcp_md5_hash_header(hp, th))
1079 goto clear_hash;
1080 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
1081 goto clear_hash;
1082 if (tcp_md5_hash_key(hp, key))
1083 goto clear_hash;
1084 if (crypto_hash_final(desc, md5_hash))
1085 goto clear_hash;
1086
1087 tcp_put_md5sig_pool();
1088 return 0;
1089
1090clear_hash:
1091 tcp_put_md5sig_pool();
1092clear_hash_noput:
1093 memset(md5_hash, 0, 16);
1094 return 1;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001095}
1096
Adam Langley49a72df2008-07-19 00:01:42 -07001097EXPORT_SYMBOL(tcp_v4_md5_hash_skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001098
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001099static int tcp_v4_inbound_md5_hash(struct sock *sk, struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001100{
1101 /*
1102 * This gets called for each TCP segment that arrives
1103 * so we want to be efficient.
1104 * We have 3 drop cases:
1105 * o No MD5 hash and one expected.
1106 * o MD5 hash and we're not expecting one.
1107 * o MD5 hash and its wrong.
1108 */
1109 __u8 *hash_location = NULL;
1110 struct tcp_md5sig_key *hash_expected;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001111 const struct iphdr *iph = ip_hdr(skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001112 struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001113 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001114 unsigned char newhash[16];
1115
1116 hash_expected = tcp_v4_md5_do_lookup(sk, iph->saddr);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +09001117 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001118
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001119 /* We've parsed the options - do we have a hash? */
1120 if (!hash_expected && !hash_location)
1121 return 0;
1122
1123 if (hash_expected && !hash_location) {
David S. Miller785957d2008-07-30 03:03:15 -07001124 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001125 return 1;
1126 }
1127
1128 if (!hash_expected && hash_location) {
David S. Miller785957d2008-07-30 03:03:15 -07001129 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001130 return 1;
1131 }
1132
1133 /* Okay, so this is hash_expected and hash_location -
1134 * so we need to calculate the checksum.
1135 */
Adam Langley49a72df2008-07-19 00:01:42 -07001136 genhash = tcp_v4_md5_hash_skb(newhash,
1137 hash_expected,
1138 NULL, NULL, skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001139
1140 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
1141 if (net_ratelimit()) {
1142 printk(KERN_INFO "MD5 Hash failed for "
1143 "(" NIPQUAD_FMT ", %d)->(" NIPQUAD_FMT ", %d)%s\n",
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001144 NIPQUAD(iph->saddr), ntohs(th->source),
1145 NIPQUAD(iph->daddr), ntohs(th->dest),
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001146 genhash ? " tcp_v4_calc_md5_hash failed" : "");
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001147 }
1148 return 1;
1149 }
1150 return 0;
1151}
1152
1153#endif
1154
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001155struct request_sock_ops tcp_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 .family = PF_INET,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001157 .obj_size = sizeof(struct tcp_request_sock),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 .rtx_syn_ack = tcp_v4_send_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001159 .send_ack = tcp_v4_reqsk_send_ack,
1160 .destructor = tcp_v4_reqsk_destructor,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 .send_reset = tcp_v4_send_reset,
1162};
1163
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001164#ifdef CONFIG_TCP_MD5SIG
Andrew Mortonb6332e62006-11-30 19:16:28 -08001165static struct tcp_request_sock_ops tcp_request_sock_ipv4_ops = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001166 .md5_lookup = tcp_v4_reqsk_md5_lookup,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001167};
Andrew Mortonb6332e62006-11-30 19:16:28 -08001168#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001169
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08001170static struct timewait_sock_ops tcp_timewait_sock_ops = {
1171 .twsk_obj_size = sizeof(struct tcp_timewait_sock),
1172 .twsk_unique = tcp_twsk_unique,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001173 .twsk_destructor= tcp_twsk_destructor,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08001174};
1175
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1177{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001178 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 struct tcp_options_received tmp_opt;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001180 struct request_sock *req;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001181 __be32 saddr = ip_hdr(skb)->saddr;
1182 __be32 daddr = ip_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 __u32 isn = TCP_SKB_CB(skb)->when;
1184 struct dst_entry *dst = NULL;
1185#ifdef CONFIG_SYN_COOKIES
1186 int want_cookie = 0;
1187#else
1188#define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */
1189#endif
1190
1191 /* Never answer to SYNs send to broadcast or multicast */
Eric Dumazetee6b9672008-03-05 18:30:47 -08001192 if (skb->rtable->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 goto drop;
1194
1195 /* TW buckets are converted to open requests without
1196 * limitations, they conserve resources and peer is
1197 * evidently real one.
1198 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001199 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200#ifdef CONFIG_SYN_COOKIES
1201 if (sysctl_tcp_syncookies) {
1202 want_cookie = 1;
1203 } else
1204#endif
1205 goto drop;
1206 }
1207
1208 /* Accept backlog is full. If we have already queued enough
1209 * of warm entries in syn queue, drop request. It is better than
1210 * clogging syn queue with openreqs with exponentially increasing
1211 * timeout.
1212 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001213 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214 goto drop;
1215
Arnaldo Carvalho de Meloce4a7d02008-06-10 12:39:35 -07001216 req = inet_reqsk_alloc(&tcp_request_sock_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217 if (!req)
1218 goto drop;
1219
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001220#ifdef CONFIG_TCP_MD5SIG
1221 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv4_ops;
1222#endif
1223
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 tcp_clear_options(&tmp_opt);
1225 tmp_opt.mss_clamp = 536;
1226 tmp_opt.user_mss = tcp_sk(sk)->rx_opt.user_mss;
1227
1228 tcp_parse_options(skb, &tmp_opt, 0);
1229
Florian Westphal4dfc2812008-04-10 03:12:40 -07001230 if (want_cookie && !tmp_opt.saw_tstamp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231 tcp_clear_options(&tmp_opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232
1233 if (tmp_opt.saw_tstamp && !tmp_opt.rcv_tsval) {
1234 /* Some OSes (unknown ones, but I see them on web server, which
1235 * contains information interesting only for windows'
1236 * users) do not send their stamp in SYN. It is easy case.
1237 * We simply do not advertise TS support.
1238 */
1239 tmp_opt.saw_tstamp = 0;
1240 tmp_opt.tstamp_ok = 0;
1241 }
1242 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
1243
1244 tcp_openreq_init(req, &tmp_opt, skb);
1245
Venkat Yekkirala4237c752006-07-24 23:32:50 -07001246 if (security_inet_conn_request(sk, skb, req))
1247 goto drop_and_free;
1248
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001249 ireq = inet_rsk(req);
1250 ireq->loc_addr = daddr;
1251 ireq->rmt_addr = saddr;
KOVACS Krisztian88ef4a52008-10-01 07:41:00 -07001252 ireq->no_srccheck = inet_sk(sk)->transparent;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001253 ireq->opt = tcp_v4_save_options(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 if (!want_cookie)
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001255 TCP_ECN_create_request(req, tcp_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256
1257 if (want_cookie) {
1258#ifdef CONFIG_SYN_COOKIES
1259 syn_flood_warning(skb);
Florian Westphal4dfc2812008-04-10 03:12:40 -07001260 req->cookie_ts = tmp_opt.tstamp_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261#endif
1262 isn = cookie_v4_init_sequence(sk, skb, &req->mss);
1263 } else if (!isn) {
1264 struct inet_peer *peer = NULL;
1265
1266 /* VJ's idea. We save last timestamp seen
1267 * from the destination in peer table, when entering
1268 * state TIME-WAIT, and check against it before
1269 * accepting new connection request.
1270 *
1271 * If "isn" is not zero, this request hit alive
1272 * timewait bucket, so that all the necessary checks
1273 * are made in the function processing timewait state.
1274 */
1275 if (tmp_opt.saw_tstamp &&
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001276 tcp_death_row.sysctl_tw_recycle &&
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001277 (dst = inet_csk_route_req(sk, req)) != NULL &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 (peer = rt_get_peer((struct rtable *)dst)) != NULL &&
1279 peer->v4daddr == saddr) {
James Morris9d729f72007-03-04 16:12:44 -08001280 if (get_seconds() < peer->tcp_ts_stamp + TCP_PAWS_MSL &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 (s32)(peer->tcp_ts - req->ts_recent) >
1282 TCP_PAWS_WINDOW) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001283 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001284 goto drop_and_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 }
1286 }
1287 /* Kill the following clause, if you dislike this way. */
1288 else if (!sysctl_tcp_syncookies &&
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001289 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290 (sysctl_max_syn_backlog >> 2)) &&
1291 (!peer || !peer->tcp_ts_stamp) &&
1292 (!dst || !dst_metric(dst, RTAX_RTT))) {
1293 /* Without syncookies last quarter of
1294 * backlog is filled with destinations,
1295 * proven to be alive.
1296 * It means that we continue to communicate
1297 * to destinations, already remembered
1298 * to the moment of synflood.
1299 */
Patrick McHardy64ce2072005-08-09 20:50:53 -07001300 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open "
YOSHIFUJI Hideakia7d632b2008-04-14 04:09:00 -07001301 "request from " NIPQUAD_FMT "/%u\n",
Patrick McHardy64ce2072005-08-09 20:50:53 -07001302 NIPQUAD(saddr),
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001303 ntohs(tcp_hdr(skb)->source));
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001304 goto drop_and_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 }
1306
Gerrit Renkera94f7232006-11-10 14:06:49 -08001307 isn = tcp_v4_init_sequence(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 }
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001309 tcp_rsk(req)->snt_isn = isn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001311 if (__tcp_v4_send_synack(sk, req, dst) || want_cookie)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 goto drop_and_free;
1313
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001314 inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 return 0;
1316
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001317drop_and_release:
1318 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319drop_and_free:
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001320 reqsk_free(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321drop:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 return 0;
1323}
1324
1325
1326/*
1327 * The three way handshake has completed - we got a valid synack -
1328 * now create the new socket.
1329 */
1330struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001331 struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 struct dst_entry *dst)
1333{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001334 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 struct inet_sock *newinet;
1336 struct tcp_sock *newtp;
1337 struct sock *newsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001338#ifdef CONFIG_TCP_MD5SIG
1339 struct tcp_md5sig_key *key;
1340#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341
1342 if (sk_acceptq_is_full(sk))
1343 goto exit_overflow;
1344
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001345 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 goto exit;
1347
1348 newsk = tcp_create_openreq_child(sk, req, skb);
1349 if (!newsk)
1350 goto exit;
1351
Herbert Xubcd76112006-06-30 13:36:35 -07001352 newsk->sk_gso_type = SKB_GSO_TCPV4;
Arnaldo Carvalho de Melo6cbb0df2005-08-09 19:49:02 -07001353 sk_setup_caps(newsk, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354
1355 newtp = tcp_sk(newsk);
1356 newinet = inet_sk(newsk);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001357 ireq = inet_rsk(req);
1358 newinet->daddr = ireq->rmt_addr;
1359 newinet->rcv_saddr = ireq->loc_addr;
1360 newinet->saddr = ireq->loc_addr;
1361 newinet->opt = ireq->opt;
1362 ireq->opt = NULL;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001363 newinet->mc_index = inet_iif(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001364 newinet->mc_ttl = ip_hdr(skb)->ttl;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001365 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 if (newinet->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001367 inet_csk(newsk)->icsk_ext_hdr_len = newinet->opt->optlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 newinet->id = newtp->write_seq ^ jiffies;
1369
John Heffner5d424d52006-03-20 17:53:41 -08001370 tcp_mtup_init(newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 tcp_sync_mss(newsk, dst_mtu(dst));
1372 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
Tom Quetchenbachf5fff5d2008-09-21 00:21:51 -07001373 if (tcp_sk(sk)->rx_opt.user_mss &&
1374 tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1375 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1376
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 tcp_initialize_rcv_mss(newsk);
1378
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001379#ifdef CONFIG_TCP_MD5SIG
1380 /* Copy over the MD5 key from the original socket */
1381 if ((key = tcp_v4_md5_do_lookup(sk, newinet->daddr)) != NULL) {
1382 /*
1383 * We're using one, so create a matching key
1384 * on the newsk structure. If we fail to get
1385 * memory, then we end up not copying the key
1386 * across. Shucks.
1387 */
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -02001388 char *newkey = kmemdup(key->key, key->keylen, GFP_ATOMIC);
1389 if (newkey != NULL)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001390 tcp_v4_md5_do_add(newsk, inet_sk(sk)->daddr,
1391 newkey, key->keylen);
Adam Langley49a72df2008-07-19 00:01:42 -07001392 newsk->sk_route_caps &= ~NETIF_F_GSO_MASK;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001393 }
1394#endif
1395
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001396 __inet_hash_nolisten(newsk);
1397 __inet_inherit_port(sk, newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398
1399 return newsk;
1400
1401exit_overflow:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001402 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403exit:
Pavel Emelyanovde0744a2008-07-16 20:31:16 -07001404 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 dst_release(dst);
1406 return NULL;
1407}
1408
1409static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
1410{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001411 struct tcphdr *th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001412 const struct iphdr *iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 struct sock *nsk;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001414 struct request_sock **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415 /* Find possible connection requests. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001416 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
1417 iph->saddr, iph->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 if (req)
1419 return tcp_check_req(sk, skb, req, prev);
1420
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001421 nsk = inet_lookup_established(sock_net(sk), &tcp_hashinfo, iph->saddr,
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001422 th->source, iph->daddr, th->dest, inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423
1424 if (nsk) {
1425 if (nsk->sk_state != TCP_TIME_WAIT) {
1426 bh_lock_sock(nsk);
1427 return nsk;
1428 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001429 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 return NULL;
1431 }
1432
1433#ifdef CONFIG_SYN_COOKIES
1434 if (!th->rst && !th->syn && th->ack)
1435 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
1436#endif
1437 return sk;
1438}
1439
Al Virob51655b2006-11-14 21:40:42 -08001440static __sum16 tcp_v4_checksum_init(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001442 const struct iphdr *iph = ip_hdr(skb);
1443
Patrick McHardy84fa7932006-08-29 16:44:56 -07001444 if (skb->ip_summed == CHECKSUM_COMPLETE) {
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001445 if (!tcp_v4_check(skb->len, iph->saddr,
1446 iph->daddr, skb->csum)) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001447 skb->ip_summed = CHECKSUM_UNNECESSARY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 return 0;
Herbert Xufb286bb2005-11-10 13:01:24 -08001449 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 }
Herbert Xufb286bb2005-11-10 13:01:24 -08001451
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001452 skb->csum = csum_tcpudp_nofold(iph->saddr, iph->daddr,
Herbert Xufb286bb2005-11-10 13:01:24 -08001453 skb->len, IPPROTO_TCP, 0);
1454
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 if (skb->len <= 76) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001456 return __skb_checksum_complete(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 }
1458 return 0;
1459}
1460
1461
1462/* The socket must have it's spinlock held when we get
1463 * here.
1464 *
1465 * We have a potential double-lock case here, so even when
1466 * doing backlog processing we use the BH locking scheme.
1467 * This is because we cannot sleep with the original spinlock
1468 * held.
1469 */
1470int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1471{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001472 struct sock *rsk;
1473#ifdef CONFIG_TCP_MD5SIG
1474 /*
1475 * We really want to reject the packet as early as possible
1476 * if:
1477 * o We're expecting an MD5'd packet and this is no MD5 tcp option
1478 * o There is an MD5 option and we're not expecting one
1479 */
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001480 if (tcp_v4_inbound_md5_hash(sk, skb))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001481 goto discard;
1482#endif
1483
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1485 TCP_CHECK_TIMER(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001486 if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001487 rsk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001489 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490 TCP_CHECK_TIMER(sk);
1491 return 0;
1492 }
1493
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07001494 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495 goto csum_err;
1496
1497 if (sk->sk_state == TCP_LISTEN) {
1498 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
1499 if (!nsk)
1500 goto discard;
1501
1502 if (nsk != sk) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001503 if (tcp_child_process(sk, nsk, skb)) {
1504 rsk = nsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001506 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 return 0;
1508 }
1509 }
1510
1511 TCP_CHECK_TIMER(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001512 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001513 rsk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001515 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 TCP_CHECK_TIMER(sk);
1517 return 0;
1518
1519reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001520 tcp_v4_send_reset(rsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521discard:
1522 kfree_skb(skb);
1523 /* Be careful here. If this function gets more complicated and
1524 * gcc suffers from register pressure on the x86, sk (in %ebx)
1525 * might be destroyed here. This current version compiles correctly,
1526 * but you have been warned.
1527 */
1528 return 0;
1529
1530csum_err:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001531 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532 goto discard;
1533}
1534
1535/*
1536 * From tcp_input.c
1537 */
1538
1539int tcp_v4_rcv(struct sk_buff *skb)
1540{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001541 const struct iphdr *iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 struct tcphdr *th;
1543 struct sock *sk;
1544 int ret;
Pavel Emelyanova86b1e32008-07-16 20:20:58 -07001545 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546
1547 if (skb->pkt_type != PACKET_HOST)
1548 goto discard_it;
1549
1550 /* Count it even if it's bad */
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001551 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552
1553 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1554 goto discard_it;
1555
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001556 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557
1558 if (th->doff < sizeof(struct tcphdr) / 4)
1559 goto bad_packet;
1560 if (!pskb_may_pull(skb, th->doff * 4))
1561 goto discard_it;
1562
1563 /* An explanation is required here, I think.
1564 * Packet length and doff are validated by header prediction,
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -08001565 * provided case of th->doff==0 is eliminated.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 * So, we defer the checks. */
Herbert Xu60476372007-04-09 11:59:39 -07001567 if (!skb_csum_unnecessary(skb) && tcp_v4_checksum_init(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568 goto bad_packet;
1569
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001570 th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001571 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1573 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1574 skb->len - th->doff * 4);
1575 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1576 TCP_SKB_CB(skb)->when = 0;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001577 TCP_SKB_CB(skb)->flags = iph->tos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578 TCP_SKB_CB(skb)->sacked = 0;
1579
Arnaldo Carvalho de Melo9a1f27c2008-10-07 11:41:57 -07001580 sk = __inet_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581 if (!sk)
1582 goto no_tcp_socket;
1583
1584process:
1585 if (sk->sk_state == TCP_TIME_WAIT)
1586 goto do_time_wait;
1587
1588 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1589 goto discard_and_relse;
Patrick McHardyb59c2702006-01-06 23:06:10 -08001590 nf_reset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001592 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593 goto discard_and_relse;
1594
1595 skb->dev = NULL;
1596
Ingo Molnarc6366182006-07-03 00:25:13 -07001597 bh_lock_sock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598 ret = 0;
1599 if (!sock_owned_by_user(sk)) {
Chris Leech1a2449a2006-05-23 18:05:53 -07001600#ifdef CONFIG_NET_DMA
1601 struct tcp_sock *tp = tcp_sk(sk);
1602 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
1603 tp->ucopy.dma_chan = get_softnet_dma();
1604 if (tp->ucopy.dma_chan)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605 ret = tcp_v4_do_rcv(sk, skb);
Chris Leech1a2449a2006-05-23 18:05:53 -07001606 else
1607#endif
1608 {
1609 if (!tcp_prequeue(sk, skb))
1610 ret = tcp_v4_do_rcv(sk, skb);
1611 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 } else
1613 sk_add_backlog(sk, skb);
1614 bh_unlock_sock(sk);
1615
1616 sock_put(sk);
1617
1618 return ret;
1619
1620no_tcp_socket:
1621 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1622 goto discard_it;
1623
1624 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1625bad_packet:
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001626 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001628 tcp_v4_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 }
1630
1631discard_it:
1632 /* Discard frame. */
1633 kfree_skb(skb);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001634 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635
1636discard_and_relse:
1637 sock_put(sk);
1638 goto discard_it;
1639
1640do_time_wait:
1641 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001642 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 goto discard_it;
1644 }
1645
1646 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
Pavel Emelyanov63231bd2008-07-16 20:22:25 -07001647 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001648 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 goto discard_it;
1650 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001651 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 case TCP_TW_SYN: {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001653 struct sock *sk2 = inet_lookup_listener(dev_net(skb->dev),
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001654 &tcp_hashinfo,
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001655 iph->daddr, th->dest,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001656 inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657 if (sk2) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001658 inet_twsk_deschedule(inet_twsk(sk), &tcp_death_row);
1659 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660 sk = sk2;
1661 goto process;
1662 }
1663 /* Fall through to ACK */
1664 }
1665 case TCP_TW_ACK:
1666 tcp_v4_timewait_ack(sk, skb);
1667 break;
1668 case TCP_TW_RST:
1669 goto no_tcp_socket;
1670 case TCP_TW_SUCCESS:;
1671 }
1672 goto discard_it;
1673}
1674
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675/* VJ's idea. Save last timestamp seen from this destination
1676 * and hold it at least for normal timewait interval to use for duplicate
1677 * segment detection in subsequent connections, before they enter synchronized
1678 * state.
1679 */
1680
1681int tcp_v4_remember_stamp(struct sock *sk)
1682{
1683 struct inet_sock *inet = inet_sk(sk);
1684 struct tcp_sock *tp = tcp_sk(sk);
1685 struct rtable *rt = (struct rtable *)__sk_dst_get(sk);
1686 struct inet_peer *peer = NULL;
1687 int release_it = 0;
1688
1689 if (!rt || rt->rt_dst != inet->daddr) {
1690 peer = inet_getpeer(inet->daddr, 1);
1691 release_it = 1;
1692 } else {
1693 if (!rt->peer)
1694 rt_bind_peer(rt, 1);
1695 peer = rt->peer;
1696 }
1697
1698 if (peer) {
1699 if ((s32)(peer->tcp_ts - tp->rx_opt.ts_recent) <= 0 ||
James Morris9d729f72007-03-04 16:12:44 -08001700 (peer->tcp_ts_stamp + TCP_PAWS_MSL < get_seconds() &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701 peer->tcp_ts_stamp <= tp->rx_opt.ts_recent_stamp)) {
1702 peer->tcp_ts_stamp = tp->rx_opt.ts_recent_stamp;
1703 peer->tcp_ts = tp->rx_opt.ts_recent;
1704 }
1705 if (release_it)
1706 inet_putpeer(peer);
1707 return 1;
1708 }
1709
1710 return 0;
1711}
1712
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001713int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001715 struct inet_peer *peer = inet_getpeer(tw->tw_daddr, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716
1717 if (peer) {
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001718 const struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
1719
1720 if ((s32)(peer->tcp_ts - tcptw->tw_ts_recent) <= 0 ||
James Morris9d729f72007-03-04 16:12:44 -08001721 (peer->tcp_ts_stamp + TCP_PAWS_MSL < get_seconds() &&
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001722 peer->tcp_ts_stamp <= tcptw->tw_ts_recent_stamp)) {
1723 peer->tcp_ts_stamp = tcptw->tw_ts_recent_stamp;
1724 peer->tcp_ts = tcptw->tw_ts_recent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725 }
1726 inet_putpeer(peer);
1727 return 1;
1728 }
1729
1730 return 0;
1731}
1732
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001733struct inet_connection_sock_af_ops ipv4_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001734 .queue_xmit = ip_queue_xmit,
1735 .send_check = tcp_v4_send_check,
1736 .rebuild_header = inet_sk_rebuild_header,
1737 .conn_request = tcp_v4_conn_request,
1738 .syn_recv_sock = tcp_v4_syn_recv_sock,
1739 .remember_stamp = tcp_v4_remember_stamp,
1740 .net_header_len = sizeof(struct iphdr),
1741 .setsockopt = ip_setsockopt,
1742 .getsockopt = ip_getsockopt,
1743 .addr2sockaddr = inet_csk_addr2sockaddr,
1744 .sockaddr_len = sizeof(struct sockaddr_in),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001745 .bind_conflict = inet_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001746#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001747 .compat_setsockopt = compat_ip_setsockopt,
1748 .compat_getsockopt = compat_ip_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001749#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750};
1751
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001752#ifdef CONFIG_TCP_MD5SIG
Andrew Mortonb6332e62006-11-30 19:16:28 -08001753static struct tcp_sock_af_ops tcp_sock_ipv4_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001754 .md5_lookup = tcp_v4_md5_lookup,
Adam Langley49a72df2008-07-19 00:01:42 -07001755 .calc_md5_hash = tcp_v4_md5_hash_skb,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001756 .md5_add = tcp_v4_md5_add_func,
1757 .md5_parse = tcp_v4_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001758};
Andrew Mortonb6332e62006-11-30 19:16:28 -08001759#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001760
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761/* NOTE: A lot of things set to zero explicitly by call to
1762 * sk_alloc() so need not be done here.
1763 */
1764static int tcp_v4_init_sock(struct sock *sk)
1765{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001766 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767 struct tcp_sock *tp = tcp_sk(sk);
1768
1769 skb_queue_head_init(&tp->out_of_order_queue);
1770 tcp_init_xmit_timers(sk);
1771 tcp_prequeue_init(tp);
1772
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001773 icsk->icsk_rto = TCP_TIMEOUT_INIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774 tp->mdev = TCP_TIMEOUT_INIT;
1775
1776 /* So many TCP implementations out there (incorrectly) count the
1777 * initial SYN frame in their delayed-ACK and congestion control
1778 * algorithms that we must have the following bandaid to talk
1779 * efficiently to them. -DaveM
1780 */
1781 tp->snd_cwnd = 2;
1782
1783 /* See draft-stevens-tcpca-spec-01 for discussion of the
1784 * initialization of these values.
1785 */
1786 tp->snd_ssthresh = 0x7fffffff; /* Infinity */
1787 tp->snd_cwnd_clamp = ~0;
David S. Millerc1b4a7e2005-07-05 15:24:38 -07001788 tp->mss_cache = 536;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789
1790 tp->reordering = sysctl_tcp_reordering;
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001791 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792
1793 sk->sk_state = TCP_CLOSE;
1794
1795 sk->sk_write_space = sk_stream_write_space;
1796 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1797
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001798 icsk->icsk_af_ops = &ipv4_specific;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001799 icsk->icsk_sync_mss = tcp_sync_mss;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001800#ifdef CONFIG_TCP_MD5SIG
1801 tp->af_specific = &tcp_sock_ipv4_specific;
1802#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803
1804 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1805 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1806
1807 atomic_inc(&tcp_sockets_allocated);
1808
1809 return 0;
1810}
1811
Brian Haley7d06b2e2008-06-14 17:04:49 -07001812void tcp_v4_destroy_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813{
1814 struct tcp_sock *tp = tcp_sk(sk);
1815
1816 tcp_clear_xmit_timers(sk);
1817
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001818 tcp_cleanup_congestion_control(sk);
Stephen Hemminger317a76f2005-06-23 12:19:55 -07001819
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820 /* Cleanup up the write buffer. */
David S. Millerfe067e82007-03-07 12:12:44 -08001821 tcp_write_queue_purge(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822
1823 /* Cleans up our, hopefully empty, out_of_order_queue. */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001824 __skb_queue_purge(&tp->out_of_order_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001826#ifdef CONFIG_TCP_MD5SIG
1827 /* Clean up the MD5 key list, if any */
1828 if (tp->md5sig_info) {
1829 tcp_v4_clear_md5_list(sk);
1830 kfree(tp->md5sig_info);
1831 tp->md5sig_info = NULL;
1832 }
1833#endif
1834
Chris Leech1a2449a2006-05-23 18:05:53 -07001835#ifdef CONFIG_NET_DMA
1836 /* Cleans up our sk_async_wait_queue */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001837 __skb_queue_purge(&sk->sk_async_wait_queue);
Chris Leech1a2449a2006-05-23 18:05:53 -07001838#endif
1839
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840 /* Clean prequeue, it must be empty really */
1841 __skb_queue_purge(&tp->ucopy.prequeue);
1842
1843 /* Clean up a referenced TCP bind bucket. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001844 if (inet_csk(sk)->icsk_bind_hash)
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001845 inet_put_port(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846
1847 /*
1848 * If sendmsg cached page exists, toss it.
1849 */
1850 if (sk->sk_sndmsg_page) {
1851 __free_page(sk->sk_sndmsg_page);
1852 sk->sk_sndmsg_page = NULL;
1853 }
1854
1855 atomic_dec(&tcp_sockets_allocated);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856}
1857
1858EXPORT_SYMBOL(tcp_v4_destroy_sock);
1859
1860#ifdef CONFIG_PROC_FS
1861/* Proc filesystem TCP sock list dumping. */
1862
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001863static inline struct inet_timewait_sock *tw_head(struct hlist_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864{
1865 return hlist_empty(head) ? NULL :
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001866 list_entry(head->first, struct inet_timewait_sock, tw_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867}
1868
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001869static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870{
1871 return tw->tw_node.next ?
1872 hlist_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
1873}
1874
1875static void *listening_get_next(struct seq_file *seq, void *cur)
1876{
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001877 struct inet_connection_sock *icsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878 struct hlist_node *node;
1879 struct sock *sk = cur;
1880 struct tcp_iter_state* st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07001881 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882
1883 if (!sk) {
1884 st->bucket = 0;
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001885 sk = sk_head(&tcp_hashinfo.listening_hash[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001886 goto get_sk;
1887 }
1888
1889 ++st->num;
1890
1891 if (st->state == TCP_SEQ_STATE_OPENREQ) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001892 struct request_sock *req = cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001894 icsk = inet_csk(st->syn_wait_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895 req = req->dl_next;
1896 while (1) {
1897 while (req) {
Daniel Lezcanobdccc4c2008-07-19 00:15:13 -07001898 if (req->rsk_ops->family == st->family) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899 cur = req;
1900 goto out;
1901 }
1902 req = req->dl_next;
1903 }
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001904 if (++st->sbucket >= icsk->icsk_accept_queue.listen_opt->nr_table_entries)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905 break;
1906get_req:
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001907 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908 }
1909 sk = sk_next(st->syn_wait_sk);
1910 st->state = TCP_SEQ_STATE_LISTENING;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001911 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 } else {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001913 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001914 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1915 if (reqsk_queue_len(&icsk->icsk_accept_queue))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 goto start_req;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001917 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 sk = sk_next(sk);
1919 }
1920get_sk:
1921 sk_for_each_from(sk, node) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09001922 if (sk->sk_family == st->family && net_eq(sock_net(sk), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923 cur = sk;
1924 goto out;
1925 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001926 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001927 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1928 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929start_req:
1930 st->uid = sock_i_uid(sk);
1931 st->syn_wait_sk = sk;
1932 st->state = TCP_SEQ_STATE_OPENREQ;
1933 st->sbucket = 0;
1934 goto get_req;
1935 }
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001936 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 }
Arnaldo Carvalho de Melo0f7ff922005-08-09 19:59:44 -07001938 if (++st->bucket < INET_LHTABLE_SIZE) {
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001939 sk = sk_head(&tcp_hashinfo.listening_hash[st->bucket]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 goto get_sk;
1941 }
1942 cur = NULL;
1943out:
1944 return cur;
1945}
1946
1947static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
1948{
1949 void *rc = listening_get_next(seq, NULL);
1950
1951 while (rc && *pos) {
1952 rc = listening_get_next(seq, rc);
1953 --*pos;
1954 }
1955 return rc;
1956}
1957
Andi Kleen6eac5602008-08-28 01:08:02 -07001958static inline int empty_bucket(struct tcp_iter_state *st)
1959{
1960 return hlist_empty(&tcp_hashinfo.ehash[st->bucket].chain) &&
1961 hlist_empty(&tcp_hashinfo.ehash[st->bucket].twchain);
1962}
1963
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964static void *established_get_first(struct seq_file *seq)
1965{
1966 struct tcp_iter_state* st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07001967 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968 void *rc = NULL;
1969
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001970 for (st->bucket = 0; st->bucket < tcp_hashinfo.ehash_size; ++st->bucket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971 struct sock *sk;
1972 struct hlist_node *node;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001973 struct inet_timewait_sock *tw;
Eric Dumazet230140c2007-11-07 02:40:20 -08001974 rwlock_t *lock = inet_ehash_lockp(&tcp_hashinfo, st->bucket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975
Andi Kleen6eac5602008-08-28 01:08:02 -07001976 /* Lockless fast path for the common case of empty buckets */
1977 if (empty_bucket(st))
1978 continue;
1979
Eric Dumazet230140c2007-11-07 02:40:20 -08001980 read_lock_bh(lock);
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001981 sk_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
Daniel Lezcanof40c8172008-03-21 04:13:54 -07001982 if (sk->sk_family != st->family ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09001983 !net_eq(sock_net(sk), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984 continue;
1985 }
1986 rc = sk;
1987 goto out;
1988 }
1989 st->state = TCP_SEQ_STATE_TIME_WAIT;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001990 inet_twsk_for_each(tw, node,
Eric Dumazetdbca9b2752007-02-08 14:16:46 -08001991 &tcp_hashinfo.ehash[st->bucket].twchain) {
Pavel Emelyanov28518fc2008-03-21 15:52:00 -07001992 if (tw->tw_family != st->family ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09001993 !net_eq(twsk_net(tw), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994 continue;
1995 }
1996 rc = tw;
1997 goto out;
1998 }
Eric Dumazet230140c2007-11-07 02:40:20 -08001999 read_unlock_bh(lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000 st->state = TCP_SEQ_STATE_ESTABLISHED;
2001 }
2002out:
2003 return rc;
2004}
2005
2006static void *established_get_next(struct seq_file *seq, void *cur)
2007{
2008 struct sock *sk = cur;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002009 struct inet_timewait_sock *tw;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002010 struct hlist_node *node;
2011 struct tcp_iter_state* st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002012 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013
2014 ++st->num;
2015
2016 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
2017 tw = cur;
2018 tw = tw_next(tw);
2019get_tw:
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002020 while (tw && (tw->tw_family != st->family || !net_eq(twsk_net(tw), net))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002021 tw = tw_next(tw);
2022 }
2023 if (tw) {
2024 cur = tw;
2025 goto out;
2026 }
Eric Dumazet230140c2007-11-07 02:40:20 -08002027 read_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028 st->state = TCP_SEQ_STATE_ESTABLISHED;
2029
Andi Kleen6eac5602008-08-28 01:08:02 -07002030 /* Look for next non empty bucket */
2031 while (++st->bucket < tcp_hashinfo.ehash_size &&
2032 empty_bucket(st))
2033 ;
2034 if (st->bucket >= tcp_hashinfo.ehash_size)
2035 return NULL;
2036
2037 read_lock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
2038 sk = sk_head(&tcp_hashinfo.ehash[st->bucket].chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039 } else
2040 sk = sk_next(sk);
2041
2042 sk_for_each_from(sk, node) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002043 if (sk->sk_family == st->family && net_eq(sock_net(sk), net))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002044 goto found;
2045 }
2046
2047 st->state = TCP_SEQ_STATE_TIME_WAIT;
Eric Dumazetdbca9b2752007-02-08 14:16:46 -08002048 tw = tw_head(&tcp_hashinfo.ehash[st->bucket].twchain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049 goto get_tw;
2050found:
2051 cur = sk;
2052out:
2053 return cur;
2054}
2055
2056static void *established_get_idx(struct seq_file *seq, loff_t pos)
2057{
2058 void *rc = established_get_first(seq);
2059
2060 while (rc && pos) {
2061 rc = established_get_next(seq, rc);
2062 --pos;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002063 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064 return rc;
2065}
2066
2067static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
2068{
2069 void *rc;
2070 struct tcp_iter_state* st = seq->private;
2071
Arnaldo Carvalho de Melof3f05f72005-08-09 20:08:09 -07002072 inet_listen_lock(&tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073 st->state = TCP_SEQ_STATE_LISTENING;
2074 rc = listening_get_idx(seq, &pos);
2075
2076 if (!rc) {
Arnaldo Carvalho de Melof3f05f72005-08-09 20:08:09 -07002077 inet_listen_unlock(&tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078 st->state = TCP_SEQ_STATE_ESTABLISHED;
2079 rc = established_get_idx(seq, pos);
2080 }
2081
2082 return rc;
2083}
2084
2085static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
2086{
2087 struct tcp_iter_state* st = seq->private;
2088 st->state = TCP_SEQ_STATE_LISTENING;
2089 st->num = 0;
2090 return *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2091}
2092
2093static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2094{
2095 void *rc = NULL;
2096 struct tcp_iter_state* st;
2097
2098 if (v == SEQ_START_TOKEN) {
2099 rc = tcp_get_idx(seq, 0);
2100 goto out;
2101 }
2102 st = seq->private;
2103
2104 switch (st->state) {
2105 case TCP_SEQ_STATE_OPENREQ:
2106 case TCP_SEQ_STATE_LISTENING:
2107 rc = listening_get_next(seq, v);
2108 if (!rc) {
Arnaldo Carvalho de Melof3f05f72005-08-09 20:08:09 -07002109 inet_listen_unlock(&tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002110 st->state = TCP_SEQ_STATE_ESTABLISHED;
2111 rc = established_get_first(seq);
2112 }
2113 break;
2114 case TCP_SEQ_STATE_ESTABLISHED:
2115 case TCP_SEQ_STATE_TIME_WAIT:
2116 rc = established_get_next(seq, v);
2117 break;
2118 }
2119out:
2120 ++*pos;
2121 return rc;
2122}
2123
2124static void tcp_seq_stop(struct seq_file *seq, void *v)
2125{
2126 struct tcp_iter_state* st = seq->private;
2127
2128 switch (st->state) {
2129 case TCP_SEQ_STATE_OPENREQ:
2130 if (v) {
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002131 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
2132 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002133 }
2134 case TCP_SEQ_STATE_LISTENING:
2135 if (v != SEQ_START_TOKEN)
Arnaldo Carvalho de Melof3f05f72005-08-09 20:08:09 -07002136 inet_listen_unlock(&tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137 break;
2138 case TCP_SEQ_STATE_TIME_WAIT:
2139 case TCP_SEQ_STATE_ESTABLISHED:
2140 if (v)
Eric Dumazet230140c2007-11-07 02:40:20 -08002141 read_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002142 break;
2143 }
2144}
2145
2146static int tcp_seq_open(struct inode *inode, struct file *file)
2147{
2148 struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149 struct tcp_iter_state *s;
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002150 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002152 err = seq_open_net(inode, file, &afinfo->seq_ops,
2153 sizeof(struct tcp_iter_state));
2154 if (err < 0)
2155 return err;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002156
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002157 s = ((struct seq_file *)file->private_data)->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158 s->family = afinfo->family;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002159 return 0;
2160}
2161
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002162int tcp_proc_register(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163{
2164 int rc = 0;
2165 struct proc_dir_entry *p;
2166
Denis V. Lunev68fcadd2008-04-13 22:13:30 -07002167 afinfo->seq_fops.open = tcp_seq_open;
2168 afinfo->seq_fops.read = seq_read;
2169 afinfo->seq_fops.llseek = seq_lseek;
2170 afinfo->seq_fops.release = seq_release_net;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002171
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002172 afinfo->seq_ops.start = tcp_seq_start;
2173 afinfo->seq_ops.next = tcp_seq_next;
2174 afinfo->seq_ops.stop = tcp_seq_stop;
2175
Denis V. Lunev84841c32008-05-02 04:10:08 -07002176 p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net,
2177 &afinfo->seq_fops, afinfo);
2178 if (!p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179 rc = -ENOMEM;
2180 return rc;
2181}
2182
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002183void tcp_proc_unregister(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002185 proc_net_remove(net, afinfo->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002186}
2187
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002188static void get_openreq4(struct sock *sk, struct request_sock *req,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002189 struct seq_file *f, int i, int uid, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002190{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002191 const struct inet_request_sock *ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192 int ttd = req->expires - jiffies;
2193
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002194 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
2195 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p%n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002196 i,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002197 ireq->loc_addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002198 ntohs(inet_sk(sk)->sport),
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002199 ireq->rmt_addr,
2200 ntohs(ireq->rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002201 TCP_SYN_RECV,
2202 0, 0, /* could print option size, but that is af dependent. */
2203 1, /* timers active (only the expire timer) */
2204 jiffies_to_clock_t(ttd),
2205 req->retrans,
2206 uid,
2207 0, /* non standard timer */
2208 0, /* open_requests have no inode */
2209 atomic_read(&sk->sk_refcnt),
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002210 req,
2211 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002212}
2213
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002214static void get_tcp4_sock(struct sock *sk, struct seq_file *f, int i, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002215{
2216 int timer_active;
2217 unsigned long timer_expires;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002218 struct tcp_sock *tp = tcp_sk(sk);
2219 const struct inet_connection_sock *icsk = inet_csk(sk);
2220 struct inet_sock *inet = inet_sk(sk);
Al Viro714e85b2006-11-14 20:51:49 -08002221 __be32 dest = inet->daddr;
2222 __be32 src = inet->rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002223 __u16 destp = ntohs(inet->dport);
2224 __u16 srcp = ntohs(inet->sport);
2225
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002226 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002227 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002228 timer_expires = icsk->icsk_timeout;
2229 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002231 timer_expires = icsk->icsk_timeout;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002232 } else if (timer_pending(&sk->sk_timer)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233 timer_active = 2;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002234 timer_expires = sk->sk_timer.expires;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235 } else {
2236 timer_active = 0;
2237 timer_expires = jiffies;
2238 }
2239
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002240 seq_printf(f, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
Stephen Hemminger7be87352008-06-27 20:00:19 -07002241 "%08X %5d %8d %lu %d %p %lu %lu %u %u %d%n",
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002242 i, src, srcp, dest, destp, sk->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07002243 tp->write_seq - tp->snd_una,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002244 sk->sk_state == TCP_LISTEN ? sk->sk_ack_backlog :
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002245 (tp->rcv_nxt - tp->copied_seq),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002246 timer_active,
2247 jiffies_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002248 icsk->icsk_retransmits,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002249 sock_i_uid(sk),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03002250 icsk->icsk_probes_out,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002251 sock_i_ino(sk),
2252 atomic_read(&sk->sk_refcnt), sk,
Stephen Hemminger7be87352008-06-27 20:00:19 -07002253 jiffies_to_clock_t(icsk->icsk_rto),
2254 jiffies_to_clock_t(icsk->icsk_ack.ato),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002255 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256 tp->snd_cwnd,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002257 tp->snd_ssthresh >= 0xFFFF ? -1 : tp->snd_ssthresh,
2258 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259}
2260
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002261static void get_timewait4_sock(struct inet_timewait_sock *tw,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002262 struct seq_file *f, int i, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002263{
Al Viro23f33c22006-09-27 18:43:50 -07002264 __be32 dest, src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265 __u16 destp, srcp;
2266 int ttd = tw->tw_ttd - jiffies;
2267
2268 if (ttd < 0)
2269 ttd = 0;
2270
2271 dest = tw->tw_daddr;
2272 src = tw->tw_rcv_saddr;
2273 destp = ntohs(tw->tw_dport);
2274 srcp = ntohs(tw->tw_sport);
2275
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002276 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
2277 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p%n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002278 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
2279 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002280 atomic_read(&tw->tw_refcnt), tw, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002281}
2282
2283#define TMPSZ 150
2284
2285static int tcp4_seq_show(struct seq_file *seq, void *v)
2286{
2287 struct tcp_iter_state* st;
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002288 int len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289
2290 if (v == SEQ_START_TOKEN) {
2291 seq_printf(seq, "%-*s\n", TMPSZ - 1,
2292 " sl local_address rem_address st tx_queue "
2293 "rx_queue tr tm->when retrnsmt uid timeout "
2294 "inode");
2295 goto out;
2296 }
2297 st = seq->private;
2298
2299 switch (st->state) {
2300 case TCP_SEQ_STATE_LISTENING:
2301 case TCP_SEQ_STATE_ESTABLISHED:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002302 get_tcp4_sock(v, seq, st->num, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002303 break;
2304 case TCP_SEQ_STATE_OPENREQ:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002305 get_openreq4(st->syn_wait_sk, v, seq, st->num, st->uid, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002306 break;
2307 case TCP_SEQ_STATE_TIME_WAIT:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002308 get_timewait4_sock(v, seq, st->num, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309 break;
2310 }
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002311 seq_printf(seq, "%*s\n", TMPSZ - 1 - len, "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002312out:
2313 return 0;
2314}
2315
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316static struct tcp_seq_afinfo tcp4_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002317 .name = "tcp",
2318 .family = AF_INET,
Denis V. Lunev5f4472c2008-04-13 22:13:53 -07002319 .seq_fops = {
2320 .owner = THIS_MODULE,
2321 },
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002322 .seq_ops = {
2323 .show = tcp4_seq_show,
2324 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002325};
2326
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002327static int tcp4_proc_init_net(struct net *net)
2328{
2329 return tcp_proc_register(net, &tcp4_seq_afinfo);
2330}
2331
2332static void tcp4_proc_exit_net(struct net *net)
2333{
2334 tcp_proc_unregister(net, &tcp4_seq_afinfo);
2335}
2336
2337static struct pernet_operations tcp4_net_ops = {
2338 .init = tcp4_proc_init_net,
2339 .exit = tcp4_proc_exit_net,
2340};
2341
Linus Torvalds1da177e2005-04-16 15:20:36 -07002342int __init tcp4_proc_init(void)
2343{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002344 return register_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002345}
2346
2347void tcp4_proc_exit(void)
2348{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002349 unregister_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002350}
2351#endif /* CONFIG_PROC_FS */
2352
2353struct proto tcp_prot = {
2354 .name = "TCP",
2355 .owner = THIS_MODULE,
2356 .close = tcp_close,
2357 .connect = tcp_v4_connect,
2358 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002359 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002360 .ioctl = tcp_ioctl,
2361 .init = tcp_v4_init_sock,
2362 .destroy = tcp_v4_destroy_sock,
2363 .shutdown = tcp_shutdown,
2364 .setsockopt = tcp_setsockopt,
2365 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366 .recvmsg = tcp_recvmsg,
2367 .backlog_rcv = tcp_v4_do_rcv,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08002368 .hash = inet_hash,
2369 .unhash = inet_unhash,
2370 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371 .enter_memory_pressure = tcp_enter_memory_pressure,
2372 .sockets_allocated = &tcp_sockets_allocated,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07002373 .orphan_count = &tcp_orphan_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002374 .memory_allocated = &tcp_memory_allocated,
2375 .memory_pressure = &tcp_memory_pressure,
2376 .sysctl_mem = sysctl_tcp_mem,
2377 .sysctl_wmem = sysctl_tcp_wmem,
2378 .sysctl_rmem = sysctl_tcp_rmem,
2379 .max_header = MAX_TCP_HEADER,
2380 .obj_size = sizeof(struct tcp_sock),
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002381 .twsk_prot = &tcp_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002382 .rsk_prot = &tcp_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07002383 .h.hashinfo = &tcp_hashinfo,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002384#ifdef CONFIG_COMPAT
2385 .compat_setsockopt = compat_tcp_setsockopt,
2386 .compat_getsockopt = compat_tcp_getsockopt,
2387#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002388};
2389
Denis V. Lunev046ee902008-04-03 14:31:33 -07002390
2391static int __net_init tcp_sk_init(struct net *net)
2392{
2393 return inet_ctl_sock_create(&net->ipv4.tcp_sock,
2394 PF_INET, SOCK_RAW, IPPROTO_TCP, net);
2395}
2396
2397static void __net_exit tcp_sk_exit(struct net *net)
2398{
2399 inet_ctl_sock_destroy(net->ipv4.tcp_sock);
Daniel Lezcanod3154922008-09-08 13:17:27 -07002400 inet_twsk_purge(net, &tcp_hashinfo, &tcp_death_row, AF_INET);
Denis V. Lunev046ee902008-04-03 14:31:33 -07002401}
2402
2403static struct pernet_operations __net_initdata tcp_sk_ops = {
2404 .init = tcp_sk_init,
2405 .exit = tcp_sk_exit,
2406};
2407
Denis V. Lunev9b0f9762008-02-29 11:13:15 -08002408void __init tcp_v4_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002409{
Denis V. Lunev046ee902008-04-03 14:31:33 -07002410 if (register_pernet_device(&tcp_sk_ops))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002411 panic("Failed to create the TCP control socket.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002412}
2413
2414EXPORT_SYMBOL(ipv4_specific);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002415EXPORT_SYMBOL(tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002416EXPORT_SYMBOL(tcp_prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002417EXPORT_SYMBOL(tcp_v4_conn_request);
2418EXPORT_SYMBOL(tcp_v4_connect);
2419EXPORT_SYMBOL(tcp_v4_do_rcv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002420EXPORT_SYMBOL(tcp_v4_remember_stamp);
2421EXPORT_SYMBOL(tcp_v4_send_check);
2422EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
2423
2424#ifdef CONFIG_PROC_FS
2425EXPORT_SYMBOL(tcp_proc_register);
2426EXPORT_SYMBOL(tcp_proc_unregister);
2427#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002428EXPORT_SYMBOL(sysctl_tcp_low_latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429