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