?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[NET] Rename open_request to request_sock
[linux-2.6/x86.git] / net / ipv4 / tcp_ipv4.c
blob95528a75a63d8f9c85f012aba8b747ebff70ee5e
1 /*
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
39 * request_sock handling and moved
40 * most of it into the af independent code.
41 * Added tail drop and some other bugfixes.
42 * Added new listen sematics.
43 * 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
55 #include <linux/config.h>
56
57 #include <linux/types.h>
58 #include <linux/fcntl.h>
59 #include <linux/module.h>
60 #include <linux/random.h>
61 #include <linux/cache.h>
62 #include <linux/jhash.h>
63 #include <linux/init.h>
64 #include <linux/times.h>
65
66 #include <net/icmp.h>
67 #include <net/tcp.h>
68 #include <net/ipv6.h>
69 #include <net/inet_common.h>
70 #include <net/xfrm.h>
71
72 #include <linux/inet.h>
73 #include <linux/ipv6.h>
74 #include <linux/stddef.h>
75 #include <linux/proc_fs.h>
76 #include <linux/seq_file.h>
77
78 extern int sysctl_ip_dynaddr;
79 int sysctl_tcp_tw_reuse;
80 int sysctl_tcp_low_latency;
81
82 /* Check TCP sequence numbers in ICMP packets. */
83 #define ICMP_MIN_LENGTH 8
84
85 /* Socket used for sending RSTs */
86 static struct socket *tcp_socket;
87
88 void tcp_v4_send_check(struct sock *sk, struct tcphdr *th, int len,
89 struct sk_buff *skb);
90
91 struct tcp_hashinfo __cacheline_aligned tcp_hashinfo = {
92 .__tcp_lhash_lock = RW_LOCK_UNLOCKED,
93 .__tcp_lhash_users = ATOMIC_INIT(0),
94 .__tcp_lhash_wait
95 = __WAIT_QUEUE_HEAD_INITIALIZER(tcp_hashinfo.__tcp_lhash_wait),
96 .__tcp_portalloc_lock = SPIN_LOCK_UNLOCKED
97 };
98
99 /*
100 * This array holds the first and last local port number.
101 * For high-usage systems, use sysctl to change this to
102 * 32768-61000
103 */
104 int sysctl_local_port_range[2] = { 1024, 4999 };
105 int tcp_port_rover = 1024 - 1;
106
107 static __inline__ int tcp_hashfn(__u32 laddr, __u16 lport,
108 __u32 faddr, __u16 fport)
109 {
110 int h = (laddr ^ lport) ^ (faddr ^ fport);
111 h ^= h >> 16;
112 h ^= h >> 8;
113 return h & (tcp_ehash_size - 1);
114 }
115
116 static __inline__ int tcp_sk_hashfn(struct sock *sk)
117 {
118 struct inet_sock *inet = inet_sk(sk);
119 __u32 laddr = inet->rcv_saddr;
120 __u16 lport = inet->num;
121 __u32 faddr = inet->daddr;
122 __u16 fport = inet->dport;
123
124 return tcp_hashfn(laddr, lport, faddr, fport);
125 }
126
127 /* Allocate and initialize a new TCP local port bind bucket.
128 * The bindhash mutex for snum's hash chain must be held here.
129 */
130 struct tcp_bind_bucket *tcp_bucket_create(struct tcp_bind_hashbucket *head,
131 unsigned short snum)
132 {
133 struct tcp_bind_bucket *tb = kmem_cache_alloc(tcp_bucket_cachep,
134 SLAB_ATOMIC);
135 if (tb) {
136 tb->port = snum;
137 tb->fastreuse = 0;
138 INIT_HLIST_HEAD(&tb->owners);
139 hlist_add_head(&tb->node, &head->chain);
140 }
141 return tb;
142 }
143
144 /* Caller must hold hashbucket lock for this tb with local BH disabled */
145 void tcp_bucket_destroy(struct tcp_bind_bucket *tb)
146 {
147 if (hlist_empty(&tb->owners)) {
148 __hlist_del(&tb->node);
149 kmem_cache_free(tcp_bucket_cachep, tb);
150 }
151 }
152
153 /* Caller must disable local BH processing. */
154 static __inline__ void __tcp_inherit_port(struct sock *sk, struct sock *child)
155 {
156 struct tcp_bind_hashbucket *head =
157 &tcp_bhash[tcp_bhashfn(inet_sk(child)->num)];
158 struct tcp_bind_bucket *tb;
159
160 spin_lock(&head->lock);
161 tb = tcp_sk(sk)->bind_hash;
162 sk_add_bind_node(child, &tb->owners);
163 tcp_sk(child)->bind_hash = tb;
164 spin_unlock(&head->lock);
165 }
166
167 inline void tcp_inherit_port(struct sock *sk, struct sock *child)
168 {
169 local_bh_disable();
170 __tcp_inherit_port(sk, child);
171 local_bh_enable();
172 }
173
174 void tcp_bind_hash(struct sock *sk, struct tcp_bind_bucket *tb,
175 unsigned short snum)
176 {
177 inet_sk(sk)->num = snum;
178 sk_add_bind_node(sk, &tb->owners);
179 tcp_sk(sk)->bind_hash = tb;
180 }
181
182 static inline int tcp_bind_conflict(struct sock *sk, struct tcp_bind_bucket *tb)
183 {
184 const u32 sk_rcv_saddr = tcp_v4_rcv_saddr(sk);
185 struct sock *sk2;
186 struct hlist_node *node;
187 int reuse = sk->sk_reuse;
188
189 sk_for_each_bound(sk2, node, &tb->owners) {
190 if (sk != sk2 &&
191 !tcp_v6_ipv6only(sk2) &&
192 (!sk->sk_bound_dev_if ||
193 !sk2->sk_bound_dev_if ||
194 sk->sk_bound_dev_if == sk2->sk_bound_dev_if)) {
195 if (!reuse || !sk2->sk_reuse ||
196 sk2->sk_state == TCP_LISTEN) {
197 const u32 sk2_rcv_saddr = tcp_v4_rcv_saddr(sk2);
198 if (!sk2_rcv_saddr || !sk_rcv_saddr ||
199 sk2_rcv_saddr == sk_rcv_saddr)
200 break;
201 }
202 }
203 }
204 return node != NULL;
205 }
206
207 /* Obtain a reference to a local port for the given sock,
208 * if snum is zero it means select any available local port.
209 */
210 static int tcp_v4_get_port(struct sock *sk, unsigned short snum)
211 {
212 struct tcp_bind_hashbucket *head;
213 struct hlist_node *node;
214 struct tcp_bind_bucket *tb;
215 int ret;
216
217 local_bh_disable();
218 if (!snum) {
219 int low = sysctl_local_port_range[0];
220 int high = sysctl_local_port_range[1];
221 int remaining = (high - low) + 1;
222 int rover;
223
224 spin_lock(&tcp_portalloc_lock);
225 if (tcp_port_rover < low)
226 rover = low;
227 else
228 rover = tcp_port_rover;
229 do {
230 rover++;
231 if (rover > high)
232 rover = low;
233 head = &tcp_bhash[tcp_bhashfn(rover)];
234 spin_lock(&head->lock);
235 tb_for_each(tb, node, &head->chain)
236 if (tb->port == rover)
237 goto next;
238 break;
239 next:
240 spin_unlock(&head->lock);
241 } while (--remaining > 0);
242 tcp_port_rover = rover;
243 spin_unlock(&tcp_portalloc_lock);
244
245 /* Exhausted local port range during search? */
246 ret = 1;
247 if (remaining <= 0)
248 goto fail;
249
250 /* OK, here is the one we will use. HEAD is
251 * non-NULL and we hold it's mutex.
252 */
253 snum = rover;
254 } else {
255 head = &tcp_bhash[tcp_bhashfn(snum)];
256 spin_lock(&head->lock);
257 tb_for_each(tb, node, &head->chain)
258 if (tb->port == snum)
259 goto tb_found;
260 }
261 tb = NULL;
262 goto tb_not_found;
263 tb_found:
264 if (!hlist_empty(&tb->owners)) {
265 if (sk->sk_reuse > 1)
266 goto success;
267 if (tb->fastreuse > 0 &&
268 sk->sk_reuse && sk->sk_state != TCP_LISTEN) {
269 goto success;
270 } else {
271 ret = 1;
272 if (tcp_bind_conflict(sk, tb))
273 goto fail_unlock;
274 }
275 }
276 tb_not_found:
277 ret = 1;
278 if (!tb && (tb = tcp_bucket_create(head, snum)) == NULL)
279 goto fail_unlock;
280 if (hlist_empty(&tb->owners)) {
281 if (sk->sk_reuse && sk->sk_state != TCP_LISTEN)
282 tb->fastreuse = 1;
283 else
284 tb->fastreuse = 0;
285 } else if (tb->fastreuse &&
286 (!sk->sk_reuse || sk->sk_state == TCP_LISTEN))
287 tb->fastreuse = 0;
288 success:
289 if (!tcp_sk(sk)->bind_hash)
290 tcp_bind_hash(sk, tb, snum);
291 BUG_TRAP(tcp_sk(sk)->bind_hash == tb);
292 ret = 0;
293
294 fail_unlock:
295 spin_unlock(&head->lock);
296 fail:
297 local_bh_enable();
298 return ret;
299 }
300
301 /* Get rid of any references to a local port held by the
302 * given sock.
303 */
304 static void __tcp_put_port(struct sock *sk)
305 {
306 struct inet_sock *inet = inet_sk(sk);
307 struct tcp_bind_hashbucket *head = &tcp_bhash[tcp_bhashfn(inet->num)];
308 struct tcp_bind_bucket *tb;
309
310 spin_lock(&head->lock);
311 tb = tcp_sk(sk)->bind_hash;
312 __sk_del_bind_node(sk);
313 tcp_sk(sk)->bind_hash = NULL;
314 inet->num = 0;
315 tcp_bucket_destroy(tb);
316 spin_unlock(&head->lock);
317 }
318
319 void tcp_put_port(struct sock *sk)
320 {
321 local_bh_disable();
322 __tcp_put_port(sk);
323 local_bh_enable();
324 }
325
326 /* This lock without WQ_FLAG_EXCLUSIVE is good on UP and it can be very bad on SMP.
327 * Look, when several writers sleep and reader wakes them up, all but one
328 * immediately hit write lock and grab all the cpus. Exclusive sleep solves
329 * this, _but_ remember, it adds useless work on UP machines (wake up each
330 * exclusive lock release). It should be ifdefed really.
331 */
332
333 void tcp_listen_wlock(void)
334 {
335 write_lock(&tcp_lhash_lock);
336
337 if (atomic_read(&tcp_lhash_users)) {
338 DEFINE_WAIT(wait);
339
340 for (;;) {
341 prepare_to_wait_exclusive(&tcp_lhash_wait,
342 &wait, TASK_UNINTERRUPTIBLE);
343 if (!atomic_read(&tcp_lhash_users))
344 break;
345 write_unlock_bh(&tcp_lhash_lock);
346 schedule();
347 write_lock_bh(&tcp_lhash_lock);
348 }
349
350 finish_wait(&tcp_lhash_wait, &wait);
351 }
352 }
353
354 static __inline__ void __tcp_v4_hash(struct sock *sk, const int listen_possible)
355 {
356 struct hlist_head *list;
357 rwlock_t *lock;
358
359 BUG_TRAP(sk_unhashed(sk));
360 if (listen_possible && sk->sk_state == TCP_LISTEN) {
361 list = &tcp_listening_hash[tcp_sk_listen_hashfn(sk)];
362 lock = &tcp_lhash_lock;
363 tcp_listen_wlock();
364 } else {
365 list = &tcp_ehash[(sk->sk_hashent = tcp_sk_hashfn(sk))].chain;
366 lock = &tcp_ehash[sk->sk_hashent].lock;
367 write_lock(lock);
368 }
369 __sk_add_node(sk, list);
370 sock_prot_inc_use(sk->sk_prot);
371 write_unlock(lock);
372 if (listen_possible && sk->sk_state == TCP_LISTEN)
373 wake_up(&tcp_lhash_wait);
374 }
375
376 static void tcp_v4_hash(struct sock *sk)
377 {
378 if (sk->sk_state != TCP_CLOSE) {
379 local_bh_disable();
380 __tcp_v4_hash(sk, 1);
381 local_bh_enable();
382 }
383 }
384
385 void tcp_unhash(struct sock *sk)
386 {
387 rwlock_t *lock;
388
389 if (sk_unhashed(sk))
390 goto ende;
391
392 if (sk->sk_state == TCP_LISTEN) {
393 local_bh_disable();
394 tcp_listen_wlock();
395 lock = &tcp_lhash_lock;
396 } else {
397 struct tcp_ehash_bucket *head = &tcp_ehash[sk->sk_hashent];
398 lock = &head->lock;
399 write_lock_bh(&head->lock);
400 }
401
402 if (__sk_del_node_init(sk))
403 sock_prot_dec_use(sk->sk_prot);
404 write_unlock_bh(lock);
405
406 ende:
407 if (sk->sk_state == TCP_LISTEN)
408 wake_up(&tcp_lhash_wait);
409 }
410
411 /* Don't inline this cruft. Here are some nice properties to
412 * exploit here. The BSD API does not allow a listening TCP
413 * to specify the remote port nor the remote address for the
414 * connection. So always assume those are both wildcarded
415 * during the search since they can never be otherwise.
416 */
417 static struct sock *__tcp_v4_lookup_listener(struct hlist_head *head, u32 daddr,
418 unsigned short hnum, int dif)
419 {
420 struct sock *result = NULL, *sk;
421 struct hlist_node *node;
422 int score, hiscore;
423
424 hiscore=-1;
425 sk_for_each(sk, node, head) {
426 struct inet_sock *inet = inet_sk(sk);
427
428 if (inet->num == hnum && !ipv6_only_sock(sk)) {
429 __u32 rcv_saddr = inet->rcv_saddr;
430
431 score = (sk->sk_family == PF_INET ? 1 : 0);
432 if (rcv_saddr) {
433 if (rcv_saddr != daddr)
434 continue;
435 score+=2;
436 }
437 if (sk->sk_bound_dev_if) {
438 if (sk->sk_bound_dev_if != dif)
439 continue;
440 score+=2;
441 }
442 if (score == 5)
443 return sk;
444 if (score > hiscore) {
445 hiscore = score;
446 result = sk;
447 }
448 }
449 }
450 return result;
451 }
452
453 /* Optimize the common listener case. */
454 static inline struct sock *tcp_v4_lookup_listener(u32 daddr,
455 unsigned short hnum, int dif)
456 {
457 struct sock *sk = NULL;
458 struct hlist_head *head;
459
460 read_lock(&tcp_lhash_lock);
461 head = &tcp_listening_hash[tcp_lhashfn(hnum)];
462 if (!hlist_empty(head)) {
463 struct inet_sock *inet = inet_sk((sk = __sk_head(head)));
464
465 if (inet->num == hnum && !sk->sk_node.next &&
466 (!inet->rcv_saddr || inet->rcv_saddr == daddr) &&
467 (sk->sk_family == PF_INET || !ipv6_only_sock(sk)) &&
468 !sk->sk_bound_dev_if)
469 goto sherry_cache;
470 sk = __tcp_v4_lookup_listener(head, daddr, hnum, dif);
471 }
472 if (sk) {
473 sherry_cache:
474 sock_hold(sk);
475 }
476 read_unlock(&tcp_lhash_lock);
477 return sk;
478 }
479
480 /* Sockets in TCP_CLOSE state are _always_ taken out of the hash, so
481 * we need not check it for TCP lookups anymore, thanks Alexey. -DaveM
482 *
483 * Local BH must be disabled here.
484 */
485
486 static inline struct sock *__tcp_v4_lookup_established(u32 saddr, u16 sport,
487 u32 daddr, u16 hnum,
488 int dif)
489 {
490 struct tcp_ehash_bucket *head;
491 TCP_V4_ADDR_COOKIE(acookie, saddr, daddr)
492 __u32 ports = TCP_COMBINED_PORTS(sport, hnum);
493 struct sock *sk;
494 struct hlist_node *node;
495 /* Optimize here for direct hit, only listening connections can
496 * have wildcards anyways.
497 */
498 int hash = tcp_hashfn(daddr, hnum, saddr, sport);
499 head = &tcp_ehash[hash];
500 read_lock(&head->lock);
501 sk_for_each(sk, node, &head->chain) {
502 if (TCP_IPV4_MATCH(sk, acookie, saddr, daddr, ports, dif))
503 goto hit; /* You sunk my battleship! */
504 }
505
506 /* Must check for a TIME_WAIT'er before going to listener hash. */
507 sk_for_each(sk, node, &(head + tcp_ehash_size)->chain) {
508 if (TCP_IPV4_TW_MATCH(sk, acookie, saddr, daddr, ports, dif))
509 goto hit;
510 }
511 sk = NULL;
512 out:
513 read_unlock(&head->lock);
514 return sk;
515 hit:
516 sock_hold(sk);
517 goto out;
518 }
519
520 static inline struct sock *__tcp_v4_lookup(u32 saddr, u16 sport,
521 u32 daddr, u16 hnum, int dif)
522 {
523 struct sock *sk = __tcp_v4_lookup_established(saddr, sport,
524 daddr, hnum, dif);
525
526 return sk ? : tcp_v4_lookup_listener(daddr, hnum, dif);
527 }
528
529 inline struct sock *tcp_v4_lookup(u32 saddr, u16 sport, u32 daddr,
530 u16 dport, int dif)
531 {
532 struct sock *sk;
533
534 local_bh_disable();
535 sk = __tcp_v4_lookup(saddr, sport, daddr, ntohs(dport), dif);
536 local_bh_enable();
537
538 return sk;
539 }
540
541 EXPORT_SYMBOL_GPL(tcp_v4_lookup);
542
543 static inline __u32 tcp_v4_init_sequence(struct sock *sk, struct sk_buff *skb)
544 {
545 return secure_tcp_sequence_number(skb->nh.iph->daddr,
546 skb->nh.iph->saddr,
547 skb->h.th->dest,
548 skb->h.th->source);
549 }
550
551 /* called with local bh disabled */
552 static int __tcp_v4_check_established(struct sock *sk, __u16 lport,
553 struct tcp_tw_bucket **twp)
554 {
555 struct inet_sock *inet = inet_sk(sk);
556 u32 daddr = inet->rcv_saddr;
557 u32 saddr = inet->daddr;
558 int dif = sk->sk_bound_dev_if;
559 TCP_V4_ADDR_COOKIE(acookie, saddr, daddr)
560 __u32 ports = TCP_COMBINED_PORTS(inet->dport, lport);
561 int hash = tcp_hashfn(daddr, lport, saddr, inet->dport);
562 struct tcp_ehash_bucket *head = &tcp_ehash[hash];
563 struct sock *sk2;
564 struct hlist_node *node;
565 struct tcp_tw_bucket *tw;
566
567 write_lock(&head->lock);
568
569 /* Check TIME-WAIT sockets first. */
570 sk_for_each(sk2, node, &(head + tcp_ehash_size)->chain) {
571 tw = (struct tcp_tw_bucket *)sk2;
572
573 if (TCP_IPV4_TW_MATCH(sk2, acookie, saddr, daddr, ports, dif)) {
574 struct tcp_sock *tp = tcp_sk(sk);
575
576 /* With PAWS, it is safe from the viewpoint
577 of data integrity. Even without PAWS it
578 is safe provided sequence spaces do not
579 overlap i.e. at data rates <= 80Mbit/sec.
580
581 Actually, the idea is close to VJ's one,
582 only timestamp cache is held not per host,
583 but per port pair and TW bucket is used
584 as state holder.
585
586 If TW bucket has been already destroyed we
587 fall back to VJ's scheme and use initial
588 timestamp retrieved from peer table.
589 */
590 if (tw->tw_ts_recent_stamp &&
591 (!twp || (sysctl_tcp_tw_reuse &&
592 xtime.tv_sec -
593 tw->tw_ts_recent_stamp > 1))) {
594 if ((tp->write_seq =
595 tw->tw_snd_nxt + 65535 + 2) == 0)
596 tp->write_seq = 1;
597 tp->rx_opt.ts_recent = tw->tw_ts_recent;
598 tp->rx_opt.ts_recent_stamp = tw->tw_ts_recent_stamp;
599 sock_hold(sk2);
600 goto unique;
601 } else
602 goto not_unique;
603 }
604 }
605 tw = NULL;
606
607 /* And established part... */
608 sk_for_each(sk2, node, &head->chain) {
609 if (TCP_IPV4_MATCH(sk2, acookie, saddr, daddr, ports, dif))
610 goto not_unique;
611 }
612
613 unique:
614 /* Must record num and sport now. Otherwise we will see
615 * in hash table socket with a funny identity. */
616 inet->num = lport;
617 inet->sport = htons(lport);
618 sk->sk_hashent = hash;
619 BUG_TRAP(sk_unhashed(sk));
620 __sk_add_node(sk, &head->chain);
621 sock_prot_inc_use(sk->sk_prot);
622 write_unlock(&head->lock);
623
624 if (twp) {
625 *twp = tw;
626 NET_INC_STATS_BH(LINUX_MIB_TIMEWAITRECYCLED);
627 } else if (tw) {
628 /* Silly. Should hash-dance instead... */
629 tcp_tw_deschedule(tw);
630 NET_INC_STATS_BH(LINUX_MIB_TIMEWAITRECYCLED);
631
632 tcp_tw_put(tw);
633 }
634
635 return 0;
636
637 not_unique:
638 write_unlock(&head->lock);
639 return -EADDRNOTAVAIL;
640 }
641
642 static inline u32 connect_port_offset(const struct sock *sk)
643 {
644 const struct inet_sock *inet = inet_sk(sk);
645
646 return secure_tcp_port_ephemeral(inet->rcv_saddr, inet->daddr,
647 inet->dport);
648 }
649
650 /*
651 * Bind a port for a connect operation and hash it.
652 */
653 static inline int tcp_v4_hash_connect(struct sock *sk)
654 {
655 unsigned short snum = inet_sk(sk)->num;
656 struct tcp_bind_hashbucket *head;
657 struct tcp_bind_bucket *tb;
658 int ret;
659
660 if (!snum) {
661 int low = sysctl_local_port_range[0];
662 int high = sysctl_local_port_range[1];
663 int range = high - low;
664 int i;
665 int port;
666 static u32 hint;
667 u32 offset = hint + connect_port_offset(sk);
668 struct hlist_node *node;
669 struct tcp_tw_bucket *tw = NULL;
670
671 local_bh_disable();
672 for (i = 1; i <= range; i++) {
673 port = low + (i + offset) % range;
674 head = &tcp_bhash[tcp_bhashfn(port)];
675 spin_lock(&head->lock);
676
677 /* Does not bother with rcv_saddr checks,
678 * because the established check is already
679 * unique enough.
680 */
681 tb_for_each(tb, node, &head->chain) {
682 if (tb->port == port) {
683 BUG_TRAP(!hlist_empty(&tb->owners));
684 if (tb->fastreuse >= 0)
685 goto next_port;
686 if (!__tcp_v4_check_established(sk,
687 port,
688 &tw))
689 goto ok;
690 goto next_port;
691 }
692 }
693
694 tb = tcp_bucket_create(head, port);
695 if (!tb) {
696 spin_unlock(&head->lock);
697 break;
698 }
699 tb->fastreuse = -1;
700 goto ok;
701
702 next_port:
703 spin_unlock(&head->lock);
704 }
705 local_bh_enable();
706
707 return -EADDRNOTAVAIL;
708
709 ok:
710 hint += i;
711
712 /* Head lock still held and bh's disabled */
713 tcp_bind_hash(sk, tb, port);
714 if (sk_unhashed(sk)) {
715 inet_sk(sk)->sport = htons(port);
716 __tcp_v4_hash(sk, 0);
717 }
718 spin_unlock(&head->lock);
719
720 if (tw) {
721 tcp_tw_deschedule(tw);
722 tcp_tw_put(tw);
723 }
724
725 ret = 0;
726 goto out;
727 }
728
729 head = &tcp_bhash[tcp_bhashfn(snum)];
730 tb = tcp_sk(sk)->bind_hash;
731 spin_lock_bh(&head->lock);
732 if (sk_head(&tb->owners) == sk && !sk->sk_bind_node.next) {
733 __tcp_v4_hash(sk, 0);
734 spin_unlock_bh(&head->lock);
735 return 0;
736 } else {
737 spin_unlock(&head->lock);
738 /* No definite answer... Walk to established hash table */
739 ret = __tcp_v4_check_established(sk, snum, NULL);
740 out:
741 local_bh_enable();
742 return ret;
743 }
744 }
745
746 /* This will initiate an outgoing connection. */
747 int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
748 {
749 struct inet_sock *inet = inet_sk(sk);
750 struct tcp_sock *tp = tcp_sk(sk);
751 struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
752 struct rtable *rt;
753 u32 daddr, nexthop;
754 int tmp;
755 int err;
756
757 if (addr_len < sizeof(struct sockaddr_in))
758 return -EINVAL;
759
760 if (usin->sin_family != AF_INET)
761 return -EAFNOSUPPORT;
762
763 nexthop = daddr = usin->sin_addr.s_addr;
764 if (inet->opt && inet->opt->srr) {
765 if (!daddr)
766 return -EINVAL;
767 nexthop = inet->opt->faddr;
768 }
769
770 tmp = ip_route_connect(&rt, nexthop, inet->saddr,
771 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
772 IPPROTO_TCP,
773 inet->sport, usin->sin_port, sk);
774 if (tmp < 0)
775 return tmp;
776
777 if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
778 ip_rt_put(rt);
779 return -ENETUNREACH;
780 }
781
782 if (!inet->opt || !inet->opt->srr)
783 daddr = rt->rt_dst;
784
785 if (!inet->saddr)
786 inet->saddr = rt->rt_src;
787 inet->rcv_saddr = inet->saddr;
788
789 if (tp->rx_opt.ts_recent_stamp && inet->daddr != daddr) {
790 /* Reset inherited state */
791 tp->rx_opt.ts_recent = 0;
792 tp->rx_opt.ts_recent_stamp = 0;
793 tp->write_seq = 0;
794 }
795
796 if (sysctl_tcp_tw_recycle &&
797 !tp->rx_opt.ts_recent_stamp && rt->rt_dst == daddr) {
798 struct inet_peer *peer = rt_get_peer(rt);
799
800 /* VJ's idea. We save last timestamp seen from
801 * the destination in peer table, when entering state TIME-WAIT
802 * and initialize rx_opt.ts_recent from it, when trying new connection.
803 */
804
805 if (peer && peer->tcp_ts_stamp + TCP_PAWS_MSL >= xtime.tv_sec) {
806 tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp;
807 tp->rx_opt.ts_recent = peer->tcp_ts;
808 }
809 }
810
811 inet->dport = usin->sin_port;
812 inet->daddr = daddr;
813
814 tp->ext_header_len = 0;
815 if (inet->opt)
816 tp->ext_header_len = inet->opt->optlen;
817
818 tp->rx_opt.mss_clamp = 536;
819
820 /* Socket identity is still unknown (sport may be zero).
821 * However we set state to SYN-SENT and not releasing socket
822 * lock select source port, enter ourselves into the hash tables and
823 * complete initialization after this.
824 */
825 tcp_set_state(sk, TCP_SYN_SENT);
826 err = tcp_v4_hash_connect(sk);
827 if (err)
828 goto failure;
829
830 err = ip_route_newports(&rt, inet->sport, inet->dport, sk);
831 if (err)
832 goto failure;
833
834 /* OK, now commit destination to socket. */
835 __sk_dst_set(sk, &rt->u.dst);
836 tcp_v4_setup_caps(sk, &rt->u.dst);
837
838 if (!tp->write_seq)
839 tp->write_seq = secure_tcp_sequence_number(inet->saddr,
840 inet->daddr,
841 inet->sport,
842 usin->sin_port);
843
844 inet->id = tp->write_seq ^ jiffies;
845
846 err = tcp_connect(sk);
847 rt = NULL;
848 if (err)
849 goto failure;
850
851 return 0;
852
853 failure:
854 /* This unhashes the socket and releases the local port, if necessary. */
855 tcp_set_state(sk, TCP_CLOSE);
856 ip_rt_put(rt);
857 sk->sk_route_caps = 0;
858 inet->dport = 0;
859 return err;
860 }
861
862 static __inline__ int tcp_v4_iif(struct sk_buff *skb)
863 {
864 return ((struct rtable *)skb->dst)->rt_iif;
865 }
866
867 static __inline__ u32 tcp_v4_synq_hash(u32 raddr, u16 rport, u32 rnd)
868 {
869 return (jhash_2words(raddr, (u32) rport, rnd) & (TCP_SYNQ_HSIZE - 1));
870 }
871
872 static struct request_sock *tcp_v4_search_req(struct tcp_sock *tp,
873 struct request_sock ***prevp,
874 __u16 rport,
875 __u32 raddr, __u32 laddr)
876 {
877 struct tcp_listen_opt *lopt = tp->listen_opt;
878 struct request_sock *req, **prev;
879
880 for (prev = &lopt->syn_table[tcp_v4_synq_hash(raddr, rport, lopt->hash_rnd)];
881 (req = *prev) != NULL;
882 prev = &req->dl_next) {
883 const struct inet_request_sock *ireq = inet_rsk(req);
884
885 if (ireq->rmt_port == rport &&
886 ireq->rmt_addr == raddr &&
887 ireq->loc_addr == laddr &&
888 TCP_INET_FAMILY(req->rsk_ops->family)) {
889 BUG_TRAP(!req->sk);
890 *prevp = prev;
891 break;
892 }
893 }
894
895 return req;
896 }
897
898 static void tcp_v4_synq_add(struct sock *sk, struct request_sock *req)
899 {
900 struct tcp_sock *tp = tcp_sk(sk);
901 struct tcp_listen_opt *lopt = tp->listen_opt;
902 u32 h = tcp_v4_synq_hash(inet_rsk(req)->rmt_addr, inet_rsk(req)->rmt_port, lopt->hash_rnd);
903
904 req->expires = jiffies + TCP_TIMEOUT_INIT;
905 req->retrans = 0;
906 req->sk = NULL;
907 req->dl_next = lopt->syn_table[h];
908
909 write_lock(&tp->syn_wait_lock);
910 lopt->syn_table[h] = req;
911 write_unlock(&tp->syn_wait_lock);
912
913 tcp_synq_added(sk);
914 }
915
916
917 /*
918 * This routine does path mtu discovery as defined in RFC1191.
919 */
920 static inline void do_pmtu_discovery(struct sock *sk, struct iphdr *iph,
921 u32 mtu)
922 {
923 struct dst_entry *dst;
924 struct inet_sock *inet = inet_sk(sk);
925 struct tcp_sock *tp = tcp_sk(sk);
926
927 /* We are not interested in TCP_LISTEN and open_requests (SYN-ACKs
928 * send out by Linux are always <576bytes so they should go through
929 * unfragmented).
930 */
931 if (sk->sk_state == TCP_LISTEN)
932 return;
933
934 /* We don't check in the destentry if pmtu discovery is forbidden
935 * on this route. We just assume that no packet_to_big packets
936 * are send back when pmtu discovery is not active.
937 * There is a small race when the user changes this flag in the
938 * route, but I think that's acceptable.
939 */
940 if ((dst = __sk_dst_check(sk, 0)) == NULL)
941 return;
942
943 dst->ops->update_pmtu(dst, mtu);
944
945 /* Something is about to be wrong... Remember soft error
946 * for the case, if this connection will not able to recover.
947 */
948 if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
949 sk->sk_err_soft = EMSGSIZE;
950
951 mtu = dst_mtu(dst);
952
953 if (inet->pmtudisc != IP_PMTUDISC_DONT &&
954 tp->pmtu_cookie > mtu) {
955 tcp_sync_mss(sk, mtu);
956
957 /* Resend the TCP packet because it's
958 * clear that the old packet has been
959 * dropped. This is the new "fast" path mtu
960 * discovery.
961 */
962 tcp_simple_retransmit(sk);
963 } /* else let the usual retransmit timer handle it */
964 }
965
966 /*
967 * This routine is called by the ICMP module when it gets some
968 * sort of error condition. If err < 0 then the socket should
969 * be closed and the error returned to the user. If err > 0
970 * it's just the icmp type << 8 | icmp code. After adjustment
971 * header points to the first 8 bytes of the tcp header. We need
972 * to find the appropriate port.
973 *
974 * The locking strategy used here is very "optimistic". When
975 * someone else accesses the socket the ICMP is just dropped
976 * and for some paths there is no check at all.
977 * A more general error queue to queue errors for later handling
978 * is probably better.
979 *
980 */
981
982 void tcp_v4_err(struct sk_buff *skb, u32 info)
983 {
984 struct iphdr *iph = (struct iphdr *)skb->data;
985 struct tcphdr *th = (struct tcphdr *)(skb->data + (iph->ihl << 2));
986 struct tcp_sock *tp;
987 struct inet_sock *inet;
988 int type = skb->h.icmph->type;
989 int code = skb->h.icmph->code;
990 struct sock *sk;
991 __u32 seq;
992 int err;
993
994 if (skb->len < (iph->ihl << 2) + 8) {
995 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
996 return;
997 }
998
999 sk = tcp_v4_lookup(iph->daddr, th->dest, iph->saddr,
1000 th->source, tcp_v4_iif(skb));
1001 if (!sk) {
1002 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
1003 return;
1004 }
1005 if (sk->sk_state == TCP_TIME_WAIT) {
1006 tcp_tw_put((struct tcp_tw_bucket *)sk);
1007 return;
1008 }
1009
1010 bh_lock_sock(sk);
1011 /* If too many ICMPs get dropped on busy
1012 * servers this needs to be solved differently.
1013 */
1014 if (sock_owned_by_user(sk))
1015 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS);
1016
1017 if (sk->sk_state == TCP_CLOSE)
1018 goto out;
1019
1020 tp = tcp_sk(sk);
1021 seq = ntohl(th->seq);
1022 if (sk->sk_state != TCP_LISTEN &&
1023 !between(seq, tp->snd_una, tp->snd_nxt)) {
1024 NET_INC_STATS(LINUX_MIB_OUTOFWINDOWICMPS);
1025 goto out;
1026 }
1027
1028 switch (type) {
1029 case ICMP_SOURCE_QUENCH:
1030 /* Just silently ignore these. */
1031 goto out;
1032 case ICMP_PARAMETERPROB:
1033 err = EPROTO;
1034 break;
1035 case ICMP_DEST_UNREACH:
1036 if (code > NR_ICMP_UNREACH)
1037 goto out;
1038
1039 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
1040 if (!sock_owned_by_user(sk))
1041 do_pmtu_discovery(sk, iph, info);
1042 goto out;
1043 }
1044
1045 err = icmp_err_convert[code].errno;
1046 break;
1047 case ICMP_TIME_EXCEEDED:
1048 err = EHOSTUNREACH;
1049 break;
1050 default:
1051 goto out;
1052 }
1053
1054 switch (sk->sk_state) {
1055 struct request_sock *req, **prev;
1056 case TCP_LISTEN:
1057 if (sock_owned_by_user(sk))
1058 goto out;
1059
1060 req = tcp_v4_search_req(tp, &prev, th->dest,
1061 iph->daddr, iph->saddr);
1062 if (!req)
1063 goto out;
1064
1065 /* ICMPs are not backlogged, hence we cannot get
1066 an established socket here.
1067 */
1068 BUG_TRAP(!req->sk);
1069
1070 if (seq != tcp_rsk(req)->snt_isn) {
1071 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
1072 goto out;
1073 }
1074
1075 /*
1076 * Still in SYN_RECV, just remove it silently.
1077 * There is no good way to pass the error to the newly
1078 * created socket, and POSIX does not want network
1079 * errors returned from accept().
1080 */
1081 tcp_synq_drop(sk, req, prev);
1082 goto out;
1083
1084 case TCP_SYN_SENT:
1085 case TCP_SYN_RECV: /* Cannot happen.
1086 It can f.e. if SYNs crossed.
1087 */
1088 if (!sock_owned_by_user(sk)) {
1089 TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
1090 sk->sk_err = err;
1091
1092 sk->sk_error_report(sk);
1093
1094 tcp_done(sk);
1095 } else {
1096 sk->sk_err_soft = err;
1097 }
1098 goto out;
1099 }
1100
1101 /* If we've already connected we will keep trying
1102 * until we time out, or the user gives up.
1103 *
1104 * rfc1122 4.2.3.9 allows to consider as hard errors
1105 * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
1106 * but it is obsoleted by pmtu discovery).
1107 *
1108 * Note, that in modern internet, where routing is unreliable
1109 * and in each dark corner broken firewalls sit, sending random
1110 * errors ordered by their masters even this two messages finally lose
1111 * their original sense (even Linux sends invalid PORT_UNREACHs)
1112 *
1113 * Now we are in compliance with RFCs.
1114 * --ANK (980905)
1115 */
1116
1117 inet = inet_sk(sk);
1118 if (!sock_owned_by_user(sk) && inet->recverr) {
1119 sk->sk_err = err;
1120 sk->sk_error_report(sk);
1121 } else { /* Only an error on timeout */
1122 sk->sk_err_soft = err;
1123 }
1124
1125 out:
1126 bh_unlock_sock(sk);
1127 sock_put(sk);
1128 }
1129
1130 /* This routine computes an IPv4 TCP checksum. */
1131 void tcp_v4_send_check(struct sock *sk, struct tcphdr *th, int len,
1132 struct sk_buff *skb)
1133 {
1134 struct inet_sock *inet = inet_sk(sk);
1135
1136 if (skb->ip_summed == CHECKSUM_HW) {
1137 th->check = ~tcp_v4_check(th, len, inet->saddr, inet->daddr, 0);
1138 skb->csum = offsetof(struct tcphdr, check);
1139 } else {
1140 th->check = tcp_v4_check(th, len, inet->saddr, inet->daddr,
1141 csum_partial((char *)th,
1142 th->doff << 2,
1143 skb->csum));
1144 }
1145 }
1146
1147 /*
1148 * This routine will send an RST to the other tcp.
1149 *
1150 * Someone asks: why I NEVER use socket parameters (TOS, TTL etc.)
1151 * for reset.
1152 * Answer: if a packet caused RST, it is not for a socket
1153 * existing in our system, if it is matched to a socket,
1154 * it is just duplicate segment or bug in other side's TCP.
1155 * So that we build reply only basing on parameters
1156 * arrived with segment.
1157 * Exception: precedence violation. We do not implement it in any case.
1158 */
1159
1160 static void tcp_v4_send_reset(struct sk_buff *skb)
1161 {
1162 struct tcphdr *th = skb->h.th;
1163 struct tcphdr rth;
1164 struct ip_reply_arg arg;
1165
1166 /* Never send a reset in response to a reset. */
1167 if (th->rst)
1168 return;
1169
1170 if (((struct rtable *)skb->dst)->rt_type != RTN_LOCAL)
1171 return;
1172
1173 /* Swap the send and the receive. */
1174 memset(&rth, 0, sizeof(struct tcphdr));
1175 rth.dest = th->source;
1176 rth.source = th->dest;
1177 rth.doff = sizeof(struct tcphdr) / 4;
1178 rth.rst = 1;
1179
1180 if (th->ack) {
1181 rth.seq = th->ack_seq;
1182 } else {
1183 rth.ack = 1;
1184 rth.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
1185 skb->len - (th->doff << 2));
1186 }
1187
1188 memset(&arg, 0, sizeof arg);
1189 arg.iov[0].iov_base = (unsigned char *)&rth;
1190 arg.iov[0].iov_len = sizeof rth;
1191 arg.csum = csum_tcpudp_nofold(skb->nh.iph->daddr,
1192 skb->nh.iph->saddr, /*XXX*/
1193 sizeof(struct tcphdr), IPPROTO_TCP, 0);
1194 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
1195
1196 ip_send_reply(tcp_socket->sk, skb, &arg, sizeof rth);
1197
1198 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
1199 TCP_INC_STATS_BH(TCP_MIB_OUTRSTS);
1200 }
1201
1202 /* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
1203 outside socket context is ugly, certainly. What can I do?
1204 */
1205
1206 static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
1207 u32 win, u32 ts)
1208 {
1209 struct tcphdr *th = skb->h.th;
1210 struct {
1211 struct tcphdr th;
1212 u32 tsopt[3];
1213 } rep;
1214 struct ip_reply_arg arg;
1215
1216 memset(&rep.th, 0, sizeof(struct tcphdr));
1217 memset(&arg, 0, sizeof arg);
1218
1219 arg.iov[0].iov_base = (unsigned char *)&rep;
1220 arg.iov[0].iov_len = sizeof(rep.th);
1221 if (ts) {
1222 rep.tsopt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1223 (TCPOPT_TIMESTAMP << 8) |
1224 TCPOLEN_TIMESTAMP);
1225 rep.tsopt[1] = htonl(tcp_time_stamp);
1226 rep.tsopt[2] = htonl(ts);
1227 arg.iov[0].iov_len = sizeof(rep);
1228 }
1229
1230 /* Swap the send and the receive. */
1231 rep.th.dest = th->source;
1232 rep.th.source = th->dest;
1233 rep.th.doff = arg.iov[0].iov_len / 4;
1234 rep.th.seq = htonl(seq);
1235 rep.th.ack_seq = htonl(ack);
1236 rep.th.ack = 1;
1237 rep.th.window = htons(win);
1238
1239 arg.csum = csum_tcpudp_nofold(skb->nh.iph->daddr,
1240 skb->nh.iph->saddr, /*XXX*/
1241 arg.iov[0].iov_len, IPPROTO_TCP, 0);
1242 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
1243
1244 ip_send_reply(tcp_socket->sk, skb, &arg, arg.iov[0].iov_len);
1245
1246 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
1247 }
1248
1249 static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
1250 {
1251 struct tcp_tw_bucket *tw = (struct tcp_tw_bucket *)sk;
1252
1253 tcp_v4_send_ack(skb, tw->tw_snd_nxt, tw->tw_rcv_nxt,
1254 tw->tw_rcv_wnd >> tw->tw_rcv_wscale, tw->tw_ts_recent);
1255
1256 tcp_tw_put(tw);
1257 }
1258
1259 static void tcp_v4_reqsk_send_ack(struct sk_buff *skb, struct request_sock *req)
1260 {
1261 tcp_v4_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd,
1262 req->ts_recent);
1263 }
1264
1265 static struct dst_entry* tcp_v4_route_req(struct sock *sk,
1266 struct request_sock *req)
1267 {
1268 struct rtable *rt;
1269 const struct inet_request_sock *ireq = inet_rsk(req);
1270 struct ip_options *opt = inet_rsk(req)->opt;
1271 struct flowi fl = { .oif = sk->sk_bound_dev_if,
1272 .nl_u = { .ip4_u =
1273 { .daddr = ((opt && opt->srr) ?
1274 opt->faddr :
1275 ireq->rmt_addr),
1276 .saddr = ireq->loc_addr,
1277 .tos = RT_CONN_FLAGS(sk) } },
1278 .proto = IPPROTO_TCP,
1279 .uli_u = { .ports =
1280 { .sport = inet_sk(sk)->sport,
1281 .dport = ireq->rmt_port } } };
1282
1283 if (ip_route_output_flow(&rt, &fl, sk, 0)) {
1284 IP_INC_STATS_BH(IPSTATS_MIB_OUTNOROUTES);
1285 return NULL;
1286 }
1287 if (opt && opt->is_strictroute && rt->rt_dst != rt->rt_gateway) {
1288 ip_rt_put(rt);
1289 IP_INC_STATS_BH(IPSTATS_MIB_OUTNOROUTES);
1290 return NULL;
1291 }
1292 return &rt->u.dst;
1293 }
1294
1295 /*
1296 * Send a SYN-ACK after having received an ACK.
1297 * This still operates on a request_sock only, not on a big
1298 * socket.
1299 */
1300 static int tcp_v4_send_synack(struct sock *sk, struct request_sock *req,
1301 struct dst_entry *dst)
1302 {
1303 const struct inet_request_sock *ireq = inet_rsk(req);
1304 int err = -1;
1305 struct sk_buff * skb;
1306
1307 /* First, grab a route. */
1308 if (!dst && (dst = tcp_v4_route_req(sk, req)) == NULL)
1309 goto out;
1310
1311 skb = tcp_make_synack(sk, dst, req);
1312
1313 if (skb) {
1314 struct tcphdr *th = skb->h.th;
1315
1316 th->check = tcp_v4_check(th, skb->len,
1317 ireq->loc_addr,
1318 ireq->rmt_addr,
1319 csum_partial((char *)th, skb->len,
1320 skb->csum));
1321
1322 err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,
1323 ireq->rmt_addr,
1324 ireq->opt);
1325 if (err == NET_XMIT_CN)
1326 err = 0;
1327 }
1328
1329 out:
1330 dst_release(dst);
1331 return err;
1332 }
1333
1334 /*
1335 * IPv4 request_sock destructor.
1336 */
1337 static void tcp_v4_reqsk_destructor(struct request_sock *req)
1338 {
1339 if (inet_rsk(req)->opt)
1340 kfree(inet_rsk(req)->opt);
1341 }
1342
1343 static inline void syn_flood_warning(struct sk_buff *skb)
1344 {
1345 static unsigned long warntime;
1346
1347 if (time_after(jiffies, (warntime + HZ * 60))) {
1348 warntime = jiffies;
1349 printk(KERN_INFO
1350 "possible SYN flooding on port %d. Sending cookies.\n",
1351 ntohs(skb->h.th->dest));
1352 }
1353 }
1354
1355 /*
1356 * Save and compile IPv4 options into the request_sock if needed.
1357 */
1358 static inline struct ip_options *tcp_v4_save_options(struct sock *sk,
1359 struct sk_buff *skb)
1360 {
1361 struct ip_options *opt = &(IPCB(skb)->opt);
1362 struct ip_options *dopt = NULL;
1363
1364 if (opt && opt->optlen) {
1365 int opt_size = optlength(opt);
1366 dopt = kmalloc(opt_size, GFP_ATOMIC);
1367 if (dopt) {
1368 if (ip_options_echo(dopt, skb)) {
1369 kfree(dopt);
1370 dopt = NULL;
1371 }
1372 }
1373 }
1374 return dopt;
1375 }
1376
1377 /*
1378 * Maximum number of SYN_RECV sockets in queue per LISTEN socket.
1379 * One SYN_RECV socket costs about 80bytes on a 32bit machine.
1380 * It would be better to replace it with a global counter for all sockets
1381 * but then some measure against one socket starving all other sockets
1382 * would be needed.
1383 *
1384 * It was 128 by default. Experiments with real servers show, that
1385 * it is absolutely not enough even at 100conn/sec. 256 cures most
1386 * of problems. This value is adjusted to 128 for very small machines
1387 * (<=32Mb of memory) and to 1024 on normal or better ones (>=256Mb).
1388 * Further increasing requires to change hash table size.
1389 */
1390 int sysctl_max_syn_backlog = 256;
1391
1392 struct request_sock_ops tcp_request_sock_ops = {
1393 .family = PF_INET,
1394 .obj_size = sizeof(struct tcp_request_sock),
1395 .rtx_syn_ack = tcp_v4_send_synack,
1396 .send_ack = tcp_v4_reqsk_send_ack,
1397 .destructor = tcp_v4_reqsk_destructor,
1398 .send_reset = tcp_v4_send_reset,
1399 };
1400
1401 int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1402 {
1403 struct inet_request_sock *ireq;
1404 struct tcp_options_received tmp_opt;
1405 struct request_sock *req;
1406 __u32 saddr = skb->nh.iph->saddr;
1407 __u32 daddr = skb->nh.iph->daddr;
1408 __u32 isn = TCP_SKB_CB(skb)->when;
1409 struct dst_entry *dst = NULL;
1410 #ifdef CONFIG_SYN_COOKIES
1411 int want_cookie = 0;
1412 #else
1413 #define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */
1414 #endif
1415
1416 /* Never answer to SYNs send to broadcast or multicast */
1417 if (((struct rtable *)skb->dst)->rt_flags &
1418 (RTCF_BROADCAST | RTCF_MULTICAST))
1419 goto drop;
1420
1421 /* TW buckets are converted to open requests without
1422 * limitations, they conserve resources and peer is
1423 * evidently real one.
1424 */
1425 if (tcp_synq_is_full(sk) && !isn) {
1426 #ifdef CONFIG_SYN_COOKIES
1427 if (sysctl_tcp_syncookies) {
1428 want_cookie = 1;
1429 } else
1430 #endif
1431 goto drop;
1432 }
1433
1434 /* Accept backlog is full. If we have already queued enough
1435 * of warm entries in syn queue, drop request. It is better than
1436 * clogging syn queue with openreqs with exponentially increasing
1437 * timeout.
1438 */
1439 if (sk_acceptq_is_full(sk) && tcp_synq_young(sk) > 1)
1440 goto drop;
1441
1442 req = reqsk_alloc(&tcp_request_sock_ops);
1443 if (!req)
1444 goto drop;
1445
1446 tcp_clear_options(&tmp_opt);
1447 tmp_opt.mss_clamp = 536;
1448 tmp_opt.user_mss = tcp_sk(sk)->rx_opt.user_mss;
1449
1450 tcp_parse_options(skb, &tmp_opt, 0);
1451
1452 if (want_cookie) {
1453 tcp_clear_options(&tmp_opt);
1454 tmp_opt.saw_tstamp = 0;
1455 }
1456
1457 if (tmp_opt.saw_tstamp && !tmp_opt.rcv_tsval) {
1458 /* Some OSes (unknown ones, but I see them on web server, which
1459 * contains information interesting only for windows'
1460 * users) do not send their stamp in SYN. It is easy case.
1461 * We simply do not advertise TS support.
1462 */
1463 tmp_opt.saw_tstamp = 0;
1464 tmp_opt.tstamp_ok = 0;
1465 }
1466 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
1467
1468 tcp_openreq_init(req, &tmp_opt, skb);
1469
1470 ireq = inet_rsk(req);
1471 ireq->loc_addr = daddr;
1472 ireq->rmt_addr = saddr;
1473 ireq->opt = tcp_v4_save_options(sk, skb);
1474 if (!want_cookie)
1475 TCP_ECN_create_request(req, skb->h.th);
1476
1477 if (want_cookie) {
1478 #ifdef CONFIG_SYN_COOKIES
1479 syn_flood_warning(skb);
1480 #endif
1481 isn = cookie_v4_init_sequence(sk, skb, &req->mss);
1482 } else if (!isn) {
1483 struct inet_peer *peer = NULL;
1484
1485 /* VJ's idea. We save last timestamp seen
1486 * from the destination in peer table, when entering
1487 * state TIME-WAIT, and check against it before
1488 * accepting new connection request.
1489 *
1490 * If "isn" is not zero, this request hit alive
1491 * timewait bucket, so that all the necessary checks
1492 * are made in the function processing timewait state.
1493 */
1494 if (tmp_opt.saw_tstamp &&
1495 sysctl_tcp_tw_recycle &&
1496 (dst = tcp_v4_route_req(sk, req)) != NULL &&
1497 (peer = rt_get_peer((struct rtable *)dst)) != NULL &&
1498 peer->v4daddr == saddr) {
1499 if (xtime.tv_sec < peer->tcp_ts_stamp + TCP_PAWS_MSL &&
1500 (s32)(peer->tcp_ts - req->ts_recent) >
1501 TCP_PAWS_WINDOW) {
1502 NET_INC_STATS_BH(LINUX_MIB_PAWSPASSIVEREJECTED);
1503 dst_release(dst);
1504 goto drop_and_free;
1505 }
1506 }
1507 /* Kill the following clause, if you dislike this way. */
1508 else if (!sysctl_tcp_syncookies &&
1509 (sysctl_max_syn_backlog - tcp_synq_len(sk) <
1510 (sysctl_max_syn_backlog >> 2)) &&
1511 (!peer || !peer->tcp_ts_stamp) &&
1512 (!dst || !dst_metric(dst, RTAX_RTT))) {
1513 /* Without syncookies last quarter of
1514 * backlog is filled with destinations,
1515 * proven to be alive.
1516 * It means that we continue to communicate
1517 * to destinations, already remembered
1518 * to the moment of synflood.
1519 */
1520 NETDEBUG(if (net_ratelimit()) \
1521 printk(KERN_DEBUG "TCP: drop open "
1522 "request from %u.%u."
1523 "%u.%u/%u\n", \
1524 NIPQUAD(saddr),
1525 ntohs(skb->h.th->source)));
1526 dst_release(dst);
1527 goto drop_and_free;
1528 }
1529
1530 isn = tcp_v4_init_sequence(sk, skb);
1531 }
1532 tcp_rsk(req)->snt_isn = isn;
1533
1534 if (tcp_v4_send_synack(sk, req, dst))
1535 goto drop_and_free;
1536
1537 if (want_cookie) {
1538 reqsk_free(req);
1539 } else {
1540 tcp_v4_synq_add(sk, req);
1541 }
1542 return 0;
1543
1544 drop_and_free:
1545 reqsk_free(req);
1546 drop:
1547 TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
1548 return 0;
1549 }
1550
1551
1552 /*
1553 * The three way handshake has completed - we got a valid synack -
1554 * now create the new socket.
1555 */
1556 struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
1557 struct request_sock *req,
1558 struct dst_entry *dst)
1559 {
1560 struct inet_request_sock *ireq;
1561 struct inet_sock *newinet;
1562 struct tcp_sock *newtp;
1563 struct sock *newsk;
1564
1565 if (sk_acceptq_is_full(sk))
1566 goto exit_overflow;
1567
1568 if (!dst && (dst = tcp_v4_route_req(sk, req)) == NULL)
1569 goto exit;
1570
1571 newsk = tcp_create_openreq_child(sk, req, skb);
1572 if (!newsk)
1573 goto exit;
1574
1575 newsk->sk_dst_cache = dst;
1576 tcp_v4_setup_caps(newsk, dst);
1577
1578 newtp = tcp_sk(newsk);
1579 newinet = inet_sk(newsk);
1580 ireq = inet_rsk(req);
1581 newinet->daddr = ireq->rmt_addr;
1582 newinet->rcv_saddr = ireq->loc_addr;
1583 newinet->saddr = ireq->loc_addr;
1584 newinet->opt = ireq->opt;
1585 ireq->opt = NULL;
1586 newinet->mc_index = tcp_v4_iif(skb);
1587 newinet->mc_ttl = skb->nh.iph->ttl;
1588 newtp->ext_header_len = 0;
1589 if (newinet->opt)
1590 newtp->ext_header_len = newinet->opt->optlen;
1591 newinet->id = newtp->write_seq ^ jiffies;
1592
1593 tcp_sync_mss(newsk, dst_mtu(dst));
1594 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
1595 tcp_initialize_rcv_mss(newsk);
1596
1597 __tcp_v4_hash(newsk, 0);
1598 __tcp_inherit_port(sk, newsk);
1599
1600 return newsk;
1601
1602 exit_overflow:
1603 NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS);
1604 exit:
1605 NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS);
1606 dst_release(dst);
1607 return NULL;
1608 }
1609
1610 static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
1611 {
1612 struct tcphdr *th = skb->h.th;
1613 struct iphdr *iph = skb->nh.iph;
1614 struct tcp_sock *tp = tcp_sk(sk);
1615 struct sock *nsk;
1616 struct request_sock **prev;
1617 /* Find possible connection requests. */
1618 struct request_sock *req = tcp_v4_search_req(tp, &prev, th->source,
1619 iph->saddr, iph->daddr);
1620 if (req)
1621 return tcp_check_req(sk, skb, req, prev);
1622
1623 nsk = __tcp_v4_lookup_established(skb->nh.iph->saddr,
1624 th->source,
1625 skb->nh.iph->daddr,
1626 ntohs(th->dest),
1627 tcp_v4_iif(skb));
1628
1629 if (nsk) {
1630 if (nsk->sk_state != TCP_TIME_WAIT) {
1631 bh_lock_sock(nsk);
1632 return nsk;
1633 }
1634 tcp_tw_put((struct tcp_tw_bucket *)nsk);
1635 return NULL;
1636 }
1637
1638 #ifdef CONFIG_SYN_COOKIES
1639 if (!th->rst && !th->syn && th->ack)
1640 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
1641 #endif
1642 return sk;
1643 }
1644
1645 static int tcp_v4_checksum_init(struct sk_buff *skb)
1646 {
1647 if (skb->ip_summed == CHECKSUM_HW) {
1648 skb->ip_summed = CHECKSUM_UNNECESSARY;
1649 if (!tcp_v4_check(skb->h.th, skb->len, skb->nh.iph->saddr,
1650 skb->nh.iph->daddr, skb->csum))
1651 return 0;
1652
1653 NETDEBUG(if (net_ratelimit())
1654 printk(KERN_DEBUG "hw tcp v4 csum failed\n"));
1655 skb->ip_summed = CHECKSUM_NONE;
1656 }
1657 if (skb->len <= 76) {
1658 if (tcp_v4_check(skb->h.th, skb->len, skb->nh.iph->saddr,
1659 skb->nh.iph->daddr,
1660 skb_checksum(skb, 0, skb->len, 0)))
1661 return -1;
1662 skb->ip_summed = CHECKSUM_UNNECESSARY;
1663 } else {
1664 skb->csum = ~tcp_v4_check(skb->h.th, skb->len,
1665 skb->nh.iph->saddr,
1666 skb->nh.iph->daddr, 0);
1667 }
1668 return 0;
1669 }
1670
1671
1672 /* The socket must have it's spinlock held when we get
1673 * here.
1674 *
1675 * We have a potential double-lock case here, so even when
1676 * doing backlog processing we use the BH locking scheme.
1677 * This is because we cannot sleep with the original spinlock
1678 * held.
1679 */
1680 int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1681 {
1682 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1683 TCP_CHECK_TIMER(sk);
1684 if (tcp_rcv_established(sk, skb, skb->h.th, skb->len))
1685 goto reset;
1686 TCP_CHECK_TIMER(sk);
1687 return 0;
1688 }
1689
1690 if (skb->len < (skb->h.th->doff << 2) || tcp_checksum_complete(skb))
1691 goto csum_err;
1692
1693 if (sk->sk_state == TCP_LISTEN) {
1694 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
1695 if (!nsk)
1696 goto discard;
1697
1698 if (nsk != sk) {
1699 if (tcp_child_process(sk, nsk, skb))
1700 goto reset;
1701 return 0;
1702 }
1703 }
1704
1705 TCP_CHECK_TIMER(sk);
1706 if (tcp_rcv_state_process(sk, skb, skb->h.th, skb->len))
1707 goto reset;
1708 TCP_CHECK_TIMER(sk);
1709 return 0;
1710
1711 reset:
1712 tcp_v4_send_reset(skb);
1713 discard:
1714 kfree_skb(skb);
1715 /* Be careful here. If this function gets more complicated and
1716 * gcc suffers from register pressure on the x86, sk (in %ebx)
1717 * might be destroyed here. This current version compiles correctly,
1718 * but you have been warned.
1719 */
1720 return 0;
1721
1722 csum_err:
1723 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1724 goto discard;
1725 }
1726
1727 /*
1728 * From tcp_input.c
1729 */
1730
1731 int tcp_v4_rcv(struct sk_buff *skb)
1732 {
1733 struct tcphdr *th;
1734 struct sock *sk;
1735 int ret;
1736
1737 if (skb->pkt_type != PACKET_HOST)
1738 goto discard_it;
1739
1740 /* Count it even if it's bad */
1741 TCP_INC_STATS_BH(TCP_MIB_INSEGS);
1742
1743 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1744 goto discard_it;
1745
1746 th = skb->h.th;
1747
1748 if (th->doff < sizeof(struct tcphdr) / 4)
1749 goto bad_packet;
1750 if (!pskb_may_pull(skb, th->doff * 4))
1751 goto discard_it;
1752
1753 /* An explanation is required here, I think.
1754 * Packet length and doff are validated by header prediction,
1755 * provided case of th->doff==0 is elimineted.
1756 * So, we defer the checks. */
1757 if ((skb->ip_summed != CHECKSUM_UNNECESSARY &&
1758 tcp_v4_checksum_init(skb) < 0))
1759 goto bad_packet;
1760
1761 th = skb->h.th;
1762 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1763 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1764 skb->len - th->doff * 4);
1765 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1766 TCP_SKB_CB(skb)->when = 0;
1767 TCP_SKB_CB(skb)->flags = skb->nh.iph->tos;
1768 TCP_SKB_CB(skb)->sacked = 0;
1769
1770 sk = __tcp_v4_lookup(skb->nh.iph->saddr, th->source,
1771 skb->nh.iph->daddr, ntohs(th->dest),
1772 tcp_v4_iif(skb));
1773
1774 if (!sk)
1775 goto no_tcp_socket;
1776
1777 process:
1778 if (sk->sk_state == TCP_TIME_WAIT)
1779 goto do_time_wait;
1780
1781 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1782 goto discard_and_relse;
1783
1784 if (sk_filter(sk, skb, 0))
1785 goto discard_and_relse;
1786
1787 skb->dev = NULL;
1788
1789 bh_lock_sock(sk);
1790 ret = 0;
1791 if (!sock_owned_by_user(sk)) {
1792 if (!tcp_prequeue(sk, skb))
1793 ret = tcp_v4_do_rcv(sk, skb);
1794 } else
1795 sk_add_backlog(sk, skb);
1796 bh_unlock_sock(sk);
1797
1798 sock_put(sk);
1799
1800 return ret;
1801
1802 no_tcp_socket:
1803 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1804 goto discard_it;
1805
1806 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1807 bad_packet:
1808 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1809 } else {
1810 tcp_v4_send_reset(skb);
1811 }
1812
1813 discard_it:
1814 /* Discard frame. */
1815 kfree_skb(skb);
1816 return 0;
1817
1818 discard_and_relse:
1819 sock_put(sk);
1820 goto discard_it;
1821
1822 do_time_wait:
1823 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1824 tcp_tw_put((struct tcp_tw_bucket *) sk);
1825 goto discard_it;
1826 }
1827
1828 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1829 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1830 tcp_tw_put((struct tcp_tw_bucket *) sk);
1831 goto discard_it;
1832 }
1833 switch (tcp_timewait_state_process((struct tcp_tw_bucket *)sk,
1834 skb, th, skb->len)) {
1835 case TCP_TW_SYN: {
1836 struct sock *sk2 = tcp_v4_lookup_listener(skb->nh.iph->daddr,
1837 ntohs(th->dest),
1838 tcp_v4_iif(skb));
1839 if (sk2) {
1840 tcp_tw_deschedule((struct tcp_tw_bucket *)sk);
1841 tcp_tw_put((struct tcp_tw_bucket *)sk);
1842 sk = sk2;
1843 goto process;
1844 }
1845 /* Fall through to ACK */
1846 }
1847 case TCP_TW_ACK:
1848 tcp_v4_timewait_ack(sk, skb);
1849 break;
1850 case TCP_TW_RST:
1851 goto no_tcp_socket;
1852 case TCP_TW_SUCCESS:;
1853 }
1854 goto discard_it;
1855 }
1856
1857 /* With per-bucket locks this operation is not-atomic, so that
1858 * this version is not worse.
1859 */
1860 static void __tcp_v4_rehash(struct sock *sk)
1861 {
1862 sk->sk_prot->unhash(sk);
1863 sk->sk_prot->hash(sk);
1864 }
1865
1866 static int tcp_v4_reselect_saddr(struct sock *sk)
1867 {
1868 struct inet_sock *inet = inet_sk(sk);
1869 int err;
1870 struct rtable *rt;
1871 __u32 old_saddr = inet->saddr;
1872 __u32 new_saddr;
1873 __u32 daddr = inet->daddr;
1874
1875 if (inet->opt && inet->opt->srr)
1876 daddr = inet->opt->faddr;
1877
1878 /* Query new route. */
1879 err = ip_route_connect(&rt, daddr, 0,
1880 RT_CONN_FLAGS(sk),
1881 sk->sk_bound_dev_if,
1882 IPPROTO_TCP,
1883 inet->sport, inet->dport, sk);
1884 if (err)
1885 return err;
1886
1887 __sk_dst_set(sk, &rt->u.dst);
1888 tcp_v4_setup_caps(sk, &rt->u.dst);
1889
1890 new_saddr = rt->rt_src;
1891
1892 if (new_saddr == old_saddr)
1893 return 0;
1894
1895 if (sysctl_ip_dynaddr > 1) {
1896 printk(KERN_INFO "tcp_v4_rebuild_header(): shifting inet->"
1897 "saddr from %d.%d.%d.%d to %d.%d.%d.%d\n",
1898 NIPQUAD(old_saddr),
1899 NIPQUAD(new_saddr));
1900 }
1901
1902 inet->saddr = new_saddr;
1903 inet->rcv_saddr = new_saddr;
1904
1905 /* XXX The only one ugly spot where we need to
1906 * XXX really change the sockets identity after
1907 * XXX it has entered the hashes. -DaveM
1908 *
1909 * Besides that, it does not check for connection
1910 * uniqueness. Wait for troubles.
1911 */
1912 __tcp_v4_rehash(sk);
1913 return 0;
1914 }
1915
1916 int tcp_v4_rebuild_header(struct sock *sk)
1917 {
1918 struct inet_sock *inet = inet_sk(sk);
1919 struct rtable *rt = (struct rtable *)__sk_dst_check(sk, 0);
1920 u32 daddr;
1921 int err;
1922
1923 /* Route is OK, nothing to do. */
1924 if (rt)
1925 return 0;
1926
1927 /* Reroute. */
1928 daddr = inet->daddr;
1929 if (inet->opt && inet->opt->srr)
1930 daddr = inet->opt->faddr;
1931
1932 {
1933 struct flowi fl = { .oif = sk->sk_bound_dev_if,
1934 .nl_u = { .ip4_u =
1935 { .daddr = daddr,
1936 .saddr = inet->saddr,
1937 .tos = RT_CONN_FLAGS(sk) } },
1938 .proto = IPPROTO_TCP,
1939 .uli_u = { .ports =
1940 { .sport = inet->sport,
1941 .dport = inet->dport } } };
1942
1943 err = ip_route_output_flow(&rt, &fl, sk, 0);
1944 }
1945 if (!err) {
1946 __sk_dst_set(sk, &rt->u.dst);
1947 tcp_v4_setup_caps(sk, &rt->u.dst);
1948 return 0;
1949 }
1950
1951 /* Routing failed... */
1952 sk->sk_route_caps = 0;
1953
1954 if (!sysctl_ip_dynaddr ||
1955 sk->sk_state != TCP_SYN_SENT ||
1956 (sk->sk_userlocks & SOCK_BINDADDR_LOCK) ||
1957 (err = tcp_v4_reselect_saddr(sk)) != 0)
1958 sk->sk_err_soft = -err;
1959
1960 return err;
1961 }
1962
1963 static void v4_addr2sockaddr(struct sock *sk, struct sockaddr * uaddr)
1964 {
1965 struct sockaddr_in *sin = (struct sockaddr_in *) uaddr;
1966 struct inet_sock *inet = inet_sk(sk);
1967
1968 sin->sin_family = AF_INET;
1969 sin->sin_addr.s_addr = inet->daddr;
1970 sin->sin_port = inet->dport;
1971 }
1972
1973 /* VJ's idea. Save last timestamp seen from this destination
1974 * and hold it at least for normal timewait interval to use for duplicate
1975 * segment detection in subsequent connections, before they enter synchronized
1976 * state.
1977 */
1978
1979 int tcp_v4_remember_stamp(struct sock *sk)
1980 {
1981 struct inet_sock *inet = inet_sk(sk);
1982 struct tcp_sock *tp = tcp_sk(sk);
1983 struct rtable *rt = (struct rtable *)__sk_dst_get(sk);
1984 struct inet_peer *peer = NULL;
1985 int release_it = 0;
1986
1987 if (!rt || rt->rt_dst != inet->daddr) {
1988 peer = inet_getpeer(inet->daddr, 1);
1989 release_it = 1;
1990 } else {
1991 if (!rt->peer)
1992 rt_bind_peer(rt, 1);
1993 peer = rt->peer;
1994 }
1995
1996 if (peer) {
1997 if ((s32)(peer->tcp_ts - tp->rx_opt.ts_recent) <= 0 ||
1998 (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec &&
1999 peer->tcp_ts_stamp <= tp->rx_opt.ts_recent_stamp)) {
2000 peer->tcp_ts_stamp = tp->rx_opt.ts_recent_stamp;
2001 peer->tcp_ts = tp->rx_opt.ts_recent;
2002 }
2003 if (release_it)
2004 inet_putpeer(peer);
2005 return 1;
2006 }
2007
2008 return 0;
2009 }
2010
2011 int tcp_v4_tw_remember_stamp(struct tcp_tw_bucket *tw)
2012 {
2013 struct inet_peer *peer = NULL;
2014
2015 peer = inet_getpeer(tw->tw_daddr, 1);
2016
2017 if (peer) {
2018 if ((s32)(peer->tcp_ts - tw->tw_ts_recent) <= 0 ||
2019 (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec &&
2020 peer->tcp_ts_stamp <= tw->tw_ts_recent_stamp)) {
2021 peer->tcp_ts_stamp = tw->tw_ts_recent_stamp;
2022 peer->tcp_ts = tw->tw_ts_recent;
2023 }
2024 inet_putpeer(peer);
2025 return 1;
2026 }
2027
2028 return 0;
2029 }
2030
2031 struct tcp_func ipv4_specific = {
2032 .queue_xmit = ip_queue_xmit,
2033 .send_check = tcp_v4_send_check,
2034 .rebuild_header = tcp_v4_rebuild_header,
2035 .conn_request = tcp_v4_conn_request,
2036 .syn_recv_sock = tcp_v4_syn_recv_sock,
2037 .remember_stamp = tcp_v4_remember_stamp,
2038 .net_header_len = sizeof(struct iphdr),
2039 .setsockopt = ip_setsockopt,
2040 .getsockopt = ip_getsockopt,
2041 .addr2sockaddr = v4_addr2sockaddr,
2042 .sockaddr_len = sizeof(struct sockaddr_in),
2043 };
2044
2045 /* NOTE: A lot of things set to zero explicitly by call to
2046 * sk_alloc() so need not be done here.
2047 */
2048 static int tcp_v4_init_sock(struct sock *sk)
2049 {
2050 struct tcp_sock *tp = tcp_sk(sk);
2051
2052 skb_queue_head_init(&tp->out_of_order_queue);
2053 tcp_init_xmit_timers(sk);
2054 tcp_prequeue_init(tp);
2055
2056 tp->rto = TCP_TIMEOUT_INIT;
2057 tp->mdev = TCP_TIMEOUT_INIT;
2058
2059 /* So many TCP implementations out there (incorrectly) count the
2060 * initial SYN frame in their delayed-ACK and congestion control
2061 * algorithms that we must have the following bandaid to talk
2062 * efficiently to them. -DaveM
2063 */
2064 tp->snd_cwnd = 2;
2065
2066 /* See draft-stevens-tcpca-spec-01 for discussion of the
2067 * initialization of these values.
2068 */
2069 tp->snd_ssthresh = 0x7fffffff; /* Infinity */
2070 tp->snd_cwnd_clamp = ~0;
2071 tp->mss_cache_std = tp->mss_cache = 536;
2072
2073 tp->reordering = sysctl_tcp_reordering;
2074
2075 sk->sk_state = TCP_CLOSE;
2076
2077 sk->sk_write_space = sk_stream_write_space;
2078 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
2079
2080 tp->af_specific = &ipv4_specific;
2081
2082 sk->sk_sndbuf = sysctl_tcp_wmem[1];
2083 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
2084
2085 atomic_inc(&tcp_sockets_allocated);
2086
2087 return 0;
2088 }
2089
2090 int tcp_v4_destroy_sock(struct sock *sk)
2091 {
2092 struct tcp_sock *tp = tcp_sk(sk);
2093
2094 tcp_clear_xmit_timers(sk);
2095
2096 /* Cleanup up the write buffer. */
2097 sk_stream_writequeue_purge(sk);
2098
2099 /* Cleans up our, hopefully empty, out_of_order_queue. */
2100 __skb_queue_purge(&tp->out_of_order_queue);
2101
2102 /* Clean prequeue, it must be empty really */
2103 __skb_queue_purge(&tp->ucopy.prequeue);
2104
2105 /* Clean up a referenced TCP bind bucket. */
2106 if (tp->bind_hash)
2107 tcp_put_port(sk);
2108
2109 /*
2110 * If sendmsg cached page exists, toss it.
2111 */
2112 if (sk->sk_sndmsg_page) {
2113 __free_page(sk->sk_sndmsg_page);
2114 sk->sk_sndmsg_page = NULL;
2115 }
2116
2117 atomic_dec(&tcp_sockets_allocated);
2118
2119 return 0;
2120 }
2121
2122 EXPORT_SYMBOL(tcp_v4_destroy_sock);
2123
2124 #ifdef CONFIG_PROC_FS
2125 /* Proc filesystem TCP sock list dumping. */
2126
2127 static inline struct tcp_tw_bucket *tw_head(struct hlist_head *head)
2128 {
2129 return hlist_empty(head) ? NULL :
2130 list_entry(head->first, struct tcp_tw_bucket, tw_node);
2131 }
2132
2133 static inline struct tcp_tw_bucket *tw_next(struct tcp_tw_bucket *tw)
2134 {
2135 return tw->tw_node.next ?
2136 hlist_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
2137 }
2138
2139 static void *listening_get_next(struct seq_file *seq, void *cur)
2140 {
2141 struct tcp_sock *tp;
2142 struct hlist_node *node;
2143 struct sock *sk = cur;
2144 struct tcp_iter_state* st = seq->private;
2145
2146 if (!sk) {
2147 st->bucket = 0;
2148 sk = sk_head(&tcp_listening_hash[0]);
2149 goto get_sk;
2150 }
2151
2152 ++st->num;
2153
2154 if (st->state == TCP_SEQ_STATE_OPENREQ) {
2155 struct request_sock *req = cur;
2156
2157 tp = tcp_sk(st->syn_wait_sk);
2158 req = req->dl_next;
2159 while (1) {
2160 while (req) {
2161 if (req->rsk_ops->family == st->family) {
2162 cur = req;
2163 goto out;
2164 }
2165 req = req->dl_next;
2166 }
2167 if (++st->sbucket >= TCP_SYNQ_HSIZE)
2168 break;
2169 get_req:
2170 req = tp->listen_opt->syn_table[st->sbucket];
2171 }
2172 sk = sk_next(st->syn_wait_sk);
2173 st->state = TCP_SEQ_STATE_LISTENING;
2174 read_unlock_bh(&tp->syn_wait_lock);
2175 } else {
2176 tp = tcp_sk(sk);
2177 read_lock_bh(&tp->syn_wait_lock);
2178 if (tp->listen_opt && tp->listen_opt->qlen)
2179 goto start_req;
2180 read_unlock_bh(&tp->syn_wait_lock);
2181 sk = sk_next(sk);
2182 }
2183 get_sk:
2184 sk_for_each_from(sk, node) {
2185 if (sk->sk_family == st->family) {
2186 cur = sk;
2187 goto out;
2188 }
2189 tp = tcp_sk(sk);
2190 read_lock_bh(&tp->syn_wait_lock);
2191 if (tp->listen_opt && tp->listen_opt->qlen) {
2192 start_req:
2193 st->uid = sock_i_uid(sk);
2194 st->syn_wait_sk = sk;
2195 st->state = TCP_SEQ_STATE_OPENREQ;
2196 st->sbucket = 0;
2197 goto get_req;
2198 }
2199 read_unlock_bh(&tp->syn_wait_lock);
2200 }
2201 if (++st->bucket < TCP_LHTABLE_SIZE) {
2202 sk = sk_head(&tcp_listening_hash[st->bucket]);
2203 goto get_sk;
2204 }
2205 cur = NULL;
2206 out:
2207 return cur;
2208 }
2209
2210 static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
2211 {
2212 void *rc = listening_get_next(seq, NULL);
2213
2214 while (rc && *pos) {
2215 rc = listening_get_next(seq, rc);
2216 --*pos;
2217 }
2218 return rc;
2219 }
2220
2221 static void *established_get_first(struct seq_file *seq)
2222 {
2223 struct tcp_iter_state* st = seq->private;
2224 void *rc = NULL;
2225
2226 for (st->bucket = 0; st->bucket < tcp_ehash_size; ++st->bucket) {
2227 struct sock *sk;
2228 struct hlist_node *node;
2229 struct tcp_tw_bucket *tw;
2230
2231 /* We can reschedule _before_ having picked the target: */
2232 cond_resched_softirq();
2233
2234 read_lock(&tcp_ehash[st->bucket].lock);
2235 sk_for_each(sk, node, &tcp_ehash[st->bucket].chain) {
2236 if (sk->sk_family != st->family) {
2237 continue;
2238 }
2239 rc = sk;
2240 goto out;
2241 }
2242 st->state = TCP_SEQ_STATE_TIME_WAIT;
2243 tw_for_each(tw, node,
2244 &tcp_ehash[st->bucket + tcp_ehash_size].chain) {
2245 if (tw->tw_family != st->family) {
2246 continue;
2247 }
2248 rc = tw;
2249 goto out;
2250 }
2251 read_unlock(&tcp_ehash[st->bucket].lock);
2252 st->state = TCP_SEQ_STATE_ESTABLISHED;
2253 }
2254 out:
2255 return rc;
2256 }
2257
2258 static void *established_get_next(struct seq_file *seq, void *cur)
2259 {
2260 struct sock *sk = cur;
2261 struct tcp_tw_bucket *tw;
2262 struct hlist_node *node;
2263 struct tcp_iter_state* st = seq->private;
2264
2265 ++st->num;
2266
2267 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
2268 tw = cur;
2269 tw = tw_next(tw);
2270 get_tw:
2271 while (tw && tw->tw_family != st->family) {
2272 tw = tw_next(tw);
2273 }
2274 if (tw) {
2275 cur = tw;
2276 goto out;
2277 }
2278 read_unlock(&tcp_ehash[st->bucket].lock);
2279 st->state = TCP_SEQ_STATE_ESTABLISHED;
2280
2281 /* We can reschedule between buckets: */
2282 cond_resched_softirq();
2283
2284 if (++st->bucket < tcp_ehash_size) {
2285 read_lock(&tcp_ehash[st->bucket].lock);
2286 sk = sk_head(&tcp_ehash[st->bucket].chain);
2287 } else {
2288 cur = NULL;
2289 goto out;
2290 }
2291 } else
2292 sk = sk_next(sk);
2293
2294 sk_for_each_from(sk, node) {
2295 if (sk->sk_family == st->family)
2296 goto found;
2297 }
2298
2299 st->state = TCP_SEQ_STATE_TIME_WAIT;
2300 tw = tw_head(&tcp_ehash[st->bucket + tcp_ehash_size].chain);
2301 goto get_tw;
2302 found:
2303 cur = sk;
2304 out:
2305 return cur;
2306 }
2307
2308 static void *established_get_idx(struct seq_file *seq, loff_t pos)
2309 {
2310 void *rc = established_get_first(seq);
2311
2312 while (rc && pos) {
2313 rc = established_get_next(seq, rc);
2314 --pos;
2315 }
2316 return rc;
2317 }
2318
2319 static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
2320 {
2321 void *rc;
2322 struct tcp_iter_state* st = seq->private;
2323
2324 tcp_listen_lock();
2325 st->state = TCP_SEQ_STATE_LISTENING;
2326 rc = listening_get_idx(seq, &pos);
2327
2328 if (!rc) {
2329 tcp_listen_unlock();
2330 local_bh_disable();
2331 st->state = TCP_SEQ_STATE_ESTABLISHED;
2332 rc = established_get_idx(seq, pos);
2333 }
2334
2335 return rc;
2336 }
2337
2338 static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
2339 {
2340 struct tcp_iter_state* st = seq->private;
2341 st->state = TCP_SEQ_STATE_LISTENING;
2342 st->num = 0;
2343 return *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2344 }
2345
2346 static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2347 {
2348 void *rc = NULL;
2349 struct tcp_iter_state* st;
2350
2351 if (v == SEQ_START_TOKEN) {
2352 rc = tcp_get_idx(seq, 0);
2353 goto out;
2354 }
2355 st = seq->private;
2356
2357 switch (st->state) {
2358 case TCP_SEQ_STATE_OPENREQ:
2359 case TCP_SEQ_STATE_LISTENING:
2360 rc = listening_get_next(seq, v);
2361 if (!rc) {
2362 tcp_listen_unlock();
2363 local_bh_disable();
2364 st->state = TCP_SEQ_STATE_ESTABLISHED;
2365 rc = established_get_first(seq);
2366 }
2367 break;
2368 case TCP_SEQ_STATE_ESTABLISHED:
2369 case TCP_SEQ_STATE_TIME_WAIT:
2370 rc = established_get_next(seq, v);
2371 break;
2372 }
2373 out:
2374 ++*pos;
2375 return rc;
2376 }
2377
2378 static void tcp_seq_stop(struct seq_file *seq, void *v)
2379 {
2380 struct tcp_iter_state* st = seq->private;
2381
2382 switch (st->state) {
2383 case TCP_SEQ_STATE_OPENREQ:
2384 if (v) {
2385 struct tcp_sock *tp = tcp_sk(st->syn_wait_sk);
2386 read_unlock_bh(&tp->syn_wait_lock);
2387 }
2388 case TCP_SEQ_STATE_LISTENING:
2389 if (v != SEQ_START_TOKEN)
2390 tcp_listen_unlock();
2391 break;
2392 case TCP_SEQ_STATE_TIME_WAIT:
2393 case TCP_SEQ_STATE_ESTABLISHED:
2394 if (v)
2395 read_unlock(&tcp_ehash[st->bucket].lock);
2396 local_bh_enable();
2397 break;
2398 }
2399 }
2400
2401 static int tcp_seq_open(struct inode *inode, struct file *file)
2402 {
2403 struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
2404 struct seq_file *seq;
2405 struct tcp_iter_state *s;
2406 int rc;
2407
2408 if (unlikely(afinfo == NULL))
2409 return -EINVAL;
2410
2411 s = kmalloc(sizeof(*s), GFP_KERNEL);
2412 if (!s)
2413 return -ENOMEM;
2414 memset(s, 0, sizeof(*s));
2415 s->family = afinfo->family;
2416 s->seq_ops.start = tcp_seq_start;
2417 s->seq_ops.next = tcp_seq_next;
2418 s->seq_ops.show = afinfo->seq_show;
2419 s->seq_ops.stop = tcp_seq_stop;
2420
2421 rc = seq_open(file, &s->seq_ops);
2422 if (rc)
2423 goto out_kfree;
2424 seq = file->private_data;
2425 seq->private = s;
2426 out:
2427 return rc;
2428 out_kfree:
2429 kfree(s);
2430 goto out;
2431 }
2432
2433 int tcp_proc_register(struct tcp_seq_afinfo *afinfo)
2434 {
2435 int rc = 0;
2436 struct proc_dir_entry *p;
2437
2438 if (!afinfo)
2439 return -EINVAL;
2440 afinfo->seq_fops->owner = afinfo->owner;
2441 afinfo->seq_fops->open = tcp_seq_open;
2442 afinfo->seq_fops->read = seq_read;
2443 afinfo->seq_fops->llseek = seq_lseek;
2444 afinfo->seq_fops->release = seq_release_private;
2445
2446 p = proc_net_fops_create(afinfo->name, S_IRUGO, afinfo->seq_fops);
2447 if (p)
2448 p->data = afinfo;
2449 else
2450 rc = -ENOMEM;
2451 return rc;
2452 }
2453
2454 void tcp_proc_unregister(struct tcp_seq_afinfo *afinfo)
2455 {
2456 if (!afinfo)
2457 return;
2458 proc_net_remove(afinfo->name);
2459 memset(afinfo->seq_fops, 0, sizeof(*afinfo->seq_fops));
2460 }
2461
2462 static void get_openreq4(struct sock *sk, struct request_sock *req,
2463 char *tmpbuf, int i, int uid)
2464 {
2465 const struct inet_request_sock *ireq = inet_rsk(req);
2466 int ttd = req->expires - jiffies;
2467
2468 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
2469 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p",
2470 i,
2471 ireq->loc_addr,
2472 ntohs(inet_sk(sk)->sport),
2473 ireq->rmt_addr,
2474 ntohs(ireq->rmt_port),
2475 TCP_SYN_RECV,
2476 0, 0, /* could print option size, but that is af dependent. */
2477 1, /* timers active (only the expire timer) */
2478 jiffies_to_clock_t(ttd),
2479 req->retrans,
2480 uid,
2481 0, /* non standard timer */
2482 0, /* open_requests have no inode */
2483 atomic_read(&sk->sk_refcnt),
2484 req);
2485 }
2486
2487 static void get_tcp4_sock(struct sock *sp, char *tmpbuf, int i)
2488 {
2489 int timer_active;
2490 unsigned long timer_expires;
2491 struct tcp_sock *tp = tcp_sk(sp);
2492 struct inet_sock *inet = inet_sk(sp);
2493 unsigned int dest = inet->daddr;
2494 unsigned int src = inet->rcv_saddr;
2495 __u16 destp = ntohs(inet->dport);
2496 __u16 srcp = ntohs(inet->sport);
2497
2498 if (tp->pending == TCP_TIME_RETRANS) {
2499 timer_active = 1;
2500 timer_expires = tp->timeout;
2501 } else if (tp->pending == TCP_TIME_PROBE0) {
2502 timer_active = 4;
2503 timer_expires = tp->timeout;
2504 } else if (timer_pending(&sp->sk_timer)) {
2505 timer_active = 2;
2506 timer_expires = sp->sk_timer.expires;
2507 } else {
2508 timer_active = 0;
2509 timer_expires = jiffies;
2510 }
2511
2512 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
2513 "%08X %5d %8d %lu %d %p %u %u %u %u %d",
2514 i, src, srcp, dest, destp, sp->sk_state,
2515 tp->write_seq - tp->snd_una, tp->rcv_nxt - tp->copied_seq,
2516 timer_active,
2517 jiffies_to_clock_t(timer_expires - jiffies),
2518 tp->retransmits,
2519 sock_i_uid(sp),
2520 tp->probes_out,
2521 sock_i_ino(sp),
2522 atomic_read(&sp->sk_refcnt), sp,
2523 tp->rto, tp->ack.ato, (tp->ack.quick << 1) | tp->ack.pingpong,
2524 tp->snd_cwnd,
2525 tp->snd_ssthresh >= 0xFFFF ? -1 : tp->snd_ssthresh);
2526 }
2527
2528 static void get_timewait4_sock(struct tcp_tw_bucket *tw, char *tmpbuf, int i)
2529 {
2530 unsigned int dest, src;
2531 __u16 destp, srcp;
2532 int ttd = tw->tw_ttd - jiffies;
2533
2534 if (ttd < 0)
2535 ttd = 0;
2536
2537 dest = tw->tw_daddr;
2538 src = tw->tw_rcv_saddr;
2539 destp = ntohs(tw->tw_dport);
2540 srcp = ntohs(tw->tw_sport);
2541
2542 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
2543 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p",
2544 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
2545 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
2546 atomic_read(&tw->tw_refcnt), tw);
2547 }
2548
2549 #define TMPSZ 150
2550
2551 static int tcp4_seq_show(struct seq_file *seq, void *v)
2552 {
2553 struct tcp_iter_state* st;
2554 char tmpbuf[TMPSZ + 1];
2555
2556 if (v == SEQ_START_TOKEN) {
2557 seq_printf(seq, "%-*s\n", TMPSZ - 1,
2558 " sl local_address rem_address st tx_queue "
2559 "rx_queue tr tm->when retrnsmt uid timeout "
2560 "inode");
2561 goto out;
2562 }
2563 st = seq->private;
2564
2565 switch (st->state) {
2566 case TCP_SEQ_STATE_LISTENING:
2567 case TCP_SEQ_STATE_ESTABLISHED:
2568 get_tcp4_sock(v, tmpbuf, st->num);
2569 break;
2570 case TCP_SEQ_STATE_OPENREQ:
2571 get_openreq4(st->syn_wait_sk, v, tmpbuf, st->num, st->uid);
2572 break;
2573 case TCP_SEQ_STATE_TIME_WAIT:
2574 get_timewait4_sock(v, tmpbuf, st->num);
2575 break;
2576 }
2577 seq_printf(seq, "%-*s\n", TMPSZ - 1, tmpbuf);
2578 out:
2579 return 0;
2580 }
2581
2582 static struct file_operations tcp4_seq_fops;
2583 static struct tcp_seq_afinfo tcp4_seq_afinfo = {
2584 .owner = THIS_MODULE,
2585 .name = "tcp",
2586 .family = AF_INET,
2587 .seq_show = tcp4_seq_show,
2588 .seq_fops = &tcp4_seq_fops,
2589 };
2590
2591 int __init tcp4_proc_init(void)
2592 {
2593 return tcp_proc_register(&tcp4_seq_afinfo);
2594 }
2595
2596 void tcp4_proc_exit(void)
2597 {
2598 tcp_proc_unregister(&tcp4_seq_afinfo);
2599 }
2600 #endif /* CONFIG_PROC_FS */
2601
2602 struct proto tcp_prot = {
2603 .name = "TCP",
2604 .owner = THIS_MODULE,
2605 .close = tcp_close,
2606 .connect = tcp_v4_connect,
2607 .disconnect = tcp_disconnect,
2608 .accept = tcp_accept,
2609 .ioctl = tcp_ioctl,
2610 .init = tcp_v4_init_sock,
2611 .destroy = tcp_v4_destroy_sock,
2612 .shutdown = tcp_shutdown,
2613 .setsockopt = tcp_setsockopt,
2614 .getsockopt = tcp_getsockopt,
2615 .sendmsg = tcp_sendmsg,
2616 .recvmsg = tcp_recvmsg,
2617 .backlog_rcv = tcp_v4_do_rcv,
2618 .hash = tcp_v4_hash,
2619 .unhash = tcp_unhash,
2620 .get_port = tcp_v4_get_port,
2621 .enter_memory_pressure = tcp_enter_memory_pressure,
2622 .sockets_allocated = &tcp_sockets_allocated,
2623 .memory_allocated = &tcp_memory_allocated,
2624 .memory_pressure = &tcp_memory_pressure,
2625 .sysctl_mem = sysctl_tcp_mem,
2626 .sysctl_wmem = sysctl_tcp_wmem,
2627 .sysctl_rmem = sysctl_tcp_rmem,
2628 .max_header = MAX_TCP_HEADER,
2629 .obj_size = sizeof(struct tcp_sock),
2630 .rsk_prot = &tcp_request_sock_ops,
2631 };
2632
2633
2634
2635 void __init tcp_v4_init(struct net_proto_family *ops)
2636 {
2637 int err = sock_create_kern(PF_INET, SOCK_RAW, IPPROTO_TCP, &tcp_socket);
2638 if (err < 0)
2639 panic("Failed to create the TCP control socket.\n");
2640 tcp_socket->sk->sk_allocation = GFP_ATOMIC;
2641 inet_sk(tcp_socket->sk)->uc_ttl = -1;
2642
2643 /* Unhash it so that IP input processing does not even
2644 * see it, we do not wish this socket to see incoming
2645 * packets.
2646 */
2647 tcp_socket->sk->sk_prot->unhash(tcp_socket->sk);
2648 }
2649
2650 EXPORT_SYMBOL(ipv4_specific);
2651 EXPORT_SYMBOL(tcp_bind_hash);
2652 EXPORT_SYMBOL(tcp_bucket_create);
2653 EXPORT_SYMBOL(tcp_hashinfo);
2654 EXPORT_SYMBOL(tcp_inherit_port);
2655 EXPORT_SYMBOL(tcp_listen_wlock);
2656 EXPORT_SYMBOL(tcp_port_rover);
2657 EXPORT_SYMBOL(tcp_prot);
2658 EXPORT_SYMBOL(tcp_put_port);
2659 EXPORT_SYMBOL(tcp_unhash);
2660 EXPORT_SYMBOL(tcp_v4_conn_request);
2661 EXPORT_SYMBOL(tcp_v4_connect);
2662 EXPORT_SYMBOL(tcp_v4_do_rcv);
2663 EXPORT_SYMBOL(tcp_v4_rebuild_header);
2664 EXPORT_SYMBOL(tcp_v4_remember_stamp);
2665 EXPORT_SYMBOL(tcp_v4_send_check);
2666 EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
2667
2668 #ifdef CONFIG_PROC_FS
2669 EXPORT_SYMBOL(tcp_proc_register);
2670 EXPORT_SYMBOL(tcp_proc_unregister);
2671 #endif
2672 EXPORT_SYMBOL(sysctl_local_port_range);
2673 EXPORT_SYMBOL(sysctl_max_syn_backlog);
2674 EXPORT_SYMBOL(sysctl_tcp_low_latency);
2675 EXPORT_SYMBOL(sysctl_tcp_tw_reuse);
2676
x86 "subsystem" repository