SAFE public projects git trees. - safe/jmp/linux-2.6/blob - include/net/inet_connection_sock.h

   1 /*
   2  * NET          Generic infrastructure for INET connection oriented protocols.
   3  *
   4  *              Definitions for inet_connection_sock
   5  *
   6  * Authors:     Many people, see the TCP sources
   7  *
   8  *              From code originally in TCP
   9  *
  10  *              This program is free software; you can redistribute it and/or
  11  *              modify it under the terms of the GNU General Public License
  12  *              as published by the Free Software Foundation; either version
  13  *              2 of the License, or (at your option) any later version.
  14  */
  15 #ifndef _INET_CONNECTION_SOCK_H
  16 #define _INET_CONNECTION_SOCK_H
  17
  18 #include <linux/compiler.h>
  19 #include <linux/ip.h>
  20 #include <linux/string.h>
  21 #include <linux/timer.h>
  22 #include <net/request_sock.h>
  23
  24 #define INET_CSK_DEBUG 1
  25
  26 /* Cancel timers, when they are not required. */
  27 #undef INET_CSK_CLEAR_TIMERS
  28
  29 struct inet_bind_bucket;
  30 struct inet_hashinfo;
  31 struct tcp_congestion_ops;
  32
  33 /*
  34  * Pointers to address related TCP functions
  35  * (i.e. things that depend on the address family)
  36  */
  37 struct inet_connection_sock_af_ops {
  38         int         (*queue_xmit)(struct sk_buff *skb, int ipfragok);
  39         void        (*send_check)(struct sock *sk, int len,
  40                                   struct sk_buff *skb);
  41         int         (*rebuild_header)(struct sock *sk);
  42         int         (*conn_request)(struct sock *sk, struct sk_buff *skb);
  43         struct sock *(*syn_recv_sock)(struct sock *sk, struct sk_buff *skb,
  44                                       struct request_sock *req,
  45                                       struct dst_entry *dst);
  46         int         (*remember_stamp)(struct sock *sk);
  47         __u16       net_header_len;
  48         int         (*setsockopt)(struct sock *sk, int level, int optname,
  49                                   char __user *optval, int optlen);
  50         int         (*getsockopt)(struct sock *sk, int level, int optname,
  51                                   char __user *optval, int __user *optlen);
  52         void        (*addr2sockaddr)(struct sock *sk, struct sockaddr *);
  53         int sockaddr_len;
  54 };
  55
  56 /** inet_connection_sock - INET connection oriented sock
  57  *
  58  * @icsk_accept_queue:     FIFO of established children
  59  * @icsk_bind_hash:        Bind node
  60  * @icsk_timeout:          Timeout
  61  * @icsk_retransmit_timer: Resend (no ack)
  62  * @icsk_rto:              Retransmit timeout
  63  * @icsk_ca_ops            Pluggable congestion control hook
  64  * @icsk_af_ops            Operations which are AF_INET{4,6} specific
  65  * @icsk_ca_state:         Congestion control state
  66  * @icsk_retransmits:      Number of unrecovered [RTO] timeouts
  67  * @icsk_pending:          Scheduled timer event
  68  * @icsk_backoff:          Backoff
  69  * @icsk_syn_retries:      Number of allowed SYN (or equivalent) retries
  70  * @icsk_probes_out:       unanswered 0 window probes
  71  * @icsk_ack:              Delayed ACK control data
  72  */
  73 struct inet_connection_sock {
  74         /* inet_sock has to be the first member! */
  75         struct inet_sock          icsk_inet;
  76         struct request_sock_queue icsk_accept_queue;
  77         struct inet_bind_bucket   *icsk_bind_hash;
  78         unsigned long             icsk_timeout;
  79         struct timer_list         icsk_retransmit_timer;
  80         struct timer_list         icsk_delack_timer;
  81         __u32                     icsk_rto;
  82         struct tcp_congestion_ops *icsk_ca_ops;
  83         struct inet_connection_sock_af_ops *icsk_af_ops;
  84         __u8                      icsk_ca_state;
  85         __u8                      icsk_retransmits;
  86         __u8                      icsk_pending;
  87         __u8                      icsk_backoff;
  88         __u8                      icsk_syn_retries;
  89         __u8                      icsk_probes_out;
  90         /* 2 BYTES HOLE, TRY TO PACK! */
  91         struct {
  92                 __u8              pending;       /* ACK is pending                         */
  93                 __u8              quick;         /* Scheduled number of quick acks         */
  94                 __u8              pingpong;      /* The session is interactive             */
  95                 __u8              blocked;       /* Delayed ACK was blocked by socket lock */
  96                 __u32             ato;           /* Predicted tick of soft clock           */
  97                 unsigned long     timeout;       /* Currently scheduled timeout            */
  98                 __u32             lrcvtime;      /* timestamp of last received data packet */
  99                 __u16             last_seg_size; /* Size of last incoming segment          */
 100                 __u16             rcv_mss;       /* MSS used for delayed ACK decisions     */
 101         } icsk_ack;
 102         u32                       icsk_ca_priv[16];
 103 #define ICSK_CA_PRIV_SIZE       (16 * sizeof(u32))
 104 };
 105
 106 #define ICSK_TIME_RETRANS       1       /* Retransmit timer */
 107 #define ICSK_TIME_DACK          2       /* Delayed ack timer */
 108 #define ICSK_TIME_PROBE0        3       /* Zero window probe timer */
 109 #define ICSK_TIME_KEEPOPEN      4       /* Keepalive timer */
 110
 111 static inline struct inet_connection_sock *inet_csk(const struct sock *sk)
 112 {
 113         return (struct inet_connection_sock *)sk;
 114 }
 115
 116 static inline void *inet_csk_ca(const struct sock *sk)
 117 {
 118         return (void *)inet_csk(sk)->icsk_ca_priv;
 119 }
 120
 121 extern struct sock *inet_csk_clone(struct sock *sk,
 122                                    const struct request_sock *req,
 123                                    const gfp_t priority);
 124
 125 enum inet_csk_ack_state_t {
 126         ICSK_ACK_SCHED  = 1,
 127         ICSK_ACK_TIMER  = 2,
 128         ICSK_ACK_PUSHED = 4
 129 };
 130
 131 extern void inet_csk_init_xmit_timers(struct sock *sk,
 132                                       void (*retransmit_handler)(unsigned long),
 133                                       void (*delack_handler)(unsigned long),
 134                                       void (*keepalive_handler)(unsigned long));
 135 extern void inet_csk_clear_xmit_timers(struct sock *sk);
 136
 137 static inline void inet_csk_schedule_ack(struct sock *sk)
 138 {
 139         inet_csk(sk)->icsk_ack.pending |= ICSK_ACK_SCHED;
 140 }
 141
 142 static inline int inet_csk_ack_scheduled(const struct sock *sk)
 143 {
 144         return inet_csk(sk)->icsk_ack.pending & ICSK_ACK_SCHED;
 145 }
 146
 147 static inline void inet_csk_delack_init(struct sock *sk)
 148 {
 149         memset(&inet_csk(sk)->icsk_ack, 0, sizeof(inet_csk(sk)->icsk_ack));
 150 }
 151
 152 extern void inet_csk_delete_keepalive_timer(struct sock *sk);
 153 extern void inet_csk_reset_keepalive_timer(struct sock *sk, unsigned long timeout);
 154
 155 #ifdef INET_CSK_DEBUG
 156 extern const char inet_csk_timer_bug_msg[];
 157 #endif
 158
 159 static inline void inet_csk_clear_xmit_timer(struct sock *sk, const int what)
 160 {
 161         struct inet_connection_sock *icsk = inet_csk(sk);
 162
 163         if (what == ICSK_TIME_RETRANS || what == ICSK_TIME_PROBE0) {
 164                 icsk->icsk_pending = 0;
 165 #ifdef INET_CSK_CLEAR_TIMERS
 166                 sk_stop_timer(sk, &icsk->icsk_retransmit_timer);
 167 #endif
 168         } else if (what == ICSK_TIME_DACK) {
 169                 icsk->icsk_ack.blocked = icsk->icsk_ack.pending = 0;
 170 #ifdef INET_CSK_CLEAR_TIMERS
 171                 sk_stop_timer(sk, &icsk->icsk_delack_timer);
 172 #endif
 173         }
 174 #ifdef INET_CSK_DEBUG
 175         else {
 176                 pr_debug("%s", inet_csk_timer_bug_msg);
 177         }
 178 #endif
 179 }
 180
 181 /*
 182  *      Reset the retransmission timer
 183  */
 184 static inline void inet_csk_reset_xmit_timer(struct sock *sk, const int what,
 185                                              unsigned long when,
 186                                              const unsigned long max_when)
 187 {
 188         struct inet_connection_sock *icsk = inet_csk(sk);
 189
 190         if (when > max_when) {
 191 #ifdef INET_CSK_DEBUG
 192                 pr_debug("reset_xmit_timer: sk=%p %d when=0x%lx, caller=%p\n",
 193                          sk, what, when, current_text_addr());
 194 #endif
 195                 when = max_when;
 196         }
 197
 198         if (what == ICSK_TIME_RETRANS || what == ICSK_TIME_PROBE0) {
 199                 icsk->icsk_pending = what;
 200                 icsk->icsk_timeout = jiffies + when;
 201                 sk_reset_timer(sk, &icsk->icsk_retransmit_timer, icsk->icsk_timeout);
 202         } else if (what == ICSK_TIME_DACK) {
 203                 icsk->icsk_ack.pending |= ICSK_ACK_TIMER;
 204                 icsk->icsk_ack.timeout = jiffies + when;
 205                 sk_reset_timer(sk, &icsk->icsk_delack_timer, icsk->icsk_ack.timeout);
 206         }
 207 #ifdef INET_CSK_DEBUG
 208         else {
 209                 pr_debug("%s", inet_csk_timer_bug_msg);
 210         }
 211 #endif
 212 }
 213
 214 extern struct sock *inet_csk_accept(struct sock *sk, int flags, int *err);
 215
 216 extern struct request_sock *inet_csk_search_req(const struct sock *sk,
 217                                                 struct request_sock ***prevp,
 218                                                 const __u16 rport,
 219                                                 const __u32 raddr,
 220                                                 const __u32 laddr);
 221 extern int inet_csk_bind_conflict(const struct sock *sk,
 222                                   const struct inet_bind_bucket *tb);
 223 extern int inet_csk_get_port(struct inet_hashinfo *hashinfo,
 224                              struct sock *sk, unsigned short snum,
 225                              int (*bind_conflict)(const struct sock *sk,
 226                                                   const struct inet_bind_bucket *tb));
 227
 228 extern struct dst_entry* inet_csk_route_req(struct sock *sk,
 229                                             const struct request_sock *req);
 230
 231 static inline void inet_csk_reqsk_queue_add(struct sock *sk,
 232                                             struct request_sock *req,
 233                                             struct sock *child)
 234 {
 235         reqsk_queue_add(&inet_csk(sk)->icsk_accept_queue, req, sk, child);
 236 }
 237
 238 extern void inet_csk_reqsk_queue_hash_add(struct sock *sk,
 239                                           struct request_sock *req,
 240                                           unsigned long timeout);
 241
 242 static inline void inet_csk_reqsk_queue_removed(struct sock *sk,
 243                                                 struct request_sock *req)
 244 {
 245         if (reqsk_queue_removed(&inet_csk(sk)->icsk_accept_queue, req) == 0)
 246                 inet_csk_delete_keepalive_timer(sk);
 247 }
 248
 249 static inline void inet_csk_reqsk_queue_added(struct sock *sk,
 250                                               const unsigned long timeout)
 251 {
 252         if (reqsk_queue_added(&inet_csk(sk)->icsk_accept_queue) == 0)
 253                 inet_csk_reset_keepalive_timer(sk, timeout);
 254 }
 255
 256 static inline int inet_csk_reqsk_queue_len(const struct sock *sk)
 257 {
 258         return reqsk_queue_len(&inet_csk(sk)->icsk_accept_queue);
 259 }
 260
 261 static inline int inet_csk_reqsk_queue_young(const struct sock *sk)
 262 {
 263         return reqsk_queue_len_young(&inet_csk(sk)->icsk_accept_queue);
 264 }
 265
 266 static inline int inet_csk_reqsk_queue_is_full(const struct sock *sk)
 267 {
 268         return reqsk_queue_is_full(&inet_csk(sk)->icsk_accept_queue);
 269 }
 270
 271 static inline void inet_csk_reqsk_queue_unlink(struct sock *sk,
 272                                                struct request_sock *req,
 273                                                struct request_sock **prev)
 274 {
 275         reqsk_queue_unlink(&inet_csk(sk)->icsk_accept_queue, req, prev);
 276 }
 277
 278 static inline void inet_csk_reqsk_queue_drop(struct sock *sk,
 279                                              struct request_sock *req,
 280                                              struct request_sock **prev)
 281 {
 282         inet_csk_reqsk_queue_unlink(sk, req, prev);
 283         inet_csk_reqsk_queue_removed(sk, req);
 284         reqsk_free(req);
 285 }
 286
 287 extern void inet_csk_reqsk_queue_prune(struct sock *parent,
 288                                        const unsigned long interval,
 289                                        const unsigned long timeout,
 290                                        const unsigned long max_rto);
 291
 292 extern void inet_csk_destroy_sock(struct sock *sk);
 293
 294 /*
 295  * LISTEN is a special case for poll..
 296  */
 297 static inline unsigned int inet_csk_listen_poll(const struct sock *sk)
 298 {
 299         return !reqsk_queue_empty(&inet_csk(sk)->icsk_accept_queue) ?
 300                         (POLLIN | POLLRDNORM) : 0;
 301 }
 302
 303 extern int  inet_csk_listen_start(struct sock *sk, const int nr_table_entries);
 304 extern void inet_csk_listen_stop(struct sock *sk);
 305
 306 #endif /* _INET_CONNECTION_SOCK_H */