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