[TCP]: Appropriate Byte Count support
[linux-2.6.git] / include / net / tcp.h
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  *              Definitions for the TCP module.
7  *
8  * Version:     @(#)tcp.h       1.0.5   05/23/93
9  *
10  * Authors:     Ross Biro
11  *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12  *
13  *              This program is free software; you can redistribute it and/or
14  *              modify it under the terms of the GNU General Public License
15  *              as published by the Free Software Foundation; either version
16  *              2 of the License, or (at your option) any later version.
17  */
18 #ifndef _TCP_H
19 #define _TCP_H
20
21 #define TCP_DEBUG 1
22 #define FASTRETRANS_DEBUG 1
23
24 #include <linux/config.h>
25 #include <linux/list.h>
26 #include <linux/tcp.h>
27 #include <linux/slab.h>
28 #include <linux/cache.h>
29 #include <linux/percpu.h>
30 #include <linux/skbuff.h>
31
32 #include <net/inet_connection_sock.h>
33 #include <net/inet_timewait_sock.h>
34 #include <net/inet_hashtables.h>
35 #include <net/checksum.h>
36 #include <net/request_sock.h>
37 #include <net/sock.h>
38 #include <net/snmp.h>
39 #include <net/ip.h>
40 #include <net/tcp_states.h>
41
42 #include <linux/seq_file.h>
43
44 extern struct inet_hashinfo tcp_hashinfo;
45
46 extern atomic_t tcp_orphan_count;
47 extern void tcp_time_wait(struct sock *sk, int state, int timeo);
48
49 #define MAX_TCP_HEADER  (128 + MAX_HEADER)
50
51 /* 
52  * Never offer a window over 32767 without using window scaling. Some
53  * poor stacks do signed 16bit maths! 
54  */
55 #define MAX_TCP_WINDOW          32767U
56
57 /* Minimal accepted MSS. It is (60+60+8) - (20+20). */
58 #define TCP_MIN_MSS             88U
59
60 /* Minimal RCV_MSS. */
61 #define TCP_MIN_RCVMSS          536U
62
63 /* After receiving this amount of duplicate ACKs fast retransmit starts. */
64 #define TCP_FASTRETRANS_THRESH 3
65
66 /* Maximal reordering. */
67 #define TCP_MAX_REORDERING      127
68
69 /* Maximal number of ACKs sent quickly to accelerate slow-start. */
70 #define TCP_MAX_QUICKACKS       16U
71
72 /* urg_data states */
73 #define TCP_URG_VALID   0x0100
74 #define TCP_URG_NOTYET  0x0200
75 #define TCP_URG_READ    0x0400
76
77 #define TCP_RETR1       3       /*
78                                  * This is how many retries it does before it
79                                  * tries to figure out if the gateway is
80                                  * down. Minimal RFC value is 3; it corresponds
81                                  * to ~3sec-8min depending on RTO.
82                                  */
83
84 #define TCP_RETR2       15      /*
85                                  * This should take at least
86                                  * 90 minutes to time out.
87                                  * RFC1122 says that the limit is 100 sec.
88                                  * 15 is ~13-30min depending on RTO.
89                                  */
90
91 #define TCP_SYN_RETRIES  5      /* number of times to retry active opening a
92                                  * connection: ~180sec is RFC minumum   */
93
94 #define TCP_SYNACK_RETRIES 5    /* number of times to retry passive opening a
95                                  * connection: ~180sec is RFC minumum   */
96
97
98 #define TCP_ORPHAN_RETRIES 7    /* number of times to retry on an orphaned
99                                  * socket. 7 is ~50sec-16min.
100                                  */
101
102
103 #define TCP_TIMEWAIT_LEN (60*HZ) /* how long to wait to destroy TIME-WAIT
104                                   * state, about 60 seconds     */
105 #define TCP_FIN_TIMEOUT TCP_TIMEWAIT_LEN
106                                  /* BSD style FIN_WAIT2 deadlock breaker.
107                                   * It used to be 3min, new value is 60sec,
108                                   * to combine FIN-WAIT-2 timeout with
109                                   * TIME-WAIT timer.
110                                   */
111
112 #define TCP_DELACK_MAX  ((unsigned)(HZ/5))      /* maximal time to delay before sending an ACK */
113 #if HZ >= 100
114 #define TCP_DELACK_MIN  ((unsigned)(HZ/25))     /* minimal time to delay before sending an ACK */
115 #define TCP_ATO_MIN     ((unsigned)(HZ/25))
116 #else
117 #define TCP_DELACK_MIN  4U
118 #define TCP_ATO_MIN     4U
119 #endif
120 #define TCP_RTO_MAX     ((unsigned)(120*HZ))
121 #define TCP_RTO_MIN     ((unsigned)(HZ/5))
122 #define TCP_TIMEOUT_INIT ((unsigned)(3*HZ))     /* RFC 1122 initial RTO value   */
123
124 #define TCP_RESOURCE_PROBE_INTERVAL ((unsigned)(HZ/2U)) /* Maximal interval between probes
125                                                          * for local resources.
126                                                          */
127
128 #define TCP_KEEPALIVE_TIME      (120*60*HZ)     /* two hours */
129 #define TCP_KEEPALIVE_PROBES    9               /* Max of 9 keepalive probes    */
130 #define TCP_KEEPALIVE_INTVL     (75*HZ)
131
132 #define MAX_TCP_KEEPIDLE        32767
133 #define MAX_TCP_KEEPINTVL       32767
134 #define MAX_TCP_KEEPCNT         127
135 #define MAX_TCP_SYNCNT          127
136
137 #define TCP_SYNQ_INTERVAL       (HZ/5)  /* Period of SYNACK timer */
138 #define TCP_SYNQ_HSIZE          512     /* Size of SYNACK hash table */
139
140 #define TCP_PAWS_24DAYS (60 * 60 * 24 * 24)
141 #define TCP_PAWS_MSL    60              /* Per-host timestamps are invalidated
142                                          * after this time. It should be equal
143                                          * (or greater than) TCP_TIMEWAIT_LEN
144                                          * to provide reliability equal to one
145                                          * provided by timewait state.
146                                          */
147 #define TCP_PAWS_WINDOW 1               /* Replay window for per-host
148                                          * timestamps. It must be less than
149                                          * minimal timewait lifetime.
150                                          */
151 /*
152  *      TCP option
153  */
154  
155 #define TCPOPT_NOP              1       /* Padding */
156 #define TCPOPT_EOL              0       /* End of options */
157 #define TCPOPT_MSS              2       /* Segment size negotiating */
158 #define TCPOPT_WINDOW           3       /* Window scaling */
159 #define TCPOPT_SACK_PERM        4       /* SACK Permitted */
160 #define TCPOPT_SACK             5       /* SACK Block */
161 #define TCPOPT_TIMESTAMP        8       /* Better RTT estimations/PAWS */
162
163 /*
164  *     TCP option lengths
165  */
166
167 #define TCPOLEN_MSS            4
168 #define TCPOLEN_WINDOW         3
169 #define TCPOLEN_SACK_PERM      2
170 #define TCPOLEN_TIMESTAMP      10
171
172 /* But this is what stacks really send out. */
173 #define TCPOLEN_TSTAMP_ALIGNED          12
174 #define TCPOLEN_WSCALE_ALIGNED          4
175 #define TCPOLEN_SACKPERM_ALIGNED        4
176 #define TCPOLEN_SACK_BASE               2
177 #define TCPOLEN_SACK_BASE_ALIGNED       4
178 #define TCPOLEN_SACK_PERBLOCK           8
179
180 /* Flags in tp->nonagle */
181 #define TCP_NAGLE_OFF           1       /* Nagle's algo is disabled */
182 #define TCP_NAGLE_CORK          2       /* Socket is corked         */
183 #define TCP_NAGLE_PUSH          4       /* Cork is overriden for already queued data */
184
185 extern struct inet_timewait_death_row tcp_death_row;
186
187 /* sysctl variables for tcp */
188 extern int sysctl_tcp_timestamps;
189 extern int sysctl_tcp_window_scaling;
190 extern int sysctl_tcp_sack;
191 extern int sysctl_tcp_fin_timeout;
192 extern int sysctl_tcp_keepalive_time;
193 extern int sysctl_tcp_keepalive_probes;
194 extern int sysctl_tcp_keepalive_intvl;
195 extern int sysctl_tcp_syn_retries;
196 extern int sysctl_tcp_synack_retries;
197 extern int sysctl_tcp_retries1;
198 extern int sysctl_tcp_retries2;
199 extern int sysctl_tcp_orphan_retries;
200 extern int sysctl_tcp_syncookies;
201 extern int sysctl_tcp_retrans_collapse;
202 extern int sysctl_tcp_stdurg;
203 extern int sysctl_tcp_rfc1337;
204 extern int sysctl_tcp_abort_on_overflow;
205 extern int sysctl_tcp_max_orphans;
206 extern int sysctl_tcp_fack;
207 extern int sysctl_tcp_reordering;
208 extern int sysctl_tcp_ecn;
209 extern int sysctl_tcp_dsack;
210 extern int sysctl_tcp_mem[3];
211 extern int sysctl_tcp_wmem[3];
212 extern int sysctl_tcp_rmem[3];
213 extern int sysctl_tcp_app_win;
214 extern int sysctl_tcp_adv_win_scale;
215 extern int sysctl_tcp_tw_reuse;
216 extern int sysctl_tcp_frto;
217 extern int sysctl_tcp_low_latency;
218 extern int sysctl_tcp_nometrics_save;
219 extern int sysctl_tcp_moderate_rcvbuf;
220 extern int sysctl_tcp_tso_win_divisor;
221 extern int sysctl_tcp_abc;
222
223 extern atomic_t tcp_memory_allocated;
224 extern atomic_t tcp_sockets_allocated;
225 extern int tcp_memory_pressure;
226
227 /*
228  *      Pointers to address related TCP functions
229  *      (i.e. things that depend on the address family)
230  */
231
232 struct tcp_func {
233         int                     (*queue_xmit)           (struct sk_buff *skb,
234                                                          int ipfragok);
235
236         void                    (*send_check)           (struct sock *sk,
237                                                          struct tcphdr *th,
238                                                          int len,
239                                                          struct sk_buff *skb);
240
241         int                     (*rebuild_header)       (struct sock *sk);
242
243         int                     (*conn_request)         (struct sock *sk,
244                                                          struct sk_buff *skb);
245
246         struct sock *           (*syn_recv_sock)        (struct sock *sk,
247                                                          struct sk_buff *skb,
248                                                          struct request_sock *req,
249                                                          struct dst_entry *dst);
250     
251         int                     (*remember_stamp)       (struct sock *sk);
252
253         __u16                   net_header_len;
254
255         int                     (*setsockopt)           (struct sock *sk, 
256                                                          int level, 
257                                                          int optname, 
258                                                          char __user *optval, 
259                                                          int optlen);
260
261         int                     (*getsockopt)           (struct sock *sk, 
262                                                          int level, 
263                                                          int optname, 
264                                                          char __user *optval, 
265                                                          int __user *optlen);
266
267
268         void                    (*addr2sockaddr)        (struct sock *sk,
269                                                          struct sockaddr *);
270
271         int sockaddr_len;
272 };
273
274 /*
275  * The next routines deal with comparing 32 bit unsigned ints
276  * and worry about wraparound (automatic with unsigned arithmetic).
277  */
278
279 static inline int before(__u32 seq1, __u32 seq2)
280 {
281         return (__s32)(seq1-seq2) < 0;
282 }
283
284 static inline int after(__u32 seq1, __u32 seq2)
285 {
286         return (__s32)(seq2-seq1) < 0;
287 }
288
289
290 /* is s2<=s1<=s3 ? */
291 static inline int between(__u32 seq1, __u32 seq2, __u32 seq3)
292 {
293         return seq3 - seq2 >= seq1 - seq2;
294 }
295
296
297 extern struct proto tcp_prot;
298
299 DECLARE_SNMP_STAT(struct tcp_mib, tcp_statistics);
300 #define TCP_INC_STATS(field)            SNMP_INC_STATS(tcp_statistics, field)
301 #define TCP_INC_STATS_BH(field)         SNMP_INC_STATS_BH(tcp_statistics, field)
302 #define TCP_INC_STATS_USER(field)       SNMP_INC_STATS_USER(tcp_statistics, field)
303 #define TCP_DEC_STATS(field)            SNMP_DEC_STATS(tcp_statistics, field)
304 #define TCP_ADD_STATS_BH(field, val)    SNMP_ADD_STATS_BH(tcp_statistics, field, val)
305 #define TCP_ADD_STATS_USER(field, val)  SNMP_ADD_STATS_USER(tcp_statistics, field, val)
306
307 extern void                     tcp_v4_err(struct sk_buff *skb, u32);
308
309 extern void                     tcp_shutdown (struct sock *sk, int how);
310
311 extern int                      tcp_v4_rcv(struct sk_buff *skb);
312
313 extern int                      tcp_v4_remember_stamp(struct sock *sk);
314
315 extern int                      tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw);
316
317 extern int                      tcp_sendmsg(struct kiocb *iocb, struct sock *sk,
318                                             struct msghdr *msg, size_t size);
319 extern ssize_t                  tcp_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags);
320
321 extern int                      tcp_ioctl(struct sock *sk, 
322                                           int cmd, 
323                                           unsigned long arg);
324
325 extern int                      tcp_rcv_state_process(struct sock *sk, 
326                                                       struct sk_buff *skb,
327                                                       struct tcphdr *th,
328                                                       unsigned len);
329
330 extern int                      tcp_rcv_established(struct sock *sk, 
331                                                     struct sk_buff *skb,
332                                                     struct tcphdr *th, 
333                                                     unsigned len);
334
335 extern void                     tcp_rcv_space_adjust(struct sock *sk);
336
337 static inline void tcp_dec_quickack_mode(struct sock *sk,
338                                          const unsigned int pkts)
339 {
340         struct inet_connection_sock *icsk = inet_csk(sk);
341
342         if (icsk->icsk_ack.quick) {
343                 if (pkts >= icsk->icsk_ack.quick) {
344                         icsk->icsk_ack.quick = 0;
345                         /* Leaving quickack mode we deflate ATO. */
346                         icsk->icsk_ack.ato   = TCP_ATO_MIN;
347                 } else
348                         icsk->icsk_ack.quick -= pkts;
349         }
350 }
351
352 extern void tcp_enter_quickack_mode(struct sock *sk);
353
354 static inline void tcp_clear_options(struct tcp_options_received *rx_opt)
355 {
356         rx_opt->tstamp_ok = rx_opt->sack_ok = rx_opt->wscale_ok = rx_opt->snd_wscale = 0;
357 }
358
359 enum tcp_tw_status
360 {
361         TCP_TW_SUCCESS = 0,
362         TCP_TW_RST = 1,
363         TCP_TW_ACK = 2,
364         TCP_TW_SYN = 3
365 };
366
367
368 extern enum tcp_tw_status       tcp_timewait_state_process(struct inet_timewait_sock *tw,
369                                                            struct sk_buff *skb,
370                                                            const struct tcphdr *th);
371
372 extern struct sock *            tcp_check_req(struct sock *sk,struct sk_buff *skb,
373                                               struct request_sock *req,
374                                               struct request_sock **prev);
375 extern int                      tcp_child_process(struct sock *parent,
376                                                   struct sock *child,
377                                                   struct sk_buff *skb);
378 extern void                     tcp_enter_frto(struct sock *sk);
379 extern void                     tcp_enter_loss(struct sock *sk, int how);
380 extern void                     tcp_clear_retrans(struct tcp_sock *tp);
381 extern void                     tcp_update_metrics(struct sock *sk);
382
383 extern void                     tcp_close(struct sock *sk, 
384                                           long timeout);
385 extern unsigned int             tcp_poll(struct file * file, struct socket *sock, struct poll_table_struct *wait);
386
387 extern int                      tcp_getsockopt(struct sock *sk, int level, 
388                                                int optname,
389                                                char __user *optval, 
390                                                int __user *optlen);
391 extern int                      tcp_setsockopt(struct sock *sk, int level, 
392                                                int optname, char __user *optval, 
393                                                int optlen);
394 extern void                     tcp_set_keepalive(struct sock *sk, int val);
395 extern int                      tcp_recvmsg(struct kiocb *iocb, struct sock *sk,
396                                             struct msghdr *msg,
397                                             size_t len, int nonblock, 
398                                             int flags, int *addr_len);
399
400 extern void                     tcp_parse_options(struct sk_buff *skb,
401                                                   struct tcp_options_received *opt_rx,
402                                                   int estab);
403
404 /*
405  *      TCP v4 functions exported for the inet6 API
406  */
407
408 extern void                     tcp_v4_send_check(struct sock *sk, 
409                                                   struct tcphdr *th, int len, 
410                                                   struct sk_buff *skb);
411
412 extern int                      tcp_v4_conn_request(struct sock *sk,
413                                                     struct sk_buff *skb);
414
415 extern struct sock *            tcp_create_openreq_child(struct sock *sk,
416                                                          struct request_sock *req,
417                                                          struct sk_buff *skb);
418
419 extern struct sock *            tcp_v4_syn_recv_sock(struct sock *sk,
420                                                      struct sk_buff *skb,
421                                                      struct request_sock *req,
422                                                         struct dst_entry *dst);
423
424 extern int                      tcp_v4_do_rcv(struct sock *sk,
425                                               struct sk_buff *skb);
426
427 extern int                      tcp_v4_connect(struct sock *sk,
428                                                struct sockaddr *uaddr,
429                                                int addr_len);
430
431 extern int                      tcp_connect(struct sock *sk);
432
433 extern struct sk_buff *         tcp_make_synack(struct sock *sk,
434                                                 struct dst_entry *dst,
435                                                 struct request_sock *req);
436
437 extern int                      tcp_disconnect(struct sock *sk, int flags);
438
439 extern void                     tcp_unhash(struct sock *sk);
440
441 extern int                      tcp_v4_hash_connecting(struct sock *sk);
442
443
444 /* From syncookies.c */
445 extern struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb, 
446                                     struct ip_options *opt);
447 extern __u32 cookie_v4_init_sequence(struct sock *sk, struct sk_buff *skb, 
448                                      __u16 *mss);
449
450 /* tcp_output.c */
451
452 extern void __tcp_push_pending_frames(struct sock *sk, struct tcp_sock *tp,
453                                       unsigned int cur_mss, int nonagle);
454 extern int tcp_may_send_now(struct sock *sk, struct tcp_sock *tp);
455 extern int tcp_retransmit_skb(struct sock *, struct sk_buff *);
456 extern void tcp_xmit_retransmit_queue(struct sock *);
457 extern void tcp_simple_retransmit(struct sock *);
458 extern int tcp_trim_head(struct sock *, struct sk_buff *, u32);
459 extern int tcp_fragment(struct sock *, struct sk_buff *, u32, unsigned int);
460
461 extern void tcp_send_probe0(struct sock *);
462 extern void tcp_send_partial(struct sock *);
463 extern int  tcp_write_wakeup(struct sock *);
464 extern void tcp_send_fin(struct sock *sk);
465 extern void tcp_send_active_reset(struct sock *sk, gfp_t priority);
466 extern int  tcp_send_synack(struct sock *);
467 extern void tcp_push_one(struct sock *, unsigned int mss_now);
468 extern void tcp_send_ack(struct sock *sk);
469 extern void tcp_send_delayed_ack(struct sock *sk);
470
471 /* tcp_input.c */
472 extern void tcp_cwnd_application_limited(struct sock *sk);
473
474 /* tcp_timer.c */
475 extern void tcp_init_xmit_timers(struct sock *);
476 static inline void tcp_clear_xmit_timers(struct sock *sk)
477 {
478         inet_csk_clear_xmit_timers(sk);
479 }
480
481 extern unsigned int tcp_sync_mss(struct sock *sk, u32 pmtu);
482 extern unsigned int tcp_current_mss(struct sock *sk, int large);
483
484 /* tcp.c */
485 extern void tcp_get_info(struct sock *, struct tcp_info *);
486
487 /* Read 'sendfile()'-style from a TCP socket */
488 typedef int (*sk_read_actor_t)(read_descriptor_t *, struct sk_buff *,
489                                 unsigned int, size_t);
490 extern int tcp_read_sock(struct sock *sk, read_descriptor_t *desc,
491                          sk_read_actor_t recv_actor);
492
493 /* Initialize RCV_MSS value.
494  * RCV_MSS is an our guess about MSS used by the peer.
495  * We haven't any direct information about the MSS.
496  * It's better to underestimate the RCV_MSS rather than overestimate.
497  * Overestimations make us ACKing less frequently than needed.
498  * Underestimations are more easy to detect and fix by tcp_measure_rcv_mss().
499  */
500
501 static inline void tcp_initialize_rcv_mss(struct sock *sk)
502 {
503         struct tcp_sock *tp = tcp_sk(sk);
504         unsigned int hint = min_t(unsigned int, tp->advmss, tp->mss_cache);
505
506         hint = min(hint, tp->rcv_wnd/2);
507         hint = min(hint, TCP_MIN_RCVMSS);
508         hint = max(hint, TCP_MIN_MSS);
509
510         inet_csk(sk)->icsk_ack.rcv_mss = hint;
511 }
512
513 static __inline__ void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd)
514 {
515         tp->pred_flags = htonl((tp->tcp_header_len << 26) |
516                                ntohl(TCP_FLAG_ACK) |
517                                snd_wnd);
518 }
519
520 static __inline__ void tcp_fast_path_on(struct tcp_sock *tp)
521 {
522         __tcp_fast_path_on(tp, tp->snd_wnd >> tp->rx_opt.snd_wscale);
523 }
524
525 static inline void tcp_fast_path_check(struct sock *sk, struct tcp_sock *tp)
526 {
527         if (skb_queue_empty(&tp->out_of_order_queue) &&
528             tp->rcv_wnd &&
529             atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf &&
530             !tp->urg_data)
531                 tcp_fast_path_on(tp);
532 }
533
534 /* Compute the actual receive window we are currently advertising.
535  * Rcv_nxt can be after the window if our peer push more data
536  * than the offered window.
537  */
538 static __inline__ u32 tcp_receive_window(const struct tcp_sock *tp)
539 {
540         s32 win = tp->rcv_wup + tp->rcv_wnd - tp->rcv_nxt;
541
542         if (win < 0)
543                 win = 0;
544         return (u32) win;
545 }
546
547 /* Choose a new window, without checks for shrinking, and without
548  * scaling applied to the result.  The caller does these things
549  * if necessary.  This is a "raw" window selection.
550  */
551 extern u32      __tcp_select_window(struct sock *sk);
552
553 /* TCP timestamps are only 32-bits, this causes a slight
554  * complication on 64-bit systems since we store a snapshot
555  * of jiffies in the buffer control blocks below.  We decidely
556  * only use of the low 32-bits of jiffies and hide the ugly
557  * casts with the following macro.
558  */
559 #define tcp_time_stamp          ((__u32)(jiffies))
560
561 /* This is what the send packet queueing engine uses to pass
562  * TCP per-packet control information to the transmission
563  * code.  We also store the host-order sequence numbers in
564  * here too.  This is 36 bytes on 32-bit architectures,
565  * 40 bytes on 64-bit machines, if this grows please adjust
566  * skbuff.h:skbuff->cb[xxx] size appropriately.
567  */
568 struct tcp_skb_cb {
569         union {
570                 struct inet_skb_parm    h4;
571 #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
572                 struct inet6_skb_parm   h6;
573 #endif
574         } header;       /* For incoming frames          */
575         __u32           seq;            /* Starting sequence number     */
576         __u32           end_seq;        /* SEQ + FIN + SYN + datalen    */
577         __u32           when;           /* used to compute rtt's        */
578         __u8            flags;          /* TCP header flags.            */
579
580         /* NOTE: These must match up to the flags byte in a
581          *       real TCP header.
582          */
583 #define TCPCB_FLAG_FIN          0x01
584 #define TCPCB_FLAG_SYN          0x02
585 #define TCPCB_FLAG_RST          0x04
586 #define TCPCB_FLAG_PSH          0x08
587 #define TCPCB_FLAG_ACK          0x10
588 #define TCPCB_FLAG_URG          0x20
589 #define TCPCB_FLAG_ECE          0x40
590 #define TCPCB_FLAG_CWR          0x80
591
592         __u8            sacked;         /* State flags for SACK/FACK.   */
593 #define TCPCB_SACKED_ACKED      0x01    /* SKB ACK'd by a SACK block    */
594 #define TCPCB_SACKED_RETRANS    0x02    /* SKB retransmitted            */
595 #define TCPCB_LOST              0x04    /* SKB is lost                  */
596 #define TCPCB_TAGBITS           0x07    /* All tag bits                 */
597
598 #define TCPCB_EVER_RETRANS      0x80    /* Ever retransmitted frame     */
599 #define TCPCB_RETRANS           (TCPCB_SACKED_RETRANS|TCPCB_EVER_RETRANS)
600
601 #define TCPCB_URG               0x20    /* Urgent pointer advenced here */
602
603 #define TCPCB_AT_TAIL           (TCPCB_URG)
604
605         __u16           urg_ptr;        /* Valid w/URG flags is set.    */
606         __u32           ack_seq;        /* Sequence number ACK'd        */
607 };
608
609 #define TCP_SKB_CB(__skb)       ((struct tcp_skb_cb *)&((__skb)->cb[0]))
610
611 #include <net/tcp_ecn.h>
612
613 /* Due to TSO, an SKB can be composed of multiple actual
614  * packets.  To keep these tracked properly, we use this.
615  */
616 static inline int tcp_skb_pcount(const struct sk_buff *skb)
617 {
618         return skb_shinfo(skb)->tso_segs;
619 }
620
621 /* This is valid iff tcp_skb_pcount() > 1. */
622 static inline int tcp_skb_mss(const struct sk_buff *skb)
623 {
624         return skb_shinfo(skb)->tso_size;
625 }
626
627 static inline void tcp_dec_pcount_approx(__u32 *count,
628                                          const struct sk_buff *skb)
629 {
630         if (*count) {
631                 *count -= tcp_skb_pcount(skb);
632                 if ((int)*count < 0)
633                         *count = 0;
634         }
635 }
636
637 static inline void tcp_packets_out_inc(struct sock *sk, 
638                                        struct tcp_sock *tp,
639                                        const struct sk_buff *skb)
640 {
641         int orig = tp->packets_out;
642
643         tp->packets_out += tcp_skb_pcount(skb);
644         if (!orig)
645                 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
646                                           inet_csk(sk)->icsk_rto, TCP_RTO_MAX);
647 }
648
649 static inline void tcp_packets_out_dec(struct tcp_sock *tp, 
650                                        const struct sk_buff *skb)
651 {
652         tp->packets_out -= tcp_skb_pcount(skb);
653 }
654
655 /* Events passed to congestion control interface */
656 enum tcp_ca_event {
657         CA_EVENT_TX_START,      /* first transmit when no packets in flight */
658         CA_EVENT_CWND_RESTART,  /* congestion window restart */
659         CA_EVENT_COMPLETE_CWR,  /* end of congestion recovery */
660         CA_EVENT_FRTO,          /* fast recovery timeout */
661         CA_EVENT_LOSS,          /* loss timeout */
662         CA_EVENT_FAST_ACK,      /* in sequence ack */
663         CA_EVENT_SLOW_ACK,      /* other ack */
664 };
665
666 /*
667  * Interface for adding new TCP congestion control handlers
668  */
669 #define TCP_CA_NAME_MAX 16
670 struct tcp_congestion_ops {
671         struct list_head        list;
672
673         /* initialize private data (optional) */
674         void (*init)(struct sock *sk);
675         /* cleanup private data  (optional) */
676         void (*release)(struct sock *sk);
677
678         /* return slow start threshold (required) */
679         u32 (*ssthresh)(struct sock *sk);
680         /* lower bound for congestion window (optional) */
681         u32 (*min_cwnd)(struct sock *sk);
682         /* do new cwnd calculation (required) */
683         void (*cong_avoid)(struct sock *sk, u32 ack,
684                            u32 rtt, u32 in_flight, int good_ack);
685         /* round trip time sample per acked packet (optional) */
686         void (*rtt_sample)(struct sock *sk, u32 usrtt);
687         /* call before changing ca_state (optional) */
688         void (*set_state)(struct sock *sk, u8 new_state);
689         /* call when cwnd event occurs (optional) */
690         void (*cwnd_event)(struct sock *sk, enum tcp_ca_event ev);
691         /* new value of cwnd after loss (optional) */
692         u32  (*undo_cwnd)(struct sock *sk);
693         /* hook for packet ack accounting (optional) */
694         void (*pkts_acked)(struct sock *sk, u32 num_acked);
695         /* get info for inet_diag (optional) */
696         void (*get_info)(struct sock *sk, u32 ext, struct sk_buff *skb);
697
698         char            name[TCP_CA_NAME_MAX];
699         struct module   *owner;
700 };
701
702 extern int tcp_register_congestion_control(struct tcp_congestion_ops *type);
703 extern void tcp_unregister_congestion_control(struct tcp_congestion_ops *type);
704
705 extern void tcp_init_congestion_control(struct sock *sk);
706 extern void tcp_cleanup_congestion_control(struct sock *sk);
707 extern int tcp_set_default_congestion_control(const char *name);
708 extern void tcp_get_default_congestion_control(char *name);
709 extern int tcp_set_congestion_control(struct sock *sk, const char *name);
710
711 extern struct tcp_congestion_ops tcp_init_congestion_ops;
712 extern u32 tcp_reno_ssthresh(struct sock *sk);
713 extern void tcp_reno_cong_avoid(struct sock *sk, u32 ack,
714                                 u32 rtt, u32 in_flight, int flag);
715 extern u32 tcp_reno_min_cwnd(struct sock *sk);
716 extern struct tcp_congestion_ops tcp_reno;
717
718 static inline void tcp_set_ca_state(struct sock *sk, const u8 ca_state)
719 {
720         struct inet_connection_sock *icsk = inet_csk(sk);
721
722         if (icsk->icsk_ca_ops->set_state)
723                 icsk->icsk_ca_ops->set_state(sk, ca_state);
724         icsk->icsk_ca_state = ca_state;
725 }
726
727 static inline void tcp_ca_event(struct sock *sk, const enum tcp_ca_event event)
728 {
729         const struct inet_connection_sock *icsk = inet_csk(sk);
730
731         if (icsk->icsk_ca_ops->cwnd_event)
732                 icsk->icsk_ca_ops->cwnd_event(sk, event);
733 }
734
735 /* This determines how many packets are "in the network" to the best
736  * of our knowledge.  In many cases it is conservative, but where
737  * detailed information is available from the receiver (via SACK
738  * blocks etc.) we can make more aggressive calculations.
739  *
740  * Use this for decisions involving congestion control, use just
741  * tp->packets_out to determine if the send queue is empty or not.
742  *
743  * Read this equation as:
744  *
745  *      "Packets sent once on transmission queue" MINUS
746  *      "Packets left network, but not honestly ACKed yet" PLUS
747  *      "Packets fast retransmitted"
748  */
749 static __inline__ unsigned int tcp_packets_in_flight(const struct tcp_sock *tp)
750 {
751         return (tp->packets_out - tp->left_out + tp->retrans_out);
752 }
753
754 /* If cwnd > ssthresh, we may raise ssthresh to be half-way to cwnd.
755  * The exception is rate halving phase, when cwnd is decreasing towards
756  * ssthresh.
757  */
758 static inline __u32 tcp_current_ssthresh(const struct sock *sk)
759 {
760         const struct tcp_sock *tp = tcp_sk(sk);
761         if ((1 << inet_csk(sk)->icsk_ca_state) & (TCPF_CA_CWR | TCPF_CA_Recovery))
762                 return tp->snd_ssthresh;
763         else
764                 return max(tp->snd_ssthresh,
765                            ((tp->snd_cwnd >> 1) +
766                             (tp->snd_cwnd >> 2)));
767 }
768
769 /*
770  * Linear increase during slow start
771  */
772 static inline void tcp_slow_start(struct tcp_sock *tp)
773 {
774         if (sysctl_tcp_abc) {
775                 /* RFC3465: Slow Start
776                  * TCP sender SHOULD increase cwnd by the number of
777                  * previously unacknowledged bytes ACKed by each incoming
778                  * acknowledgment, provided the increase is not more than L
779                  */
780                 if (tp->bytes_acked < tp->mss_cache)
781                         return;
782
783                 /* We MAY increase by 2 if discovered delayed ack */
784                 if (sysctl_tcp_abc > 1 && tp->bytes_acked > 2*tp->mss_cache) {
785                         if (tp->snd_cwnd < tp->snd_cwnd_clamp)
786                                 tp->snd_cwnd++;
787                 }
788         }
789         tp->bytes_acked = 0;
790
791         if (tp->snd_cwnd < tp->snd_cwnd_clamp)
792                 tp->snd_cwnd++;
793 }
794
795
796 static inline void tcp_sync_left_out(struct tcp_sock *tp)
797 {
798         if (tp->rx_opt.sack_ok &&
799             (tp->sacked_out >= tp->packets_out - tp->lost_out))
800                 tp->sacked_out = tp->packets_out - tp->lost_out;
801         tp->left_out = tp->sacked_out + tp->lost_out;
802 }
803
804 /* Set slow start threshold and cwnd not falling to slow start */
805 static inline void __tcp_enter_cwr(struct sock *sk)
806 {
807         const struct inet_connection_sock *icsk = inet_csk(sk);
808         struct tcp_sock *tp = tcp_sk(sk);
809
810         tp->undo_marker = 0;
811         tp->snd_ssthresh = icsk->icsk_ca_ops->ssthresh(sk);
812         tp->snd_cwnd = min(tp->snd_cwnd,
813                            tcp_packets_in_flight(tp) + 1U);
814         tp->snd_cwnd_cnt = 0;
815         tp->high_seq = tp->snd_nxt;
816         tp->snd_cwnd_stamp = tcp_time_stamp;
817         TCP_ECN_queue_cwr(tp);
818 }
819
820 static inline void tcp_enter_cwr(struct sock *sk)
821 {
822         struct tcp_sock *tp = tcp_sk(sk);
823
824         tp->prior_ssthresh = 0;
825         tp->bytes_acked = 0;
826         if (inet_csk(sk)->icsk_ca_state < TCP_CA_CWR) {
827                 __tcp_enter_cwr(sk);
828                 tcp_set_ca_state(sk, TCP_CA_CWR);
829         }
830 }
831
832 extern __u32 tcp_init_cwnd(struct tcp_sock *tp, struct dst_entry *dst);
833
834 /* Slow start with delack produces 3 packets of burst, so that
835  * it is safe "de facto".
836  */
837 static __inline__ __u32 tcp_max_burst(const struct tcp_sock *tp)
838 {
839         return 3;
840 }
841
842 /* RFC2861 Check whether we are limited by application or congestion window
843  * This is the inverse of cwnd check in tcp_tso_should_defer
844  */
845 static inline int tcp_is_cwnd_limited(const struct sock *sk, u32 in_flight)
846 {
847         const struct tcp_sock *tp = tcp_sk(sk);
848         u32 left;
849
850         if (in_flight >= tp->snd_cwnd)
851                 return 1;
852
853         if (!(sk->sk_route_caps & NETIF_F_TSO))
854                 return 0;
855
856         left = tp->snd_cwnd - in_flight;
857         if (sysctl_tcp_tso_win_divisor)
858                 return left * sysctl_tcp_tso_win_divisor < tp->snd_cwnd;
859         else
860                 return left <= tcp_max_burst(tp);
861 }
862
863 static __inline__ void tcp_minshall_update(struct tcp_sock *tp, int mss, 
864                                            const struct sk_buff *skb)
865 {
866         if (skb->len < mss)
867                 tp->snd_sml = TCP_SKB_CB(skb)->end_seq;
868 }
869
870 static __inline__ void tcp_check_probe_timer(struct sock *sk, struct tcp_sock *tp)
871 {
872         const struct inet_connection_sock *icsk = inet_csk(sk);
873         if (!tp->packets_out && !icsk->icsk_pending)
874                 inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0,
875                                           icsk->icsk_rto, TCP_RTO_MAX);
876 }
877
878 static __inline__ void tcp_push_pending_frames(struct sock *sk,
879                                                struct tcp_sock *tp)
880 {
881         __tcp_push_pending_frames(sk, tp, tcp_current_mss(sk, 1), tp->nonagle);
882 }
883
884 static __inline__ void tcp_init_wl(struct tcp_sock *tp, u32 ack, u32 seq)
885 {
886         tp->snd_wl1 = seq;
887 }
888
889 static __inline__ void tcp_update_wl(struct tcp_sock *tp, u32 ack, u32 seq)
890 {
891         tp->snd_wl1 = seq;
892 }
893
894 /*
895  * Calculate(/check) TCP checksum
896  */
897 static __inline__ u16 tcp_v4_check(struct tcphdr *th, int len,
898                                    unsigned long saddr, unsigned long daddr, 
899                                    unsigned long base)
900 {
901         return csum_tcpudp_magic(saddr,daddr,len,IPPROTO_TCP,base);
902 }
903
904 static __inline__ int __tcp_checksum_complete(struct sk_buff *skb)
905 {
906         return __skb_checksum_complete(skb);
907 }
908
909 static __inline__ int tcp_checksum_complete(struct sk_buff *skb)
910 {
911         return skb->ip_summed != CHECKSUM_UNNECESSARY &&
912                 __tcp_checksum_complete(skb);
913 }
914
915 /* Prequeue for VJ style copy to user, combined with checksumming. */
916
917 static __inline__ void tcp_prequeue_init(struct tcp_sock *tp)
918 {
919         tp->ucopy.task = NULL;
920         tp->ucopy.len = 0;
921         tp->ucopy.memory = 0;
922         skb_queue_head_init(&tp->ucopy.prequeue);
923 }
924
925 /* Packet is added to VJ-style prequeue for processing in process
926  * context, if a reader task is waiting. Apparently, this exciting
927  * idea (VJ's mail "Re: query about TCP header on tcp-ip" of 07 Sep 93)
928  * failed somewhere. Latency? Burstiness? Well, at least now we will
929  * see, why it failed. 8)8)                               --ANK
930  *
931  * NOTE: is this not too big to inline?
932  */
933 static __inline__ int tcp_prequeue(struct sock *sk, struct sk_buff *skb)
934 {
935         struct tcp_sock *tp = tcp_sk(sk);
936
937         if (!sysctl_tcp_low_latency && tp->ucopy.task) {
938                 __skb_queue_tail(&tp->ucopy.prequeue, skb);
939                 tp->ucopy.memory += skb->truesize;
940                 if (tp->ucopy.memory > sk->sk_rcvbuf) {
941                         struct sk_buff *skb1;
942
943                         BUG_ON(sock_owned_by_user(sk));
944
945                         while ((skb1 = __skb_dequeue(&tp->ucopy.prequeue)) != NULL) {
946                                 sk->sk_backlog_rcv(sk, skb1);
947                                 NET_INC_STATS_BH(LINUX_MIB_TCPPREQUEUEDROPPED);
948                         }
949
950                         tp->ucopy.memory = 0;
951                 } else if (skb_queue_len(&tp->ucopy.prequeue) == 1) {
952                         wake_up_interruptible(sk->sk_sleep);
953                         if (!inet_csk_ack_scheduled(sk))
954                                 inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
955                                                           (3 * TCP_RTO_MIN) / 4,
956                                                           TCP_RTO_MAX);
957                 }
958                 return 1;
959         }
960         return 0;
961 }
962
963
964 #undef STATE_TRACE
965
966 #ifdef STATE_TRACE
967 static const char *statename[]={
968         "Unused","Established","Syn Sent","Syn Recv",
969         "Fin Wait 1","Fin Wait 2","Time Wait", "Close",
970         "Close Wait","Last ACK","Listen","Closing"
971 };
972 #endif
973
974 static __inline__ void tcp_set_state(struct sock *sk, int state)
975 {
976         int oldstate = sk->sk_state;
977
978         switch (state) {
979         case TCP_ESTABLISHED:
980                 if (oldstate != TCP_ESTABLISHED)
981                         TCP_INC_STATS(TCP_MIB_CURRESTAB);
982                 break;
983
984         case TCP_CLOSE:
985                 if (oldstate == TCP_CLOSE_WAIT || oldstate == TCP_ESTABLISHED)
986                         TCP_INC_STATS(TCP_MIB_ESTABRESETS);
987
988                 sk->sk_prot->unhash(sk);
989                 if (inet_csk(sk)->icsk_bind_hash &&
990                     !(sk->sk_userlocks & SOCK_BINDPORT_LOCK))
991                         inet_put_port(&tcp_hashinfo, sk);
992                 /* fall through */
993         default:
994                 if (oldstate==TCP_ESTABLISHED)
995                         TCP_DEC_STATS(TCP_MIB_CURRESTAB);
996         }
997
998         /* Change state AFTER socket is unhashed to avoid closed
999          * socket sitting in hash tables.
1000          */
1001         sk->sk_state = state;
1002
1003 #ifdef STATE_TRACE
1004         SOCK_DEBUG(sk, "TCP sk=%p, State %s -> %s\n",sk, statename[oldstate],statename[state]);
1005 #endif  
1006 }
1007
1008 static __inline__ void tcp_done(struct sock *sk)
1009 {
1010         tcp_set_state(sk, TCP_CLOSE);
1011         tcp_clear_xmit_timers(sk);
1012
1013         sk->sk_shutdown = SHUTDOWN_MASK;
1014
1015         if (!sock_flag(sk, SOCK_DEAD))
1016                 sk->sk_state_change(sk);
1017         else
1018                 inet_csk_destroy_sock(sk);
1019 }
1020
1021 static __inline__ void tcp_sack_reset(struct tcp_options_received *rx_opt)
1022 {
1023         rx_opt->dsack = 0;
1024         rx_opt->eff_sacks = 0;
1025         rx_opt->num_sacks = 0;
1026 }
1027
1028 static __inline__ void tcp_build_and_update_options(__u32 *ptr, struct tcp_sock *tp, __u32 tstamp)
1029 {
1030         if (tp->rx_opt.tstamp_ok) {
1031                 *ptr++ = __constant_htonl((TCPOPT_NOP << 24) |
1032                                           (TCPOPT_NOP << 16) |
1033                                           (TCPOPT_TIMESTAMP << 8) |
1034                                           TCPOLEN_TIMESTAMP);
1035                 *ptr++ = htonl(tstamp);
1036                 *ptr++ = htonl(tp->rx_opt.ts_recent);
1037         }
1038         if (tp->rx_opt.eff_sacks) {
1039                 struct tcp_sack_block *sp = tp->rx_opt.dsack ? tp->duplicate_sack : tp->selective_acks;
1040                 int this_sack;
1041
1042                 *ptr++ = __constant_htonl((TCPOPT_NOP << 24) |
1043                                           (TCPOPT_NOP << 16) |
1044                                           (TCPOPT_SACK << 8) |
1045                                           (TCPOLEN_SACK_BASE +
1046                                            (tp->rx_opt.eff_sacks * TCPOLEN_SACK_PERBLOCK)));
1047                 for(this_sack = 0; this_sack < tp->rx_opt.eff_sacks; this_sack++) {
1048                         *ptr++ = htonl(sp[this_sack].start_seq);
1049                         *ptr++ = htonl(sp[this_sack].end_seq);
1050                 }
1051                 if (tp->rx_opt.dsack) {
1052                         tp->rx_opt.dsack = 0;
1053                         tp->rx_opt.eff_sacks--;
1054                 }
1055         }
1056 }
1057
1058 /* Construct a tcp options header for a SYN or SYN_ACK packet.
1059  * If this is every changed make sure to change the definition of
1060  * MAX_SYN_SIZE to match the new maximum number of options that you
1061  * can generate.
1062  */
1063 static inline void tcp_syn_build_options(__u32 *ptr, int mss, int ts, int sack,
1064                                              int offer_wscale, int wscale, __u32 tstamp, __u32 ts_recent)
1065 {
1066         /* We always get an MSS option.
1067          * The option bytes which will be seen in normal data
1068          * packets should timestamps be used, must be in the MSS
1069          * advertised.  But we subtract them from tp->mss_cache so
1070          * that calculations in tcp_sendmsg are simpler etc.
1071          * So account for this fact here if necessary.  If we
1072          * don't do this correctly, as a receiver we won't
1073          * recognize data packets as being full sized when we
1074          * should, and thus we won't abide by the delayed ACK
1075          * rules correctly.
1076          * SACKs don't matter, we never delay an ACK when we
1077          * have any of those going out.
1078          */
1079         *ptr++ = htonl((TCPOPT_MSS << 24) | (TCPOLEN_MSS << 16) | mss);
1080         if (ts) {
1081                 if(sack)
1082                         *ptr++ = __constant_htonl((TCPOPT_SACK_PERM << 24) | (TCPOLEN_SACK_PERM << 16) |
1083                                                   (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
1084                 else
1085                         *ptr++ = __constant_htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1086                                                   (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
1087                 *ptr++ = htonl(tstamp);         /* TSVAL */
1088                 *ptr++ = htonl(ts_recent);      /* TSECR */
1089         } else if(sack)
1090                 *ptr++ = __constant_htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1091                                           (TCPOPT_SACK_PERM << 8) | TCPOLEN_SACK_PERM);
1092         if (offer_wscale)
1093                 *ptr++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_WINDOW << 16) | (TCPOLEN_WINDOW << 8) | (wscale));
1094 }
1095
1096 /* Determine a window scaling and initial window to offer. */
1097 extern void tcp_select_initial_window(int __space, __u32 mss,
1098                                       __u32 *rcv_wnd, __u32 *window_clamp,
1099                                       int wscale_ok, __u8 *rcv_wscale);
1100
1101 static inline int tcp_win_from_space(int space)
1102 {
1103         return sysctl_tcp_adv_win_scale<=0 ?
1104                 (space>>(-sysctl_tcp_adv_win_scale)) :
1105                 space - (space>>sysctl_tcp_adv_win_scale);
1106 }
1107
1108 /* Note: caller must be prepared to deal with negative returns */ 
1109 static inline int tcp_space(const struct sock *sk)
1110 {
1111         return tcp_win_from_space(sk->sk_rcvbuf -
1112                                   atomic_read(&sk->sk_rmem_alloc));
1113
1114
1115 static inline int tcp_full_space(const struct sock *sk)
1116 {
1117         return tcp_win_from_space(sk->sk_rcvbuf); 
1118 }
1119
1120 static __inline__ void tcp_openreq_init(struct request_sock *req,
1121                                         struct tcp_options_received *rx_opt,
1122                                         struct sk_buff *skb)
1123 {
1124         struct inet_request_sock *ireq = inet_rsk(req);
1125
1126         req->rcv_wnd = 0;               /* So that tcp_send_synack() knows! */
1127         tcp_rsk(req)->rcv_isn = TCP_SKB_CB(skb)->seq;
1128         req->mss = rx_opt->mss_clamp;
1129         req->ts_recent = rx_opt->saw_tstamp ? rx_opt->rcv_tsval : 0;
1130         ireq->tstamp_ok = rx_opt->tstamp_ok;
1131         ireq->sack_ok = rx_opt->sack_ok;
1132         ireq->snd_wscale = rx_opt->snd_wscale;
1133         ireq->wscale_ok = rx_opt->wscale_ok;
1134         ireq->acked = 0;
1135         ireq->ecn_ok = 0;
1136         ireq->rmt_port = skb->h.th->source;
1137 }
1138
1139 extern void tcp_enter_memory_pressure(void);
1140
1141 static inline int keepalive_intvl_when(const struct tcp_sock *tp)
1142 {
1143         return tp->keepalive_intvl ? : sysctl_tcp_keepalive_intvl;
1144 }
1145
1146 static inline int keepalive_time_when(const struct tcp_sock *tp)
1147 {
1148         return tp->keepalive_time ? : sysctl_tcp_keepalive_time;
1149 }
1150
1151 static inline int tcp_fin_time(const struct sock *sk)
1152 {
1153         int fin_timeout = tcp_sk(sk)->linger2 ? : sysctl_tcp_fin_timeout;
1154         const int rto = inet_csk(sk)->icsk_rto;
1155
1156         if (fin_timeout < (rto << 2) - (rto >> 1))
1157                 fin_timeout = (rto << 2) - (rto >> 1);
1158
1159         return fin_timeout;
1160 }
1161
1162 static inline int tcp_paws_check(const struct tcp_options_received *rx_opt, int rst)
1163 {
1164         if ((s32)(rx_opt->rcv_tsval - rx_opt->ts_recent) >= 0)
1165                 return 0;
1166         if (xtime.tv_sec >= rx_opt->ts_recent_stamp + TCP_PAWS_24DAYS)
1167                 return 0;
1168
1169         /* RST segments are not recommended to carry timestamp,
1170            and, if they do, it is recommended to ignore PAWS because
1171            "their cleanup function should take precedence over timestamps."
1172            Certainly, it is mistake. It is necessary to understand the reasons
1173            of this constraint to relax it: if peer reboots, clock may go
1174            out-of-sync and half-open connections will not be reset.
1175            Actually, the problem would be not existing if all
1176            the implementations followed draft about maintaining clock
1177            via reboots. Linux-2.2 DOES NOT!
1178
1179            However, we can relax time bounds for RST segments to MSL.
1180          */
1181         if (rst && xtime.tv_sec >= rx_opt->ts_recent_stamp + TCP_PAWS_MSL)
1182                 return 0;
1183         return 1;
1184 }
1185
1186 #define TCP_CHECK_TIMER(sk) do { } while (0)
1187
1188 static inline int tcp_use_frto(const struct sock *sk)
1189 {
1190         const struct tcp_sock *tp = tcp_sk(sk);
1191         
1192         /* F-RTO must be activated in sysctl and there must be some
1193          * unsent new data, and the advertised window should allow
1194          * sending it.
1195          */
1196         return (sysctl_tcp_frto && sk->sk_send_head &&
1197                 !after(TCP_SKB_CB(sk->sk_send_head)->end_seq,
1198                        tp->snd_una + tp->snd_wnd));
1199 }
1200
1201 static inline void tcp_mib_init(void)
1202 {
1203         /* See RFC 2012 */
1204         TCP_ADD_STATS_USER(TCP_MIB_RTOALGORITHM, 1);
1205         TCP_ADD_STATS_USER(TCP_MIB_RTOMIN, TCP_RTO_MIN*1000/HZ);
1206         TCP_ADD_STATS_USER(TCP_MIB_RTOMAX, TCP_RTO_MAX*1000/HZ);
1207         TCP_ADD_STATS_USER(TCP_MIB_MAXCONN, -1);
1208 }
1209
1210 /* /proc */
1211 enum tcp_seq_states {
1212         TCP_SEQ_STATE_LISTENING,
1213         TCP_SEQ_STATE_OPENREQ,
1214         TCP_SEQ_STATE_ESTABLISHED,
1215         TCP_SEQ_STATE_TIME_WAIT,
1216 };
1217
1218 struct tcp_seq_afinfo {
1219         struct module           *owner;
1220         char                    *name;
1221         sa_family_t             family;
1222         int                     (*seq_show) (struct seq_file *m, void *v);
1223         struct file_operations  *seq_fops;
1224 };
1225
1226 struct tcp_iter_state {
1227         sa_family_t             family;
1228         enum tcp_seq_states     state;
1229         struct sock             *syn_wait_sk;
1230         int                     bucket, sbucket, num, uid;
1231         struct seq_operations   seq_ops;
1232 };
1233
1234 extern int tcp_proc_register(struct tcp_seq_afinfo *afinfo);
1235 extern void tcp_proc_unregister(struct tcp_seq_afinfo *afinfo);
1236
1237 extern struct request_sock_ops tcp_request_sock_ops;
1238
1239 extern int tcp_v4_destroy_sock(struct sock *sk);
1240
1241 #ifdef CONFIG_PROC_FS
1242 extern int  tcp4_proc_init(void);
1243 extern void tcp4_proc_exit(void);
1244 #endif
1245
1246 extern void tcp_v4_init(struct net_proto_family *ops);
1247 extern void tcp_init(void);
1248
1249 #endif  /* _TCP_H */