libratbox/include/commio-int.h

   1 /*
   2  *  ircd-ratbox: A slightly useful ircd.
   3  *  commio-int.h: A header for the network subsystem.
   4  *
   5  *  Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
   6  *  Copyright (C) 1996-2002 Hybrid Development Team
   7  *  Copyright (C) 2002-2007 ircd-ratbox development team
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
  22  *  USA
  23  *
  24  *  $Id: commio.h 24059 2007-07-24 17:25:41Z androsyn $
  25  */
  26
  27
  28 #define RB_FD_HASH_BITS 12
  29 #define RB_FD_HASH_SIZE (1UL << RB_FD_HASH_BITS)
  30 #define RB_FD_HASH_MASK (RB_FD_HASH_SIZE-1)
  31
  32 #define FD_DESC_SZ 128          /* hostlen + comment */
  33
  34
  35 #ifdef WIN32
  36 #define rb_get_errno() do { errno = WSAGetLastError(); WSASetLastError(errno); } while(0)
  37 #else
  38 #define rb_get_errno()
  39 #endif
  40
  41 #define rb_hash_fd(x) ((x ^ (x >> RB_FD_HASH_BITS) ^ (x >> (RB_FD_HASH_BITS * 2))) & RB_FD_HASH_MASK)
  42
  43 #ifdef HAVE_WRITEV
  44         #ifndef UIO_MAXIOV
  45                 # if defined(__FreeBSD__) || defined(__APPLE__) || defined(__NetBSD__)
  46                         /* FreeBSD 4.7 defines it in sys/uio.h only if _KERNEL is specified */
  47                         #  define RB_UIO_MAXIOV 1024
  48                 # elif defined(__sgi)
  49                         /* IRIX 6.5 has sysconf(_SC_IOV_MAX) which might return 512 or bigger */
  50                         #  define RB_UIO_MAXIOV 512
  51                 # elif defined(__sun)
  52                         /* Solaris (and SunOS?) defines IOV_MAX instead */
  53                         #  ifndef IOV_MAX
  54                                 #   define RB_UIO_MAXIOV 16
  55                         #  else
  56                                 #   define RB_UIO_MAXIOV IOV_MAX
  57                         #  endif
  58
  59                 # elif defined(IOV_MAX)
  60                         #  define RB_UIO_MAXIOV IOV_MAX
  61                 # else
  62                         #  define RB_UIO_MAXIOV 16
  63                 # endif
  64         #else
  65                 #define RB_UIO_MAXIOV UIO_MAXIOV
  66         #endif
  67 #else
  68         #define RB_UIO_MAXIOV 16
  69 #endif
  70 struct conndata
  71 {
  72         /* We don't need the host here ? */
  73         struct rb_sockaddr_storage S;
  74         struct rb_sockaddr_storage hostaddr;
  75         time_t t;
  76         CNCB *callback;
  77         void *data;
  78         /* We'd also add the retry count here when we get to that -- adrian */
  79 };
  80
  81 struct acceptdata
  82 {
  83         struct rb_sockaddr_storage S;
  84         rb_socklen_t addrlen;
  85         ACCB *callback;
  86         ACPRE *precb;
  87         void *data;
  88 };
  89
  90 /* Only have open flags for now, could be more later */
  91 #define FLAG_OPEN       0x1
  92 #define IsFDOpen(F)     (F->flags & FLAG_OPEN)
  93 #define SetFDOpen(F)    (F->flags |= FLAG_OPEN)
  94 #define ClearFDOpen(F)  (F->flags &= ~FLAG_OPEN)
  95
  96
  97 struct _fde
  98 {
  99         /* New-school stuff, again pretty much ripped from squid */
 100         /*
 101          * Yes, this gives us only one pending read and one pending write per
 102          * filedescriptor. Think though: when do you think we'll need more?
 103          */
 104         rb_dlink_node node;
 105         int fd;                 /* So we can use the rb_fde_t as a callback ptr */
 106         uint8_t flags;
 107         uint8_t type;
 108         int pflags;
 109         char *desc;
 110         PF *read_handler;
 111         void *read_data;
 112         PF *write_handler;
 113         void *write_data;
 114         struct timeout_data *timeout;
 115         struct conndata *connect;
 116         struct acceptdata *accept;
 117         void *ssl;
 118         unsigned int handshake_count;
 119         unsigned long ssl_errno;
 120 };
 121
 122 typedef void (*comm_event_cb_t)(void *);
 123
 124 #ifdef USE_TIMER_CREATE
 125 typedef struct timer_data {
 126         timer_t td_timer_id;
 127         comm_event_cb_t  td_cb;
 128         void *td_udata;
 129         int td_repeat;
 130 } *comm_event_id;
 131 #endif
 132
 133 extern rb_dlink_list *rb_fd_table;
 134
 135 static inline rb_fde_t *
 136 rb_find_fd(int fd)
 137 {
 138         rb_dlink_list *hlist;
 139         rb_dlink_node *ptr;
 140
 141         if(rb_unlikely(fd < 0))
 142                 return NULL;
 143
 144         hlist = &rb_fd_table[rb_hash_fd(fd)];
 145
 146         if(hlist->head == NULL)
 147                 return NULL;
 148
 149         RB_DLINK_FOREACH(ptr, hlist->head)
 150         {
 151                 rb_fde_t *F = ptr->data;
 152                 if(F->fd == fd)
 153                         return F;
 154         }
 155         return NULL;
 156 }
 157
 158
 159 int rb_setup_fd(rb_fde_t *F);
 160 void rb_connect_callback(rb_fde_t *F, int status);
 161
 162
 163 int rb_io_sched_event(struct ev_entry *ev, int when);
 164 void rb_io_unsched_event(struct ev_entry *ev);
 165 int rb_io_supports_event(void);
 166 void rb_io_init_event(void);
 167
 168 /* epoll versions */
 169 void rb_setselect_epoll(rb_fde_t *F, unsigned int type, PF * handler, void *client_data);
 170 int rb_init_netio_epoll(void);
 171 int rb_select_epoll(long);
 172 int rb_setup_fd_epoll(rb_fde_t *F);
 173
 174 void rb_epoll_init_event(void);
 175 int rb_epoll_sched_event(struct ev_entry *event, int when);
 176 void rb_epoll_unsched_event(struct ev_entry *event);
 177 int rb_epoll_supports_event(void);
 178
 179
 180 /* poll versions */
 181 void rb_setselect_poll(rb_fde_t *F, unsigned int type, PF * handler, void *client_data);
 182 int rb_init_netio_poll(void);
 183 int rb_select_poll(long);
 184 int rb_setup_fd_poll(rb_fde_t *F);
 185
 186 /* devpoll versions */
 187 void rb_setselect_devpoll(rb_fde_t *F, unsigned int type, PF * handler, void *client_data);
 188 int rb_init_netio_devpoll(void);
 189 int rb_select_devpoll(long);
 190 int rb_setup_fd_devpoll(rb_fde_t *F);
 191
 192 /* sigio versions */
 193 void rb_setselect_sigio(rb_fde_t *F, unsigned int type, PF * handler, void *client_data);
 194 int rb_init_netio_sigio(void);
 195 int rb_select_sigio(long);
 196 int rb_setup_fd_sigio(rb_fde_t *F);
 197
 198 void rb_sigio_init_event(void);
 199 int rb_sigio_sched_event(struct ev_entry *event, int when);
 200 void rb_sigio_unsched_event(struct ev_entry *event);
 201 int rb_sigio_supports_event(void);
 202
 203
 204 /* ports versions */
 205 void rb_setselect_ports(rb_fde_t *F, unsigned int type, PF * handler, void *client_data);
 206 int rb_init_netio_ports(void);
 207 int rb_select_ports(long);
 208 int rb_setup_fd_ports(rb_fde_t *F);
 209
 210 /* kqueue versions */
 211 void rb_setselect_kqueue(rb_fde_t *F, unsigned int type, PF * handler, void *client_data);
 212 int rb_init_netio_kqueue(void);
 213 int rb_select_kqueue(long);
 214 int rb_setup_fd_kqueue(rb_fde_t *F);
 215
 216 void rb_kqueue_init_event(void);
 217 int rb_kqueue_sched_event(struct ev_entry *event, int when);
 218 void rb_kqueue_unsched_event(struct ev_entry *event);
 219 int rb_kqueue_supports_event(void);
 220
 221
 222 /* select versions */
 223 void rb_setselect_select(rb_fde_t *F, unsigned int type, PF * handler, void *client_data);
 224 int rb_init_netio_select(void);
 225 int rb_select_select(long);
 226 int rb_setup_fd_select(rb_fde_t *F);
 227
 228 /* win32 versions */
 229 void rb_setselect_win32(rb_fde_t *F, unsigned int type, PF * handler, void *client_data);
 230 int rb_init_netio_win32(void);
 231 int rb_select_win32(long);
 232 int rb_setup_fd_win32(rb_fde_t *F);
 233