[BACK]Return to eventlib_p.h CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / lib / libc / isc

Annotation of src/lib/libc/isc/eventlib_p.h, Revision 1.2.14.1

1.2.14.1! riz         1: /*     $NetBSD: eventlib_p.h,v 1.3 2009/04/12 17:07:17 christos Exp $  */
1.1       christos    2:
                      3: /*
1.2       christos    4:  * Copyright (c) 2005 by Internet Systems Consortium, Inc. ("ISC")
1.1       christos    5:  * Copyright (c) 1995-1999 by Internet Software Consortium
                      6:  *
                      7:  * Permission to use, copy, modify, and distribute this software for any
                      8:  * purpose with or without fee is hereby granted, provided that the above
                      9:  * copyright notice and this permission notice appear in all copies.
                     10:  *
                     11:  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
                     12:  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
                     13:  * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
                     14:  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
                     15:  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
                     16:  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
                     17:  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
                     18:  */
                     19:
1.2       christos   20: /*! \file
                     21:  * \brief private interfaces for eventlib
                     22:  * \author vix 09sep95 [initial]
1.1       christos   23:  *
1.2       christos   24:  * Id: eventlib_p.h,v 1.9 2006/03/09 23:57:56 marka Exp
1.1       christos   25:  */
                     26:
                     27: #ifndef _EVENTLIB_P_H
                     28: #define _EVENTLIB_P_H
                     29:
                     30: #include <sys/param.h>
                     31: #include <sys/types.h>
                     32: #include <sys/socket.h>
                     33: #include <netinet/in.h>
                     34: #include <sys/un.h>
                     35:
                     36: #define EVENTLIB_DEBUG 1
                     37:
                     38: #include <errno.h>
                     39: #include <fcntl.h>
                     40: #include <stdio.h>
                     41: #include <stdlib.h>
                     42: #include <string.h>
                     43:
                     44: #include <isc/heap.h>
                     45: #include <isc/list.h>
                     46: #include <isc/memcluster.h>
                     47:
                     48: #define        EV_MASK_ALL     (EV_READ | EV_WRITE | EV_EXCEPT)
                     49: #define EV_ERR(e)              return (errno = (e), -1)
                     50: #define OK(x)          if ((x) < 0) EV_ERR(errno); else (void)NULL
1.2       christos   51: #define OKFREE(x, y)   if ((x) < 0) { FREE((y)); EV_ERR(errno); } \
                     52:                        else (void)NULL
1.1       christos   53:
                     54: #define        NEW(p)          if (((p) = memget(sizeof *(p))) != NULL) \
                     55:                                FILL(p); \
                     56:                        else \
                     57:                                (void)NULL;
                     58: #define OKNEW(p)       if (!((p) = memget(sizeof *(p)))) { \
                     59:                                errno = ENOMEM; \
                     60:                                return (-1); \
                     61:                        } else \
                     62:                                FILL(p)
                     63: #define FREE(p)                memput((p), sizeof *(p))
                     64:
                     65: #if EVENTLIB_DEBUG
                     66: #define FILL(p)                memset((p), 0xF5, sizeof *(p))
                     67: #else
                     68: #define FILL(p)
                     69: #endif
                     70:
1.2       christos   71: #ifdef USE_POLL
                     72: #ifdef HAVE_STROPTS_H
                     73: #include <stropts.h>
                     74: #endif
                     75: #include <poll.h>
                     76: #endif /* USE_POLL */
                     77:
1.1       christos   78: typedef struct evConn {
                     79:        evConnFunc      func;
                     80:        void *          uap;
                     81:        int             fd;
                     82:        int             flags;
1.2       christos   83: #define EV_CONN_LISTEN         0x0001          /*%< Connection is a listener. */
                     84: #define EV_CONN_SELECTED       0x0002          /*%< evSelectFD(conn->file). */
                     85: #define EV_CONN_BLOCK          0x0004          /*%< Listener fd was blocking. */
1.1       christos   86:        evFileID        file;
                     87:        struct evConn * prev;
                     88:        struct evConn * next;
                     89: } evConn;
                     90:
                     91: typedef struct evAccept {
                     92:        int             fd;
                     93:        union {
                     94:                struct sockaddr         sa;
                     95:                struct sockaddr_in      in;
                     96: #ifndef NO_SOCKADDR_UN
                     97:                struct sockaddr_un      un;
                     98: #endif
                     99:        }               la;
                    100:        ISC_SOCKLEN_T   lalen;
                    101:        union {
                    102:                struct sockaddr         sa;
                    103:                struct sockaddr_in      in;
                    104: #ifndef NO_SOCKADDR_UN
                    105:                struct sockaddr_un      un;
                    106: #endif
                    107:        }               ra;
                    108:        ISC_SOCKLEN_T   ralen;
                    109:        int             ioErrno;
                    110:        evConn *        conn;
                    111:        LINK(struct evAccept) link;
                    112: } evAccept;
                    113:
                    114: typedef struct evFile {
                    115:        evFileFunc      func;
                    116:        void *          uap;
                    117:        int             fd;
                    118:        int             eventmask;
                    119:        int             preemptive;
                    120:        struct evFile * prev;
                    121:        struct evFile * next;
                    122:        struct evFile * fdprev;
                    123:        struct evFile * fdnext;
                    124: } evFile;
                    125:
                    126: typedef struct evStream {
                    127:        evStreamFunc    func;
                    128:        void *          uap;
                    129:        evFileID        file;
                    130:        evTimerID       timer;
                    131:        int             flags;
1.2       christos  132: #define EV_STR_TIMEROK 0x0001  /*%< IFF timer valid. */
1.1       christos  133:        int             fd;
                    134:        struct iovec *  iovOrig;
                    135:        int             iovOrigCount;
                    136:        struct iovec *  iovCur;
                    137:        int             iovCurCount;
                    138:        int             ioTotal;
                    139:        int             ioDone;
                    140:        int             ioErrno;
                    141:        struct evStream *prevDone, *nextDone;
                    142:        struct evStream *prev, *next;
                    143: } evStream;
                    144:
                    145: typedef struct evTimer {
                    146:        evTimerFunc     func;
                    147:        void *          uap;
                    148:        struct timespec due, inter;
                    149:        int             index;
                    150:        int             mode;
                    151: #define EV_TMR_RATE    1
                    152: } evTimer;
                    153:
                    154: typedef struct evWait {
                    155:        evWaitFunc      func;
                    156:        void *          uap;
                    157:        const void *    tag;
                    158:        struct evWait * next;
                    159: } evWait;
                    160:
                    161: typedef struct evWaitList {
                    162:        evWait *                first;
                    163:        evWait *                last;
                    164:        struct evWaitList *     prev;
                    165:        struct evWaitList *     next;
                    166: } evWaitList;
                    167:
                    168: typedef struct evEvent_p {
                    169:        enum {  Accept, File, Stream, Timer, Wait, Free, Null  } type;
                    170:        union {
                    171:                struct {  evAccept *this;  }                    accept;
                    172:                struct {  evFile *this; int eventmask;  }       file;
                    173:                struct {  evStream *this;  }                    stream;
                    174:                struct {  evTimer *this;  }                     timer;
                    175:                struct {  evWait *this;  }                      wait;
                    176:                struct {  struct evEvent_p *next;  }            free;
                    177:                struct {  const void *placeholder;  }           null;
                    178:        } u;
                    179: } evEvent_p;
                    180:
