projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge master.kernel.org:/pub/scm/linux/kernel/git/jejb/scsi-rc-fixes-2.6
[deliverable/linux.git] / net / ipv4 / tcp_ipv4.c
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 listen_sock *lopt = tp->accept_queue.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 listen_sock *lopt = tp->accept_queue.listen_opt;
902 u32 h = tcp_v4_synq_hash(inet_rsk(req)->rmt_addr, inet_rsk(req)->rmt_port, lopt->hash_rnd);
903
904 reqsk_queue_hash_req(&tp->accept_queue, h, req, TCP_TIMEOUT_INIT);
905 tcp_synq_added(sk);
906 }
907
908
909 /*
910 * This routine does path mtu discovery as defined in RFC1191.
911 */
912 static inline void do_pmtu_discovery(struct sock *sk, struct iphdr *iph,
913 u32 mtu)
914 {
915 struct dst_entry *dst;
916 struct inet_sock *inet = inet_sk(sk);
917 struct tcp_sock *tp = tcp_sk(sk);
918
919 /* We are not interested in TCP_LISTEN and open_requests (SYN-ACKs
920 * send out by Linux are always <576bytes so they should go through
921 * unfragmented).
922 */
923 if (sk->sk_state == TCP_LISTEN)
924 return;
925
926 /* We don't check in the destentry if pmtu discovery is forbidden
927 * on this route. We just assume that no packet_to_big packets
928 * are send back when pmtu discovery is not active.
929 * There is a small race when the user changes this flag in the
930 * route, but I think that's acceptable.
931 */
932 if ((dst = __sk_dst_check(sk, 0)) == NULL)
933 return;
934
935 dst->ops->update_pmtu(dst, mtu);
936
937 /* Something is about to be wrong... Remember soft error
938 * for the case, if this connection will not able to recover.
939 */
940 if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
941 sk->sk_err_soft = EMSGSIZE;
942
943 mtu = dst_mtu(dst);
944
945 if (inet->pmtudisc != IP_PMTUDISC_DONT &&
946 tp->pmtu_cookie > mtu) {
947 tcp_sync_mss(sk, mtu);
948
949 /* Resend the TCP packet because it's
950 * clear that the old packet has been
951 * dropped. This is the new "fast" path mtu
952 * discovery.
953 */
954 tcp_simple_retransmit(sk);
955 } /* else let the usual retransmit timer handle it */
956 }
957
958 /*
959 * This routine is called by the ICMP module when it gets some
960 * sort of error condition. If err < 0 then the socket should
961 * be closed and the error returned to the user. If err > 0
962 * it's just the icmp type << 8 | icmp code. After adjustment
963 * header points to the first 8 bytes of the tcp header. We need
964 * to find the appropriate port.
965 *
966 * The locking strategy used here is very "optimistic". When
967 * someone else accesses the socket the ICMP is just dropped
968 * and for some paths there is no check at all.
969 * A more general error queue to queue errors for later handling
970 * is probably better.
971 *
972 */
973
974 void tcp_v4_err(struct sk_buff *skb, u32 info)
975 {
976 struct iphdr *iph = (struct iphdr *)skb->data;
977 struct tcphdr *th = (struct tcphdr *)(skb->data + (iph->ihl << 2));
978 struct tcp_sock *tp;
979 struct inet_sock *inet;
980 int type = skb->h.icmph->type;
981 int code = skb->h.icmph->code;
982 struct sock *sk;
983 __u32 seq;
984 int err;
985
986 if (skb->len < (iph->ihl << 2) + 8) {
987 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
988 return;
989 }
990
991 sk = tcp_v4_lookup(iph->daddr, th->dest, iph->saddr,
992 th->source, tcp_v4_iif(skb));
993 if (!sk) {
994 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
995 return;
996 }
997 if (sk->sk_state == TCP_TIME_WAIT) {
998 tcp_tw_put((struct tcp_tw_bucket *)sk);
999 return;
1000 }
1001
1002 bh_lock_sock(sk);
1003 /* If too many ICMPs get dropped on busy
1004 * servers this needs to be solved differently.
1005 */
1006 if (sock_owned_by_user(sk))
1007 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS);
1008
1009 if (sk->sk_state == TCP_CLOSE)
1010 goto out;
1011
1012 tp = tcp_sk(sk);
1013 seq = ntohl(th->seq);
1014 if (sk->sk_state != TCP_LISTEN &&
1015 !between(seq, tp->snd_una, tp->snd_nxt)) {
1016 NET_INC_STATS(LINUX_MIB_OUTOFWINDOWICMPS);
1017 goto out;
1018 }
1019
1020 switch (type) {
1021 case ICMP_SOURCE_QUENCH:
1022 /* Just silently ignore these. */
1023 goto out;
1024 case ICMP_PARAMETERPROB:
1025 err = EPROTO;
1026 break;
1027 case ICMP_DEST_UNREACH:
1028 if (code > NR_ICMP_UNREACH)
1029 goto out;
1030
1031 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
1032 if (!sock_owned_by_user(sk))
1033 do_pmtu_discovery(sk, iph, info);
1034 goto out;
1035 }
1036
1037 err = icmp_err_convert[code].errno;
1038 break;
1039 case ICMP_TIME_EXCEEDED:
1040 err = EHOSTUNREACH;
1041 break;
1042 default:
1043 goto out;
1044 }
1045
1046 switch (sk->sk_state) {
1047 struct request_sock *req, **prev;
1048 case TCP_LISTEN:
1049 if (sock_owned_by_user(sk))
1050 goto out;
1051
1052 req = tcp_v4_search_req(tp, &prev, th->dest,
1053 iph->daddr, iph->saddr);
1054 if (!req)
1055 goto out;
1056
1057 /* ICMPs are not backlogged, hence we cannot get
1058 an established socket here.
1059 */
1060 BUG_TRAP(!req->sk);
1061
1062 if (seq != tcp_rsk(req)->snt_isn) {
1063 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
1064 goto out;
1065 }
1066
1067 /*
1068 * Still in SYN_RECV, just remove it silently.
1069 * There is no good way to pass the error to the newly
1070 * created socket, and POSIX does not want network
1071 * errors returned from accept().
1072 */
1073 tcp_synq_drop(sk, req, prev);
1074 goto out;
1075
1076 case TCP_SYN_SENT:
1077 case TCP_SYN_RECV: /* Cannot happen.
1078 It can f.e. if SYNs crossed.
1079 */
1080 if (!sock_owned_by_user(sk)) {
1081 TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
1082 sk->sk_err = err;
1083
1084 sk->sk_error_report(sk);
1085
1086 tcp_done(sk);
1087 } else {
1088 sk->sk_err_soft = err;
1089 }
1090 goto out;
1091 }
1092
1093 /* If we've already connected we will keep trying
1094 * until we time out, or the user gives up.
1095 *
1096 * rfc1122 4.2.3.9 allows to consider as hard errors
1097 * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
1098 * but it is obsoleted by pmtu discovery).
1099 *
1100 * Note, that in modern internet, where routing is unreliable
1101 * and in each dark corner broken firewalls sit, sending random
1102 * errors ordered by their masters even this two messages finally lose
1103 * their original sense (even Linux sends invalid PORT_UNREACHs)
1104 *
1105 * Now we are in compliance with RFCs.
1106 * --ANK (980905)
1107 */
1108
1109 inet = inet_sk(sk);
1110 if (!sock_owned_by_user(sk) && inet->recverr) {
1111 sk->sk_err = err;
1112 sk->sk_error_report(sk);
1113 } else { /* Only an error on timeout */
1114 sk->sk_err_soft = err;
1115 }
1116
1117 out:
1118 bh_unlock_sock(sk);
1119 sock_put(sk);
1120 }
1121
1122 /* This routine computes an IPv4 TCP checksum. */
1123 void tcp_v4_send_check(struct sock *sk, struct tcphdr *th, int len,
1124 struct sk_buff *skb)
1125 {
1126 struct inet_sock *inet = inet_sk(sk);
1127
1128 if (skb->ip_summed == CHECKSUM_HW) {
1129 th->check = ~tcp_v4_check(th, len, inet->saddr, inet->daddr, 0);
1130 skb->csum = offsetof(struct tcphdr, check);
1131 } else {
1132 th->check = tcp_v4_check(th, len, inet->saddr, inet->daddr,
1133 csum_partial((char *)th,
1134 th->doff << 2,
1135 skb->csum));
1136 }
1137 }
1138
1139 /*
1140 * This routine will send an RST to the other tcp.
1141 *
1142 * Someone asks: why I NEVER use socket parameters (TOS, TTL etc.)
1143 * for reset.
1144 * Answer: if a packet caused RST, it is not for a socket
1145 * existing in our system, if it is matched to a socket,
1146 * it is just duplicate segment or bug in other side's TCP.
1147 * So that we build reply only basing on parameters
1148 * arrived with segment.
1149 * Exception: precedence violation. We do not implement it in any case.
1150 */
1151
1152 static void tcp_v4_send_reset(struct sk_buff *skb)
1153 {
1154 struct tcphdr *th = skb->h.th;
1155 struct tcphdr rth;
1156 struct ip_reply_arg arg;
1157
1158 /* Never send a reset in response to a reset. */
1159 if (th->rst)
1160 return;
1161
1162 if (((struct rtable *)skb->dst)->rt_type != RTN_LOCAL)
1163 return;
1164
1165 /* Swap the send and the receive. */
1166 memset(&rth, 0, sizeof(struct tcphdr));
1167 rth.dest = th->source;
1168 rth.source = th->dest;
1169 rth.doff = sizeof(struct tcphdr) / 4;
1170 rth.rst = 1;
1171
1172 if (th->ack) {
1173 rth.seq = th->ack_seq;
1174 } else {
1175 rth.ack = 1;
1176 rth.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
1177 skb->len - (th->doff << 2));
1178 }
1179
1180 memset(&arg, 0, sizeof arg);
1181 arg.iov[0].iov_base = (unsigned char *)&rth;
1182 arg.iov[0].iov_len = sizeof rth;
1183 arg.csum = csum_tcpudp_nofold(skb->nh.iph->daddr,
1184 skb->nh.iph->saddr, /*XXX*/
1185 sizeof(struct tcphdr), IPPROTO_TCP, 0);
1186 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
1187
1188 ip_send_reply(tcp_socket->sk, skb, &arg, sizeof rth);
1189
1190 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
1191 TCP_INC_STATS_BH(TCP_MIB_OUTRSTS);
1192 }
1193
1194 /* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
1195 outside socket context is ugly, certainly. What can I do?
1196 */
1197
1198 static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
1199 u32 win, u32 ts)
1200 {
1201 struct tcphdr *th = skb->h.th;
1202 struct {
1203 struct tcphdr th;
1204 u32 tsopt[3];
1205 } rep;
1206 struct ip_reply_arg arg;
1207
1208 memset(&rep.th, 0, sizeof(struct tcphdr));
1209 memset(&arg, 0, sizeof arg);
1210
1211 arg.iov[0].iov_base = (unsigned char *)&rep;
1212 arg.iov[0].iov_len = sizeof(rep.th);
1213 if (ts) {
1214 rep.tsopt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1215 (TCPOPT_TIMESTAMP << 8) |
1216 TCPOLEN_TIMESTAMP);
1217 rep.tsopt[1] = htonl(tcp_time_stamp);
1218 rep.tsopt[2] = htonl(ts);
1219 arg.iov[0].iov_len = sizeof(rep);
1220 }
1221
1222 /* Swap the send and the receive. */
1223 rep.th.dest = th->source;
1224 rep.th.source = th->dest;
1225 rep.th.doff = arg.iov[0].iov_len / 4;
1226 rep.th.seq = htonl(seq);
1227 rep.th.ack_seq = htonl(ack);
1228 rep.th.ack = 1;
1229 rep.th.window = htons(win);
1230
1231 arg.csum = csum_tcpudp_nofold(skb->nh.iph->daddr,
1232 skb->nh.iph->saddr, /*XXX*/
1233 arg.iov[0].iov_len, IPPROTO_TCP, 0);
1234 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
1235
1236 ip_send_reply(tcp_socket->sk, skb, &arg, arg.iov[0].iov_len);
1237
1238 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
1239 }
1240
1241 static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
1242 {
1243 struct tcp_tw_bucket *tw = (struct tcp_tw_bucket *)sk;
1244
1245 tcp_v4_send_ack(skb, tw->tw_snd_nxt, tw->tw_rcv_nxt,
1246 tw->tw_rcv_wnd >> tw->tw_rcv_wscale, tw->tw_ts_recent);
1247
1248 tcp_tw_put(tw);
1249 }
1250
1251 static void tcp_v4_reqsk_send_ack(struct sk_buff *skb, struct request_sock *req)
1252 {
1253 tcp_v4_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd,
1254 req->ts_recent);
1255 }
1256
1257 static struct dst_entry* tcp_v4_route_req(struct sock *sk,
1258 struct request_sock *req)
1259 {
1260 struct rtable *rt;
1261 const struct inet_request_sock *ireq = inet_rsk(req);
1262 struct ip_options *opt = inet_rsk(req)->opt;
1263 struct flowi fl = { .oif = sk->sk_bound_dev_if,
1264 .nl_u = { .ip4_u =
1265 { .daddr = ((opt && opt->srr) ?
1266 opt->faddr :
1267 ireq->rmt_addr),
1268 .saddr = ireq->loc_addr,
1269 .tos = RT_CONN_FLAGS(sk) } },
1270 .proto = IPPROTO_TCP,
1271 .uli_u = { .ports =
1272 { .sport = inet_sk(sk)->sport,
1273 .dport = ireq->rmt_port } } };
1274
1275 if (ip_route_output_flow(&rt, &fl, sk, 0)) {
1276 IP_INC_STATS_BH(IPSTATS_MIB_OUTNOROUTES);
1277 return NULL;
1278 }
1279 if (opt && opt->is_strictroute && rt->rt_dst != rt->rt_gateway) {
1280 ip_rt_put(rt);
1281 IP_INC_STATS_BH(IPSTATS_MIB_OUTNOROUTES);
1282 return NULL;
1283 }
1284 return &rt->u.dst;
1285 }
1286
1287 /*
1288 * Send a SYN-ACK after having received an ACK.
1289 * This still operates on a request_sock only, not on a big
1290 * socket.
1291 */
1292 static int tcp_v4_send_synack(struct sock *sk, struct request_sock *req,
1293 struct dst_entry *dst)
1294 {
1295 const struct inet_request_sock *ireq = inet_rsk(req);
1296 int err = -1;
1297 struct sk_buff * skb;
1298
1299 /* First, grab a route. */
1300 if (!dst && (dst = tcp_v4_route_req(sk, req)) == NULL)
1301 goto out;
1302
1303 skb = tcp_make_synack(sk, dst, req);
1304
1305 if (skb) {
1306 struct tcphdr *th = skb->h.th;
1307
1308 th->check = tcp_v4_check(th, skb->len,
1309 ireq->loc_addr,
1310 ireq->rmt_addr,
1311 csum_partial((char *)th, skb->len,
1312 skb->csum));
1313
1314 err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,
1315 ireq->rmt_addr,
1316 ireq->opt);
1317 if (err == NET_XMIT_CN)
1318 err = 0;
1319 }
1320
1321 out:
1322 dst_release(dst);
1323 return err;
1324 }
1325
1326 /*
1327 * IPv4 request_sock destructor.
1328 */
1329 static void tcp_v4_reqsk_destructor(struct request_sock *req)
1330 {
1331 if (inet_rsk(req)->opt)
1332 kfree(inet_rsk(req)->opt);
1333 }
1334
1335 static inline void syn_flood_warning(struct sk_buff *skb)
1336 {
1337 static unsigned long warntime;
1338
1339 if (time_after(jiffies, (warntime + HZ * 60))) {
1340 warntime = jiffies;
1341 printk(KERN_INFO
1342 "possible SYN flooding on port %d. Sending cookies.\n",
1343 ntohs(skb->h.th->dest));
1344 }
1345 }
1346
1347 /*
1348 * Save and compile IPv4 options into the request_sock if needed.
1349 */
1350 static inline struct ip_options *tcp_v4_save_options(struct sock *sk,
1351 struct sk_buff *skb)
1352 {
1353 struct ip_options *opt = &(IPCB(skb)->opt);
1354 struct ip_options *dopt = NULL;
1355
1356 if (opt && opt->optlen) {
1357 int opt_size = optlength(opt);
1358 dopt = kmalloc(opt_size, GFP_ATOMIC);
1359 if (dopt) {
1360 if (ip_options_echo(dopt, skb)) {
1361 kfree(dopt);
1362 dopt = NULL;
1363 }
1364 }
1365 }
1366 return dopt;
1367 }
1368
1369 struct request_sock_ops tcp_request_sock_ops = {
1370 .family = PF_INET,
1371 .obj_size = sizeof(struct tcp_request_sock),
1372 .rtx_syn_ack = tcp_v4_send_synack,
1373 .send_ack = tcp_v4_reqsk_send_ack,
1374 .destructor = tcp_v4_reqsk_destructor,
1375 .send_reset = tcp_v4_send_reset,
1376 };
1377
1378 int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1379 {
1380 struct inet_request_sock *ireq;
1381 struct tcp_options_received tmp_opt;
1382 struct request_sock *req;
1383 __u32 saddr = skb->nh.iph->saddr;
1384 __u32 daddr = skb->nh.iph->daddr;
1385 __u32 isn = TCP_SKB_CB(skb)->when;
1386 struct dst_entry *dst = NULL;
1387 #ifdef CONFIG_SYN_COOKIES
1388 int want_cookie = 0;
1389 #else
1390 #define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */
1391 #endif
1392
1393 /* Never answer to SYNs send to broadcast or multicast */
1394 if (((struct rtable *)skb->dst)->rt_flags &
1395 (RTCF_BROADCAST | RTCF_MULTICAST))
1396 goto drop;
1397
1398 /* TW buckets are converted to open requests without
1399 * limitations, they conserve resources and peer is
1400 * evidently real one.
1401 */
1402 if (tcp_synq_is_full(sk) && !isn) {
1403 #ifdef CONFIG_SYN_COOKIES
1404 if (sysctl_tcp_syncookies) {
1405 want_cookie = 1;
1406 } else
1407 #endif
1408 goto drop;
1409 }
1410
1411 /* Accept backlog is full. If we have already queued enough
1412 * of warm entries in syn queue, drop request. It is better than
1413 * clogging syn queue with openreqs with exponentially increasing
1414 * timeout.
1415 */
1416 if (sk_acceptq_is_full(sk) && tcp_synq_young(sk) > 1)
1417 goto drop;
1418
1419 req = reqsk_alloc(&tcp_request_sock_ops);
1420 if (!req)
1421 goto drop;
1422
1423 tcp_clear_options(&tmp_opt);
1424 tmp_opt.mss_clamp = 536;
1425 tmp_opt.user_mss = tcp_sk(sk)->rx_opt.user_mss;
1426
1427 tcp_parse_options(skb, &tmp_opt, 0);
1428
1429 if (want_cookie) {
1430 tcp_clear_options(&tmp_opt);
1431 tmp_opt.saw_tstamp = 0;
1432 }
1433
1434 if (tmp_opt.saw_tstamp && !tmp_opt.rcv_tsval) {
1435 /* Some OSes (unknown ones, but I see them on web server, which
1436 * contains information interesting only for windows'
1437 * users) do not send their stamp in SYN. It is easy case.
1438 * We simply do not advertise TS support.
1439 */
1440 tmp_opt.saw_tstamp = 0;
1441 tmp_opt.tstamp_ok = 0;
1442 }
1443 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
1444
1445 tcp_openreq_init(req, &tmp_opt, skb);
1446
1447 ireq = inet_rsk(req);
1448 ireq->loc_addr = daddr;
1449 ireq->rmt_addr = saddr;
1450 ireq->opt = tcp_v4_save_options(sk, skb);
1451 if (!want_cookie)
1452 TCP_ECN_create_request(req, skb->h.th);
1453
1454 if (want_cookie) {
1455 #ifdef CONFIG_SYN_COOKIES
1456 syn_flood_warning(skb);
1457 #endif
1458 isn = cookie_v4_init_sequence(sk, skb, &req->mss);
1459 } else if (!isn) {
1460 struct inet_peer *peer = NULL;
1461
1462 /* VJ's idea. We save last timestamp seen
1463 * from the destination in peer table, when entering
1464 * state TIME-WAIT, and check against it before
1465 * accepting new connection request.
1466 *
1467 * If "isn" is not zero, this request hit alive
1468 * timewait bucket, so that all the necessary checks
1469 * are made in the function processing timewait state.
1470 */
1471 if (tmp_opt.saw_tstamp &&
1472 sysctl_tcp_tw_recycle &&
1473 (dst = tcp_v4_route_req(sk, req)) != NULL &&
1474 (peer = rt_get_peer((struct rtable *)dst)) != NULL &&
1475 peer->v4daddr == saddr) {
1476 if (xtime.tv_sec < peer->tcp_ts_stamp + TCP_PAWS_MSL &&
1477 (s32)(peer->tcp_ts - req->ts_recent) >
1478 TCP_PAWS_WINDOW) {
1479 NET_INC_STATS_BH(LINUX_MIB_PAWSPASSIVEREJECTED);
1480 dst_release(dst);
1481 goto drop_and_free;
1482 }
1483 }
1484 /* Kill the following clause, if you dislike this way. */
1485 else if (!sysctl_tcp_syncookies &&
1486 (sysctl_max_syn_backlog - tcp_synq_len(sk) <
1487 (sysctl_max_syn_backlog >> 2)) &&
1488 (!peer || !peer->tcp_ts_stamp) &&
1489 (!dst || !dst_metric(dst, RTAX_RTT))) {
1490 /* Without syncookies last quarter of
1491 * backlog is filled with destinations,
1492 * proven to be alive.
1493 * It means that we continue to communicate
1494 * to destinations, already remembered
1495 * to the moment of synflood.
1496 */
1497 LIMIT_NETDEBUG(printk(KERN_DEBUG "TCP: drop open "
1498 "request from %u.%u."
1499 "%u.%u/%u\n",
1500 NIPQUAD(saddr),
1501 ntohs(skb->h.th->source)));
1502 dst_release(dst);
1503 goto drop_and_free;
1504 }
1505
1506 isn = tcp_v4_init_sequence(sk, skb);
1507 }
1508 tcp_rsk(req)->snt_isn = isn;
1509
1510 if (tcp_v4_send_synack(sk, req, dst))
1511 goto drop_and_free;
1512
1513 if (want_cookie) {
1514 reqsk_free(req);
1515 } else {
1516 tcp_v4_synq_add(sk, req);
1517 }
1518 return 0;
1519
1520 drop_and_free:
1521 reqsk_free(req);
1522 drop:
1523 TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
1524 return 0;
1525 }
1526
1527
1528 /*
1529 * The three way handshake has completed - we got a valid synack -
1530 * now create the new socket.
1531 */
1532 struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
1533 struct request_sock *req,
1534 struct dst_entry *dst)
1535 {
1536 struct inet_request_sock *ireq;
1537 struct inet_sock *newinet;
1538 struct tcp_sock *newtp;
1539 struct sock *newsk;
1540
1541 if (sk_acceptq_is_full(sk))
1542 goto exit_overflow;
1543
1544 if (!dst && (dst = tcp_v4_route_req(sk, req)) == NULL)
1545 goto exit;
1546
1547 newsk = tcp_create_openreq_child(sk, req, skb);
1548 if (!newsk)
1549 goto exit;
1550
1551 newsk->sk_dst_cache = dst;
1552 tcp_v4_setup_caps(newsk, dst);
1553
1554 newtp = tcp_sk(newsk);
1555 newinet = inet_sk(newsk);
1556 ireq = inet_rsk(req);
1557 newinet->daddr = ireq->rmt_addr;
1558 newinet->rcv_saddr = ireq->loc_addr;
1559 newinet->saddr = ireq->loc_addr;
1560 newinet->opt = ireq->opt;
1561 ireq->opt = NULL;
1562 newinet->mc_index = tcp_v4_iif(skb);
1563 newinet->mc_ttl = skb->nh.iph->ttl;
1564 newtp->ext_header_len = 0;
1565 if (newinet->opt)
1566 newtp->ext_header_len = newinet->opt->optlen;
1567 newinet->id = newtp->write_seq ^ jiffies;
1568
1569 tcp_sync_mss(newsk, dst_mtu(dst));
1570 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
1571 tcp_initialize_rcv_mss(newsk);
1572
1573 __tcp_v4_hash(newsk, 0);
1574 __tcp_inherit_port(sk, newsk);
1575
1576 return newsk;
1577
1578 exit_overflow:
1579 NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS);
1580 exit:
1581 NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS);
1582 dst_release(dst);
1583 return NULL;
1584 }
1585
1586 static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
1587 {
1588 struct tcphdr *th = skb->h.th;
1589 struct iphdr *iph = skb->nh.iph;
1590 struct tcp_sock *tp = tcp_sk(sk);
1591 struct sock *nsk;
1592 struct request_sock **prev;
1593 /* Find possible connection requests. */
1594 struct request_sock *req = tcp_v4_search_req(tp, &prev, th->source,
1595 iph->saddr, iph->daddr);
1596 if (req)
1597 return tcp_check_req(sk, skb, req, prev);
1598
1599 nsk = __tcp_v4_lookup_established(skb->nh.iph->saddr,
1600 th->source,
1601 skb->nh.iph->daddr,
1602 ntohs(th->dest),
1603 tcp_v4_iif(skb));
1604
1605 if (nsk) {
1606 if (nsk->sk_state != TCP_TIME_WAIT) {
1607 bh_lock_sock(nsk);
1608 return nsk;
1609 }
1610 tcp_tw_put((struct tcp_tw_bucket *)nsk);
1611 return NULL;
1612 }
1613
1614 #ifdef CONFIG_SYN_COOKIES
1615 if (!th->rst && !th->syn && th->ack)
1616 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
1617 #endif
1618 return sk;
1619 }
1620
1621 static int tcp_v4_checksum_init(struct sk_buff *skb)
1622 {
1623 if (skb->ip_summed == CHECKSUM_HW) {
1624 skb->ip_summed = CHECKSUM_UNNECESSARY;
1625 if (!tcp_v4_check(skb->h.th, skb->len, skb->nh.iph->saddr,
1626 skb->nh.iph->daddr, skb->csum))
1627 return 0;
1628
1629 LIMIT_NETDEBUG(printk(KERN_DEBUG "hw tcp v4 csum failed\n"));
1630 skb->ip_summed = CHECKSUM_NONE;
1631 }
1632 if (skb->len <= 76) {
1633 if (tcp_v4_check(skb->h.th, skb->len, skb->nh.iph->saddr,
1634 skb->nh.iph->daddr,
1635 skb_checksum(skb, 0, skb->len, 0)))
1636 return -1;
1637 skb->ip_summed = CHECKSUM_UNNECESSARY;
1638 } else {
1639 skb->csum = ~tcp_v4_check(skb->h.th, skb->len,
1640 skb->nh.iph->saddr,
1641 skb->nh.iph->daddr, 0);
1642 }
1643 return 0;
1644 }
1645
1646
1647 /* The socket must have it's spinlock held when we get
1648 * here.
1649 *
1650 * We have a potential double-lock case here, so even when
1651 * doing backlog processing we use the BH locking scheme.
1652 * This is because we cannot sleep with the original spinlock
1653 * held.
1654 */
1655 int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1656 {
1657 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1658 TCP_CHECK_TIMER(sk);
1659 if (tcp_rcv_established(sk, skb, skb->h.th, skb->len))
1660 goto reset;
1661 TCP_CHECK_TIMER(sk);
1662 return 0;
1663 }
1664
1665 if (skb->len < (skb->h.th->doff << 2) || tcp_checksum_complete(skb))
1666 goto csum_err;
1667
1668 if (sk->sk_state == TCP_LISTEN) {
1669 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
1670 if (!nsk)
1671 goto discard;
1672
1673 if (nsk != sk) {
1674 if (tcp_child_process(sk, nsk, skb))
1675 goto reset;
1676 return 0;
1677 }
1678 }
1679
1680 TCP_CHECK_TIMER(sk);
1681 if (tcp_rcv_state_process(sk, skb, skb->h.th, skb->len))
1682 goto reset;
1683 TCP_CHECK_TIMER(sk);
1684 return 0;
1685
1686 reset:
1687 tcp_v4_send_reset(skb);
1688 discard:
1689 kfree_skb(skb);
1690 /* Be careful here. If this function gets more complicated and
1691 * gcc suffers from register pressure on the x86, sk (in %ebx)
1692 * might be destroyed here. This current version compiles correctly,
1693 * but you have been warned.
1694 */
1695 return 0;
1696
1697 csum_err:
1698 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1699 goto discard;
1700 }
1701
1702 /*
1703 * From tcp_input.c
1704 */
1705
1706 int tcp_v4_rcv(struct sk_buff *skb)
1707 {
1708 struct tcphdr *th;
1709 struct sock *sk;
1710 int ret;
1711
1712 if (skb->pkt_type != PACKET_HOST)
1713 goto discard_it;
1714
1715 /* Count it even if it's bad */
1716 TCP_INC_STATS_BH(TCP_MIB_INSEGS);
1717
1718 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1719 goto discard_it;
1720
1721 th = skb->h.th;
1722
1723 if (th->doff < sizeof(struct tcphdr) / 4)
1724 goto bad_packet;
1725 if (!pskb_may_pull(skb, th->doff * 4))
1726 goto discard_it;
1727
1728 /* An explanation is required here, I think.
1729 * Packet length and doff are validated by header prediction,
1730 * provided case of th->doff==0 is elimineted.
1731 * So, we defer the checks. */
1732 if ((skb->ip_summed != CHECKSUM_UNNECESSARY &&
1733 tcp_v4_checksum_init(skb) < 0))
1734 goto bad_packet;
1735
1736 th = skb->h.th;
1737 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1738 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1739 skb->len - th->doff * 4);
1740 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1741 TCP_SKB_CB(skb)->when = 0;
1742 TCP_SKB_CB(skb)->flags = skb->nh.iph->tos;
1743 TCP_SKB_CB(skb)->sacked = 0;
1744
1745 sk = __tcp_v4_lookup(skb->nh.iph->saddr, th->source,
1746 skb->nh.iph->daddr, ntohs(th->dest),
1747 tcp_v4_iif(skb));
1748
1749 if (!sk)
1750 goto no_tcp_socket;
1751
1752 process:
1753 if (sk->sk_state == TCP_TIME_WAIT)
1754 goto do_time_wait;
1755
1756 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1757 goto discard_and_relse;
1758
1759 if (sk_filter(sk, skb, 0))
1760 goto discard_and_relse;
1761
1762 skb->dev = NULL;
1763
1764 bh_lock_sock(sk);
1765 ret = 0;
1766 if (!sock_owned_by_user(sk)) {
1767 if (!tcp_prequeue(sk, skb))
1768 ret = tcp_v4_do_rcv(sk, skb);
1769 } else
1770 sk_add_backlog(sk, skb);
1771 bh_unlock_sock(sk);
1772
1773 sock_put(sk);
1774
1775 return ret;
1776
1777 no_tcp_socket:
1778 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1779 goto discard_it;
1780
1781 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1782 bad_packet:
1783 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1784 } else {
1785 tcp_v4_send_reset(skb);
1786 }
1787
1788 discard_it:
1789 /* Discard frame. */
1790 kfree_skb(skb);
1791 return 0;
1792
1793 discard_and_relse:
1794 sock_put(sk);
1795 goto discard_it;
1796
1797 do_time_wait:
1798 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1799 tcp_tw_put((struct tcp_tw_bucket *) sk);
1800 goto discard_it;
1801 }
1802
1803 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1804 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1805 tcp_tw_put((struct tcp_tw_bucket *) sk);
1806 goto discard_it;
1807 }
1808 switch (tcp_timewait_state_process((struct tcp_tw_bucket *)sk,
1809 skb, th, skb->len)) {
1810 case TCP_TW_SYN: {
1811 struct sock *sk2 = tcp_v4_lookup_listener(skb->nh.iph->daddr,
1812 ntohs(th->dest),
1813 tcp_v4_iif(skb));
1814 if (sk2) {
1815 tcp_tw_deschedule((struct tcp_tw_bucket *)sk);
1816 tcp_tw_put((struct tcp_tw_bucket *)sk);
1817 sk = sk2;
1818 goto process;
1819 }
1820 /* Fall through to ACK */
1821 }
1822 case TCP_TW_ACK:
1823 tcp_v4_timewait_ack(sk, skb);
1824 break;
1825 case TCP_TW_RST:
1826 goto no_tcp_socket;
1827 case TCP_TW_SUCCESS:;
1828 }
1829 goto discard_it;
1830 }
1831
1832 /* With per-bucket locks this operation is not-atomic, so that
1833 * this version is not worse.
1834 */
1835 static void __tcp_v4_rehash(struct sock *sk)
1836 {
1837 sk->sk_prot->unhash(sk);
1838 sk->sk_prot->hash(sk);
1839 }
1840
1841 static int tcp_v4_reselect_saddr(struct sock *sk)
1842 {
1843 struct inet_sock *inet = inet_sk(sk);
1844 int err;
1845 struct rtable *rt;
1846 __u32 old_saddr = inet->saddr;
1847 __u32 new_saddr;
1848 __u32 daddr = inet->daddr;
1849
1850 if (inet->opt && inet->opt->srr)
1851 daddr = inet->opt->faddr;
1852
1853 /* Query new route. */
1854 err = ip_route_connect(&rt, daddr, 0,
1855 RT_CONN_FLAGS(sk),
1856 sk->sk_bound_dev_if,
1857 IPPROTO_TCP,
1858 inet->sport, inet->dport, sk);
1859 if (err)
1860 return err;
1861
1862 __sk_dst_set(sk, &rt->u.dst);
1863 tcp_v4_setup_caps(sk, &rt->u.dst);
1864
1865 new_saddr = rt->rt_src;
1866
1867 if (new_saddr == old_saddr)
1868 return 0;
1869
1870 if (sysctl_ip_dynaddr > 1) {
1871 printk(KERN_INFO "tcp_v4_rebuild_header(): shifting inet->"
1872 "saddr from %d.%d.%d.%d to %d.%d.%d.%d\n",
1873 NIPQUAD(old_saddr),
1874 NIPQUAD(new_saddr));
1875 }
1876
1877 inet->saddr = new_saddr;
1878 inet->rcv_saddr = new_saddr;
1879
1880 /* XXX The only one ugly spot where we need to
1881 * XXX really change the sockets identity after
1882 * XXX it has entered the hashes. -DaveM
1883 *
1884 * Besides that, it does not check for connection
1885 * uniqueness. Wait for troubles.
1886 */
1887 __tcp_v4_rehash(sk);
1888 return 0;
1889 }
1890
1891 int tcp_v4_rebuild_header(struct sock *sk)
1892 {
1893 struct inet_sock *inet = inet_sk(sk);
1894 struct rtable *rt = (struct rtable *)__sk_dst_check(sk, 0);
1895 u32 daddr;
1896 int err;
1897
1898 /* Route is OK, nothing to do. */
1899 if (rt)
1900 return 0;
1901
1902 /* Reroute. */
1903 daddr = inet->daddr;
1904 if (inet->opt && inet->opt->srr)
1905 daddr = inet->opt->faddr;
1906
1907 {
1908 struct flowi fl = { .oif = sk->sk_bound_dev_if,
1909 .nl_u = { .ip4_u =
1910 { .daddr = daddr,
1911 .saddr = inet->saddr,
1912 .tos = RT_CONN_FLAGS(sk) } },
1913 .proto = IPPROTO_TCP,
1914 .uli_u = { .ports =
1915 { .sport = inet->sport,
1916 .dport = inet->dport } } };
1917
1918 err = ip_route_output_flow(&rt, &fl, sk, 0);
1919 }
1920 if (!err) {
1921 __sk_dst_set(sk, &rt->u.dst);
1922 tcp_v4_setup_caps(sk, &rt->u.dst);
1923 return 0;
1924 }
1925
1926 /* Routing failed... */
1927 sk->sk_route_caps = 0;
1928
1929 if (!sysctl_ip_dynaddr ||
1930 sk->sk_state != TCP_SYN_SENT ||
1931 (sk->sk_userlocks & SOCK_BINDADDR_LOCK) ||
1932 (err = tcp_v4_reselect_saddr(sk)) != 0)
1933 sk->sk_err_soft = -err;
1934
1935 return err;
1936 }
1937
1938 static void v4_addr2sockaddr(struct sock *sk, struct sockaddr * uaddr)
1939 {
1940 struct sockaddr_in *sin = (struct sockaddr_in *) uaddr;
1941 struct inet_sock *inet = inet_sk(sk);
1942
1943 sin->sin_family = AF_INET;
1944 sin->sin_addr.s_addr = inet->daddr;
1945 sin->sin_port = inet->dport;
1946 }
1947
1948 /* VJ's idea. Save last timestamp seen from this destination
1949 * and hold it at least for normal timewait interval to use for duplicate
1950 * segment detection in subsequent connections, before they enter synchronized
1951 * state.
1952 */
1953
1954 int tcp_v4_remember_stamp(struct sock *sk)
1955 {
1956 struct inet_sock *inet = inet_sk(sk);
1957 struct tcp_sock *tp = tcp_sk(sk);
1958 struct rtable *rt = (struct rtable *)__sk_dst_get(sk);
1959 struct inet_peer *peer = NULL;
1960 int release_it = 0;
1961
1962 if (!rt || rt->rt_dst != inet->daddr) {
1963 peer = inet_getpeer(inet->daddr, 1);
1964 release_it = 1;
1965 } else {
1966 if (!rt->peer)
1967 rt_bind_peer(rt, 1);
1968 peer = rt->peer;
1969 }
1970
1971 if (peer) {
1972 if ((s32)(peer->tcp_ts - tp->rx_opt.ts_recent) <= 0 ||
1973 (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec &&
1974 peer->tcp_ts_stamp <= tp->rx_opt.ts_recent_stamp)) {
1975 peer->tcp_ts_stamp = tp->rx_opt.ts_recent_stamp;
1976 peer->tcp_ts = tp->rx_opt.ts_recent;
1977 }
1978 if (release_it)
1979 inet_putpeer(peer);
1980 return 1;
1981 }
1982
1983 return 0;
1984 }
1985
1986 int tcp_v4_tw_remember_stamp(struct tcp_tw_bucket *tw)
1987 {
1988 struct inet_peer *peer = NULL;
1989
1990 peer = inet_getpeer(tw->tw_daddr, 1);
1991
1992 if (peer) {
1993 if ((s32)(peer->tcp_ts - tw->tw_ts_recent) <= 0 ||
1994 (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec &&
1995 peer->tcp_ts_stamp <= tw->tw_ts_recent_stamp)) {
1996 peer->tcp_ts_stamp = tw->tw_ts_recent_stamp;
1997 peer->tcp_ts = tw->tw_ts_recent;
1998 }
1999 inet_putpeer(peer);
2000 return 1;
2001 }
2002
2003 return 0;
2004 }
2005
2006 struct tcp_func ipv4_specific = {
2007 .queue_xmit = ip_queue_xmit,
2008 .send_check = tcp_v4_send_check,
2009 .rebuild_header = tcp_v4_rebuild_header,
2010 .conn_request = tcp_v4_conn_request,
2011 .syn_recv_sock = tcp_v4_syn_recv_sock,
2012 .remember_stamp = tcp_v4_remember_stamp,
2013 .net_header_len = sizeof(struct iphdr),
2014 .setsockopt = ip_setsockopt,
2015 .getsockopt = ip_getsockopt,
2016 .addr2sockaddr = v4_addr2sockaddr,
2017 .sockaddr_len = sizeof(struct sockaddr_in),
2018 };
2019
2020 /* NOTE: A lot of things set to zero explicitly by call to
2021 * sk_alloc() so need not be done here.
2022 */
2023 static int tcp_v4_init_sock(struct sock *sk)
2024 {
2025 struct tcp_sock *tp = tcp_sk(sk);
2026
2027 skb_queue_head_init(&tp->out_of_order_queue);
2028 tcp_init_xmit_timers(sk);
2029 tcp_prequeue_init(tp);
2030
2031 tp->rto = TCP_TIMEOUT_INIT;
2032 tp->mdev = TCP_TIMEOUT_INIT;
2033
2034 /* So many TCP implementations out there (incorrectly) count the
2035 * initial SYN frame in their delayed-ACK and congestion control
2036 * algorithms that we must have the following bandaid to talk
2037 * efficiently to them. -DaveM
2038 */
2039 tp->snd_cwnd = 2;
2040
2041 /* See draft-stevens-tcpca-spec-01 for discussion of the
2042 * initialization of these values.
2043 */
2044 tp->snd_ssthresh = 0x7fffffff; /* Infinity */
2045 tp->snd_cwnd_clamp = ~0;
2046 tp->mss_cache = 536;
2047
2048 tp->reordering = sysctl_tcp_reordering;
2049 tp->ca_ops = &tcp_init_congestion_ops;
2050
2051 sk->sk_state = TCP_CLOSE;
2052
2053 sk->sk_write_space = sk_stream_write_space;
2054 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
2055
2056 tp->af_specific = &ipv4_specific;
2057
2058 sk->sk_sndbuf = sysctl_tcp_wmem[1];
2059 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
2060
2061 atomic_inc(&tcp_sockets_allocated);
2062
2063 return 0;
2064 }
2065
2066 int tcp_v4_destroy_sock(struct sock *sk)
2067 {
2068 struct tcp_sock *tp = tcp_sk(sk);
2069
2070 tcp_clear_xmit_timers(sk);
2071
2072 tcp_cleanup_congestion_control(tp);
2073
2074 /* Cleanup up the write buffer. */
2075 sk_stream_writequeue_purge(sk);
2076
2077 /* Cleans up our, hopefully empty, out_of_order_queue. */
2078 __skb_queue_purge(&tp->out_of_order_queue);
2079
2080 /* Clean prequeue, it must be empty really */
2081 __skb_queue_purge(&tp->ucopy.prequeue);
2082
2083 /* Clean up a referenced TCP bind bucket. */
2084 if (tp->bind_hash)
2085 tcp_put_port(sk);
2086
2087 /*
2088 * If sendmsg cached page exists, toss it.
2089 */
2090 if (sk->sk_sndmsg_page) {
2091 __free_page(sk->sk_sndmsg_page);
2092 sk->sk_sndmsg_page = NULL;
2093 }
2094
2095 atomic_dec(&tcp_sockets_allocated);
2096
2097 return 0;
2098 }
2099
2100 EXPORT_SYMBOL(tcp_v4_destroy_sock);
2101
2102 #ifdef CONFIG_PROC_FS
2103 /* Proc filesystem TCP sock list dumping. */
2104
2105 static inline struct tcp_tw_bucket *tw_head(struct hlist_head *head)
2106 {
2107 return hlist_empty(head) ? NULL :
2108 list_entry(head->first, struct tcp_tw_bucket, tw_node);
2109 }
2110
2111 static inline struct tcp_tw_bucket *tw_next(struct tcp_tw_bucket *tw)
2112 {
2113 return tw->tw_node.next ?
2114 hlist_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
2115 }
2116
2117 static void *listening_get_next(struct seq_file *seq, void *cur)
2118 {
2119 struct tcp_sock *tp;
2120 struct hlist_node *node;
2121 struct sock *sk = cur;
2122 struct tcp_iter_state* st = seq->private;
2123
2124 if (!sk) {
2125 st->bucket = 0;
2126 sk = sk_head(&tcp_listening_hash[0]);
2127 goto get_sk;
2128 }
2129
2130 ++st->num;
2131
2132 if (st->state == TCP_SEQ_STATE_OPENREQ) {
2133 struct request_sock *req = cur;
2134
2135 tp = tcp_sk(st->syn_wait_sk);
2136 req = req->dl_next;
2137 while (1) {
2138 while (req) {
2139 if (req->rsk_ops->family == st->family) {
2140 cur = req;
2141 goto out;
2142 }
2143 req = req->dl_next;
2144 }
2145 if (++st->sbucket >= TCP_SYNQ_HSIZE)
2146 break;
2147 get_req:
2148 req = tp->accept_queue.listen_opt->syn_table[st->sbucket];
2149 }
2150 sk = sk_next(st->syn_wait_sk);
2151 st->state = TCP_SEQ_STATE_LISTENING;
2152 read_unlock_bh(&tp->accept_queue.syn_wait_lock);
2153 } else {
2154 tp = tcp_sk(sk);
2155 read_lock_bh(&tp->accept_queue.syn_wait_lock);
2156 if (reqsk_queue_len(&tp->accept_queue))
2157 goto start_req;
2158 read_unlock_bh(&tp->accept_queue.syn_wait_lock);
2159 sk = sk_next(sk);
2160 }
2161 get_sk:
2162 sk_for_each_from(sk, node) {
2163 if (sk->sk_family == st->family) {
2164 cur = sk;
2165 goto out;
2166 }
2167 tp = tcp_sk(sk);
2168 read_lock_bh(&tp->accept_queue.syn_wait_lock);
2169 if (reqsk_queue_len(&tp->accept_queue)) {
2170 start_req:
2171 st->uid = sock_i_uid(sk);
2172 st->syn_wait_sk = sk;
2173 st->state = TCP_SEQ_STATE_OPENREQ;
2174 st->sbucket = 0;
2175 goto get_req;
2176 }
2177 read_unlock_bh(&tp->accept_queue.syn_wait_lock);
2178 }
2179 if (++st->bucket < TCP_LHTABLE_SIZE) {
2180 sk = sk_head(&tcp_listening_hash[st->bucket]);
2181 goto get_sk;
2182 }
2183 cur = NULL;
2184 out:
2185 return cur;
2186 }
2187
2188 static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
2189 {
2190 void *rc = listening_get_next(seq, NULL);
2191
2192 while (rc && *pos) {
2193 rc = listening_get_next(seq, rc);
2194 --*pos;
2195 }
2196 return rc;
2197 }
2198
2199 static void *established_get_first(struct seq_file *seq)
2200 {
2201 struct tcp_iter_state* st = seq->private;
2202 void *rc = NULL;
2203
2204 for (st->bucket = 0; st->bucket < tcp_ehash_size; ++st->bucket) {
2205 struct sock *sk;
2206 struct hlist_node *node;
2207 struct tcp_tw_bucket *tw;
2208
2209 /* We can reschedule _before_ having picked the target: */
2210 cond_resched_softirq();
2211
2212 read_lock(&tcp_ehash[st->bucket].lock);
2213 sk_for_each(sk, node, &tcp_ehash[st->bucket].chain) {
2214 if (sk->sk_family != st->family) {
2215 continue;
2216 }
2217 rc = sk;
2218 goto out;
2219 }
2220 st->state = TCP_SEQ_STATE_TIME_WAIT;
2221 tw_for_each(tw, node,
2222 &tcp_ehash[st->bucket + tcp_ehash_size].chain) {
2223 if (tw->tw_family != st->family) {
2224 continue;
2225 }
2226 rc = tw;
2227 goto out;
2228 }
2229 read_unlock(&tcp_ehash[st->bucket].lock);
2230 st->state = TCP_SEQ_STATE_ESTABLISHED;
2231 }
2232 out:
2233 return rc;
2234 }
2235
2236 static void *established_get_next(struct seq_file *seq, void *cur)
2237 {
2238 struct sock *sk = cur;
2239 struct tcp_tw_bucket *tw;
2240 struct hlist_node *node;
2241 struct tcp_iter_state* st = seq->private;
2242
2243 ++st->num;
2244
2245 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
2246 tw = cur;
2247 tw = tw_next(tw);
2248 get_tw:
2249 while (tw && tw->tw_family != st->family) {
2250 tw = tw_next(tw);
2251 }
2252 if (tw) {
2253 cur = tw;
2254 goto out;
2255 }
2256 read_unlock(&tcp_ehash[st->bucket].lock);
2257 st->state = TCP_SEQ_STATE_ESTABLISHED;
2258
2259 /* We can reschedule between buckets: */
2260 cond_resched_softirq();
2261
2262 if (++st->bucket < tcp_ehash_size) {
2263 read_lock(&tcp_ehash[st->bucket].lock);
2264 sk = sk_head(&tcp_ehash[st->bucket].chain);
2265 } else {
2266 cur = NULL;
2267 goto out;
2268 }
2269 } else
2270 sk = sk_next(sk);
2271
2272 sk_for_each_from(sk, node) {
2273 if (sk->sk_family == st->family)
2274 goto found;
2275 }
2276
2277 st->state = TCP_SEQ_STATE_TIME_WAIT;
2278 tw = tw_head(&tcp_ehash[st->bucket + tcp_ehash_size].chain);
2279 goto get_tw;
2280 found:
2281 cur = sk;
2282 out:
2283 return cur;
2284 }
2285
2286 static void *established_get_idx(struct seq_file *seq, loff_t pos)
2287 {
2288 void *rc = established_get_first(seq);
2289
2290 while (rc && pos) {
2291 rc = established_get_next(seq, rc);
2292 --pos;
2293 }
2294 return rc;
2295 }
2296
2297 static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
2298 {
2299 void *rc;
2300 struct tcp_iter_state* st = seq->private;
2301
2302 tcp_listen_lock();
2303 st->state = TCP_SEQ_STATE_LISTENING;
2304 rc = listening_get_idx(seq, &pos);
2305
2306 if (!rc) {
2307 tcp_listen_unlock();
2308 local_bh_disable();
2309 st->state = TCP_SEQ_STATE_ESTABLISHED;
2310 rc = established_get_idx(seq, pos);
2311 }
2312
2313 return rc;
2314 }
2315
2316 static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
2317 {
2318 struct tcp_iter_state* st = seq->private;
2319 st->state = TCP_SEQ_STATE_LISTENING;
2320 st->num = 0;
2321 return *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2322 }
2323
2324 static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2325 {
2326 void *rc = NULL;
2327 struct tcp_iter_state* st;
2328
2329 if (v == SEQ_START_TOKEN) {
2330 rc = tcp_get_idx(seq, 0);
2331 goto out;
2332 }
2333 st = seq->private;
2334
2335 switch (st->state) {
2336 case TCP_SEQ_STATE_OPENREQ:
2337 case TCP_SEQ_STATE_LISTENING:
2338 rc = listening_get_next(seq, v);
2339 if (!rc) {
2340 tcp_listen_unlock();
2341 local_bh_disable();
2342 st->state = TCP_SEQ_STATE_ESTABLISHED;
2343 rc = established_get_first(seq);
2344 }
2345 break;
2346 case TCP_SEQ_STATE_ESTABLISHED:
2347 case TCP_SEQ_STATE_TIME_WAIT:
2348 rc = established_get_next(seq, v);
2349 break;
2350 }
2351 out:
2352 ++*pos;
2353 return rc;
2354 }
2355
2356 static void tcp_seq_stop(struct seq_file *seq, void *v)
2357 {
2358 struct tcp_iter_state* st = seq->private;
2359
2360 switch (st->state) {
2361 case TCP_SEQ_STATE_OPENREQ:
2362 if (v) {
2363 struct tcp_sock *tp = tcp_sk(st->syn_wait_sk);
2364 read_unlock_bh(&tp->accept_queue.syn_wait_lock);
2365 }
2366 case TCP_SEQ_STATE_LISTENING:
2367 if (v != SEQ_START_TOKEN)
2368 tcp_listen_unlock();
2369 break;
2370 case TCP_SEQ_STATE_TIME_WAIT:
2371 case TCP_SEQ_STATE_ESTABLISHED:
2372 if (v)
2373 read_unlock(&tcp_ehash[st->bucket].lock);
2374 local_bh_enable();
2375 break;
2376 }
2377 }
2378
2379 static int tcp_seq_open(struct inode *inode, struct file *file)
2380 {
2381 struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
2382 struct seq_file *seq;
2383 struct tcp_iter_state *s;
2384 int rc;
2385
2386 if (unlikely(afinfo == NULL))
2387 return -EINVAL;
2388
2389 s = kmalloc(sizeof(*s), GFP_KERNEL);
2390 if (!s)
2391 return -ENOMEM;
2392 memset(s, 0, sizeof(*s));
2393 s->family = afinfo->family;
2394 s->seq_ops.start = tcp_seq_start;
2395 s->seq_ops.next = tcp_seq_next;
2396 s->seq_ops.show = afinfo->seq_show;
2397 s->seq_ops.stop = tcp_seq_stop;
2398
2399 rc = seq_open(file, &s->seq_ops);
2400 if (rc)
2401 goto out_kfree;
2402 seq = file->private_data;
2403 seq->private = s;
2404 out:
2405 return rc;
2406 out_kfree:
2407 kfree(s);
2408 goto out;
2409 }
2410
2411 int tcp_proc_register(struct tcp_seq_afinfo *afinfo)
2412 {
2413 int rc = 0;
2414 struct proc_dir_entry *p;
2415
2416 if (!afinfo)
2417 return -EINVAL;
2418 afinfo->seq_fops->owner = afinfo->owner;
2419 afinfo->seq_fops->open = tcp_seq_open;
2420 afinfo->seq_fops->read = seq_read;
2421 afinfo->seq_fops->llseek = seq_lseek;
2422 afinfo->seq_fops->release = seq_release_private;
2423
2424 p = proc_net_fops_create(afinfo->name, S_IRUGO, afinfo->seq_fops);
2425 if (p)
2426 p->data = afinfo;
2427 else
2428 rc = -ENOMEM;
2429 return rc;
2430 }
2431
2432 void tcp_proc_unregister(struct tcp_seq_afinfo *afinfo)
2433 {
2434 if (!afinfo)
2435 return;
2436 proc_net_remove(afinfo->name);
2437 memset(afinfo->seq_fops, 0, sizeof(*afinfo->seq_fops));
2438 }
2439
2440 static void get_openreq4(struct sock *sk, struct request_sock *req,
2441 char *tmpbuf, int i, int uid)
2442 {
2443 const struct inet_request_sock *ireq = inet_rsk(req);
2444 int ttd = req->expires - jiffies;
2445
2446 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
2447 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p",
2448 i,
2449 ireq->loc_addr,
2450 ntohs(inet_sk(sk)->sport),
2451 ireq->rmt_addr,
2452 ntohs(ireq->rmt_port),
2453 TCP_SYN_RECV,
2454 0, 0, /* could print option size, but that is af dependent. */
2455 1, /* timers active (only the expire timer) */
2456 jiffies_to_clock_t(ttd),
2457 req->retrans,
2458 uid,
2459 0, /* non standard timer */
2460 0, /* open_requests have no inode */
2461 atomic_read(&sk->sk_refcnt),
2462 req);
2463 }
2464
2465 static void get_tcp4_sock(struct sock *sp, char *tmpbuf, int i)
2466 {
2467 int timer_active;
2468 unsigned long timer_expires;
2469 struct tcp_sock *tp = tcp_sk(sp);
2470 struct inet_sock *inet = inet_sk(sp);
2471 unsigned int dest = inet->daddr;
2472 unsigned int src = inet->rcv_saddr;
2473 __u16 destp = ntohs(inet->dport);
2474 __u16 srcp = ntohs(inet->sport);
2475
2476 if (tp->pending == TCP_TIME_RETRANS) {
2477 timer_active = 1;
2478 timer_expires = tp->timeout;
2479 } else if (tp->pending == TCP_TIME_PROBE0) {
2480 timer_active = 4;
2481 timer_expires = tp->timeout;
2482 } else if (timer_pending(&sp->sk_timer)) {
2483 timer_active = 2;
2484 timer_expires = sp->sk_timer.expires;
2485 } else {
2486 timer_active = 0;
2487 timer_expires = jiffies;
2488 }
2489
2490 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
2491 "%08X %5d %8d %lu %d %p %u %u %u %u %d",
2492 i, src, srcp, dest, destp, sp->sk_state,
2493 tp->write_seq - tp->snd_una, tp->rcv_nxt - tp->copied_seq,
2494 timer_active,
2495 jiffies_to_clock_t(timer_expires - jiffies),
2496 tp->retransmits,
2497 sock_i_uid(sp),
2498 tp->probes_out,
2499 sock_i_ino(sp),
2500 atomic_read(&sp->sk_refcnt), sp,
2501 tp->rto, tp->ack.ato, (tp->ack.quick << 1) | tp->ack.pingpong,
2502 tp->snd_cwnd,
2503 tp->snd_ssthresh >= 0xFFFF ? -1 : tp->snd_ssthresh);
2504 }
2505
2506 static void get_timewait4_sock(struct tcp_tw_bucket *tw, char *tmpbuf, int i)
2507 {
2508 unsigned int dest, src;
2509 __u16 destp, srcp;
2510 int ttd = tw->tw_ttd - jiffies;
2511
2512 if (ttd < 0)
2513 ttd = 0;
2514
2515 dest = tw->tw_daddr;
2516 src = tw->tw_rcv_saddr;
2517 destp = ntohs(tw->tw_dport);
2518 srcp = ntohs(tw->tw_sport);
2519
2520 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
2521 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p",
2522 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
2523 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
2524 atomic_read(&tw->tw_refcnt), tw);
2525 }
2526
2527 #define TMPSZ 150
2528
2529 static int tcp4_seq_show(struct seq_file *seq, void *v)
2530 {
2531 struct tcp_iter_state* st;
2532 char tmpbuf[TMPSZ + 1];
2533
2534 if (v == SEQ_START_TOKEN) {
2535 seq_printf(seq, "%-*s\n", TMPSZ - 1,
2536 " sl local_address rem_address st tx_queue "
2537 "rx_queue tr tm->when retrnsmt uid timeout "
2538 "inode");
2539 goto out;
2540 }
2541 st = seq->private;
2542
2543 switch (st->state) {
2544 case TCP_SEQ_STATE_LISTENING:
2545 case TCP_SEQ_STATE_ESTABLISHED:
2546 get_tcp4_sock(v, tmpbuf, st->num);
2547 break;
2548 case TCP_SEQ_STATE_OPENREQ:
2549 get_openreq4(st->syn_wait_sk, v, tmpbuf, st->num, st->uid);
2550 break;
2551 case TCP_SEQ_STATE_TIME_WAIT:
2552 get_timewait4_sock(v, tmpbuf, st->num);
2553 break;
2554 }
2555 seq_printf(seq, "%-*s\n", TMPSZ - 1, tmpbuf);
2556 out:
2557 return 0;
2558 }
2559
2560 static struct file_operations tcp4_seq_fops;
2561 static struct tcp_seq_afinfo tcp4_seq_afinfo = {
2562 .owner = THIS_MODULE,
2563 .name = "tcp",
2564 .family = AF_INET,
2565 .seq_show = tcp4_seq_show,
2566 .seq_fops = &tcp4_seq_fops,
2567 };
2568
2569 int __init tcp4_proc_init(void)
2570 {
2571 return tcp_proc_register(&tcp4_seq_afinfo);
2572 }
2573
2574 void tcp4_proc_exit(void)
2575 {
2576 tcp_proc_unregister(&tcp4_seq_afinfo);
2577 }
2578 #endif /* CONFIG_PROC_FS */
2579
2580 struct proto tcp_prot = {
2581 .name = "TCP",
2582 .owner = THIS_MODULE,
2583 .close = tcp_close,
2584 .connect = tcp_v4_connect,
2585 .disconnect = tcp_disconnect,
2586 .accept = tcp_accept,
2587 .ioctl = tcp_ioctl,
2588 .init = tcp_v4_init_sock,
2589 .destroy = tcp_v4_destroy_sock,
2590 .shutdown = tcp_shutdown,
2591 .setsockopt = tcp_setsockopt,
2592 .getsockopt = tcp_getsockopt,
2593 .sendmsg = tcp_sendmsg,
2594 .recvmsg = tcp_recvmsg,
2595 .backlog_rcv = tcp_v4_do_rcv,
2596 .hash = tcp_v4_hash,
2597 .unhash = tcp_unhash,
2598 .get_port = tcp_v4_get_port,
2599 .enter_memory_pressure = tcp_enter_memory_pressure,
2600 .sockets_allocated = &tcp_sockets_allocated,
2601 .memory_allocated = &tcp_memory_allocated,
2602 .memory_pressure = &tcp_memory_pressure,
2603 .sysctl_mem = sysctl_tcp_mem,
2604 .sysctl_wmem = sysctl_tcp_wmem,
2605 .sysctl_rmem = sysctl_tcp_rmem,
2606 .max_header = MAX_TCP_HEADER,
2607 .obj_size = sizeof(struct tcp_sock),
2608 .rsk_prot = &tcp_request_sock_ops,
2609 };
2610
2611
2612
2613 void __init tcp_v4_init(struct net_proto_family *ops)
2614 {
2615 int err = sock_create_kern(PF_INET, SOCK_RAW, IPPROTO_TCP, &tcp_socket);
2616 if (err < 0)
2617 panic("Failed to create the TCP control socket.\n");
2618 tcp_socket->sk->sk_allocation = GFP_ATOMIC;
2619 inet_sk(tcp_socket->sk)->uc_ttl = -1;
2620
2621 /* Unhash it so that IP input processing does not even
2622 * see it, we do not wish this socket to see incoming
2623 * packets.
2624 */
2625 tcp_socket->sk->sk_prot->unhash(tcp_socket->sk);
2626 }
2627
2628 EXPORT_SYMBOL(ipv4_specific);
2629 EXPORT_SYMBOL(tcp_bind_hash);
2630 EXPORT_SYMBOL(tcp_bucket_create);
2631 EXPORT_SYMBOL(tcp_hashinfo);
2632 EXPORT_SYMBOL(tcp_inherit_port);
2633 EXPORT_SYMBOL(tcp_listen_wlock);
2634 EXPORT_SYMBOL(tcp_port_rover);
2635 EXPORT_SYMBOL(tcp_prot);
2636 EXPORT_SYMBOL(tcp_put_port);
2637 EXPORT_SYMBOL(tcp_unhash);
2638 EXPORT_SYMBOL(tcp_v4_conn_request);
2639 EXPORT_SYMBOL(tcp_v4_connect);
2640 EXPORT_SYMBOL(tcp_v4_do_rcv);
2641 EXPORT_SYMBOL(tcp_v4_rebuild_header);
2642 EXPORT_SYMBOL(tcp_v4_remember_stamp);
2643 EXPORT_SYMBOL(tcp_v4_send_check);
2644 EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
2645
2646 #ifdef CONFIG_PROC_FS
2647 EXPORT_SYMBOL(tcp_proc_register);
2648 EXPORT_SYMBOL(tcp_proc_unregister);
2649 #endif
2650 EXPORT_SYMBOL(sysctl_local_port_range);
2651 EXPORT_SYMBOL(sysctl_tcp_low_latency);
2652 EXPORT_SYMBOL(sysctl_tcp_tw_reuse);
2653
Linux kernel - Deliverables
This page took 0.128856 seconds and 6 git commands to generate.