blob: f25445d21bdf1cbaa56612d91553951c5088e52f [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 *
8 * Version: $Id: tcp_ipv4.c,v 1.240 2002/02/01 22:01:04 davem Exp $
9 *
10 * IPv4 specific functions
11 *
12 *
13 * code split from:
14 * linux/ipv4/tcp.c
15 * linux/ipv4/tcp_input.c
16 * linux/ipv4/tcp_output.c
17 *
18 * See tcp.c for author information
19 *
20 * This program is free software; you can redistribute it and/or
21 * modify it under the terms of the GNU General Public License
22 * as published by the Free Software Foundation; either version
23 * 2 of the License, or (at your option) any later version.
24 */
25
26/*
27 * Changes:
28 * David S. Miller : New socket lookup architecture.
29 * This code is dedicated to John Dyson.
30 * David S. Miller : Change semantics of established hash,
31 * half is devoted to TIME_WAIT sockets
32 * and the rest go in the other half.
33 * Andi Kleen : Add support for syncookies and fixed
34 * some bugs: ip options weren't passed to
35 * the TCP layer, missed a check for an
36 * ACK bit.
37 * Andi Kleen : Implemented fast path mtu discovery.
38 * Fixed many serious bugs in the
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -070039 * request_sock handling and moved
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 * most of it into the af independent code.
41 * Added tail drop and some other bugfixes.
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -080042 * Added new listen semantics.
Linus Torvalds1da177e2005-04-16 15:20:36 -070043 * Mike McLagan : Routing by source
44 * Juan Jose Ciarlante: ip_dynaddr bits
45 * Andi Kleen: various fixes.
46 * Vitaly E. Lavrov : Transparent proxy revived after year
47 * coma.
48 * Andi Kleen : Fix new listen.
49 * Andi Kleen : Fix accept error reporting.
50 * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which
51 * Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind
52 * a single port at the same time.
53 */
54
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
56#include <linux/types.h>
57#include <linux/fcntl.h>
58#include <linux/module.h>
59#include <linux/random.h>
60#include <linux/cache.h>
61#include <linux/jhash.h>
62#include <linux/init.h>
63#include <linux/times.h>
64
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020065#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070066#include <net/icmp.h>
Arnaldo Carvalho de Melo304a1612005-08-09 19:59:20 -070067#include <net/inet_hashtables.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070068#include <net/tcp.h>
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -030069#include <net/transp_v6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070070#include <net/ipv6.h>
71#include <net/inet_common.h>
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -080072#include <net/timewait_sock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070073#include <net/xfrm.h>
Chris Leech1a2449a2006-05-23 18:05:53 -070074#include <net/netdma.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
76#include <linux/inet.h>
77#include <linux/ipv6.h>
78#include <linux/stddef.h>
79#include <linux/proc_fs.h>
80#include <linux/seq_file.h>
81
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080082#include <linux/crypto.h>
83#include <linux/scatterlist.h>
84
Brian Haleyab32ea52006-09-22 14:15:41 -070085int sysctl_tcp_tw_reuse __read_mostly;
86int sysctl_tcp_low_latency __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
88/* Check TCP sequence numbers in ICMP packets. */
89#define ICMP_MIN_LENGTH 8
90
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -080091void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080093#ifdef CONFIG_TCP_MD5SIG
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -020094static struct tcp_md5sig_key *tcp_v4_md5_do_lookup(struct sock *sk,
95 __be32 addr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080096static int tcp_v4_do_calc_md5_hash(char *md5_hash, struct tcp_md5sig_key *key,
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -020097 __be32 saddr, __be32 daddr,
YOSHIFUJI Hideaki076fb722008-04-17 12:48:12 +090098 struct tcphdr *th, unsigned int tcplen);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -080099#endif
100
Arnaldo Carvalho de Melo0f7ff922005-08-09 19:59:44 -0700101struct inet_hashinfo __cacheline_aligned tcp_hashinfo = {
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200102 .lhash_lock = __RW_LOCK_UNLOCKED(tcp_hashinfo.lhash_lock),
103 .lhash_users = ATOMIC_INIT(0),
104 .lhash_wait = __WAIT_QUEUE_HEAD_INITIALIZER(tcp_hashinfo.lhash_wait),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105};
106
Gerrit Renkera94f7232006-11-10 14:06:49 -0800107static inline __u32 tcp_v4_init_sequence(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700109 return secure_tcp_sequence_number(ip_hdr(skb)->daddr,
110 ip_hdr(skb)->saddr,
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700111 tcp_hdr(skb)->dest,
112 tcp_hdr(skb)->source);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113}
114
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800115int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp)
116{
117 const struct tcp_timewait_sock *tcptw = tcp_twsk(sktw);
118 struct tcp_sock *tp = tcp_sk(sk);
119
120 /* With PAWS, it is safe from the viewpoint
121 of data integrity. Even without PAWS it is safe provided sequence
122 spaces do not overlap i.e. at data rates <= 80Mbit/sec.
123
124 Actually, the idea is close to VJ's one, only timestamp cache is
125 held not per host, but per port pair and TW bucket is used as state
126 holder.
127
128 If TW bucket has been already destroyed we fall back to VJ's scheme
129 and use initial timestamp retrieved from peer table.
130 */
131 if (tcptw->tw_ts_recent_stamp &&
132 (twp == NULL || (sysctl_tcp_tw_reuse &&
James Morris9d729f72007-03-04 16:12:44 -0800133 get_seconds() - tcptw->tw_ts_recent_stamp > 1))) {
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800134 tp->write_seq = tcptw->tw_snd_nxt + 65535 + 2;
135 if (tp->write_seq == 0)
136 tp->write_seq = 1;
137 tp->rx_opt.ts_recent = tcptw->tw_ts_recent;
138 tp->rx_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp;
139 sock_hold(sktw);
140 return 1;
141 }
142
143 return 0;
144}
145
146EXPORT_SYMBOL_GPL(tcp_twsk_unique);
147
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148/* This will initiate an outgoing connection. */
149int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
150{
151 struct inet_sock *inet = inet_sk(sk);
152 struct tcp_sock *tp = tcp_sk(sk);
153 struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
154 struct rtable *rt;
Al Virobada8ad2006-09-26 21:27:15 -0700155 __be32 daddr, nexthop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 int tmp;
157 int err;
158
159 if (addr_len < sizeof(struct sockaddr_in))
160 return -EINVAL;
161
162 if (usin->sin_family != AF_INET)
163 return -EAFNOSUPPORT;
164
165 nexthop = daddr = usin->sin_addr.s_addr;
166 if (inet->opt && inet->opt->srr) {
167 if (!daddr)
168 return -EINVAL;
169 nexthop = inet->opt->faddr;
170 }
171
172 tmp = ip_route_connect(&rt, nexthop, inet->saddr,
173 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
174 IPPROTO_TCP,
David S. Miller8eb90862007-02-08 02:09:21 -0800175 inet->sport, usin->sin_port, sk, 1);
Wei Dong584bdf82007-05-31 22:49:28 -0700176 if (tmp < 0) {
177 if (tmp == -ENETUNREACH)
178 IP_INC_STATS_BH(IPSTATS_MIB_OUTNOROUTES);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 return tmp;
Wei Dong584bdf82007-05-31 22:49:28 -0700180 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181
182 if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
183 ip_rt_put(rt);
184 return -ENETUNREACH;
185 }
186
187 if (!inet->opt || !inet->opt->srr)
188 daddr = rt->rt_dst;
189
190 if (!inet->saddr)
191 inet->saddr = rt->rt_src;
192 inet->rcv_saddr = inet->saddr;
193
194 if (tp->rx_opt.ts_recent_stamp && inet->daddr != daddr) {
195 /* Reset inherited state */
196 tp->rx_opt.ts_recent = 0;
197 tp->rx_opt.ts_recent_stamp = 0;
198 tp->write_seq = 0;
199 }
200
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -0700201 if (tcp_death_row.sysctl_tw_recycle &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 !tp->rx_opt.ts_recent_stamp && rt->rt_dst == daddr) {
203 struct inet_peer *peer = rt_get_peer(rt);
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200204 /*
205 * VJ's idea. We save last timestamp seen from
206 * the destination in peer table, when entering state
207 * TIME-WAIT * and initialize rx_opt.ts_recent from it,
208 * when trying new connection.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 */
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200210 if (peer != NULL &&
James Morris9d729f72007-03-04 16:12:44 -0800211 peer->tcp_ts_stamp + TCP_PAWS_MSL >= get_seconds()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp;
213 tp->rx_opt.ts_recent = peer->tcp_ts;
214 }
215 }
216
217 inet->dport = usin->sin_port;
218 inet->daddr = daddr;
219
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800220 inet_csk(sk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 if (inet->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800222 inet_csk(sk)->icsk_ext_hdr_len = inet->opt->optlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223
224 tp->rx_opt.mss_clamp = 536;
225
226 /* Socket identity is still unknown (sport may be zero).
227 * However we set state to SYN-SENT and not releasing socket
228 * lock select source port, enter ourselves into the hash tables and
229 * complete initialization after this.
230 */
231 tcp_set_state(sk, TCP_SYN_SENT);
Arnaldo Carvalho de Meloa7f5e7f2005-12-13 23:25:31 -0800232 err = inet_hash_connect(&tcp_death_row, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 if (err)
234 goto failure;
235
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200236 err = ip_route_newports(&rt, IPPROTO_TCP,
237 inet->sport, inet->dport, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 if (err)
239 goto failure;
240
241 /* OK, now commit destination to socket. */
Herbert Xubcd76112006-06-30 13:36:35 -0700242 sk->sk_gso_type = SKB_GSO_TCPV4;
Arnaldo Carvalho de Melo6cbb0df2005-08-09 19:49:02 -0700243 sk_setup_caps(sk, &rt->u.dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
245 if (!tp->write_seq)
246 tp->write_seq = secure_tcp_sequence_number(inet->saddr,
247 inet->daddr,
248 inet->sport,
249 usin->sin_port);
250
251 inet->id = tp->write_seq ^ jiffies;
252
253 err = tcp_connect(sk);
254 rt = NULL;
255 if (err)
256 goto failure;
257
258 return 0;
259
260failure:
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200261 /*
262 * This unhashes the socket and releases the local port,
263 * if necessary.
264 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 tcp_set_state(sk, TCP_CLOSE);
266 ip_rt_put(rt);
267 sk->sk_route_caps = 0;
268 inet->dport = 0;
269 return err;
270}
271
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272/*
273 * This routine does path mtu discovery as defined in RFC1191.
274 */
Stephen Hemminger40efc6f2006-01-03 16:03:49 -0800275static void do_pmtu_discovery(struct sock *sk, struct iphdr *iph, u32 mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276{
277 struct dst_entry *dst;
278 struct inet_sock *inet = inet_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279
280 /* We are not interested in TCP_LISTEN and open_requests (SYN-ACKs
281 * send out by Linux are always <576bytes so they should go through
282 * unfragmented).
283 */
284 if (sk->sk_state == TCP_LISTEN)
285 return;
286
287 /* We don't check in the destentry if pmtu discovery is forbidden
288 * on this route. We just assume that no packet_to_big packets
289 * are send back when pmtu discovery is not active.
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900290 * There is a small race when the user changes this flag in the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 * route, but I think that's acceptable.
292 */
293 if ((dst = __sk_dst_check(sk, 0)) == NULL)
294 return;
295
296 dst->ops->update_pmtu(dst, mtu);
297
298 /* Something is about to be wrong... Remember soft error
299 * for the case, if this connection will not able to recover.
300 */
301 if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
302 sk->sk_err_soft = EMSGSIZE;
303
304 mtu = dst_mtu(dst);
305
306 if (inet->pmtudisc != IP_PMTUDISC_DONT &&
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800307 inet_csk(sk)->icsk_pmtu_cookie > mtu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 tcp_sync_mss(sk, mtu);
309
310 /* Resend the TCP packet because it's
311 * clear that the old packet has been
312 * dropped. This is the new "fast" path mtu
313 * discovery.
314 */
315 tcp_simple_retransmit(sk);
316 } /* else let the usual retransmit timer handle it */
317}
318
319/*
320 * This routine is called by the ICMP module when it gets some
321 * sort of error condition. If err < 0 then the socket should
322 * be closed and the error returned to the user. If err > 0
323 * it's just the icmp type << 8 | icmp code. After adjustment
324 * header points to the first 8 bytes of the tcp header. We need
325 * to find the appropriate port.
326 *
327 * The locking strategy used here is very "optimistic". When
328 * someone else accesses the socket the ICMP is just dropped
329 * and for some paths there is no check at all.
330 * A more general error queue to queue errors for later handling
331 * is probably better.
332 *
333 */
334
335void tcp_v4_err(struct sk_buff *skb, u32 info)
336{
337 struct iphdr *iph = (struct iphdr *)skb->data;
338 struct tcphdr *th = (struct tcphdr *)(skb->data + (iph->ihl << 2));
339 struct tcp_sock *tp;
340 struct inet_sock *inet;
Arnaldo Carvalho de Melo88c76642007-03-13 14:43:18 -0300341 const int type = icmp_hdr(skb)->type;
342 const int code = icmp_hdr(skb)->code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 struct sock *sk;
344 __u32 seq;
345 int err;
346
347 if (skb->len < (iph->ihl << 2) + 8) {
348 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
349 return;
350 }
351
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900352 sk = inet_lookup(dev_net(skb->dev), &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) {
355 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
356 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))
368 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS);
369
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)) {
Eric Dumazet06ca7192006-10-20 00:22:25 -0700377 NET_INC_STATS_BH(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 */
421 BUG_TRAP(!req->sk);
422
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700423 if (seq != tcp_rsk(req)->snt_isn) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
425 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546
547 /* Never send a reset in response to a reset. */
548 if (th->rst)
549 return;
550
Eric Dumazetee6b9672008-03-05 18:30:47 -0800551 if (skb->rtable->rt_type != RTN_LOCAL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 return;
553
554 /* Swap the send and the receive. */
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800555 memset(&rep, 0, sizeof(rep));
556 rep.th.dest = th->source;
557 rep.th.source = th->dest;
558 rep.th.doff = sizeof(struct tcphdr) / 4;
559 rep.th.rst = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560
561 if (th->ack) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800562 rep.th.seq = th->ack_seq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800564 rep.th.ack = 1;
565 rep.th.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
566 skb->len - (th->doff << 2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 }
568
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200569 memset(&arg, 0, sizeof(arg));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800570 arg.iov[0].iov_base = (unsigned char *)&rep;
571 arg.iov[0].iov_len = sizeof(rep.th);
572
573#ifdef CONFIG_TCP_MD5SIG
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700574 key = sk ? tcp_v4_md5_do_lookup(sk, ip_hdr(skb)->daddr) : NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800575 if (key) {
576 rep.opt[0] = htonl((TCPOPT_NOP << 24) |
577 (TCPOPT_NOP << 16) |
578 (TCPOPT_MD5SIG << 8) |
579 TCPOLEN_MD5SIG);
580 /* Update length and the length the header thinks exists */
581 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
582 rep.th.doff = arg.iov[0].iov_len / 4;
583
584 tcp_v4_do_calc_md5_hash((__u8 *)&rep.opt[1],
585 key,
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700586 ip_hdr(skb)->daddr,
587 ip_hdr(skb)->saddr,
YOSHIFUJI Hideaki076fb722008-04-17 12:48:12 +0900588 &rep.th, arg.iov[0].iov_len);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800589 }
590#endif
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700591 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
592 ip_hdr(skb)->saddr, /* XXX */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 sizeof(struct tcphdr), IPPROTO_TCP, 0);
594 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
595
Denis V. Lunev7feb49c2008-04-03 14:32:00 -0700596 ip_send_reply(dev_net(skb->dst->dev)->ipv4.tcp_sock, skb,
597 &arg, arg.iov[0].iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598
599 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
600 TCP_INC_STATS_BH(TCP_MIB_OUTRSTS);
601}
602
603/* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
604 outside socket context is ugly, certainly. What can I do?
605 */
606
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800607static void tcp_v4_send_ack(struct tcp_timewait_sock *twsk,
608 struct sk_buff *skb, u32 seq, u32 ack,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 u32 win, u32 ts)
610{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700611 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 struct {
613 struct tcphdr th;
Al Viro714e85b2006-11-14 20:51:49 -0800614 __be32 opt[(TCPOLEN_TSTAMP_ALIGNED >> 2)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800615#ifdef CONFIG_TCP_MD5SIG
Al Viro714e85b2006-11-14 20:51:49 -0800616 + (TCPOLEN_MD5SIG_ALIGNED >> 2)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800617#endif
618 ];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 } rep;
620 struct ip_reply_arg arg;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800621#ifdef CONFIG_TCP_MD5SIG
622 struct tcp_md5sig_key *key;
623 struct tcp_md5sig_key tw_key;
624#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625
626 memset(&rep.th, 0, sizeof(struct tcphdr));
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200627 memset(&arg, 0, sizeof(arg));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628
629 arg.iov[0].iov_base = (unsigned char *)&rep;
630 arg.iov[0].iov_len = sizeof(rep.th);
631 if (ts) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800632 rep.opt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
633 (TCPOPT_TIMESTAMP << 8) |
634 TCPOLEN_TIMESTAMP);
635 rep.opt[1] = htonl(tcp_time_stamp);
636 rep.opt[2] = htonl(ts);
Craig Schlentercb48cfe2007-01-09 00:11:15 -0800637 arg.iov[0].iov_len += TCPOLEN_TSTAMP_ALIGNED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 }
639
640 /* Swap the send and the receive. */
641 rep.th.dest = th->source;
642 rep.th.source = th->dest;
643 rep.th.doff = arg.iov[0].iov_len / 4;
644 rep.th.seq = htonl(seq);
645 rep.th.ack_seq = htonl(ack);
646 rep.th.ack = 1;
647 rep.th.window = htons(win);
648
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800649#ifdef CONFIG_TCP_MD5SIG
650 /*
651 * The SKB holds an imcoming packet, but may not have a valid ->sk
652 * pointer. This is especially the case when we're dealing with a
653 * TIME_WAIT ack, because the sk structure is long gone, and only
654 * the tcp_timewait_sock remains. So the md5 key is stashed in that
655 * structure, and we use it in preference. I believe that (twsk ||
656 * skb->sk) holds true, but we program defensively.
657 */
658 if (!twsk && skb->sk) {
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700659 key = tcp_v4_md5_do_lookup(skb->sk, ip_hdr(skb)->daddr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800660 } else if (twsk && twsk->tw_md5_keylen) {
661 tw_key.key = twsk->tw_md5_key;
662 tw_key.keylen = twsk->tw_md5_keylen;
663 key = &tw_key;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200664 } else
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800665 key = NULL;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800666
667 if (key) {
668 int offset = (ts) ? 3 : 0;
669
670 rep.opt[offset++] = htonl((TCPOPT_NOP << 24) |
671 (TCPOPT_NOP << 16) |
672 (TCPOPT_MD5SIG << 8) |
673 TCPOLEN_MD5SIG);
674 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
675 rep.th.doff = arg.iov[0].iov_len/4;
676
677 tcp_v4_do_calc_md5_hash((__u8 *)&rep.opt[offset],
678 key,
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700679 ip_hdr(skb)->daddr,
680 ip_hdr(skb)->saddr,
YOSHIFUJI Hideaki076fb722008-04-17 12:48:12 +0900681 &rep.th, arg.iov[0].iov_len);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800682 }
683#endif
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700684 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
685 ip_hdr(skb)->saddr, /* XXX */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 arg.iov[0].iov_len, IPPROTO_TCP, 0);
687 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
Patrick McHardyf0e48db2007-06-04 21:32:46 -0700688 if (twsk)
689 arg.bound_dev_if = twsk->tw_sk.tw_bound_dev_if;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690
Denis V. Lunev7feb49c2008-04-03 14:32:00 -0700691 ip_send_reply(dev_net(skb->dev)->ipv4.tcp_sock, skb,
692 &arg, arg.iov[0].iov_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693
694 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
695}
696
697static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
698{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700699 struct inet_timewait_sock *tw = inet_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800700 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800702 tcp_v4_send_ack(tcptw, skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200703 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
704 tcptw->tw_ts_recent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700706 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707}
708
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200709static void tcp_v4_reqsk_send_ack(struct sk_buff *skb,
710 struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800712 tcp_v4_send_ack(NULL, skb, tcp_rsk(req)->snt_isn + 1,
713 tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 req->ts_recent);
715}
716
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717/*
Kris Katterjohn9bf1d832008-02-17 22:29:19 -0800718 * Send a SYN-ACK after having received a SYN.
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700719 * This still operates on a request_sock only, not on a big
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 * socket.
721 */
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800722static int __tcp_v4_send_synack(struct sock *sk, struct request_sock *req,
723 struct dst_entry *dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700725 const struct inet_request_sock *ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 int err = -1;
727 struct sk_buff * skb;
728
729 /* First, grab a route. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700730 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800731 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732
733 skb = tcp_make_synack(sk, dst, req);
734
735 if (skb) {
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700736 struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737
Frederik Deweerdtba7808e2007-02-04 20:15:27 -0800738 th->check = tcp_v4_check(skb->len,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700739 ireq->loc_addr,
740 ireq->rmt_addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 csum_partial((char *)th, skb->len,
742 skb->csum));
743
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700744 err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,
745 ireq->rmt_addr,
746 ireq->opt);
Gerrit Renkerb9df3cb2006-11-14 11:21:36 -0200747 err = net_xmit_eval(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 }
749
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 dst_release(dst);
751 return err;
752}
753
Denis V. Lunevfd80eb92008-02-29 11:43:03 -0800754static int tcp_v4_send_synack(struct sock *sk, struct request_sock *req)
755{
756 return __tcp_v4_send_synack(sk, req, NULL);
757}
758
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700760 * IPv4 request_sock destructor.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 */
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700762static void tcp_v4_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763{
Jesper Juhla51482b2005-11-08 09:41:34 -0800764 kfree(inet_rsk(req)->opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765}
766
Arnaldo Carvalho de Melo80e40da2006-01-04 01:58:06 -0200767#ifdef CONFIG_SYN_COOKIES
Stephen Hemminger40efc6f2006-01-03 16:03:49 -0800768static void syn_flood_warning(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769{
770 static unsigned long warntime;
771
772 if (time_after(jiffies, (warntime + HZ * 60))) {
773 warntime = jiffies;
774 printk(KERN_INFO
775 "possible SYN flooding on port %d. Sending cookies.\n",
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700776 ntohs(tcp_hdr(skb)->dest));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 }
778}
Arnaldo Carvalho de Melo80e40da2006-01-04 01:58:06 -0200779#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
781/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700782 * Save and compile IPv4 options into the request_sock if needed.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 */
Stephen Hemminger40efc6f2006-01-03 16:03:49 -0800784static struct ip_options *tcp_v4_save_options(struct sock *sk,
785 struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786{
787 struct ip_options *opt = &(IPCB(skb)->opt);
788 struct ip_options *dopt = NULL;
789
790 if (opt && opt->optlen) {
791 int opt_size = optlength(opt);
792 dopt = kmalloc(opt_size, GFP_ATOMIC);
793 if (dopt) {
794 if (ip_options_echo(dopt, skb)) {
795 kfree(dopt);
796 dopt = NULL;
797 }
798 }
799 }
800 return dopt;
801}
802
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800803#ifdef CONFIG_TCP_MD5SIG
804/*
805 * RFC2385 MD5 checksumming requires a mapping of
806 * IP address->MD5 Key.
807 * We need to maintain these in the sk structure.
808 */
809
810/* Find the Key structure for an address. */
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200811static struct tcp_md5sig_key *
812 tcp_v4_md5_do_lookup(struct sock *sk, __be32 addr)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800813{
814 struct tcp_sock *tp = tcp_sk(sk);
815 int i;
816
817 if (!tp->md5sig_info || !tp->md5sig_info->entries4)
818 return NULL;
819 for (i = 0; i < tp->md5sig_info->entries4; i++) {
820 if (tp->md5sig_info->keys4[i].addr == addr)
David S. Millerf8ab18d2007-09-28 15:18:35 -0700821 return &tp->md5sig_info->keys4[i].base;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800822 }
823 return NULL;
824}
825
826struct tcp_md5sig_key *tcp_v4_md5_lookup(struct sock *sk,
827 struct sock *addr_sk)
828{
829 return tcp_v4_md5_do_lookup(sk, inet_sk(addr_sk)->daddr);
830}
831
832EXPORT_SYMBOL(tcp_v4_md5_lookup);
833
Adrian Bunkf5b99bc2006-11-30 17:22:29 -0800834static struct tcp_md5sig_key *tcp_v4_reqsk_md5_lookup(struct sock *sk,
835 struct request_sock *req)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800836{
837 return tcp_v4_md5_do_lookup(sk, inet_rsk(req)->rmt_addr);
838}
839
840/* This can be called on a newly created socket, from other files */
841int tcp_v4_md5_do_add(struct sock *sk, __be32 addr,
842 u8 *newkey, u8 newkeylen)
843{
844 /* Add Key to the list */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700845 struct tcp_md5sig_key *key;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800846 struct tcp_sock *tp = tcp_sk(sk);
847 struct tcp4_md5sig_key *keys;
848
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700849 key = tcp_v4_md5_do_lookup(sk, addr);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800850 if (key) {
851 /* Pre-existing entry - just update that one. */
Matthias M. Dellwegb0a713e2007-10-29 20:55:27 -0700852 kfree(key->key);
853 key->key = newkey;
854 key->keylen = newkeylen;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800855 } else {
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200856 struct tcp_md5sig_info *md5sig;
857
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800858 if (!tp->md5sig_info) {
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200859 tp->md5sig_info = kzalloc(sizeof(*tp->md5sig_info),
860 GFP_ATOMIC);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800861 if (!tp->md5sig_info) {
862 kfree(newkey);
863 return -ENOMEM;
864 }
David S. Miller3d7dbea2007-06-12 14:36:42 -0700865 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800866 }
867 if (tcp_alloc_md5sig_pool() == NULL) {
868 kfree(newkey);
869 return -ENOMEM;
870 }
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200871 md5sig = tp->md5sig_info;
872
873 if (md5sig->alloced4 == md5sig->entries4) {
874 keys = kmalloc((sizeof(*keys) *
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900875 (md5sig->entries4 + 1)), GFP_ATOMIC);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800876 if (!keys) {
877 kfree(newkey);
878 tcp_free_md5sig_pool();
879 return -ENOMEM;
880 }
881
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200882 if (md5sig->entries4)
883 memcpy(keys, md5sig->keys4,
884 sizeof(*keys) * md5sig->entries4);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800885
886 /* Free old key list, and reference new one */
YOSHIFUJI Hideakia80cc202007-11-20 17:30:06 -0800887 kfree(md5sig->keys4);
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200888 md5sig->keys4 = keys;
889 md5sig->alloced4++;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800890 }
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200891 md5sig->entries4++;
David S. Millerf8ab18d2007-09-28 15:18:35 -0700892 md5sig->keys4[md5sig->entries4 - 1].addr = addr;
893 md5sig->keys4[md5sig->entries4 - 1].base.key = newkey;
894 md5sig->keys4[md5sig->entries4 - 1].base.keylen = newkeylen;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800895 }
896 return 0;
897}
898
899EXPORT_SYMBOL(tcp_v4_md5_do_add);
900
901static int tcp_v4_md5_add_func(struct sock *sk, struct sock *addr_sk,
902 u8 *newkey, u8 newkeylen)
903{
904 return tcp_v4_md5_do_add(sk, inet_sk(addr_sk)->daddr,
905 newkey, newkeylen);
906}
907
908int tcp_v4_md5_do_del(struct sock *sk, __be32 addr)
909{
910 struct tcp_sock *tp = tcp_sk(sk);
911 int i;
912
913 for (i = 0; i < tp->md5sig_info->entries4; i++) {
914 if (tp->md5sig_info->keys4[i].addr == addr) {
915 /* Free the key */
David S. Millerf8ab18d2007-09-28 15:18:35 -0700916 kfree(tp->md5sig_info->keys4[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800917 tp->md5sig_info->entries4--;
918
919 if (tp->md5sig_info->entries4 == 0) {
920 kfree(tp->md5sig_info->keys4);
921 tp->md5sig_info->keys4 = NULL;
Leigh Brown8228a18d2006-12-17 17:12:30 -0800922 tp->md5sig_info->alloced4 = 0;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200923 } else if (tp->md5sig_info->entries4 != i) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800924 /* Need to do some manipulation */
YOSHIFUJI Hideaki354faf02007-11-20 17:30:31 -0800925 memmove(&tp->md5sig_info->keys4[i],
926 &tp->md5sig_info->keys4[i+1],
927 (tp->md5sig_info->entries4 - i) *
928 sizeof(struct tcp4_md5sig_key));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800929 }
930 tcp_free_md5sig_pool();
931 return 0;
932 }
933 }
934 return -ENOENT;
935}
936
937EXPORT_SYMBOL(tcp_v4_md5_do_del);
938
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200939static void tcp_v4_clear_md5_list(struct sock *sk)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800940{
941 struct tcp_sock *tp = tcp_sk(sk);
942
943 /* Free each key, then the set of key keys,
944 * the crypto element, and then decrement our
945 * hold on the last resort crypto.
946 */
947 if (tp->md5sig_info->entries4) {
948 int i;
949 for (i = 0; i < tp->md5sig_info->entries4; i++)
David S. Millerf8ab18d2007-09-28 15:18:35 -0700950 kfree(tp->md5sig_info->keys4[i].base.key);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800951 tp->md5sig_info->entries4 = 0;
952 tcp_free_md5sig_pool();
953 }
954 if (tp->md5sig_info->keys4) {
955 kfree(tp->md5sig_info->keys4);
956 tp->md5sig_info->keys4 = NULL;
957 tp->md5sig_info->alloced4 = 0;
958 }
959}
960
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200961static int tcp_v4_parse_md5_keys(struct sock *sk, char __user *optval,
962 int optlen)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800963{
964 struct tcp_md5sig cmd;
965 struct sockaddr_in *sin = (struct sockaddr_in *)&cmd.tcpm_addr;
966 u8 *newkey;
967
968 if (optlen < sizeof(cmd))
969 return -EINVAL;
970
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200971 if (copy_from_user(&cmd, optval, sizeof(cmd)))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800972 return -EFAULT;
973
974 if (sin->sin_family != AF_INET)
975 return -EINVAL;
976
977 if (!cmd.tcpm_key || !cmd.tcpm_keylen) {
978 if (!tcp_sk(sk)->md5sig_info)
979 return -ENOENT;
980 return tcp_v4_md5_do_del(sk, sin->sin_addr.s_addr);
981 }
982
983 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
984 return -EINVAL;
985
986 if (!tcp_sk(sk)->md5sig_info) {
987 struct tcp_sock *tp = tcp_sk(sk);
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -0200988 struct tcp_md5sig_info *p = kzalloc(sizeof(*p), GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800989
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800990 if (!p)
991 return -EINVAL;
992
993 tp->md5sig_info = p;
David S. Miller3d7dbea2007-06-12 14:36:42 -0700994 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800995 }
996
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -0200997 newkey = kmemdup(cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800998 if (!newkey)
999 return -ENOMEM;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001000 return tcp_v4_md5_do_add(sk, sin->sin_addr.s_addr,
1001 newkey, cmd.tcpm_keylen);
1002}
1003
1004static int tcp_v4_do_calc_md5_hash(char *md5_hash, struct tcp_md5sig_key *key,
1005 __be32 saddr, __be32 daddr,
YOSHIFUJI Hideaki076fb722008-04-17 12:48:12 +09001006 struct tcphdr *th,
YOSHIFUJI Hideaki9cb57342008-01-12 02:16:03 -08001007 unsigned int tcplen)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001008{
1009 struct scatterlist sg[4];
1010 __u16 data_len;
1011 int block = 0;
Al Viro8e5200f2006-11-20 18:06:37 -08001012 __sum16 old_checksum;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001013 struct tcp_md5sig_pool *hp;
1014 struct tcp4_pseudohdr *bp;
1015 struct hash_desc *desc;
1016 int err;
1017 unsigned int nbytes = 0;
1018
1019 /*
1020 * Okay, so RFC2385 is turned on for this connection,
1021 * so we need to generate the MD5 hash for the packet now.
1022 */
1023
1024 hp = tcp_get_md5sig_pool();
1025 if (!hp)
1026 goto clear_hash_noput;
1027
1028 bp = &hp->md5_blk.ip4;
1029 desc = &hp->md5_desc;
1030
1031 /*
1032 * 1. the TCP pseudo-header (in the order: source IP address,
1033 * destination IP address, zero-padded protocol number, and
1034 * segment length)
1035 */
1036 bp->saddr = saddr;
1037 bp->daddr = daddr;
1038 bp->pad = 0;
YOSHIFUJI Hideaki076fb722008-04-17 12:48:12 +09001039 bp->protocol = IPPROTO_TCP;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001040 bp->len = htons(tcplen);
David S. Millerc7da57a2007-10-26 00:41:21 -07001041
1042 sg_init_table(sg, 4);
1043
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001044 sg_set_buf(&sg[block++], bp, sizeof(*bp));
1045 nbytes += sizeof(*bp);
1046
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001047 /* 2. the TCP header, excluding options, and assuming a
1048 * checksum of zero/
1049 */
1050 old_checksum = th->check;
1051 th->check = 0;
1052 sg_set_buf(&sg[block++], th, sizeof(struct tcphdr));
1053 nbytes += sizeof(struct tcphdr);
David S. Miller08dd1a52006-11-30 16:35:01 -08001054
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001055 /* 3. the TCP segment data (if any) */
1056 data_len = tcplen - (th->doff << 2);
1057 if (data_len > 0) {
1058 unsigned char *data = (unsigned char *)th + (th->doff << 2);
1059 sg_set_buf(&sg[block++], data, data_len);
1060 nbytes += data_len;
1061 }
1062
1063 /* 4. an independently-specified key or password, known to both
1064 * TCPs and presumably connection-specific
1065 */
1066 sg_set_buf(&sg[block++], key->key, key->keylen);
1067 nbytes += key->keylen;
1068
Jens Axboec46f2332007-10-31 12:06:37 +01001069 sg_mark_end(&sg[block - 1]);
David S. Millerc7da57a2007-10-26 00:41:21 -07001070
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001071 /* Now store the Hash into the packet */
1072 err = crypto_hash_init(desc);
1073 if (err)
1074 goto clear_hash;
1075 err = crypto_hash_update(desc, sg, nbytes);
1076 if (err)
1077 goto clear_hash;
1078 err = crypto_hash_final(desc, md5_hash);
1079 if (err)
1080 goto clear_hash;
1081
1082 /* Reset header, and free up the crypto */
1083 tcp_put_md5sig_pool();
1084 th->check = old_checksum;
1085
1086out:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001087 return 0;
1088clear_hash:
1089 tcp_put_md5sig_pool();
1090clear_hash_noput:
1091 memset(md5_hash, 0, 16);
1092 goto out;
1093}
1094
1095int tcp_v4_calc_md5_hash(char *md5_hash, struct tcp_md5sig_key *key,
1096 struct sock *sk,
1097 struct dst_entry *dst,
1098 struct request_sock *req,
YOSHIFUJI Hideaki076fb722008-04-17 12:48:12 +09001099 struct tcphdr *th,
YOSHIFUJI Hideaki9cb57342008-01-12 02:16:03 -08001100 unsigned int tcplen)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001101{
1102 __be32 saddr, daddr;
1103
1104 if (sk) {
1105 saddr = inet_sk(sk)->saddr;
1106 daddr = inet_sk(sk)->daddr;
1107 } else {
1108 struct rtable *rt = (struct rtable *)dst;
1109 BUG_ON(!rt);
1110 saddr = rt->rt_src;
1111 daddr = rt->rt_dst;
1112 }
1113 return tcp_v4_do_calc_md5_hash(md5_hash, key,
1114 saddr, daddr,
YOSHIFUJI Hideaki076fb722008-04-17 12:48:12 +09001115 th, tcplen);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001116}
1117
1118EXPORT_SYMBOL(tcp_v4_calc_md5_hash);
1119
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001120static int tcp_v4_inbound_md5_hash(struct sock *sk, struct sk_buff *skb)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001121{
1122 /*
1123 * This gets called for each TCP segment that arrives
1124 * so we want to be efficient.
1125 * We have 3 drop cases:
1126 * o No MD5 hash and one expected.
1127 * o MD5 hash and we're not expecting one.
1128 * o MD5 hash and its wrong.
1129 */
1130 __u8 *hash_location = NULL;
1131 struct tcp_md5sig_key *hash_expected;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001132 const struct iphdr *iph = ip_hdr(skb);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001133 struct tcphdr *th = tcp_hdr(skb);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001134 int genhash;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001135 unsigned char newhash[16];
1136
1137 hash_expected = tcp_v4_md5_do_lookup(sk, iph->saddr);
YOSHIFUJI Hideaki7d5d5522008-04-17 12:29:53 +09001138 hash_location = tcp_parse_md5sig_option(th);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001139
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001140 /* We've parsed the options - do we have a hash? */
1141 if (!hash_expected && !hash_location)
1142 return 0;
1143
1144 if (hash_expected && !hash_location) {
Leigh Browna9fc00c2006-12-17 17:13:10 -08001145 LIMIT_NETDEBUG(KERN_INFO "MD5 Hash expected but NOT found "
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001146 "(" NIPQUAD_FMT ", %d)->(" NIPQUAD_FMT ", %d)\n",
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001147 NIPQUAD(iph->saddr), ntohs(th->source),
1148 NIPQUAD(iph->daddr), ntohs(th->dest));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001149 return 1;
1150 }
1151
1152 if (!hash_expected && hash_location) {
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001153 LIMIT_NETDEBUG(KERN_INFO "MD5 Hash NOT expected but found "
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001154 "(" NIPQUAD_FMT ", %d)->(" NIPQUAD_FMT ", %d)\n",
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001155 NIPQUAD(iph->saddr), ntohs(th->source),
1156 NIPQUAD(iph->daddr), ntohs(th->dest));
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001157 return 1;
1158 }
1159
1160 /* Okay, so this is hash_expected and hash_location -
1161 * so we need to calculate the checksum.
1162 */
1163 genhash = tcp_v4_do_calc_md5_hash(newhash,
1164 hash_expected,
1165 iph->saddr, iph->daddr,
YOSHIFUJI Hideaki076fb722008-04-17 12:48:12 +09001166 th, skb->len);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001167
1168 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
1169 if (net_ratelimit()) {
1170 printk(KERN_INFO "MD5 Hash failed for "
1171 "(" NIPQUAD_FMT ", %d)->(" NIPQUAD_FMT ", %d)%s\n",
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001172 NIPQUAD(iph->saddr), ntohs(th->source),
1173 NIPQUAD(iph->daddr), ntohs(th->dest),
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001174 genhash ? " tcp_v4_calc_md5_hash failed" : "");
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001175 }
1176 return 1;
1177 }
1178 return 0;
1179}
1180
1181#endif
1182
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001183struct request_sock_ops tcp_request_sock_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184 .family = PF_INET,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001185 .obj_size = sizeof(struct tcp_request_sock),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 .rtx_syn_ack = tcp_v4_send_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001187 .send_ack = tcp_v4_reqsk_send_ack,
1188 .destructor = tcp_v4_reqsk_destructor,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 .send_reset = tcp_v4_send_reset,
1190};
1191
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001192#ifdef CONFIG_TCP_MD5SIG
Andrew Mortonb6332e62006-11-30 19:16:28 -08001193static struct tcp_request_sock_ops tcp_request_sock_ipv4_ops = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001194 .md5_lookup = tcp_v4_reqsk_md5_lookup,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001195};
Andrew Mortonb6332e62006-11-30 19:16:28 -08001196#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001197
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08001198static struct timewait_sock_ops tcp_timewait_sock_ops = {
1199 .twsk_obj_size = sizeof(struct tcp_timewait_sock),
1200 .twsk_unique = tcp_twsk_unique,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001201 .twsk_destructor= tcp_twsk_destructor,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08001202};
1203
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1205{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001206 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207 struct tcp_options_received tmp_opt;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001208 struct request_sock *req;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001209 __be32 saddr = ip_hdr(skb)->saddr;
1210 __be32 daddr = ip_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211 __u32 isn = TCP_SKB_CB(skb)->when;
1212 struct dst_entry *dst = NULL;
1213#ifdef CONFIG_SYN_COOKIES
1214 int want_cookie = 0;
1215#else
1216#define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */
1217#endif
1218
1219 /* Never answer to SYNs send to broadcast or multicast */
Eric Dumazetee6b9672008-03-05 18:30:47 -08001220 if (skb->rtable->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 goto drop;
1222
1223 /* TW buckets are converted to open requests without
1224 * limitations, they conserve resources and peer is
1225 * evidently real one.
1226 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001227 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228#ifdef CONFIG_SYN_COOKIES
1229 if (sysctl_tcp_syncookies) {
1230 want_cookie = 1;
1231 } else
1232#endif
1233 goto drop;
1234 }
1235
1236 /* Accept backlog is full. If we have already queued enough
1237 * of warm entries in syn queue, drop request. It is better than
1238 * clogging syn queue with openreqs with exponentially increasing
1239 * timeout.
1240 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001241 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242 goto drop;
1243
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001244 req = reqsk_alloc(&tcp_request_sock_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 if (!req)
1246 goto drop;
1247
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001248#ifdef CONFIG_TCP_MD5SIG
1249 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv4_ops;
1250#endif
1251
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 tcp_clear_options(&tmp_opt);
1253 tmp_opt.mss_clamp = 536;
1254 tmp_opt.user_mss = tcp_sk(sk)->rx_opt.user_mss;
1255
1256 tcp_parse_options(skb, &tmp_opt, 0);
1257
Florian Westphal4dfc2812008-04-10 03:12:40 -07001258 if (want_cookie && !tmp_opt.saw_tstamp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 tcp_clear_options(&tmp_opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260
1261 if (tmp_opt.saw_tstamp && !tmp_opt.rcv_tsval) {
1262 /* Some OSes (unknown ones, but I see them on web server, which
1263 * contains information interesting only for windows'
1264 * users) do not send their stamp in SYN. It is easy case.
1265 * We simply do not advertise TS support.
1266 */
1267 tmp_opt.saw_tstamp = 0;
1268 tmp_opt.tstamp_ok = 0;
1269 }
1270 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
1271
1272 tcp_openreq_init(req, &tmp_opt, skb);
1273
Venkat Yekkirala4237c752006-07-24 23:32:50 -07001274 if (security_inet_conn_request(sk, skb, req))
1275 goto drop_and_free;
1276
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001277 ireq = inet_rsk(req);
1278 ireq->loc_addr = daddr;
1279 ireq->rmt_addr = saddr;
1280 ireq->opt = tcp_v4_save_options(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 if (!want_cookie)
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001282 TCP_ECN_create_request(req, tcp_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283
1284 if (want_cookie) {
1285#ifdef CONFIG_SYN_COOKIES
1286 syn_flood_warning(skb);
Florian Westphal4dfc2812008-04-10 03:12:40 -07001287 req->cookie_ts = tmp_opt.tstamp_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288#endif
1289 isn = cookie_v4_init_sequence(sk, skb, &req->mss);
1290 } else if (!isn) {
1291 struct inet_peer *peer = NULL;
1292
1293 /* VJ's idea. We save last timestamp seen
1294 * from the destination in peer table, when entering
1295 * state TIME-WAIT, and check against it before
1296 * accepting new connection request.
1297 *
1298 * If "isn" is not zero, this request hit alive
1299 * timewait bucket, so that all the necessary checks
1300 * are made in the function processing timewait state.
1301 */
1302 if (tmp_opt.saw_tstamp &&
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001303 tcp_death_row.sysctl_tw_recycle &&
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001304 (dst = inet_csk_route_req(sk, req)) != NULL &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 (peer = rt_get_peer((struct rtable *)dst)) != NULL &&
1306 peer->v4daddr == saddr) {
James Morris9d729f72007-03-04 16:12:44 -08001307 if (get_seconds() < peer->tcp_ts_stamp + TCP_PAWS_MSL &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 (s32)(peer->tcp_ts - req->ts_recent) >
1309 TCP_PAWS_WINDOW) {
1310 NET_INC_STATS_BH(LINUX_MIB_PAWSPASSIVEREJECTED);
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001311 goto drop_and_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 }
1313 }
1314 /* Kill the following clause, if you dislike this way. */
1315 else if (!sysctl_tcp_syncookies &&
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001316 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 (sysctl_max_syn_backlog >> 2)) &&
1318 (!peer || !peer->tcp_ts_stamp) &&
1319 (!dst || !dst_metric(dst, RTAX_RTT))) {
1320 /* Without syncookies last quarter of
1321 * backlog is filled with destinations,
1322 * proven to be alive.
1323 * It means that we continue to communicate
1324 * to destinations, already remembered
1325 * to the moment of synflood.
1326 */
Patrick McHardy64ce2072005-08-09 20:50:53 -07001327 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open "
YOSHIFUJI Hideakia7d632b2008-04-14 04:09:00 -07001328 "request from " NIPQUAD_FMT "/%u\n",
Patrick McHardy64ce2072005-08-09 20:50:53 -07001329 NIPQUAD(saddr),
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001330 ntohs(tcp_hdr(skb)->source));
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001331 goto drop_and_release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 }
1333
Gerrit Renkera94f7232006-11-10 14:06:49 -08001334 isn = tcp_v4_init_sequence(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 }
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001336 tcp_rsk(req)->snt_isn = isn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001338 if (__tcp_v4_send_synack(sk, req, dst) || want_cookie)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339 goto drop_and_free;
1340
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001341 inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 return 0;
1343
Denis V. Lunev7cd04fa2008-03-03 11:59:32 -08001344drop_and_release:
1345 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346drop_and_free:
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001347 reqsk_free(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348drop:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349 return 0;
1350}
1351
1352
1353/*
1354 * The three way handshake has completed - we got a valid synack -
1355 * now create the new socket.
1356 */
1357struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001358 struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 struct dst_entry *dst)
1360{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001361 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 struct inet_sock *newinet;
1363 struct tcp_sock *newtp;
1364 struct sock *newsk;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001365#ifdef CONFIG_TCP_MD5SIG
1366 struct tcp_md5sig_key *key;
1367#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368
1369 if (sk_acceptq_is_full(sk))
1370 goto exit_overflow;
1371
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001372 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 goto exit;
1374
1375 newsk = tcp_create_openreq_child(sk, req, skb);
1376 if (!newsk)
1377 goto exit;
1378
Herbert Xubcd76112006-06-30 13:36:35 -07001379 newsk->sk_gso_type = SKB_GSO_TCPV4;
Arnaldo Carvalho de Melo6cbb0df2005-08-09 19:49:02 -07001380 sk_setup_caps(newsk, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381
1382 newtp = tcp_sk(newsk);
1383 newinet = inet_sk(newsk);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001384 ireq = inet_rsk(req);
1385 newinet->daddr = ireq->rmt_addr;
1386 newinet->rcv_saddr = ireq->loc_addr;
1387 newinet->saddr = ireq->loc_addr;
1388 newinet->opt = ireq->opt;
1389 ireq->opt = NULL;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001390 newinet->mc_index = inet_iif(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001391 newinet->mc_ttl = ip_hdr(skb)->ttl;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001392 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393 if (newinet->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001394 inet_csk(newsk)->icsk_ext_hdr_len = newinet->opt->optlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 newinet->id = newtp->write_seq ^ jiffies;
1396
John Heffner5d424d52006-03-20 17:53:41 -08001397 tcp_mtup_init(newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398 tcp_sync_mss(newsk, dst_mtu(dst));
1399 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
1400 tcp_initialize_rcv_mss(newsk);
1401
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001402#ifdef CONFIG_TCP_MD5SIG
1403 /* Copy over the MD5 key from the original socket */
1404 if ((key = tcp_v4_md5_do_lookup(sk, newinet->daddr)) != NULL) {
1405 /*
1406 * We're using one, so create a matching key
1407 * on the newsk structure. If we fail to get
1408 * memory, then we end up not copying the key
1409 * across. Shucks.
1410 */
Arnaldo Carvalho de Melof6685932006-11-17 11:06:01 -02001411 char *newkey = kmemdup(key->key, key->keylen, GFP_ATOMIC);
1412 if (newkey != NULL)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001413 tcp_v4_md5_do_add(newsk, inet_sk(sk)->daddr,
1414 newkey, key->keylen);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001415 }
1416#endif
1417
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001418 __inet_hash_nolisten(newsk);
1419 __inet_inherit_port(sk, newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420
1421 return newsk;
1422
1423exit_overflow:
1424 NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS);
1425exit:
1426 NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS);
1427 dst_release(dst);
1428 return NULL;
1429}
1430
1431static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
1432{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001433 struct tcphdr *th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001434 const struct iphdr *iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 struct sock *nsk;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001436 struct request_sock **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437 /* Find possible connection requests. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001438 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
1439 iph->saddr, iph->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440 if (req)
1441 return tcp_check_req(sk, skb, req, prev);
1442
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001443 nsk = inet_lookup_established(sock_net(sk), &tcp_hashinfo, iph->saddr,
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001444 th->source, iph->daddr, th->dest, inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445
1446 if (nsk) {
1447 if (nsk->sk_state != TCP_TIME_WAIT) {
1448 bh_lock_sock(nsk);
1449 return nsk;
1450 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001451 inet_twsk_put(inet_twsk(nsk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452 return NULL;
1453 }
1454
1455#ifdef CONFIG_SYN_COOKIES
1456 if (!th->rst && !th->syn && th->ack)
1457 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
1458#endif
1459 return sk;
1460}
1461
Al Virob51655b2006-11-14 21:40:42 -08001462static __sum16 tcp_v4_checksum_init(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001464 const struct iphdr *iph = ip_hdr(skb);
1465
Patrick McHardy84fa7932006-08-29 16:44:56 -07001466 if (skb->ip_summed == CHECKSUM_COMPLETE) {
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001467 if (!tcp_v4_check(skb->len, iph->saddr,
1468 iph->daddr, skb->csum)) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001469 skb->ip_summed = CHECKSUM_UNNECESSARY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470 return 0;
Herbert Xufb286bb2005-11-10 13:01:24 -08001471 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472 }
Herbert Xufb286bb2005-11-10 13:01:24 -08001473
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001474 skb->csum = csum_tcpudp_nofold(iph->saddr, iph->daddr,
Herbert Xufb286bb2005-11-10 13:01:24 -08001475 skb->len, IPPROTO_TCP, 0);
1476
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477 if (skb->len <= 76) {
Herbert Xufb286bb2005-11-10 13:01:24 -08001478 return __skb_checksum_complete(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 }
1480 return 0;
1481}
1482
1483
1484/* The socket must have it's spinlock held when we get
1485 * here.
1486 *
1487 * We have a potential double-lock case here, so even when
1488 * doing backlog processing we use the BH locking scheme.
1489 * This is because we cannot sleep with the original spinlock
1490 * held.
1491 */
1492int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1493{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001494 struct sock *rsk;
1495#ifdef CONFIG_TCP_MD5SIG
1496 /*
1497 * We really want to reject the packet as early as possible
1498 * if:
1499 * o We're expecting an MD5'd packet and this is no MD5 tcp option
1500 * o There is an MD5 option and we're not expecting one
1501 */
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02001502 if (tcp_v4_inbound_md5_hash(sk, skb))
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001503 goto discard;
1504#endif
1505
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1507 TCP_CHECK_TIMER(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001508 if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001509 rsk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001511 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512 TCP_CHECK_TIMER(sk);
1513 return 0;
1514 }
1515
Arnaldo Carvalho de Meloab6a5bb2007-03-18 17:43:48 -07001516 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517 goto csum_err;
1518
1519 if (sk->sk_state == TCP_LISTEN) {
1520 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
1521 if (!nsk)
1522 goto discard;
1523
1524 if (nsk != sk) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001525 if (tcp_child_process(sk, nsk, skb)) {
1526 rsk = nsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001528 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 return 0;
1530 }
1531 }
1532
1533 TCP_CHECK_TIMER(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001534 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len)) {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001535 rsk = sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536 goto reset;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001537 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 TCP_CHECK_TIMER(sk);
1539 return 0;
1540
1541reset:
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001542 tcp_v4_send_reset(rsk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543discard:
1544 kfree_skb(skb);
1545 /* Be careful here. If this function gets more complicated and
1546 * gcc suffers from register pressure on the x86, sk (in %ebx)
1547 * might be destroyed here. This current version compiles correctly,
1548 * but you have been warned.
1549 */
1550 return 0;
1551
1552csum_err:
1553 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1554 goto discard;
1555}
1556
1557/*
1558 * From tcp_input.c
1559 */
1560
1561int tcp_v4_rcv(struct sk_buff *skb)
1562{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001563 const struct iphdr *iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 struct tcphdr *th;
1565 struct sock *sk;
1566 int ret;
1567
1568 if (skb->pkt_type != PACKET_HOST)
1569 goto discard_it;
1570
1571 /* Count it even if it's bad */
1572 TCP_INC_STATS_BH(TCP_MIB_INSEGS);
1573
1574 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1575 goto discard_it;
1576
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001577 th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578
1579 if (th->doff < sizeof(struct tcphdr) / 4)
1580 goto bad_packet;
1581 if (!pskb_may_pull(skb, th->doff * 4))
1582 goto discard_it;
1583
1584 /* An explanation is required here, I think.
1585 * Packet length and doff are validated by header prediction,
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -08001586 * provided case of th->doff==0 is eliminated.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 * So, we defer the checks. */
Herbert Xu60476372007-04-09 11:59:39 -07001588 if (!skb_csum_unnecessary(skb) && tcp_v4_checksum_init(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589 goto bad_packet;
1590
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -07001591 th = tcp_hdr(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001592 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1594 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1595 skb->len - th->doff * 4);
1596 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1597 TCP_SKB_CB(skb)->when = 0;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001598 TCP_SKB_CB(skb)->flags = iph->tos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599 TCP_SKB_CB(skb)->sacked = 0;
1600
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001601 sk = __inet_lookup(dev_net(skb->dev), &tcp_hashinfo, iph->saddr,
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001602 th->source, iph->daddr, th->dest, inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603 if (!sk)
1604 goto no_tcp_socket;
1605
1606process:
1607 if (sk->sk_state == TCP_TIME_WAIT)
1608 goto do_time_wait;
1609
1610 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1611 goto discard_and_relse;
Patrick McHardyb59c2702006-01-06 23:06:10 -08001612 nf_reset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001614 if (sk_filter(sk, skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615 goto discard_and_relse;
1616
1617 skb->dev = NULL;
1618
Ingo Molnarc6366182006-07-03 00:25:13 -07001619 bh_lock_sock_nested(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 ret = 0;
1621 if (!sock_owned_by_user(sk)) {
Chris Leech1a2449a2006-05-23 18:05:53 -07001622#ifdef CONFIG_NET_DMA
1623 struct tcp_sock *tp = tcp_sk(sk);
1624 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
1625 tp->ucopy.dma_chan = get_softnet_dma();
1626 if (tp->ucopy.dma_chan)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 ret = tcp_v4_do_rcv(sk, skb);
Chris Leech1a2449a2006-05-23 18:05:53 -07001628 else
1629#endif
1630 {
1631 if (!tcp_prequeue(sk, skb))
1632 ret = tcp_v4_do_rcv(sk, skb);
1633 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634 } else
1635 sk_add_backlog(sk, skb);
1636 bh_unlock_sock(sk);
1637
1638 sock_put(sk);
1639
1640 return ret;
1641
1642no_tcp_socket:
1643 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1644 goto discard_it;
1645
1646 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1647bad_packet:
1648 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1649 } else {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001650 tcp_v4_send_reset(NULL, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 }
1652
1653discard_it:
1654 /* Discard frame. */
1655 kfree_skb(skb);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001656 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657
1658discard_and_relse:
1659 sock_put(sk);
1660 goto discard_it;
1661
1662do_time_wait:
1663 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001664 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665 goto discard_it;
1666 }
1667
1668 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1669 TCP_INC_STATS_BH(TCP_MIB_INERRS);
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001670 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671 goto discard_it;
1672 }
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001673 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 case TCP_TW_SYN: {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001675 struct sock *sk2 = inet_lookup_listener(dev_net(skb->dev),
Pavel Emelyanovc67499c2008-01-31 05:06:40 -08001676 &tcp_hashinfo,
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001677 iph->daddr, th->dest,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001678 inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679 if (sk2) {
YOSHIFUJI Hideaki9469c7b2006-10-10 19:41:46 -07001680 inet_twsk_deschedule(inet_twsk(sk), &tcp_death_row);
1681 inet_twsk_put(inet_twsk(sk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 sk = sk2;
1683 goto process;
1684 }
1685 /* Fall through to ACK */
1686 }
1687 case TCP_TW_ACK:
1688 tcp_v4_timewait_ack(sk, skb);
1689 break;
1690 case TCP_TW_RST:
1691 goto no_tcp_socket;
1692 case TCP_TW_SUCCESS:;
1693 }
1694 goto discard_it;
1695}
1696
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697/* VJ's idea. Save last timestamp seen from this destination
1698 * and hold it at least for normal timewait interval to use for duplicate
1699 * segment detection in subsequent connections, before they enter synchronized
1700 * state.
1701 */
1702
1703int tcp_v4_remember_stamp(struct sock *sk)
1704{
1705 struct inet_sock *inet = inet_sk(sk);
1706 struct tcp_sock *tp = tcp_sk(sk);
1707 struct rtable *rt = (struct rtable *)__sk_dst_get(sk);
1708 struct inet_peer *peer = NULL;
1709 int release_it = 0;
1710
1711 if (!rt || rt->rt_dst != inet->daddr) {
1712 peer = inet_getpeer(inet->daddr, 1);
1713 release_it = 1;
1714 } else {
1715 if (!rt->peer)
1716 rt_bind_peer(rt, 1);
1717 peer = rt->peer;
1718 }
1719
1720 if (peer) {
1721 if ((s32)(peer->tcp_ts - tp->rx_opt.ts_recent) <= 0 ||
James Morris9d729f72007-03-04 16:12:44 -08001722 (peer->tcp_ts_stamp + TCP_PAWS_MSL < get_seconds() &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723 peer->tcp_ts_stamp <= tp->rx_opt.ts_recent_stamp)) {
1724 peer->tcp_ts_stamp = tp->rx_opt.ts_recent_stamp;
1725 peer->tcp_ts = tp->rx_opt.ts_recent;
1726 }
1727 if (release_it)
1728 inet_putpeer(peer);
1729 return 1;
1730 }
1731
1732 return 0;
1733}
1734
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001735int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001737 struct inet_peer *peer = inet_getpeer(tw->tw_daddr, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738
1739 if (peer) {
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001740 const struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
1741
1742 if ((s32)(peer->tcp_ts - tcptw->tw_ts_recent) <= 0 ||
James Morris9d729f72007-03-04 16:12:44 -08001743 (peer->tcp_ts_stamp + TCP_PAWS_MSL < get_seconds() &&
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001744 peer->tcp_ts_stamp <= tcptw->tw_ts_recent_stamp)) {
1745 peer->tcp_ts_stamp = tcptw->tw_ts_recent_stamp;
1746 peer->tcp_ts = tcptw->tw_ts_recent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747 }
1748 inet_putpeer(peer);
1749 return 1;
1750 }
1751
1752 return 0;
1753}
1754
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001755struct inet_connection_sock_af_ops ipv4_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001756 .queue_xmit = ip_queue_xmit,
1757 .send_check = tcp_v4_send_check,
1758 .rebuild_header = inet_sk_rebuild_header,
1759 .conn_request = tcp_v4_conn_request,
1760 .syn_recv_sock = tcp_v4_syn_recv_sock,
1761 .remember_stamp = tcp_v4_remember_stamp,
1762 .net_header_len = sizeof(struct iphdr),
1763 .setsockopt = ip_setsockopt,
1764 .getsockopt = ip_getsockopt,
1765 .addr2sockaddr = inet_csk_addr2sockaddr,
1766 .sockaddr_len = sizeof(struct sockaddr_in),
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001767 .bind_conflict = inet_csk_bind_conflict,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001768#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001769 .compat_setsockopt = compat_ip_setsockopt,
1770 .compat_getsockopt = compat_ip_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001771#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772};
1773
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001774#ifdef CONFIG_TCP_MD5SIG
Andrew Mortonb6332e62006-11-30 19:16:28 -08001775static struct tcp_sock_af_ops tcp_sock_ipv4_specific = {
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001776 .md5_lookup = tcp_v4_md5_lookup,
1777 .calc_md5_hash = tcp_v4_calc_md5_hash,
1778 .md5_add = tcp_v4_md5_add_func,
1779 .md5_parse = tcp_v4_parse_md5_keys,
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001780};
Andrew Mortonb6332e62006-11-30 19:16:28 -08001781#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001782
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783/* NOTE: A lot of things set to zero explicitly by call to
1784 * sk_alloc() so need not be done here.
1785 */
1786static int tcp_v4_init_sock(struct sock *sk)
1787{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001788 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789 struct tcp_sock *tp = tcp_sk(sk);
1790
1791 skb_queue_head_init(&tp->out_of_order_queue);
1792 tcp_init_xmit_timers(sk);
1793 tcp_prequeue_init(tp);
1794
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001795 icsk->icsk_rto = TCP_TIMEOUT_INIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 tp->mdev = TCP_TIMEOUT_INIT;
1797
1798 /* So many TCP implementations out there (incorrectly) count the
1799 * initial SYN frame in their delayed-ACK and congestion control
1800 * algorithms that we must have the following bandaid to talk
1801 * efficiently to them. -DaveM
1802 */
1803 tp->snd_cwnd = 2;
1804
1805 /* See draft-stevens-tcpca-spec-01 for discussion of the
1806 * initialization of these values.
1807 */
1808 tp->snd_ssthresh = 0x7fffffff; /* Infinity */
1809 tp->snd_cwnd_clamp = ~0;
David S. Millerc1b4a7e2005-07-05 15:24:38 -07001810 tp->mss_cache = 536;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811
1812 tp->reordering = sysctl_tcp_reordering;
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001813 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814
1815 sk->sk_state = TCP_CLOSE;
1816
1817 sk->sk_write_space = sk_stream_write_space;
1818 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1819
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001820 icsk->icsk_af_ops = &ipv4_specific;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001821 icsk->icsk_sync_mss = tcp_sync_mss;
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001822#ifdef CONFIG_TCP_MD5SIG
1823 tp->af_specific = &tcp_sock_ipv4_specific;
1824#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825
1826 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1827 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1828
1829 atomic_inc(&tcp_sockets_allocated);
1830
1831 return 0;
1832}
1833
1834int tcp_v4_destroy_sock(struct sock *sk)
1835{
1836 struct tcp_sock *tp = tcp_sk(sk);
1837
1838 tcp_clear_xmit_timers(sk);
1839
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001840 tcp_cleanup_congestion_control(sk);
Stephen Hemminger317a76f2005-06-23 12:19:55 -07001841
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842 /* Cleanup up the write buffer. */
David S. Millerfe067e82007-03-07 12:12:44 -08001843 tcp_write_queue_purge(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844
1845 /* Cleans up our, hopefully empty, out_of_order_queue. */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001846 __skb_queue_purge(&tp->out_of_order_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -08001848#ifdef CONFIG_TCP_MD5SIG
1849 /* Clean up the MD5 key list, if any */
1850 if (tp->md5sig_info) {
1851 tcp_v4_clear_md5_list(sk);
1852 kfree(tp->md5sig_info);
1853 tp->md5sig_info = NULL;
1854 }
1855#endif
1856
Chris Leech1a2449a2006-05-23 18:05:53 -07001857#ifdef CONFIG_NET_DMA
1858 /* Cleans up our sk_async_wait_queue */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001859 __skb_queue_purge(&sk->sk_async_wait_queue);
Chris Leech1a2449a2006-05-23 18:05:53 -07001860#endif
1861
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 /* Clean prequeue, it must be empty really */
1863 __skb_queue_purge(&tp->ucopy.prequeue);
1864
1865 /* Clean up a referenced TCP bind bucket. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001866 if (inet_csk(sk)->icsk_bind_hash)
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08001867 inet_put_port(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868
1869 /*
1870 * If sendmsg cached page exists, toss it.
1871 */
1872 if (sk->sk_sndmsg_page) {
1873 __free_page(sk->sk_sndmsg_page);
1874 sk->sk_sndmsg_page = NULL;
1875 }
1876
Patrick McManusec3c0982008-03-21 16:33:01 -07001877 if (tp->defer_tcp_accept.request) {
1878 reqsk_free(tp->defer_tcp_accept.request);
1879 sock_put(tp->defer_tcp_accept.listen_sk);
1880 sock_put(sk);
1881 tp->defer_tcp_accept.listen_sk = NULL;
1882 tp->defer_tcp_accept.request = NULL;
1883 }
1884
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885 atomic_dec(&tcp_sockets_allocated);
1886
1887 return 0;
1888}
1889
1890EXPORT_SYMBOL(tcp_v4_destroy_sock);
1891
1892#ifdef CONFIG_PROC_FS
1893/* Proc filesystem TCP sock list dumping. */
1894
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001895static inline struct inet_timewait_sock *tw_head(struct hlist_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896{
1897 return hlist_empty(head) ? NULL :
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001898 list_entry(head->first, struct inet_timewait_sock, tw_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899}
1900
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001901static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902{
1903 return tw->tw_node.next ?
1904 hlist_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
1905}
1906
1907static void *listening_get_next(struct seq_file *seq, void *cur)
1908{
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001909 struct inet_connection_sock *icsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 struct hlist_node *node;
1911 struct sock *sk = cur;
1912 struct tcp_iter_state* st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07001913 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914
1915 if (!sk) {
1916 st->bucket = 0;
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001917 sk = sk_head(&tcp_hashinfo.listening_hash[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 goto get_sk;
1919 }
1920
1921 ++st->num;
1922
1923 if (st->state == TCP_SEQ_STATE_OPENREQ) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001924 struct request_sock *req = cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001926 icsk = inet_csk(st->syn_wait_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927 req = req->dl_next;
1928 while (1) {
1929 while (req) {
Daniel Lezcanof40c8172008-03-21 04:13:54 -07001930 if (req->rsk_ops->family == st->family &&
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09001931 net_eq(sock_net(req->sk), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932 cur = req;
1933 goto out;
1934 }
1935 req = req->dl_next;
1936 }
Eric Dumazet72a3eff2006-11-16 02:30:37 -08001937 if (++st->sbucket >= icsk->icsk_accept_queue.listen_opt->nr_table_entries)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938 break;
1939get_req:
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001940 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941 }
1942 sk = sk_next(st->syn_wait_sk);
1943 st->state = TCP_SEQ_STATE_LISTENING;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001944 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945 } else {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001946 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001947 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1948 if (reqsk_queue_len(&icsk->icsk_accept_queue))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949 goto start_req;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001950 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 sk = sk_next(sk);
1952 }
1953get_sk:
1954 sk_for_each_from(sk, node) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09001955 if (sk->sk_family == st->family && net_eq(sock_net(sk), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001956 cur = sk;
1957 goto out;
1958 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001959 icsk = inet_csk(sk);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001960 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1961 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001962start_req:
1963 st->uid = sock_i_uid(sk);
1964 st->syn_wait_sk = sk;
1965 st->state = TCP_SEQ_STATE_OPENREQ;
1966 st->sbucket = 0;
1967 goto get_req;
1968 }
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001969 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970 }
Arnaldo Carvalho de Melo0f7ff922005-08-09 19:59:44 -07001971 if (++st->bucket < INET_LHTABLE_SIZE) {
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001972 sk = sk_head(&tcp_hashinfo.listening_hash[st->bucket]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973 goto get_sk;
1974 }
1975 cur = NULL;
1976out:
1977 return cur;
1978}
1979
1980static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
1981{
1982 void *rc = listening_get_next(seq, NULL);
1983
1984 while (rc && *pos) {
1985 rc = listening_get_next(seq, rc);
1986 --*pos;
1987 }
1988 return rc;
1989}
1990
1991static void *established_get_first(struct seq_file *seq)
1992{
1993 struct tcp_iter_state* st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07001994 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995 void *rc = NULL;
1996
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001997 for (st->bucket = 0; st->bucket < tcp_hashinfo.ehash_size; ++st->bucket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998 struct sock *sk;
1999 struct hlist_node *node;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002000 struct inet_timewait_sock *tw;
Eric Dumazet230140c2007-11-07 02:40:20 -08002001 rwlock_t *lock = inet_ehash_lockp(&tcp_hashinfo, st->bucket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002
Eric Dumazet230140c2007-11-07 02:40:20 -08002003 read_lock_bh(lock);
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07002004 sk_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002005 if (sk->sk_family != st->family ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002006 !net_eq(sock_net(sk), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002007 continue;
2008 }
2009 rc = sk;
2010 goto out;
2011 }
2012 st->state = TCP_SEQ_STATE_TIME_WAIT;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002013 inet_twsk_for_each(tw, node,
Eric Dumazetdbca9b2752007-02-08 14:16:46 -08002014 &tcp_hashinfo.ehash[st->bucket].twchain) {
Pavel Emelyanov28518fc2008-03-21 15:52:00 -07002015 if (tw->tw_family != st->family ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002016 !net_eq(twsk_net(tw), net)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017 continue;
2018 }
2019 rc = tw;
2020 goto out;
2021 }
Eric Dumazet230140c2007-11-07 02:40:20 -08002022 read_unlock_bh(lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002023 st->state = TCP_SEQ_STATE_ESTABLISHED;
2024 }
2025out:
2026 return rc;
2027}
2028
2029static void *established_get_next(struct seq_file *seq, void *cur)
2030{
2031 struct sock *sk = cur;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002032 struct inet_timewait_sock *tw;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033 struct hlist_node *node;
2034 struct tcp_iter_state* st = seq->private;
Denis V. Luneva4146b12008-04-13 22:11:14 -07002035 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036
2037 ++st->num;
2038
2039 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
2040 tw = cur;
2041 tw = tw_next(tw);
2042get_tw:
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002043 while (tw && (tw->tw_family != st->family || !net_eq(twsk_net(tw), net))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002044 tw = tw_next(tw);
2045 }
2046 if (tw) {
2047 cur = tw;
2048 goto out;
2049 }
Eric Dumazet230140c2007-11-07 02:40:20 -08002050 read_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002051 st->state = TCP_SEQ_STATE_ESTABLISHED;
2052
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07002053 if (++st->bucket < tcp_hashinfo.ehash_size) {
Eric Dumazet230140c2007-11-07 02:40:20 -08002054 read_lock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07002055 sk = sk_head(&tcp_hashinfo.ehash[st->bucket].chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002056 } else {
2057 cur = NULL;
2058 goto out;
2059 }
2060 } else
2061 sk = sk_next(sk);
2062
2063 sk_for_each_from(sk, node) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002064 if (sk->sk_family == st->family && net_eq(sock_net(sk), net))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002065 goto found;
2066 }
2067
2068 st->state = TCP_SEQ_STATE_TIME_WAIT;
Eric Dumazetdbca9b2752007-02-08 14:16:46 -08002069 tw = tw_head(&tcp_hashinfo.ehash[st->bucket].twchain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070 goto get_tw;
2071found:
2072 cur = sk;
2073out:
2074 return cur;
2075}
2076
2077static void *established_get_idx(struct seq_file *seq, loff_t pos)
2078{
2079 void *rc = established_get_first(seq);
2080
2081 while (rc && pos) {
2082 rc = established_get_next(seq, rc);
2083 --pos;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002084 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085 return rc;
2086}
2087
2088static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
2089{
2090 void *rc;
2091 struct tcp_iter_state* st = seq->private;
2092
Arnaldo Carvalho de Melof3f05f72005-08-09 20:08:09 -07002093 inet_listen_lock(&tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094 st->state = TCP_SEQ_STATE_LISTENING;
2095 rc = listening_get_idx(seq, &pos);
2096
2097 if (!rc) {
Arnaldo Carvalho de Melof3f05f72005-08-09 20:08:09 -07002098 inet_listen_unlock(&tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002099 st->state = TCP_SEQ_STATE_ESTABLISHED;
2100 rc = established_get_idx(seq, pos);
2101 }
2102
2103 return rc;
2104}
2105
2106static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
2107{
2108 struct tcp_iter_state* st = seq->private;
2109 st->state = TCP_SEQ_STATE_LISTENING;
2110 st->num = 0;
2111 return *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2112}
2113
2114static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2115{
2116 void *rc = NULL;
2117 struct tcp_iter_state* st;
2118
2119 if (v == SEQ_START_TOKEN) {
2120 rc = tcp_get_idx(seq, 0);
2121 goto out;
2122 }
2123 st = seq->private;
2124
2125 switch (st->state) {
2126 case TCP_SEQ_STATE_OPENREQ:
2127 case TCP_SEQ_STATE_LISTENING:
2128 rc = listening_get_next(seq, v);
2129 if (!rc) {
Arnaldo Carvalho de Melof3f05f72005-08-09 20:08:09 -07002130 inet_listen_unlock(&tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002131 st->state = TCP_SEQ_STATE_ESTABLISHED;
2132 rc = established_get_first(seq);
2133 }
2134 break;
2135 case TCP_SEQ_STATE_ESTABLISHED:
2136 case TCP_SEQ_STATE_TIME_WAIT:
2137 rc = established_get_next(seq, v);
2138 break;
2139 }
2140out:
2141 ++*pos;
2142 return rc;
2143}
2144
2145static void tcp_seq_stop(struct seq_file *seq, void *v)
2146{
2147 struct tcp_iter_state* st = seq->private;
2148
2149 switch (st->state) {
2150 case TCP_SEQ_STATE_OPENREQ:
2151 if (v) {
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002152 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
2153 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002154 }
2155 case TCP_SEQ_STATE_LISTENING:
2156 if (v != SEQ_START_TOKEN)
Arnaldo Carvalho de Melof3f05f72005-08-09 20:08:09 -07002157 inet_listen_unlock(&tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158 break;
2159 case TCP_SEQ_STATE_TIME_WAIT:
2160 case TCP_SEQ_STATE_ESTABLISHED:
2161 if (v)
Eric Dumazet230140c2007-11-07 02:40:20 -08002162 read_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163 break;
2164 }
2165}
2166
2167static int tcp_seq_open(struct inode *inode, struct file *file)
2168{
2169 struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002170 struct tcp_iter_state *s;
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002171 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002172
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002173 err = seq_open_net(inode, file, &afinfo->seq_ops,
2174 sizeof(struct tcp_iter_state));
2175 if (err < 0)
2176 return err;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002177
Denis V. Lunev52d6f3f2008-04-13 22:12:41 -07002178 s = ((struct seq_file *)file->private_data)->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179 s->family = afinfo->family;
Daniel Lezcanof40c8172008-03-21 04:13:54 -07002180 return 0;
2181}
2182
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002183int tcp_proc_register(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184{
2185 int rc = 0;
2186 struct proc_dir_entry *p;
2187
Denis V. Lunev68fcadd2008-04-13 22:13:30 -07002188 afinfo->seq_fops.open = tcp_seq_open;
2189 afinfo->seq_fops.read = seq_read;
2190 afinfo->seq_fops.llseek = seq_lseek;
2191 afinfo->seq_fops.release = seq_release_net;
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002192
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002193 afinfo->seq_ops.start = tcp_seq_start;
2194 afinfo->seq_ops.next = tcp_seq_next;
2195 afinfo->seq_ops.stop = tcp_seq_stop;
2196
Denis V. Lunev84841c32008-05-02 04:10:08 -07002197 p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net,
2198 &afinfo->seq_fops, afinfo);
2199 if (!p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200 rc = -ENOMEM;
2201 return rc;
2202}
2203
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002204void tcp_proc_unregister(struct net *net, struct tcp_seq_afinfo *afinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205{
Daniel Lezcano6f8b13b2008-03-21 04:14:45 -07002206 proc_net_remove(net, afinfo->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002207}
2208
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002209static void get_openreq4(struct sock *sk, struct request_sock *req,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002210 struct seq_file *f, int i, int uid, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002211{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002212 const struct inet_request_sock *ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213 int ttd = req->expires - jiffies;
2214
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002215 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
2216 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p%n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217 i,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002218 ireq->loc_addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002219 ntohs(inet_sk(sk)->sport),
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002220 ireq->rmt_addr,
2221 ntohs(ireq->rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002222 TCP_SYN_RECV,
2223 0, 0, /* could print option size, but that is af dependent. */
2224 1, /* timers active (only the expire timer) */
2225 jiffies_to_clock_t(ttd),
2226 req->retrans,
2227 uid,
2228 0, /* non standard timer */
2229 0, /* open_requests have no inode */
2230 atomic_read(&sk->sk_refcnt),
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002231 req,
2232 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233}
2234
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002235static void get_tcp4_sock(struct sock *sk, struct seq_file *f, int i, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236{
2237 int timer_active;
2238 unsigned long timer_expires;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002239 struct tcp_sock *tp = tcp_sk(sk);
2240 const struct inet_connection_sock *icsk = inet_csk(sk);
2241 struct inet_sock *inet = inet_sk(sk);
Al Viro714e85b2006-11-14 20:51:49 -08002242 __be32 dest = inet->daddr;
2243 __be32 src = inet->rcv_saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244 __u16 destp = ntohs(inet->dport);
2245 __u16 srcp = ntohs(inet->sport);
2246
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002247 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002248 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002249 timer_expires = icsk->icsk_timeout;
2250 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002251 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002252 timer_expires = icsk->icsk_timeout;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002253 } else if (timer_pending(&sk->sk_timer)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002254 timer_active = 2;
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002255 timer_expires = sk->sk_timer.expires;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256 } else {
2257 timer_active = 0;
2258 timer_expires = jiffies;
2259 }
2260
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002261 seq_printf(f, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
2262 "%08X %5d %8d %lu %d %p %u %u %u %u %d%n",
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002263 i, src, srcp, dest, destp, sk->sk_state,
Sridhar Samudrala47da8ee2006-06-27 13:29:00 -07002264 tp->write_seq - tp->snd_una,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002265 sk->sk_state == TCP_LISTEN ? sk->sk_ack_backlog :
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002266 (tp->rcv_nxt - tp->copied_seq),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002267 timer_active,
2268 jiffies_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002269 icsk->icsk_retransmits,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002270 sock_i_uid(sk),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03002271 icsk->icsk_probes_out,
Ilpo Järvinencf4c6bf2007-02-22 01:13:58 -08002272 sock_i_ino(sk),
2273 atomic_read(&sk->sk_refcnt), sk,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002274 icsk->icsk_rto,
2275 icsk->icsk_ack.ato,
2276 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002277 tp->snd_cwnd,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002278 tp->snd_ssthresh >= 0xFFFF ? -1 : tp->snd_ssthresh,
2279 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002280}
2281
Arnaldo Carvalho de Melo71742592006-11-17 10:57:30 -02002282static void get_timewait4_sock(struct inet_timewait_sock *tw,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002283 struct seq_file *f, int i, int *len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002284{
Al Viro23f33c22006-09-27 18:43:50 -07002285 __be32 dest, src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002286 __u16 destp, srcp;
2287 int ttd = tw->tw_ttd - jiffies;
2288
2289 if (ttd < 0)
2290 ttd = 0;
2291
2292 dest = tw->tw_daddr;
2293 src = tw->tw_rcv_saddr;
2294 destp = ntohs(tw->tw_dport);
2295 srcp = ntohs(tw->tw_sport);
2296
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002297 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
2298 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p%n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002299 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
2300 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002301 atomic_read(&tw->tw_refcnt), tw, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002302}
2303
2304#define TMPSZ 150
2305
2306static int tcp4_seq_show(struct seq_file *seq, void *v)
2307{
2308 struct tcp_iter_state* st;
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002309 int len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002310
2311 if (v == SEQ_START_TOKEN) {
2312 seq_printf(seq, "%-*s\n", TMPSZ - 1,
2313 " sl local_address rem_address st tx_queue "
2314 "rx_queue tr tm->when retrnsmt uid timeout "
2315 "inode");
2316 goto out;
2317 }
2318 st = seq->private;
2319
2320 switch (st->state) {
2321 case TCP_SEQ_STATE_LISTENING:
2322 case TCP_SEQ_STATE_ESTABLISHED:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002323 get_tcp4_sock(v, seq, st->num, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002324 break;
2325 case TCP_SEQ_STATE_OPENREQ:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002326 get_openreq4(st->syn_wait_sk, v, seq, st->num, st->uid, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002327 break;
2328 case TCP_SEQ_STATE_TIME_WAIT:
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002329 get_timewait4_sock(v, seq, st->num, &len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330 break;
2331 }
Pavel Emelyanov5e659e42008-04-24 01:02:16 -07002332 seq_printf(seq, "%*s\n", TMPSZ - 1 - len, "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333out:
2334 return 0;
2335}
2336
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337static struct tcp_seq_afinfo tcp4_seq_afinfo = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002338 .name = "tcp",
2339 .family = AF_INET,
Denis V. Lunev5f4472c2008-04-13 22:13:53 -07002340 .seq_fops = {
2341 .owner = THIS_MODULE,
2342 },
Denis V. Lunev9427c4b2008-04-13 22:12:13 -07002343 .seq_ops = {
2344 .show = tcp4_seq_show,
2345 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002346};
2347
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002348static int tcp4_proc_init_net(struct net *net)
2349{
2350 return tcp_proc_register(net, &tcp4_seq_afinfo);
2351}
2352
2353static void tcp4_proc_exit_net(struct net *net)
2354{
2355 tcp_proc_unregister(net, &tcp4_seq_afinfo);
2356}
2357
2358static struct pernet_operations tcp4_net_ops = {
2359 .init = tcp4_proc_init_net,
2360 .exit = tcp4_proc_exit_net,
2361};
2362
Linus Torvalds1da177e2005-04-16 15:20:36 -07002363int __init tcp4_proc_init(void)
2364{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002365 return register_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366}
2367
2368void tcp4_proc_exit(void)
2369{
Pavel Emelyanov757764f2008-03-24 14:56:02 -07002370 unregister_pernet_subsys(&tcp4_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371}
2372#endif /* CONFIG_PROC_FS */
2373
2374struct proto tcp_prot = {
2375 .name = "TCP",
2376 .owner = THIS_MODULE,
2377 .close = tcp_close,
2378 .connect = tcp_v4_connect,
2379 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07002380 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002381 .ioctl = tcp_ioctl,
2382 .init = tcp_v4_init_sock,
2383 .destroy = tcp_v4_destroy_sock,
2384 .shutdown = tcp_shutdown,
2385 .setsockopt = tcp_setsockopt,
2386 .getsockopt = tcp_getsockopt,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002387 .recvmsg = tcp_recvmsg,
2388 .backlog_rcv = tcp_v4_do_rcv,
Arnaldo Carvalho de Meloab1e0a12008-02-03 04:06:04 -08002389 .hash = inet_hash,
2390 .unhash = inet_unhash,
2391 .get_port = inet_csk_get_port,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392 .enter_memory_pressure = tcp_enter_memory_pressure,
2393 .sockets_allocated = &tcp_sockets_allocated,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07002394 .orphan_count = &tcp_orphan_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002395 .memory_allocated = &tcp_memory_allocated,
2396 .memory_pressure = &tcp_memory_pressure,
2397 .sysctl_mem = sysctl_tcp_mem,
2398 .sysctl_wmem = sysctl_tcp_wmem,
2399 .sysctl_rmem = sysctl_tcp_rmem,
2400 .max_header = MAX_TCP_HEADER,
2401 .obj_size = sizeof(struct tcp_sock),
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002402 .twsk_prot = &tcp_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07002403 .rsk_prot = &tcp_request_sock_ops,
Pavel Emelyanov39d8cda2008-03-22 16:50:58 -07002404 .h.hashinfo = &tcp_hashinfo,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002405#ifdef CONFIG_COMPAT
2406 .compat_setsockopt = compat_tcp_setsockopt,
2407 .compat_getsockopt = compat_tcp_getsockopt,
2408#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002409};
2410
Denis V. Lunev046ee902008-04-03 14:31:33 -07002411
2412static int __net_init tcp_sk_init(struct net *net)
2413{
2414 return inet_ctl_sock_create(&net->ipv4.tcp_sock,
2415 PF_INET, SOCK_RAW, IPPROTO_TCP, net);
2416}
2417
2418static void __net_exit tcp_sk_exit(struct net *net)
2419{
2420 inet_ctl_sock_destroy(net->ipv4.tcp_sock);
2421}
2422
2423static struct pernet_operations __net_initdata tcp_sk_ops = {
2424 .init = tcp_sk_init,
2425 .exit = tcp_sk_exit,
2426};
2427
Denis V. Lunev9b0f9762008-02-29 11:13:15 -08002428void __init tcp_v4_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429{
Denis V. Lunev046ee902008-04-03 14:31:33 -07002430 if (register_pernet_device(&tcp_sk_ops))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002431 panic("Failed to create the TCP control socket.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002432}
2433
2434EXPORT_SYMBOL(ipv4_specific);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002435EXPORT_SYMBOL(tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002436EXPORT_SYMBOL(tcp_prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002437EXPORT_SYMBOL(tcp_v4_conn_request);
2438EXPORT_SYMBOL(tcp_v4_connect);
2439EXPORT_SYMBOL(tcp_v4_do_rcv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002440EXPORT_SYMBOL(tcp_v4_remember_stamp);
2441EXPORT_SYMBOL(tcp_v4_send_check);
2442EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
2443
2444#ifdef CONFIG_PROC_FS
2445EXPORT_SYMBOL(tcp_proc_register);
2446EXPORT_SYMBOL(tcp_proc_unregister);
2447#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002448EXPORT_SYMBOL(sysctl_tcp_low_latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002449