1.2       christos  181: #ifdef USE_POLL
                    182: typedef struct {
                    183:        void            *ctx;   /* pointer to the evContext_p   */
                    184:        uint32_t        type;   /* READ, WRITE, EXCEPT, nonblk  */
                    185:        uint32_t        result; /* 1 => revents, 0 => events    */
                    186: } __evEmulMask;
                    187:
                    188: #define emulMaskInit(ctx, field, ev, lastnext) \
                    189:        ctx->field.ctx = ctx; \
                    190:        ctx->field.type = ev; \
                    191:        ctx->field.result = lastnext;
                    192:
                    193: extern short   *__fd_eventfield(int fd, __evEmulMask *maskp);
                    194: extern short   __poll_event(__evEmulMask *maskp);
                    195: extern void            __fd_clr(int fd, __evEmulMask *maskp);
                    196: extern void            __fd_set(int fd, __evEmulMask *maskp);
                    197:
                    198: #undef  FD_ZERO
                    199: #define FD_ZERO(maskp)
                    200:
                    201: #undef  FD_SET
                    202: #define FD_SET(fd, maskp) \
                    203:        __fd_set(fd, maskp)
                    204:
                    205: #undef  FD_CLR
                    206: #define FD_CLR(fd, maskp) \
                    207:        __fd_clr(fd, maskp)
                    208:
                    209: #undef  FD_ISSET
                    210: #define FD_ISSET(fd, maskp) \
                    211:        ((*__fd_eventfield(fd, maskp) & __poll_event(maskp)) != 0)
                    212:
                    213: #endif /* USE_POLL */
                    214:
1.1       christos  215: typedef struct {
                    216:        /* Global. */
                    217:        const evEvent_p *cur;
                    218:        /* Debugging. */
                    219:        int             debug;
                    220:        FILE            *output;
                    221:        /* Connections. */
                    222:        evConn          *conns;
                    223:        LIST(evAccept)  accepts;
                    224:        /* Files. */
                    225:        evFile          *files, *fdNext;
1.2       christos  226: #ifndef USE_POLL
1.1       christos  227:        fd_set          rdLast, rdNext;
                    228:        fd_set          wrLast, wrNext;
                    229:        fd_set          exLast, exNext;
                    230:        fd_set          nonblockBefore;
                    231:        int             fdMax, fdCount, highestFD;
                    232:        evFile          *fdTable[FD_SETSIZE];
1.2       christos  233: #else
                    234:        struct pollfd   *pollfds;       /* Allocated as needed  */
                    235:        evFile          **fdTable;      /* Ditto                */
                    236:        int             maxnfds;        /* # elements in above  */
                    237:        int             firstfd;        /* First active fd      */
                    238:        int             fdMax;          /* Last active fd       */
                    239:        int             fdCount;        /* # fd:s with I/O      */
                    240:        int             highestFD;      /* max fd allowed by OS */
                    241:        __evEmulMask    rdLast, rdNext;
                    242:        __evEmulMask    wrLast, wrNext;
                    243:        __evEmulMask    exLast, exNext;
                    244:        __evEmulMask    nonblockBefore;
                    245: #endif /* USE_POLL */
1.1       christos  246: #ifdef EVENTLIB_TIME_CHECKS
                    247:        struct timespec lastSelectTime;
                    248:        int             lastFdCount;
                    249: #endif
                    250:        /* Streams. */
                    251:        evStream        *streams;
                    252:        evStream        *strDone, *strLast;
                    253:        /* Timers. */
                    254:        struct timespec lastEventTime;
                    255:        heap_context    timers;
                    256:        /* Waits. */
                    257:        evWaitList      *waitLists;
                    258:        evWaitList      waitDone;
                    259: } evContext_p;
                    260:
                    261: /* eventlib.c */
                    262: #define evPrintf __evPrintf
                    263: void evPrintf(const evContext_p *ctx, int level, const char *fmt, ...)
                    264:      ISC_FORMAT_PRINTF(3, 4);
                    265:
1.2       christos  266: #ifdef USE_POLL
                    267: extern int evPollfdRealloc(evContext_p *ctx, int pollfd_chunk_size, int fd);
                    268: #endif /* USE_POLL */
                    269:
1.1       christos  270: /* ev_timers.c */
                    271: #define evCreateTimers __evCreateTimers
                    272: heap_context evCreateTimers(const evContext_p *);
                    273: #define evDestroyTimers __evDestroyTimers
                    274: void evDestroyTimers(const evContext_p *);
                    275:
                    276: /* ev_waits.c */
                    277: #define evFreeWait __evFreeWait
                    278: evWait *evFreeWait(evContext_p *ctx, evWait *old);
                    279:
                    280: /* Global options */
1.2       christos  281: extern int     __evOptMonoTime;
1.1       christos  282:
                    283: #endif /*_EVENTLIB_P_H*/

CVSweb <webmaster@jp.NetBSD.org>