?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] I2C: Kill i2c_algorithm.id (6/7)
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / net / ipv4 / tcp_ipv4.c
blob13dfb391cdf17a376c301c9f56973db93696c1d6
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/inet_hashtables.h>
68 #include <net/tcp.h>
69 #include <net/transp_v6.h>
70 #include <net/ipv6.h>
71 #include <net/inet_common.h>
72 #include <net/xfrm.h>
73
74 #include <linux/inet.h>
75 #include <linux/ipv6.h>
76 #include <linux/stddef.h>
77 #include <linux/proc_fs.h>
78 #include <linux/seq_file.h>
79
80 int sysctl_tcp_tw_reuse;
81 int sysctl_tcp_low_latency;
82
83 /* Check TCP sequence numbers in ICMP packets. */
84 #define ICMP_MIN_LENGTH 8
85
86 /* Socket used for sending RSTs */
87 static struct socket *tcp_socket;
88
89 void tcp_v4_send_check(struct sock *sk, struct tcphdr *th, int len,
90 struct sk_buff *skb);
91
92 struct inet_hashinfo __cacheline_aligned tcp_hashinfo = {
93 .lhash_lock = RW_LOCK_UNLOCKED,
94 .lhash_users = ATOMIC_INIT(0),
95 .lhash_wait = __WAIT_QUEUE_HEAD_INITIALIZER(tcp_hashinfo.lhash_wait),
96 .portalloc_lock = SPIN_LOCK_UNLOCKED,
97 .port_rover = 1024 - 1,
98 };
99
100 static int tcp_v4_get_port(struct sock *sk, unsigned short snum)
101 {
102 return inet_csk_get_port(&tcp_hashinfo, sk, snum);
103 }
104
105 static void tcp_v4_hash(struct sock *sk)
106 {
107 inet_hash(&tcp_hashinfo, sk);
108 }
109
110 void tcp_unhash(struct sock *sk)
111 {
112 inet_unhash(&tcp_hashinfo, sk);
113 }
114
115 static inline __u32 tcp_v4_init_sequence(struct sock *sk, struct sk_buff *skb)
116 {
117 return secure_tcp_sequence_number(skb->nh.iph->daddr,
118 skb->nh.iph->saddr,
119 skb->h.th->dest,
120 skb->h.th->source);
121 }
122
123 /* called with local bh disabled */
124 static int __tcp_v4_check_established(struct sock *sk, __u16 lport,
125 struct inet_timewait_sock **twp)
126 {
127 struct inet_sock *inet = inet_sk(sk);
128 u32 daddr = inet->rcv_saddr;
129 u32 saddr = inet->daddr;
130 int dif = sk->sk_bound_dev_if;
131 INET_ADDR_COOKIE(acookie, saddr, daddr)
132 const __u32 ports = INET_COMBINED_PORTS(inet->dport, lport);
133 const int hash = inet_ehashfn(daddr, lport, saddr, inet->dport, tcp_hashinfo.ehash_size);
134 struct inet_ehash_bucket *head = &tcp_hashinfo.ehash[hash];
135 struct sock *sk2;
136 const struct hlist_node *node;
137 struct inet_timewait_sock *tw;
138
139 write_lock(&head->lock);
140
141 /* Check TIME-WAIT sockets first. */
142 sk_for_each(sk2, node, &(head + tcp_hashinfo.ehash_size)->chain) {
143 tw = inet_twsk(sk2);
144
145 if (INET_TW_MATCH(sk2, acookie, saddr, daddr, ports, dif)) {
146 const struct tcp_timewait_sock *tcptw = tcp_twsk(sk2);
147 struct tcp_sock *tp = tcp_sk(sk);
148
149 /* With PAWS, it is safe from the viewpoint
150 of data integrity. Even without PAWS it
151 is safe provided sequence spaces do not
152 overlap i.e. at data rates <= 80Mbit/sec.
153
154 Actually, the idea is close to VJ's one,
155 only timestamp cache is held not per host,
156 but per port pair and TW bucket is used
157 as state holder.
158
159 If TW bucket has been already destroyed we
160 fall back to VJ's scheme and use initial
161 timestamp retrieved from peer table.
162 */
163 if (tcptw->tw_ts_recent_stamp &&
164 (!twp || (sysctl_tcp_tw_reuse &&
165 xtime.tv_sec -
166 tcptw->tw_ts_recent_stamp > 1))) {
167 tp->write_seq = tcptw->tw_snd_nxt + 65535 + 2;
168 if (tp->write_seq == 0)
169 tp->write_seq = 1;
170 tp->rx_opt.ts_recent = tcptw->tw_ts_recent;
171 tp->rx_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp;
172 sock_hold(sk2);
173 goto unique;
174 } else
175 goto not_unique;
176 }
177 }
178 tw = NULL;
179
180 /* And established part... */
181 sk_for_each(sk2, node, &head->chain) {
182 if (INET_MATCH(sk2, acookie, saddr, daddr, ports, dif))
183 goto not_unique;
184 }
185
186 unique:
187 /* Must record num and sport now. Otherwise we will see
188 * in hash table socket with a funny identity. */
189 inet->num = lport;
190 inet->sport = htons(lport);
191 sk->sk_hashent = hash;
192 BUG_TRAP(sk_unhashed(sk));
193 __sk_add_node(sk, &head->chain);
194 sock_prot_inc_use(sk->sk_prot);
195 write_unlock(&head->lock);
196
197 if (twp) {
198 *twp = tw;
199 NET_INC_STATS_BH(LINUX_MIB_TIMEWAITRECYCLED);
200 } else if (tw) {
201 /* Silly. Should hash-dance instead... */
202 inet_twsk_deschedule(tw, &tcp_death_row);
203 NET_INC_STATS_BH(LINUX_MIB_TIMEWAITRECYCLED);
204
205 inet_twsk_put(tw);
206 }
207
208 return 0;
209
210 not_unique:
211 write_unlock(&head->lock);
212 return -EADDRNOTAVAIL;
213 }
214
215 static inline u32 connect_port_offset(const struct sock *sk)
216 {
217 const struct inet_sock *inet = inet_sk(sk);
218
219 return secure_tcp_port_ephemeral(inet->rcv_saddr, inet->daddr,
220 inet->dport);
221 }
222
223 /*
224 * Bind a port for a connect operation and hash it.
225 */
226 static inline int tcp_v4_hash_connect(struct sock *sk)
227 {
228 const unsigned short snum = inet_sk(sk)->num;
229 struct inet_bind_hashbucket *head;
230 struct inet_bind_bucket *tb;
231 int ret;
232
233 if (!snum) {
234 int low = sysctl_local_port_range[0];
235 int high = sysctl_local_port_range[1];
236 int range = high - low;
237 int i;
238 int port;
239 static u32 hint;
240 u32 offset = hint + connect_port_offset(sk);
241 struct hlist_node *node;
242 struct inet_timewait_sock *tw = NULL;
243
244 local_bh_disable();
245 for (i = 1; i <= range; i++) {
246 port = low + (i + offset) % range;
247 head = &tcp_hashinfo.bhash[inet_bhashfn(port, tcp_hashinfo.bhash_size)];
248 spin_lock(&head->lock);
249
250 /* Does not bother with rcv_saddr checks,
251 * because the established check is already
252 * unique enough.
253 */
254 inet_bind_bucket_for_each(tb, node, &head->chain) {
255 if (tb->port == port) {
256 BUG_TRAP(!hlist_empty(&tb->owners));
257 if (tb->fastreuse >= 0)
258 goto next_port;
259 if (!__tcp_v4_check_established(sk,
260 port,
261 &tw))
262 goto ok;
263 goto next_port;
264 }
265 }
266
267 tb = inet_bind_bucket_create(tcp_hashinfo.bind_bucket_cachep, head, port);
268 if (!tb) {
269 spin_unlock(&head->lock);
270 break;
271 }
272 tb->fastreuse = -1;
273 goto ok;
274
275 next_port:
276 spin_unlock(&head->lock);
277 }
278 local_bh_enable();
279
280 return -EADDRNOTAVAIL;
281
282 ok:
283 hint += i;
284
285 /* Head lock still held and bh's disabled */
286 inet_bind_hash(sk, tb, port);
287 if (sk_unhashed(sk)) {
288 inet_sk(sk)->sport = htons(port);
289 __inet_hash(&tcp_hashinfo, sk, 0);
290 }
291 spin_unlock(&head->lock);
292
293 if (tw) {
294 inet_twsk_deschedule(tw, &tcp_death_row);;
295 inet_twsk_put(tw);
296 }
297
298 ret = 0;
299 goto out;
300 }
301
302 head = &tcp_hashinfo.bhash[inet_bhashfn(snum, tcp_hashinfo.bhash_size)];
303 tb = inet_csk(sk)->icsk_bind_hash;
304 spin_lock_bh(&head->lock);
305 if (sk_head(&tb->owners) == sk && !sk->sk_bind_node.next) {
306 __inet_hash(&tcp_hashinfo, sk, 0);
307 spin_unlock_bh(&head->lock);
308 return 0;
309 } else {
310 spin_unlock(&head->lock);
311 /* No definite answer... Walk to established hash table */
312 ret = __tcp_v4_check_established(sk, snum, NULL);
313 out:
314 local_bh_enable();
315 return ret;
316 }
317 }
318
319 /* This will initiate an outgoing connection. */
320 int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
321 {
322 struct inet_sock *inet = inet_sk(sk);
323 struct tcp_sock *tp = tcp_sk(sk);
324 struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
325 struct rtable *rt;
326 u32 daddr, nexthop;
327 int tmp;
328 int err;
329
330 if (addr_len < sizeof(struct sockaddr_in))
331 return -EINVAL;
332
333 if (usin->sin_family != AF_INET)
334 return -EAFNOSUPPORT;
335
336 nexthop = daddr = usin->sin_addr.s_addr;
337 if (inet->opt && inet->opt->srr) {
338 if (!daddr)
339 return -EINVAL;
340 nexthop = inet->opt->faddr;
341 }
342
343 tmp = ip_route_connect(&rt, nexthop, inet->saddr,
344 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
345 IPPROTO_TCP,
346 inet->sport, usin->sin_port, sk);
347 if (tmp < 0)
348 return tmp;
349
350 if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
351 ip_rt_put(rt);
352 return -ENETUNREACH;
353 }
354
355 if (!inet->opt || !inet->opt->srr)
356 daddr = rt->rt_dst;
357
358 if (!inet->saddr)
359 inet->saddr = rt->rt_src;
360 inet->rcv_saddr = inet->saddr;
361
362 if (tp->rx_opt.ts_recent_stamp && inet->daddr != daddr) {
363 /* Reset inherited state */
364 tp->rx_opt.ts_recent = 0;
365 tp->rx_opt.ts_recent_stamp = 0;
366 tp->write_seq = 0;
367 }
368
369 if (tcp_death_row.sysctl_tw_recycle &&
370 !tp->rx_opt.ts_recent_stamp && rt->rt_dst == daddr) {
371 struct inet_peer *peer = rt_get_peer(rt);
372
373 /* VJ's idea. We save last timestamp seen from
374 * the destination in peer table, when entering state TIME-WAIT
375 * and initialize rx_opt.ts_recent from it, when trying new connection.
376 */
377
378 if (peer && peer->tcp_ts_stamp + TCP_PAWS_MSL >= xtime.tv_sec) {
379 tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp;
380 tp->rx_opt.ts_recent = peer->tcp_ts;
381 }
382 }
383
384 inet->dport = usin->sin_port;
385 inet->daddr = daddr;
386
387 tp->ext_header_len = 0;
388 if (inet->opt)
389 tp->ext_header_len = inet->opt->optlen;
390
391 tp->rx_opt.mss_clamp = 536;
392
393 /* Socket identity is still unknown (sport may be zero).
394 * However we set state to SYN-SENT and not releasing socket
395 * lock select source port, enter ourselves into the hash tables and
396 * complete initialization after this.
397 */
398 tcp_set_state(sk, TCP_SYN_SENT);
399 err = tcp_v4_hash_connect(sk);
400 if (err)
401 goto failure;
402
403 err = ip_route_newports(&rt, inet->sport, inet->dport, sk);
404 if (err)
405 goto failure;
406
407 /* OK, now commit destination to socket. */
408 sk_setup_caps(sk, &rt->u.dst);
409
410 if (!tp->write_seq)
411 tp->write_seq = secure_tcp_sequence_number(inet->saddr,
412 inet->daddr,
413 inet->sport,
414 usin->sin_port);
415
416 inet->id = tp->write_seq ^ jiffies;
417
418 err = tcp_connect(sk);
419 rt = NULL;
420 if (err)
421 goto failure;
422
423 return 0;
424
425 failure:
426 /* This unhashes the socket and releases the local port, if necessary. */
427 tcp_set_state(sk, TCP_CLOSE);
428 ip_rt_put(rt);
429 sk->sk_route_caps = 0;
430 inet->dport = 0;
431 return err;
432 }
433
434 /*
435 * This routine does path mtu discovery as defined in RFC1191.
436 */
437 static inline void do_pmtu_discovery(struct sock *sk, struct iphdr *iph,
438 u32 mtu)
439 {
440 struct dst_entry *dst;
441 struct inet_sock *inet = inet_sk(sk);
442 struct tcp_sock *tp = tcp_sk(sk);
443
444 /* We are not interested in TCP_LISTEN and open_requests (SYN-ACKs
445 * send out by Linux are always <576bytes so they should go through
446 * unfragmented).
447 */
448 if (sk->sk_state == TCP_LISTEN)
449 return;
450
451 /* We don't check in the destentry if pmtu discovery is forbidden
452 * on this route. We just assume that no packet_to_big packets
453 * are send back when pmtu discovery is not active.
454 * There is a small race when the user changes this flag in the
455 * route, but I think that's acceptable.
456 */
457 if ((dst = __sk_dst_check(sk, 0)) == NULL)
458 return;
459
460 dst->ops->update_pmtu(dst, mtu);
461
462 /* Something is about to be wrong... Remember soft error
463 * for the case, if this connection will not able to recover.
464 */
465 if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
466 sk->sk_err_soft = EMSGSIZE;
467
468 mtu = dst_mtu(dst);
469
470 if (inet->pmtudisc != IP_PMTUDISC_DONT &&
471 tp->pmtu_cookie > mtu) {
472 tcp_sync_mss(sk, mtu);
473
474 /* Resend the TCP packet because it's
475 * clear that the old packet has been
476 * dropped. This is the new "fast" path mtu
477 * discovery.
478 */
479 tcp_simple_retransmit(sk);
480 } /* else let the usual retransmit timer handle it */
481 }
482
483 /*
484 * This routine is called by the ICMP module when it gets some
485 * sort of error condition. If err < 0 then the socket should
486 * be closed and the error returned to the user. If err > 0
487 * it's just the icmp type << 8 | icmp code. After adjustment
488 * header points to the first 8 bytes of the tcp header. We need
489 * to find the appropriate port.
490 *
491 * The locking strategy used here is very "optimistic". When
492 * someone else accesses the socket the ICMP is just dropped
493 * and for some paths there is no check at all.
494 * A more general error queue to queue errors for later handling
495 * is probably better.
496 *
497 */
498
499 void tcp_v4_err(struct sk_buff *skb, u32 info)
500 {
501 struct iphdr *iph = (struct iphdr *)skb->data;
502 struct tcphdr *th = (struct tcphdr *)(skb->data + (iph->ihl << 2));
503 struct tcp_sock *tp;
504 struct inet_sock *inet;
505 int type = skb->h.icmph->type;
506 int code = skb->h.icmph->code;
507 struct sock *sk;
508 __u32 seq;
509 int err;
510
511 if (skb->len < (iph->ihl << 2) + 8) {
512 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
513 return;
514 }
515
516 sk = inet_lookup(&tcp_hashinfo, iph->daddr, th->dest, iph->saddr,
517 th->source, inet_iif(skb));
518 if (!sk) {
519 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
520 return;
521 }
522 if (sk->sk_state == TCP_TIME_WAIT) {
523 inet_twsk_put((struct inet_timewait_sock *)sk);
524 return;
525 }
526
527 bh_lock_sock(sk);
528 /* If too many ICMPs get dropped on busy
529 * servers this needs to be solved differently.
530 */
531 if (sock_owned_by_user(sk))
532 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS);
533
534 if (sk->sk_state == TCP_CLOSE)
535 goto out;
536
537 tp = tcp_sk(sk);
538 seq = ntohl(th->seq);
539 if (sk->sk_state != TCP_LISTEN &&
540 !between(seq, tp->snd_una, tp->snd_nxt)) {
541 NET_INC_STATS(LINUX_MIB_OUTOFWINDOWICMPS);
542 goto out;
543 }
544
545 switch (type) {
546 case ICMP_SOURCE_QUENCH:
547 /* Just silently ignore these. */
548 goto out;
549 case ICMP_PARAMETERPROB:
550 err = EPROTO;
551 break;
552 case ICMP_DEST_UNREACH:
553 if (code > NR_ICMP_UNREACH)
554 goto out;
555
556 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
557 if (!sock_owned_by_user(sk))
558 do_pmtu_discovery(sk, iph, info);
559 goto out;
560 }
561
562 err = icmp_err_convert[code].errno;
563 break;
564 case ICMP_TIME_EXCEEDED:
565 err = EHOSTUNREACH;
566 break;
567 default:
568 goto out;
569 }
570
571 switch (sk->sk_state) {
572 struct request_sock *req, **prev;
573 case TCP_LISTEN:
574 if (sock_owned_by_user(sk))
575 goto out;
576
577 req = inet_csk_search_req(sk, &prev, th->dest,
578 iph->daddr, iph->saddr);
579 if (!req)
580 goto out;
581
582 /* ICMPs are not backlogged, hence we cannot get
583 an established socket here.
584 */
585 BUG_TRAP(!req->sk);
586
587 if (seq != tcp_rsk(req)->snt_isn) {
588 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
589 goto out;
590 }
591
592 /*
593 * Still in SYN_RECV, just remove it silently.
594 * There is no good way to pass the error to the newly
595 * created socket, and POSIX does not want network
596 * errors returned from accept().
597 */
598 inet_csk_reqsk_queue_drop(sk, req, prev);
599 goto out;
600
601 case TCP_SYN_SENT:
602 case TCP_SYN_RECV: /* Cannot happen.
603 It can f.e. if SYNs crossed.
604 */
605 if (!sock_owned_by_user(sk)) {
606 TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
607 sk->sk_err = err;
608
609 sk->sk_error_report(sk);
610
611 tcp_done(sk);
612 } else {
613 sk->sk_err_soft = err;
614 }
615 goto out;
616 }
617
618 /* If we've already connected we will keep trying
619 * until we time out, or the user gives up.
620 *
621 * rfc1122 4.2.3.9 allows to consider as hard errors
622 * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
623 * but it is obsoleted by pmtu discovery).
624 *
625 * Note, that in modern internet, where routing is unreliable
626 * and in each dark corner broken firewalls sit, sending random
627 * errors ordered by their masters even this two messages finally lose
628 * their original sense (even Linux sends invalid PORT_UNREACHs)
629 *
630 * Now we are in compliance with RFCs.
631 * --ANK (980905)
632 */
633
634 inet = inet_sk(sk);
635 if (!sock_owned_by_user(sk) && inet->recverr) {
636 sk->sk_err = err;
637 sk->sk_error_report(sk);
638 } else { /* Only an error on timeout */
639 sk->sk_err_soft = err;
640 }
641
642 out:
643 bh_unlock_sock(sk);
644 sock_put(sk);
645 }
646
647 /* This routine computes an IPv4 TCP checksum. */
648 void tcp_v4_send_check(struct sock *sk, struct tcphdr *th, int len,
649 struct sk_buff *skb)
650 {
651 struct inet_sock *inet = inet_sk(sk);
652
653 if (skb->ip_summed == CHECKSUM_HW) {
654 th->check = ~tcp_v4_check(th, len, inet->saddr, inet->daddr, 0);
655 skb->csum = offsetof(struct tcphdr, check);
656 } else {
657 th->check = tcp_v4_check(th, len, inet->saddr, inet->daddr,
658 csum_partial((char *)th,
659 th->doff << 2,
660 skb->csum));
661 }
662 }
663
664 /*
665 * This routine will send an RST to the other tcp.
666 *
667 * Someone asks: why I NEVER use socket parameters (TOS, TTL etc.)
668 * for reset.
669 * Answer: if a packet caused RST, it is not for a socket
670 * existing in our system, if it is matched to a socket,
671 * it is just duplicate segment or bug in other side's TCP.
672 * So that we build reply only basing on parameters
673 * arrived with segment.
674 * Exception: precedence violation. We do not implement it in any case.
675 */
676
677 static void tcp_v4_send_reset(struct sk_buff *skb)
678 {
679 struct tcphdr *th = skb->h.th;
680 struct tcphdr rth;
681 struct ip_reply_arg arg;
682
683 /* Never send a reset in response to a reset. */
684 if (th->rst)
685 return;
686
687 if (((struct rtable *)skb->dst)->rt_type != RTN_LOCAL)
688 return;
689
690 /* Swap the send and the receive. */
691 memset(&rth, 0, sizeof(struct tcphdr));
692 rth.dest = th->source;
693 rth.source = th->dest;
694 rth.doff = sizeof(struct tcphdr) / 4;
695 rth.rst = 1;
696
697 if (th->ack) {
698 rth.seq = th->ack_seq;
699 } else {
700 rth.ack = 1;
701 rth.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
702 skb->len - (th->doff << 2));
703 }
704
705 memset(&arg, 0, sizeof arg);
706 arg.iov[0].iov_base = (unsigned char *)&rth;
707 arg.iov[0].iov_len = sizeof rth;
708 arg.csum = csum_tcpudp_nofold(skb->nh.iph->daddr,
709 skb->nh.iph->saddr, /*XXX*/
710 sizeof(struct tcphdr), IPPROTO_TCP, 0);
711 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
712
713 ip_send_reply(tcp_socket->sk, skb, &arg, sizeof rth);
714
715 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
716 TCP_INC_STATS_BH(TCP_MIB_OUTRSTS);
717 }
718
719 /* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
720 outside socket context is ugly, certainly. What can I do?
721 */
722
723 static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
724 u32 win, u32 ts)
725 {
726 struct tcphdr *th = skb->h.th;
727 struct {
728 struct tcphdr th;
729 u32 tsopt[3];
730 } rep;
731 struct ip_reply_arg arg;
732
733 memset(&rep.th, 0, sizeof(struct tcphdr));
734 memset(&arg, 0, sizeof arg);
735
736 arg.iov[0].iov_base = (unsigned char *)&rep;
737 arg.iov[0].iov_len = sizeof(rep.th);
738 if (ts) {
739 rep.tsopt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
740 (TCPOPT_TIMESTAMP << 8) |
741 TCPOLEN_TIMESTAMP);
742 rep.tsopt[1] = htonl(tcp_time_stamp);
743 rep.tsopt[2] = htonl(ts);
744 arg.iov[0].iov_len = sizeof(rep);
745 }
746
747 /* Swap the send and the receive. */
748 rep.th.dest = th->source;
749 rep.th.source = th->dest;
750 rep.th.doff = arg.iov[0].iov_len / 4;
751 rep.th.seq = htonl(seq);
752 rep.th.ack_seq = htonl(ack);
753 rep.th.ack = 1;
754 rep.th.window = htons(win);
755
756 arg.csum = csum_tcpudp_nofold(skb->nh.iph->daddr,
757 skb->nh.iph->saddr, /*XXX*/
758 arg.iov[0].iov_len, IPPROTO_TCP, 0);
759 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
760
761 ip_send_reply(tcp_socket->sk, skb, &arg, arg.iov[0].iov_len);
762
763 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
764 }
765
766 static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
767 {
768 struct inet_timewait_sock *tw = inet_twsk(sk);
769 const struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
770
771 tcp_v4_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
772 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale, tcptw->tw_ts_recent);
773
774 inet_twsk_put(tw);
775 }
776
777 static void tcp_v4_reqsk_send_ack(struct sk_buff *skb, struct request_sock *req)
778 {
779 tcp_v4_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd,
780 req->ts_recent);
781 }
782
783 /*
784 * Send a SYN-ACK after having received an ACK.
785 * This still operates on a request_sock only, not on a big
786 * socket.
787 */
788 static int tcp_v4_send_synack(struct sock *sk, struct request_sock *req,
789 struct dst_entry *dst)
790 {
791 const struct inet_request_sock *ireq = inet_rsk(req);
792 int err = -1;
793 struct sk_buff * skb;
794
795 /* First, grab a route. */
796 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
797 goto out;
798
799 skb = tcp_make_synack(sk, dst, req);
800
801 if (skb) {
802 struct tcphdr *th = skb->h.th;
803
804 th->check = tcp_v4_check(th, skb->len,
805 ireq->loc_addr,
806 ireq->rmt_addr,
807 csum_partial((char *)th, skb->len,
808 skb->csum));
809
810 err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,
811 ireq->rmt_addr,
812 ireq->opt);
813 if (err == NET_XMIT_CN)
814 err = 0;
815 }
816
817 out:
818 dst_release(dst);
819 return err;
820 }
821
822 /*
823 * IPv4 request_sock destructor.
824 */
825 static void tcp_v4_reqsk_destructor(struct request_sock *req)
826 {
827 if (inet_rsk(req)->opt)
828 kfree(inet_rsk(req)->opt);
829 }
830
831 static inline void syn_flood_warning(struct sk_buff *skb)
832 {
833 static unsigned long warntime;
834
835 if (time_after(jiffies, (warntime + HZ * 60))) {
836 warntime = jiffies;
837 printk(KERN_INFO
838 "possible SYN flooding on port %d. Sending cookies.\n",
839 ntohs(skb->h.th->dest));
840 }
841 }
842
843 /*
844 * Save and compile IPv4 options into the request_sock if needed.
845 */
846 static inline struct ip_options *tcp_v4_save_options(struct sock *sk,
847 struct sk_buff *skb)
848 {
849 struct ip_options *opt = &(IPCB(skb)->opt);
850 struct ip_options *dopt = NULL;
851
852 if (opt && opt->optlen) {
853 int opt_size = optlength(opt);
854 dopt = kmalloc(opt_size, GFP_ATOMIC);
855 if (dopt) {
856 if (ip_options_echo(dopt, skb)) {
857 kfree(dopt);
858 dopt = NULL;
859 }
860 }
861 }
862 return dopt;
863 }
864
865 struct request_sock_ops tcp_request_sock_ops = {
866 .family = PF_INET,
867 .obj_size = sizeof(struct tcp_request_sock),
868 .rtx_syn_ack = tcp_v4_send_synack,
869 .send_ack = tcp_v4_reqsk_send_ack,
870 .destructor = tcp_v4_reqsk_destructor,
871 .send_reset = tcp_v4_send_reset,
872 };
873
874 int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
875 {
876 struct inet_request_sock *ireq;
877 struct tcp_options_received tmp_opt;
878 struct request_sock *req;
879 __u32 saddr = skb->nh.iph->saddr;
880 __u32 daddr = skb->nh.iph->daddr;
881 __u32 isn = TCP_SKB_CB(skb)->when;
882 struct dst_entry *dst = NULL;
883 #ifdef CONFIG_SYN_COOKIES
884 int want_cookie = 0;
885 #else
886 #define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */
887 #endif
888
889 /* Never answer to SYNs send to broadcast or multicast */
890 if (((struct rtable *)skb->dst)->rt_flags &
891 (RTCF_BROADCAST | RTCF_MULTICAST))
892 goto drop;
893
894 /* TW buckets are converted to open requests without
895 * limitations, they conserve resources and peer is
896 * evidently real one.
897 */
898 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
899 #ifdef CONFIG_SYN_COOKIES
900 if (sysctl_tcp_syncookies) {
901 want_cookie = 1;
902 } else
903 #endif
904 goto drop;
905 }
906
907 /* Accept backlog is full. If we have already queued enough
908 * of warm entries in syn queue, drop request. It is better than
909 * clogging syn queue with openreqs with exponentially increasing
910 * timeout.
911 */
912 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
913 goto drop;
914
915 req = reqsk_alloc(&tcp_request_sock_ops);
916 if (!req)
917 goto drop;
918
919 tcp_clear_options(&tmp_opt);
920 tmp_opt.mss_clamp = 536;
921 tmp_opt.user_mss = tcp_sk(sk)->rx_opt.user_mss;
922
923 tcp_parse_options(skb, &tmp_opt, 0);
924
925 if (want_cookie) {
926 tcp_clear_options(&tmp_opt);
927 tmp_opt.saw_tstamp = 0;
928 }
929
930 if (tmp_opt.saw_tstamp && !tmp_opt.rcv_tsval) {
931 /* Some OSes (unknown ones, but I see them on web server, which
932 * contains information interesting only for windows'
933 * users) do not send their stamp in SYN. It is easy case.
934 * We simply do not advertise TS support.
935 */
936 tmp_opt.saw_tstamp = 0;
937 tmp_opt.tstamp_ok = 0;
938 }
939 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
940
941 tcp_openreq_init(req, &tmp_opt, skb);
942
943 ireq = inet_rsk(req);
944 ireq->loc_addr = daddr;
945 ireq->rmt_addr = saddr;
946 ireq->opt = tcp_v4_save_options(sk, skb);
947 if (!want_cookie)
948 TCP_ECN_create_request(req, skb->h.th);
949
950 if (want_cookie) {
951 #ifdef CONFIG_SYN_COOKIES
952 syn_flood_warning(skb);
953 #endif
954 isn = cookie_v4_init_sequence(sk, skb, &req->mss);
955 } else if (!isn) {
956 struct inet_peer *peer = NULL;
957
958 /* VJ's idea. We save last timestamp seen
959 * from the destination in peer table, when entering
960 * state TIME-WAIT, and check against it before
961 * accepting new connection request.
962 *
963 * If "isn" is not zero, this request hit alive
964 * timewait bucket, so that all the necessary checks
965 * are made in the function processing timewait state.
966 */
967 if (tmp_opt.saw_tstamp &&
968 tcp_death_row.sysctl_tw_recycle &&
969 (dst = inet_csk_route_req(sk, req)) != NULL &&
970 (peer = rt_get_peer((struct rtable *)dst)) != NULL &&
971 peer->v4daddr == saddr) {
972 if (xtime.tv_sec < peer->tcp_ts_stamp + TCP_PAWS_MSL &&
973 (s32)(peer->tcp_ts - req->ts_recent) >
974 TCP_PAWS_WINDOW) {
975 NET_INC_STATS_BH(LINUX_MIB_PAWSPASSIVEREJECTED);
976 dst_release(dst);
977 goto drop_and_free;
978 }
979 }
980 /* Kill the following clause, if you dislike this way. */
981 else if (!sysctl_tcp_syncookies &&
982 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
983 (sysctl_max_syn_backlog >> 2)) &&
984 (!peer || !peer->tcp_ts_stamp) &&
985 (!dst || !dst_metric(dst, RTAX_RTT))) {
986 /* Without syncookies last quarter of
987 * backlog is filled with destinations,
988 * proven to be alive.
989 * It means that we continue to communicate
990 * to destinations, already remembered
991 * to the moment of synflood.
992 */
993 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open "
994 "request from %u.%u.%u.%u/%u\n",
995 NIPQUAD(saddr),
996 ntohs(skb->h.th->source));
997 dst_release(dst);
998 goto drop_and_free;
999 }
1000
1001 isn = tcp_v4_init_sequence(sk, skb);
1002 }
1003 tcp_rsk(req)->snt_isn = isn;
1004
1005 if (tcp_v4_send_synack(sk, req, dst))
1006 goto drop_and_free;
1007
1008 if (want_cookie) {
1009 reqsk_free(req);
1010 } else {
1011 inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
1012 }
1013 return 0;
1014
1015 drop_and_free:
1016 reqsk_free(req);
1017 drop:
1018 TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
1019 return 0;
1020 }
1021
1022
1023 /*
1024 * The three way handshake has completed - we got a valid synack -
1025 * now create the new socket.
1026 */
1027 struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
1028 struct request_sock *req,
1029 struct dst_entry *dst)
1030 {
1031 struct inet_request_sock *ireq;
1032 struct inet_sock *newinet;
1033 struct tcp_sock *newtp;
1034 struct sock *newsk;
1035
1036 if (sk_acceptq_is_full(sk))
1037 goto exit_overflow;
1038
1039 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
1040 goto exit;
1041
1042 newsk = tcp_create_openreq_child(sk, req, skb);
1043 if (!newsk)
1044 goto exit;
1045
1046 sk_setup_caps(newsk, dst);
1047
1048 newtp = tcp_sk(newsk);
1049 newinet = inet_sk(newsk);
1050 ireq = inet_rsk(req);
1051 newinet->daddr = ireq->rmt_addr;
1052 newinet->rcv_saddr = ireq->loc_addr;
1053 newinet->saddr = ireq->loc_addr;
1054 newinet->opt = ireq->opt;
1055 ireq->opt = NULL;
1056 newinet->mc_index = inet_iif(skb);
1057 newinet->mc_ttl = skb->nh.iph->ttl;
1058 newtp->ext_header_len = 0;
1059 if (newinet->opt)
1060 newtp->ext_header_len = newinet->opt->optlen;
1061 newinet->id = newtp->write_seq ^ jiffies;
1062
1063 tcp_sync_mss(newsk, dst_mtu(dst));
1064 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
1065 tcp_initialize_rcv_mss(newsk);
1066
1067 __inet_hash(&tcp_hashinfo, newsk, 0);
1068 __inet_inherit_port(&tcp_hashinfo, sk, newsk);
1069
1070 return newsk;
1071
1072 exit_overflow:
1073 NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS);
1074 exit:
1075 NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS);
1076 dst_release(dst);
1077 return NULL;
1078 }
1079
1080 static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
1081 {
1082 struct tcphdr *th = skb->h.th;
1083 struct iphdr *iph = skb->nh.iph;
1084 struct sock *nsk;
1085 struct request_sock **prev;
1086 /* Find possible connection requests. */
1087 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
1088 iph->saddr, iph->daddr);
1089 if (req)
1090 return tcp_check_req(sk, skb, req, prev);
1091
1092 nsk = __inet_lookup_established(&tcp_hashinfo, skb->nh.iph->saddr,
1093 th->source, skb->nh.iph->daddr,
1094 ntohs(th->dest), inet_iif(skb));
1095
1096 if (nsk) {
1097 if (nsk->sk_state != TCP_TIME_WAIT) {
1098 bh_lock_sock(nsk);
1099 return nsk;
1100 }
1101 inet_twsk_put((struct inet_timewait_sock *)nsk);
1102 return NULL;
1103 }
1104
1105 #ifdef CONFIG_SYN_COOKIES
1106 if (!th->rst && !th->syn && th->ack)
1107 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
1108 #endif
1109 return sk;
1110 }
1111
1112 static int tcp_v4_checksum_init(struct sk_buff *skb)
1113 {
1114 if (skb->ip_summed == CHECKSUM_HW) {
1115 skb->ip_summed = CHECKSUM_UNNECESSARY;
1116 if (!tcp_v4_check(skb->h.th, skb->len, skb->nh.iph->saddr,
1117 skb->nh.iph->daddr, skb->csum))
1118 return 0;
1119
1120 LIMIT_NETDEBUG(KERN_DEBUG "hw tcp v4 csum failed\n");
1121 skb->ip_summed = CHECKSUM_NONE;
1122 }
1123 if (skb->len <= 76) {
1124 if (tcp_v4_check(skb->h.th, skb->len, skb->nh.iph->saddr,
1125 skb->nh.iph->daddr,
1126 skb_checksum(skb, 0, skb->len, 0)))
1127 return -1;
1128 skb->ip_summed = CHECKSUM_UNNECESSARY;
1129 } else {
1130 skb->csum = ~tcp_v4_check(skb->h.th, skb->len,
1131 skb->nh.iph->saddr,
1132 skb->nh.iph->daddr, 0);
1133 }
1134 return 0;
1135 }
1136
1137
1138 /* The socket must have it's spinlock held when we get
1139 * here.
1140 *
1141 * We have a potential double-lock case here, so even when
1142 * doing backlog processing we use the BH locking scheme.
1143 * This is because we cannot sleep with the original spinlock
1144 * held.
1145 */
1146 int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1147 {
1148 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1149 TCP_CHECK_TIMER(sk);
1150 if (tcp_rcv_established(sk, skb, skb->h.th, skb->len))
1151 goto reset;
1152 TCP_CHECK_TIMER(sk);
1153 return 0;
1154 }
1155
1156 if (skb->len < (skb->h.th->doff << 2) || tcp_checksum_complete(skb))
1157 goto csum_err;
1158
1159 if (sk->sk_state == TCP_LISTEN) {
1160 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
1161 if (!nsk)
1162 goto discard;
1163
1164 if (nsk != sk) {
1165 if (tcp_child_process(sk, nsk, skb))
1166 goto reset;
1167 return 0;
1168 }
1169 }
1170
1171 TCP_CHECK_TIMER(sk);
1172 if (tcp_rcv_state_process(sk, skb, skb->h.th, skb->len))
1173 goto reset;
1174 TCP_CHECK_TIMER(sk);
1175 return 0;
1176
1177 reset:
1178 tcp_v4_send_reset(skb);
1179 discard:
1180 kfree_skb(skb);
1181 /* Be careful here. If this function gets more complicated and
1182 * gcc suffers from register pressure on the x86, sk (in %ebx)
1183 * might be destroyed here. This current version compiles correctly,
1184 * but you have been warned.
1185 */
1186 return 0;
1187
1188 csum_err:
1189 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1190 goto discard;
1191 }
1192
1193 /*
1194 * From tcp_input.c
1195 */
1196
1197 int tcp_v4_rcv(struct sk_buff *skb)
1198 {
1199 struct tcphdr *th;
1200 struct sock *sk;
1201 int ret;
1202
1203 if (skb->pkt_type != PACKET_HOST)
1204 goto discard_it;
1205
1206 /* Count it even if it's bad */
1207 TCP_INC_STATS_BH(TCP_MIB_INSEGS);
1208
1209 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1210 goto discard_it;
1211
1212 th = skb->h.th;
1213
1214 if (th->doff < sizeof(struct tcphdr) / 4)
1215 goto bad_packet;
1216 if (!pskb_may_pull(skb, th->doff * 4))
1217 goto discard_it;
1218
1219 /* An explanation is required here, I think.
1220 * Packet length and doff are validated by header prediction,
1221 * provided case of th->doff==0 is elimineted.
1222 * So, we defer the checks. */
1223 if ((skb->ip_summed != CHECKSUM_UNNECESSARY &&
1224 tcp_v4_checksum_init(skb) < 0))
1225 goto bad_packet;
1226
1227 th = skb->h.th;
1228 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1229 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1230 skb->len - th->doff * 4);
1231 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1232 TCP_SKB_CB(skb)->when = 0;
1233 TCP_SKB_CB(skb)->flags = skb->nh.iph->tos;
1234 TCP_SKB_CB(skb)->sacked = 0;
1235
1236 sk = __inet_lookup(&tcp_hashinfo, skb->nh.iph->saddr, th->source,
1237 skb->nh.iph->daddr, ntohs(th->dest),
1238 inet_iif(skb));
1239
1240 if (!sk)
1241 goto no_tcp_socket;
1242
1243 process:
1244 if (sk->sk_state == TCP_TIME_WAIT)
1245 goto do_time_wait;
1246
1247 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1248 goto discard_and_relse;
1249
1250 if (sk_filter(sk, skb, 0))
1251 goto discard_and_relse;
1252
1253 skb->dev = NULL;
1254
1255 bh_lock_sock(sk);
1256 ret = 0;
1257 if (!sock_owned_by_user(sk)) {
1258 if (!tcp_prequeue(sk, skb))
1259 ret = tcp_v4_do_rcv(sk, skb);
1260 } else
1261 sk_add_backlog(sk, skb);
1262 bh_unlock_sock(sk);
1263
1264 sock_put(sk);
1265
1266 return ret;
1267
1268 no_tcp_socket:
1269 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1270 goto discard_it;
1271
1272 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1273 bad_packet:
1274 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1275 } else {
1276 tcp_v4_send_reset(skb);
1277 }
1278
1279 discard_it:
1280 /* Discard frame. */
1281 kfree_skb(skb);
1282 return 0;
1283
1284 discard_and_relse:
1285 sock_put(sk);
1286 goto discard_it;
1287
1288 do_time_wait:
1289 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1290 inet_twsk_put((struct inet_timewait_sock *) sk);
1291 goto discard_it;
1292 }
1293
1294 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1295 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1296 inet_twsk_put((struct inet_timewait_sock *) sk);
1297 goto discard_it;
1298 }
1299 switch (tcp_timewait_state_process((struct inet_timewait_sock *)sk,
1300 skb, th)) {
1301 case TCP_TW_SYN: {
1302 struct sock *sk2 = inet_lookup_listener(&tcp_hashinfo,
1303 skb->nh.iph->daddr,
1304 ntohs(th->dest),
1305 inet_iif(skb));
1306 if (sk2) {
1307 inet_twsk_deschedule((struct inet_timewait_sock *)sk,
1308 &tcp_death_row);
1309 inet_twsk_put((struct inet_timewait_sock *)sk);
1310 sk = sk2;
1311 goto process;
1312 }
1313 /* Fall through to ACK */
1314 }
1315 case TCP_TW_ACK:
1316 tcp_v4_timewait_ack(sk, skb);
1317 break;
1318 case TCP_TW_RST:
1319 goto no_tcp_socket;
1320 case TCP_TW_SUCCESS:;
1321 }
1322 goto discard_it;
1323 }
1324
1325 static void v4_addr2sockaddr(struct sock *sk, struct sockaddr * uaddr)
1326 {
1327 struct sockaddr_in *sin = (struct sockaddr_in *) uaddr;
1328 struct inet_sock *inet = inet_sk(sk);
1329
1330 sin->sin_family = AF_INET;
1331 sin->sin_addr.s_addr = inet->daddr;
1332 sin->sin_port = inet->dport;
1333 }
1334
1335 /* VJ's idea. Save last timestamp seen from this destination
1336 * and hold it at least for normal timewait interval to use for duplicate
1337 * segment detection in subsequent connections, before they enter synchronized
1338 * state.
1339 */
1340
1341 int tcp_v4_remember_stamp(struct sock *sk)
1342 {
1343 struct inet_sock *inet = inet_sk(sk);
1344 struct tcp_sock *tp = tcp_sk(sk);
1345 struct rtable *rt = (struct rtable *)__sk_dst_get(sk);
1346 struct inet_peer *peer = NULL;
1347 int release_it = 0;
1348
1349 if (!rt || rt->rt_dst != inet->daddr) {
1350 peer = inet_getpeer(inet->daddr, 1);
1351 release_it = 1;
1352 } else {
1353 if (!rt->peer)
1354 rt_bind_peer(rt, 1);
1355 peer = rt->peer;
1356 }
1357
1358 if (peer) {
1359 if ((s32)(peer->tcp_ts - tp->rx_opt.ts_recent) <= 0 ||
1360 (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec &&
1361 peer->tcp_ts_stamp <= tp->rx_opt.ts_recent_stamp)) {
1362 peer->tcp_ts_stamp = tp->rx_opt.ts_recent_stamp;
1363 peer->tcp_ts = tp->rx_opt.ts_recent;
1364 }
1365 if (release_it)
1366 inet_putpeer(peer);
1367 return 1;
1368 }
1369
1370 return 0;
1371 }
1372
1373 int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw)
1374 {
1375 struct inet_peer *peer = inet_getpeer(tw->tw_daddr, 1);
1376
1377 if (peer) {
1378 const struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
1379
1380 if ((s32)(peer->tcp_ts - tcptw->tw_ts_recent) <= 0 ||
1381 (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec &&
1382 peer->tcp_ts_stamp <= tcptw->tw_ts_recent_stamp)) {
1383 peer->tcp_ts_stamp = tcptw->tw_ts_recent_stamp;
1384 peer->tcp_ts = tcptw->tw_ts_recent;
1385 }
1386 inet_putpeer(peer);
1387 return 1;
1388 }
1389
1390 return 0;
1391 }
1392
1393 struct tcp_func ipv4_specific = {
1394 .queue_xmit = ip_queue_xmit,
1395 .send_check = tcp_v4_send_check,
1396 .rebuild_header = inet_sk_rebuild_header,
1397 .conn_request = tcp_v4_conn_request,
1398 .syn_recv_sock = tcp_v4_syn_recv_sock,
1399 .remember_stamp = tcp_v4_remember_stamp,
1400 .net_header_len = sizeof(struct iphdr),
1401 .setsockopt = ip_setsockopt,
1402 .getsockopt = ip_getsockopt,
1403 .addr2sockaddr = v4_addr2sockaddr,
1404 .sockaddr_len = sizeof(struct sockaddr_in),
1405 };
1406
1407 /* NOTE: A lot of things set to zero explicitly by call to
1408 * sk_alloc() so need not be done here.
1409 */
1410 static int tcp_v4_init_sock(struct sock *sk)
1411 {
1412 struct inet_connection_sock *icsk = inet_csk(sk);
1413 struct tcp_sock *tp = tcp_sk(sk);
1414
1415 skb_queue_head_init(&tp->out_of_order_queue);
1416 tcp_init_xmit_timers(sk);
1417 tcp_prequeue_init(tp);
1418
1419 icsk->icsk_rto = TCP_TIMEOUT_INIT;
1420 tp->mdev = TCP_TIMEOUT_INIT;
1421
1422 /* So many TCP implementations out there (incorrectly) count the
1423 * initial SYN frame in their delayed-ACK and congestion control
1424 * algorithms that we must have the following bandaid to talk
1425 * efficiently to them. -DaveM
1426 */
1427 tp->snd_cwnd = 2;
1428
1429 /* See draft-stevens-tcpca-spec-01 for discussion of the
1430 * initialization of these values.
1431 */
1432 tp->snd_ssthresh = 0x7fffffff; /* Infinity */
1433 tp->snd_cwnd_clamp = ~0;
1434 tp->mss_cache = 536;
1435
1436 tp->reordering = sysctl_tcp_reordering;
1437 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
1438
1439 sk->sk_state = TCP_CLOSE;
1440
1441 sk->sk_write_space = sk_stream_write_space;
1442 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1443
1444 tp->af_specific = &ipv4_specific;
1445
1446 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1447 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1448
1449 atomic_inc(&tcp_sockets_allocated);
1450
1451 return 0;
1452 }
1453
1454 int tcp_v4_destroy_sock(struct sock *sk)
1455 {
1456 struct tcp_sock *tp = tcp_sk(sk);
1457
1458 tcp_clear_xmit_timers(sk);
1459
1460 tcp_cleanup_congestion_control(sk);
1461
1462 /* Cleanup up the write buffer. */
1463 sk_stream_writequeue_purge(sk);
1464
1465 /* Cleans up our, hopefully empty, out_of_order_queue. */
1466 __skb_queue_purge(&tp->out_of_order_queue);
1467
1468 /* Clean prequeue, it must be empty really */
1469 __skb_queue_purge(&tp->ucopy.prequeue);
1470
1471 /* Clean up a referenced TCP bind bucket. */
1472 if (inet_csk(sk)->icsk_bind_hash)
1473 inet_put_port(&tcp_hashinfo, sk);
1474
1475 /*
1476 * If sendmsg cached page exists, toss it.
1477 */
1478 if (sk->sk_sndmsg_page) {
1479 __free_page(sk->sk_sndmsg_page);
1480 sk->sk_sndmsg_page = NULL;
1481 }
1482
1483 atomic_dec(&tcp_sockets_allocated);
1484
1485 return 0;
1486 }
1487
1488 EXPORT_SYMBOL(tcp_v4_destroy_sock);
1489
1490 #ifdef CONFIG_PROC_FS
1491 /* Proc filesystem TCP sock list dumping. */
1492
1493 static inline struct inet_timewait_sock *tw_head(struct hlist_head *head)
1494 {
1495 return hlist_empty(head) ? NULL :
1496 list_entry(head->first, struct inet_timewait_sock, tw_node);
1497 }
1498
1499 static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
1500 {
1501 return tw->tw_node.next ?
1502 hlist_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
1503 }
1504
1505 static void *listening_get_next(struct seq_file *seq, void *cur)
1506 {
1507 struct inet_connection_sock *icsk;
1508 struct hlist_node *node;
1509 struct sock *sk = cur;
1510 struct tcp_iter_state* st = seq->private;
1511
1512 if (!sk) {
1513 st->bucket = 0;
1514 sk = sk_head(&tcp_hashinfo.listening_hash[0]);
1515 goto get_sk;
1516 }
1517
1518 ++st->num;
1519
1520 if (st->state == TCP_SEQ_STATE_OPENREQ) {
1521 struct request_sock *req = cur;
1522
1523 icsk = inet_csk(st->syn_wait_sk);
1524 req = req->dl_next;
1525 while (1) {
1526 while (req) {
1527 if (req->rsk_ops->family == st->family) {
1528 cur = req;
1529 goto out;
1530 }
1531 req = req->dl_next;
1532 }
1533 if (++st->sbucket >= TCP_SYNQ_HSIZE)
1534 break;
1535 get_req:
1536 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
1537 }
1538 sk = sk_next(st->syn_wait_sk);
1539 st->state = TCP_SEQ_STATE_LISTENING;
1540 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1541 } else {
1542 icsk = inet_csk(sk);
1543 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1544 if (reqsk_queue_len(&icsk->icsk_accept_queue))
1545 goto start_req;
1546 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1547 sk = sk_next(sk);
1548 }
1549 get_sk:
1550 sk_for_each_from(sk, node) {
1551 if (sk->sk_family == st->family) {
1552 cur = sk;
1553 goto out;
1554 }
1555 icsk = inet_csk(sk);
1556 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1557 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
1558 start_req:
1559 st->uid = sock_i_uid(sk);
1560 st->syn_wait_sk = sk;
1561 st->state = TCP_SEQ_STATE_OPENREQ;
1562 st->sbucket = 0;
1563 goto get_req;
1564 }
1565 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1566 }
1567 if (++st->bucket < INET_LHTABLE_SIZE) {
1568 sk = sk_head(&tcp_hashinfo.listening_hash[st->bucket]);
1569 goto get_sk;
1570 }
1571 cur = NULL;
1572 out:
1573 return cur;
1574 }
1575
1576 static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
1577 {
1578 void *rc = listening_get_next(seq, NULL);
1579
1580 while (rc && *pos) {
1581 rc = listening_get_next(seq, rc);
1582 --*pos;
1583 }
1584 return rc;
1585 }
1586
1587 static void *established_get_first(struct seq_file *seq)
1588 {
1589 struct tcp_iter_state* st = seq->private;
1590 void *rc = NULL;
1591
1592 for (st->bucket = 0; st->bucket < tcp_hashinfo.ehash_size; ++st->bucket) {
1593 struct sock *sk;
1594 struct hlist_node *node;
1595 struct inet_timewait_sock *tw;
1596
1597 /* We can reschedule _before_ having picked the target: */
1598 cond_resched_softirq();
1599
1600 read_lock(&tcp_hashinfo.ehash[st->bucket].lock);
1601 sk_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
1602 if (sk->sk_family != st->family) {
1603 continue;
1604 }
1605 rc = sk;
1606 goto out;
1607 }
1608 st->state = TCP_SEQ_STATE_TIME_WAIT;
1609 inet_twsk_for_each(tw, node,
1610 &tcp_hashinfo.ehash[st->bucket + tcp_hashinfo.ehash_size].chain) {
1611 if (tw->tw_family != st->family) {
1612 continue;
1613 }
1614 rc = tw;
1615 goto out;
1616 }
1617 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
1618 st->state = TCP_SEQ_STATE_ESTABLISHED;
1619 }
1620 out:
1621 return rc;
1622 }
1623
1624 static void *established_get_next(struct seq_file *seq, void *cur)
1625 {
1626 struct sock *sk = cur;
1627 struct inet_timewait_sock *tw;
1628 struct hlist_node *node;
1629 struct tcp_iter_state* st = seq->private;
1630
1631 ++st->num;
1632
1633 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
1634 tw = cur;
1635 tw = tw_next(tw);
1636 get_tw:
1637 while (tw && tw->tw_family != st->family) {
1638 tw = tw_next(tw);
1639 }
1640 if (tw) {
1641 cur = tw;
1642 goto out;
1643 }
1644 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
1645 st->state = TCP_SEQ_STATE_ESTABLISHED;
1646
1647 /* We can reschedule between buckets: */
1648 cond_resched_softirq();
1649
1650 if (++st->bucket < tcp_hashinfo.ehash_size) {
1651 read_lock(&tcp_hashinfo.ehash[st->bucket].lock);
1652 sk = sk_head(&tcp_hashinfo.ehash[st->bucket].chain);
1653 } else {
1654 cur = NULL;
1655 goto out;
1656 }
1657 } else
1658 sk = sk_next(sk);
1659
1660 sk_for_each_from(sk, node) {
1661 if (sk->sk_family == st->family)
1662 goto found;
1663 }
1664
1665 st->state = TCP_SEQ_STATE_TIME_WAIT;
1666 tw = tw_head(&tcp_hashinfo.ehash[st->bucket + tcp_hashinfo.ehash_size].chain);
1667 goto get_tw;
1668 found:
1669 cur = sk;
1670 out:
1671 return cur;
1672 }
1673
1674 static void *established_get_idx(struct seq_file *seq, loff_t pos)
1675 {
1676 void *rc = established_get_first(seq);
1677
1678 while (rc && pos) {
1679 rc = established_get_next(seq, rc);
1680 --pos;
1681 }
1682 return rc;
1683 }
1684
1685 static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
1686 {
1687 void *rc;
1688 struct tcp_iter_state* st = seq->private;
1689
1690 inet_listen_lock(&tcp_hashinfo);
1691 st->state = TCP_SEQ_STATE_LISTENING;
1692 rc = listening_get_idx(seq, &pos);
1693
1694 if (!rc) {
1695 inet_listen_unlock(&tcp_hashinfo);
1696 local_bh_disable();
1697 st->state = TCP_SEQ_STATE_ESTABLISHED;
1698 rc = established_get_idx(seq, pos);
1699 }
1700
1701 return rc;
1702 }
1703
1704 static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
1705 {
1706 struct tcp_iter_state* st = seq->private;
1707 st->state = TCP_SEQ_STATE_LISTENING;
1708 st->num = 0;
1709 return *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
1710 }
1711
1712 static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1713 {
1714 void *rc = NULL;
1715 struct tcp_iter_state* st;
1716
1717 if (v == SEQ_START_TOKEN) {
1718 rc = tcp_get_idx(seq, 0);
1719 goto out;
1720 }
1721 st = seq->private;
1722
1723 switch (st->state) {
1724 case TCP_SEQ_STATE_OPENREQ:
1725 case TCP_SEQ_STATE_LISTENING:
1726 rc = listening_get_next(seq, v);
1727 if (!rc) {
1728 inet_listen_unlock(&tcp_hashinfo);
1729 local_bh_disable();
1730 st->state = TCP_SEQ_STATE_ESTABLISHED;
1731 rc = established_get_first(seq);
1732 }
1733 break;
1734 case TCP_SEQ_STATE_ESTABLISHED:
1735 case TCP_SEQ_STATE_TIME_WAIT:
1736 rc = established_get_next(seq, v);
1737 break;
1738 }
1739 out:
1740 ++*pos;
1741 return rc;
1742 }
1743
1744 static void tcp_seq_stop(struct seq_file *seq, void *v)
1745 {
1746 struct tcp_iter_state* st = seq->private;
1747
1748 switch (st->state) {
1749 case TCP_SEQ_STATE_OPENREQ:
1750 if (v) {
1751 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
1752 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1753 }
1754 case TCP_SEQ_STATE_LISTENING:
1755 if (v != SEQ_START_TOKEN)
1756 inet_listen_unlock(&tcp_hashinfo);
1757 break;
1758 case TCP_SEQ_STATE_TIME_WAIT:
1759 case TCP_SEQ_STATE_ESTABLISHED:
1760 if (v)
1761 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
1762 local_bh_enable();
1763 break;
1764 }
1765 }
1766
1767 static int tcp_seq_open(struct inode *inode, struct file *file)
1768 {
1769 struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
1770 struct seq_file *seq;
1771 struct tcp_iter_state *s;
1772 int rc;
1773
1774 if (unlikely(afinfo == NULL))
1775 return -EINVAL;
1776
1777 s = kmalloc(sizeof(*s), GFP_KERNEL);
1778 if (!s)
1779 return -ENOMEM;
1780 memset(s, 0, sizeof(*s));
1781 s->family = afinfo->family;
1782 s->seq_ops.start = tcp_seq_start;
1783 s->seq_ops.next = tcp_seq_next;
1784 s->seq_ops.show = afinfo->seq_show;
1785 s->seq_ops.stop = tcp_seq_stop;
1786
1787 rc = seq_open(file, &s->seq_ops);
1788 if (rc)
1789 goto out_kfree;
1790 seq = file->private_data;
1791 seq->private = s;
1792 out:
1793 return rc;
1794 out_kfree:
1795 kfree(s);
1796 goto out;
1797 }
1798
1799 int tcp_proc_register(struct tcp_seq_afinfo *afinfo)
1800 {
1801 int rc = 0;
1802 struct proc_dir_entry *p;
1803
1804 if (!afinfo)
1805 return -EINVAL;
1806 afinfo->seq_fops->owner = afinfo->owner;
1807 afinfo->seq_fops->open = tcp_seq_open;
1808 afinfo->seq_fops->read = seq_read;
1809 afinfo->seq_fops->llseek = seq_lseek;
1810 afinfo->seq_fops->release = seq_release_private;
1811
1812 p = proc_net_fops_create(afinfo->name, S_IRUGO, afinfo->seq_fops);
1813 if (p)
1814 p->data = afinfo;
1815 else
1816 rc = -ENOMEM;
1817 return rc;
1818 }
1819
1820 void tcp_proc_unregister(struct tcp_seq_afinfo *afinfo)
1821 {
1822 if (!afinfo)
1823 return;
1824 proc_net_remove(afinfo->name);
1825 memset(afinfo->seq_fops, 0, sizeof(*afinfo->seq_fops));
1826 }
1827
1828 static void get_openreq4(struct sock *sk, struct request_sock *req,
1829 char *tmpbuf, int i, int uid)
1830 {
1831 const struct inet_request_sock *ireq = inet_rsk(req);
1832 int ttd = req->expires - jiffies;
1833
1834 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
1835 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p",
1836 i,
1837 ireq->loc_addr,
1838 ntohs(inet_sk(sk)->sport),
1839 ireq->rmt_addr,
1840 ntohs(ireq->rmt_port),
1841 TCP_SYN_RECV,
1842 0, 0, /* could print option size, but that is af dependent. */
1843 1, /* timers active (only the expire timer) */
1844 jiffies_to_clock_t(ttd),
1845 req->retrans,
1846 uid,
1847 0, /* non standard timer */
1848 0, /* open_requests have no inode */
1849 atomic_read(&sk->sk_refcnt),
1850 req);
1851 }
1852
1853 static void get_tcp4_sock(struct sock *sp, char *tmpbuf, int i)
1854 {
1855 int timer_active;
1856 unsigned long timer_expires;
1857 struct tcp_sock *tp = tcp_sk(sp);
1858 const struct inet_connection_sock *icsk = inet_csk(sp);
1859 struct inet_sock *inet = inet_sk(sp);
1860 unsigned int dest = inet->daddr;
1861 unsigned int src = inet->rcv_saddr;
1862 __u16 destp = ntohs(inet->dport);
1863 __u16 srcp = ntohs(inet->sport);
1864
1865 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
1866 timer_active = 1;
1867 timer_expires = icsk->icsk_timeout;
1868 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
1869 timer_active = 4;
1870 timer_expires = icsk->icsk_timeout;
1871 } else if (timer_pending(&sp->sk_timer)) {
1872 timer_active = 2;
1873 timer_expires = sp->sk_timer.expires;
1874 } else {
1875 timer_active = 0;
1876 timer_expires = jiffies;
1877 }
1878
1879 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
1880 "%08X %5d %8d %lu %d %p %u %u %u %u %d",
1881 i, src, srcp, dest, destp, sp->sk_state,
1882 tp->write_seq - tp->snd_una, tp->rcv_nxt - tp->copied_seq,
1883 timer_active,
1884 jiffies_to_clock_t(timer_expires - jiffies),
1885 icsk->icsk_retransmits,
1886 sock_i_uid(sp),
1887 icsk->icsk_probes_out,
1888 sock_i_ino(sp),
1889 atomic_read(&sp->sk_refcnt), sp,
1890 icsk->icsk_rto,
1891 icsk->icsk_ack.ato,
1892 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
1893 tp->snd_cwnd,
1894 tp->snd_ssthresh >= 0xFFFF ? -1 : tp->snd_ssthresh);
1895 }
1896
1897 static void get_timewait4_sock(struct inet_timewait_sock *tw, char *tmpbuf, int i)
1898 {
1899 unsigned int dest, src;
1900 __u16 destp, srcp;
1901 int ttd = tw->tw_ttd - jiffies;
1902
1903 if (ttd < 0)
1904 ttd = 0;
1905
1906 dest = tw->tw_daddr;
1907 src = tw->tw_rcv_saddr;
1908 destp = ntohs(tw->tw_dport);
1909 srcp = ntohs(tw->tw_sport);
1910
1911 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
1912 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p",
1913 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
1914 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
1915 atomic_read(&tw->tw_refcnt), tw);
1916 }
1917
1918 #define TMPSZ 150
1919
1920 static int tcp4_seq_show(struct seq_file *seq, void *v)
1921 {
1922 struct tcp_iter_state* st;
1923 char tmpbuf[TMPSZ + 1];
1924
1925 if (v == SEQ_START_TOKEN) {
1926 seq_printf(seq, "%-*s\n", TMPSZ - 1,
1927 " sl local_address rem_address st tx_queue "
1928 "rx_queue tr tm->when retrnsmt uid timeout "
1929 "inode");
1930 goto out;
1931 }
1932 st = seq->private;
1933
1934 switch (st->state) {
1935 case TCP_SEQ_STATE_LISTENING:
1936 case TCP_SEQ_STATE_ESTABLISHED:
1937 get_tcp4_sock(v, tmpbuf, st->num);
1938 break;
1939 case TCP_SEQ_STATE_OPENREQ:
1940 get_openreq4(st->syn_wait_sk, v, tmpbuf, st->num, st->uid);
1941 break;
1942 case TCP_SEQ_STATE_TIME_WAIT:
1943 get_timewait4_sock(v, tmpbuf, st->num);
1944 break;
1945 }
1946 seq_printf(seq, "%-*s\n", TMPSZ - 1, tmpbuf);
1947 out:
1948 return 0;
1949 }
1950
1951 static struct file_operations tcp4_seq_fops;
1952 static struct tcp_seq_afinfo tcp4_seq_afinfo = {
1953 .owner = THIS_MODULE,
1954 .name = "tcp",
1955 .family = AF_INET,
1956 .seq_show = tcp4_seq_show,
1957 .seq_fops = &tcp4_seq_fops,
1958 };
1959
1960 int __init tcp4_proc_init(void)
1961 {
1962 return tcp_proc_register(&tcp4_seq_afinfo);
1963 }
1964
1965 void tcp4_proc_exit(void)
1966 {
1967 tcp_proc_unregister(&tcp4_seq_afinfo);
1968 }
1969 #endif /* CONFIG_PROC_FS */
1970
1971 struct proto tcp_prot = {
1972 .name = "TCP",
1973 .owner = THIS_MODULE,
1974 .close = tcp_close,
1975 .connect = tcp_v4_connect,
1976 .disconnect = tcp_disconnect,
1977 .accept = inet_csk_accept,
1978 .ioctl = tcp_ioctl,
1979 .init = tcp_v4_init_sock,
1980 .destroy = tcp_v4_destroy_sock,
1981 .shutdown = tcp_shutdown,
1982 .setsockopt = tcp_setsockopt,
1983 .getsockopt = tcp_getsockopt,
1984 .sendmsg = tcp_sendmsg,
1985 .recvmsg = tcp_recvmsg,
1986 .backlog_rcv = tcp_v4_do_rcv,
1987 .hash = tcp_v4_hash,
1988 .unhash = tcp_unhash,
1989 .get_port = tcp_v4_get_port,
1990 .enter_memory_pressure = tcp_enter_memory_pressure,
1991 .sockets_allocated = &tcp_sockets_allocated,
1992 .orphan_count = &tcp_orphan_count,
1993 .memory_allocated = &tcp_memory_allocated,
1994 .memory_pressure = &tcp_memory_pressure,
1995 .sysctl_mem = sysctl_tcp_mem,
1996 .sysctl_wmem = sysctl_tcp_wmem,
1997 .sysctl_rmem = sysctl_tcp_rmem,
1998 .max_header = MAX_TCP_HEADER,
1999 .obj_size = sizeof(struct tcp_sock),
2000 .twsk_obj_size = sizeof(struct tcp_timewait_sock),
2001 .rsk_prot = &tcp_request_sock_ops,
2002 };
2003
2004
2005
2006 void __init tcp_v4_init(struct net_proto_family *ops)
2007 {
2008 int err = sock_create_kern(PF_INET, SOCK_RAW, IPPROTO_TCP, &tcp_socket);
2009 if (err < 0)
2010 panic("Failed to create the TCP control socket.\n");
2011 tcp_socket->sk->sk_allocation = GFP_ATOMIC;
2012 inet_sk(tcp_socket->sk)->uc_ttl = -1;
2013
2014 /* Unhash it so that IP input processing does not even
2015 * see it, we do not wish this socket to see incoming
2016 * packets.
2017 */
2018 tcp_socket->sk->sk_prot->unhash(tcp_socket->sk);
2019 }
2020
2021 EXPORT_SYMBOL(ipv4_specific);
2022 EXPORT_SYMBOL(inet_bind_bucket_create);
2023 EXPORT_SYMBOL(tcp_hashinfo);
2024 EXPORT_SYMBOL(tcp_prot);
2025 EXPORT_SYMBOL(tcp_unhash);
2026 EXPORT_SYMBOL(tcp_v4_conn_request);
2027 EXPORT_SYMBOL(tcp_v4_connect);
2028 EXPORT_SYMBOL(tcp_v4_do_rcv);
2029 EXPORT_SYMBOL(tcp_v4_remember_stamp);
2030 EXPORT_SYMBOL(tcp_v4_send_check);
2031 EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
2032
2033 #ifdef CONFIG_PROC_FS
2034 EXPORT_SYMBOL(tcp_proc_register);
2035 EXPORT_SYMBOL(tcp_proc_unregister);
2036 #endif
2037 EXPORT_SYMBOL(sysctl_local_port_range);
2038 EXPORT_SYMBOL(sysctl_tcp_low_latency);
2039 EXPORT_SYMBOL(sysctl_tcp_tw_reuse);
2040
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree