event.h

Go to the documentation of this file.

/*
** Copyright (C) 2005 by Kevin L. Mitchell <klmitch@mit.edu>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 2 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
**
** @(#)$Id: event.h,v 1.30 2005/12/29 04:33:58 klmitch Exp $
*/
#ifndef __include_event_event_h__
#define __include_event_event_h__

#undef EV_BEGIN_C_DECLS
#undef EV_END_C_DECLS
#ifdef __cplusplus
# define EV_BEGIN_C_DECLS extern "C" {
# define EV_END_C_DECLS }
#else
# define EV_BEGIN_C_DECLS /* empty */
# define EV_END_C_DECLS   /* empty */
#endif

#include <errno.h> /* for EINVAL and friends */
#include <stdlib.h> /* for size_t definition */
#include <treeconf/treeconf.h> /* for treeconf_ctx_t definition */

EV_BEGIN_C_DECLS

#ifndef __EVENT_LIBRARY__
# include <event/event_err.h>
# include <event/event_version.h>
# include <event/gcc-attrs.h>
#endif /* __EVENT_LIBRARY__ */

typedef struct _ev_ctx_s ev_ctx_t;

typedef struct _ev_englist_s _ev_englist_t;

typedef struct _ev_attr_s *ev_attr_t;

typedef struct _event_s event_t;

typedef struct _ev_genhdr_s ev_genhdr_t;

typedef enum {
  ET_NONE,              
  ET_READ,              
  ET_WRITE,             
  ET_ACCEPT,            
  ET_CONNECT,           
  ET_EOF,               
  ET_ERROR,             
  ET_SIGNAL,            
  ET_EXPIRE,            
  ET_RESERVED = 100,    
  ET_USER = 1000        
} ev_type_t;

typedef enum {
  EP_NONE,              
  EP_INT,               
  EP_PTR                
} ev_paramtype_t;

typedef enum {
  EGT_NONE,             
  EGT_SOCKET,           
  EGT_SIGNAL,           
  EGT_TIMER,            
  EGT_RESERVED = 10,    
  EGT_USER = 100        
} ev_gentype_t;

typedef unsigned int ev_err_t;

typedef unsigned long ev_magic_t;

typedef unsigned long ev_flags_t;

typedef void (*ev_call_t)(ev_ctx_t *ctx, event_t *event, void *data);

typedef void (*ev_log_t)(const char *file, int line, const char *func,
                         const char *msg);

typedef void (*ev_freegen_t)(ev_ctx_t *ctx, void *gen);

struct _ev_englist_s {
  struct _ev_engine_s  *el_first;       
  struct _ev_engine_s  *el_last;        
};

struct _ev_ctx_s {
  ev_magic_t            ec_magic;       
  ev_flags_t            ec_flags;       
  const char           *ec_prog;        
  treeconf_ctx_t        ec_conf;        
  unsigned int          ec_maxgen;      
  struct _ev_gens_s    *ec_gens;        
  struct {
    struct _ev_tim_s   *tt_root;        
    struct _ev_tim_s   *tt_insert;      
  }                     ec_timtree;     
  struct _ev_engine_s  *ec_engine;      
  _ev_englist_t         ec_socket;      
  _ev_englist_t         ec_signal;      
  _ev_englist_t         ec_timer;       
  unsigned int          ec_evcnt;       
  event_t              *ec_evs;         
};

#define EV_CTX_MAGIC 0xf3d94057

#define EV_CTX_SECURE           0x00000001

#define EV_CTX_RUNNING          0x00000002

#define ec_verify(ctx)          ((ctx) && (ctx)->ec_magic == EV_CTX_MAGIC)

#define ec_flags(ctx)           ((ctx)->ec_flags)

#define ec_prog(ctx)            ((ctx)->ec_prog)

#define ec_conf(ctx)            (&((ctx)->ec_conf))

struct _event_s {
  ev_magic_t            ev_magic;       
  ev_ctx_t             *ev_context;     
  event_t              *ev_next;        
  event_t              *ev_prev;        
  unsigned int          ev_type;        
  ev_flags_t            ev_flags;       
  ev_genhdr_t          *ev_generator;   
  ev_paramtype_t        ev_paramtype;   
  union {
    unsigned int        evp_int;        
    void               *evp_ptr;        
  }                     ev_param;       
};

#define EVENT_MAGIC 0x7bf8ac57

#define ev_verify(event)        ((event) && (event)->ev_magic == EVENT_MAGIC)

#define ev_context(event)       ((event)->ev_context)

#define ev_type(event)          ((event)->ev_type)

#define ev_generator(event)     ((event)->ev_generator)

#define ev_paramtype(event)     ((event)->ev_paramtype)

#define ev_intparam(event)      ((event)->ev_param.evp_int)

#define ev_ptrparam(event)      ((event)->ev_param.evp_ptr)

struct _ev_genhdr_s {
  ev_magic_t            eg_magic;       
  unsigned int          eg_type;        
  ev_flags_t            eg_flags;       
  ev_genhdr_t          *eg_next;        
  ev_genhdr_t          *eg_prev;        
  ev_ctx_t             *eg_context;     
  unsigned int          eg_ref;         
  ev_call_t             eg_callback;    
  void                 *eg_calldata;    
  union {
    int                 egd_int;        
    void               *egd_ptr;        
  }                     eg_engdata;     
};

#define EV_GEN_ACTIVE           0x00000001

#define EV_GEN_DELETED          0x00000002

#define _eg_hdr(gen)            ((ev_genhdr_t *)(gen))

#define eg_verify(gen, magic)   ((gen) && _eg_hdr(gen)->eg_magic == (magic))

#define eg_type(gen)            ((gen) ? _eg_hdr(gen)->eg_type : EGT_NONE)

#define eg_flags(gen)           (_eg_hdr(gen)->eg_flags)

#define eg_flags_set(gen, fl)   (_eg_hdr(gen)->eg_flags |= (fl))

#define eg_flags_clr(gen, fl)   (_eg_hdr(gen)->eg_flags &= ~(fl))

#define eg_next(gen)            (_eg_hdr(gen)->eg_next)

#define eg_prev(gen)            (_eg_hdr(gen)->eg_prev)

#define eg_context(gen)         (_eg_hdr(gen)->eg_context)

#define eg_ref(gen)             (_eg_hdr(gen)->eg_ref)

#define eg_ref_inc(ctx, gen)    (_eg_hdr(gen)->eg_ref++)

#define eg_ref_dec(ctx, gen)                                                  \
do {                                                                          \
  ev_genhdr_t *_gen = _eg_hdr(gen);                                           \
  if (_gen->eg_ref && !--_gen->eg_ref && (_gen->eg_flags & EV_GEN_DELETED))   \
    event_gen_release((ctx), _gen); /* release the generator */               \
} while (0)

#define eg_callback(gen)        (_eg_hdr(gen)->eg_callback)

#define eg_callback_set(gen, call)                                            \
                                (_eg_hdr(gen)->eg_callback = (call))

#define eg_calldata(gen)        (_eg_hdr(gen)->eg_calldata)

#define eg_calldata_set(gen, data)                                            \
                                (_eg_hdr(gen)->eg_calldata = (data))

extern ev_err_t event_init(ev_ctx_t *ctx, const ev_attr_t *attr,
                           ev_flags_t flags, const char *prog,
                           const char *envpath)
     _gca_nonnull((1)) _gca_useresult;

extern ev_err_t event_destroy(ev_ctx_t *ctx)
     _gca_nonnull((1));

#define EV_INIT_SECURE          EV_CTX_SECURE

extern ev_err_t event_attr_init(ev_attr_t *attr)
     _gca_nonnull((1));

extern ev_err_t event_attr_confpath(ev_attr_t *attr, const char **path)
     _gca_nonnull((1, 2));

extern ev_err_t event_attr_libpath(ev_attr_t *attr, const char **path)
     _gca_nonnull((1, 2));

extern ev_err_t event_attr_modlist(ev_attr_t *attr, const char **list)
     _gca_nonnull((1, 2));

extern ev_err_t event_attr_confreg(ev_attr_t *attr, const char *name,
                                   const char *def,
                                   treeconf_nodown_t nodown,
                                   treeconf_change_t change, void *assoc)
     _gca_nonnull((1, 2));

extern ev_err_t event_attr_confvar(ev_attr_t *attr, const char *name,
                                   const char *value)
     _gca_nonnull((1, 2));

extern ev_err_t event_attr_destroy(ev_attr_t *attr)
     _gca_nonnull((1));

extern ev_err_t event_gen_register(ev_ctx_t *ctx, unsigned int gentype,
                                   ev_magic_t genmagic, size_t gensize,
                                   ev_freegen_t genrel)
     _gca_nonnull((1));

extern ev_err_t event_gen_alloc(ev_ctx_t *ctx, unsigned int gentype, void *gen)
     _gca_nonnull((1, 3));

extern ev_err_t event_gen_release(ev_ctx_t *ctx, ev_genhdr_t *gen)
     _gca_nonnull((1, 2));

extern ev_err_t event_log_set(ev_log_t logger);

extern ev_err_t event_log_reset(void);

extern ev_err_t event_log_debug(int onoff);

extern ev_err_t event_log_trace(int onoff);

extern ev_err_t event_log_abort(int onoff);

EV_END_C_DECLS

#endif /* __include_event_event_h__ */

---