From 4ad2ea2af98ea8d53d9afdc8516e662c4b13734f Mon Sep 17 00:00:00 2001 From: "John D. Robertson" Date: Tue, 15 Sep 2020 11:31:27 -0400 Subject: [PATCH] update ez files --- es.c | 277 +++++++++++-- es.h | 90 +++-- ez.h | 128 ++++++ ez_es.c | 171 -------- ez_es.h | 144 ------- ez_libanl.h | 49 +-- ez_libc.c | 507 +++++++++++------------ ez_libc.h | 1015 +++++++++++++++++++++-------------------------- ez_libdb.c | 70 +--- ez_libdb.h | 156 +++----- ez_libpthread.c | 57 +-- ez_libpthread.h | 124 +++--- ez_libz.c | 79 +--- ez_libz.h | 166 +++----- pdns.c | 2 +- 15 files changed, 1319 insertions(+), 1716 deletions(-) create mode 100644 ez.h delete mode 100644 ez_es.c delete mode 100644 ez_es.h diff --git a/es.c b/es.c index 3b89732..bd95088 100644 --- a/es.c +++ b/es.c @@ -1,3 +1,4 @@ +#define _GNU_SOURCE #include #include #include @@ -6,11 +7,11 @@ #include #include -#include "util.h" -#include "msgqueue.h" -#include "ez_es.h" -#include "map.h" +#include "es.h" #include "ez_libpthread.h" +#include "map.h" +#include "msgqueue.h" +#include "util.h" /* Types of registered callbacks */ enum ES_type { @@ -79,9 +80,14 @@ static _Thread_local struct _TS { */ pthread_t tid; + enum { + TS_PROCESSING_FLG= 1<<0 + } flags; + /* Vectors of Cb by type, for fast processing */ PTRVEC fd_vec, - timer_vec; + timer_vec, + deleted_vec; PTRVEC sig_vec_arr[NUMSIGS]; // One vector for each Unix signal /* Hash table to quickly find Cb's */ @@ -98,6 +104,7 @@ static _Thread_local struct _TS { MAP cb_map; } vsig; + } TS; static void @@ -115,6 +122,10 @@ UnixSignalHandler (int signo) /******************************************************************/ typedef struct { + enum { + CB_DELETED_FLG=1<<31 + } flags; + int64_t lastActivity_ms; /* Process-wide unique integer */ @@ -188,6 +199,7 @@ Cb_FdConstructor( */ { assert(self); + memset(self, 0, sizeof(*self)); self->key= ++S.keySrc; self->type= ES_FD_TYPE; self->un.fd.fd= fd; @@ -213,6 +225,7 @@ Cb_SignalConstructor( */ { assert(self); + memset(self, 0, sizeof(*self)); self->key= ++S.keySrc; self->type= ES_SIG_TYPE; self->un.sig.signum= signum; @@ -235,6 +248,7 @@ Cb_VSignalConstructor( */ { assert(self); + memset(self, 0, sizeof(*self)); self->key= ++S.keySrc; self->type= ES_VSIG_TYPE; self->un.sig.signum= signum; @@ -258,6 +272,7 @@ Cb_TimerConstructor( */ { assert(self); + memset(self, 0, sizeof(*self)); self->key= ++S.keySrc; self->type= ES_TIMER_TYPE; #if ! (defined (_WIN32) || defined (__CYGWIN__)) @@ -337,7 +352,8 @@ initialize() if(!(S.flags & GLOBAL_INIT_FLG)) { S.flags |= GLOBAL_INIT_FLG; - if(-1 == sigemptyset(&S.dflt_sa.set)) assert(0); + if(-1 == sigemptyset(&S.dflt_sa.set)) + assert(0); MAP_constructor(&S.vsig.thrd_ts_map, 10, 10); } /* Release the global mutex */ @@ -346,10 +362,12 @@ initialize() /* Per-thread static data */ PTRVEC_constructor(&TS.fd_vec, 10); PTRVEC_constructor(&TS.timer_vec, 10); + PTRVEC_constructor(&TS.deleted_vec, 10); for(int i= 0; i < NUMSIGS; ++i) { PTRVEC_constructor(&TS.sig_vec_arr[i], 10); } - if(-1 == sigemptyset(&TS.sigsRaised)) assert(0); + if(-1 == sigemptyset(&TS.sigsRaised)) + assert(0); MAP_constructor(&TS.key_map, 10, 10); @@ -411,16 +429,19 @@ ES_registerSignal ( sigaddset(&S.dflt_sa.set, signum); - if (sigaction (signum, &act, &S.dflt_sa.arr[ndx])) assert (0); + if (sigaction (signum, &act, &S.dflt_sa.arr[ndx])) + assert (0); } else { - if (sigaction (signum, &act, NULL)) assert (0); + if (sigaction (signum, &act, NULL)) + assert (0); } } - if(!Cb_SignalCreate(cb, signum, callback_f, ctxt)) assert(0); + if(!Cb_SignalCreate(cb, signum, callback_f, ctxt)) + assert(0); /* All callbacks are put in the key table */ MAP_addTypedKey(&TS.key_map, cb->key, cb); @@ -455,7 +476,8 @@ ES_registerVSignal ( Cb *cb; - if(!Cb_VSignalCreate(cb, signum, callback_f, ctxt)) assert(0); + if(!Cb_VSignalCreate(cb, signum, callback_f, ctxt)) + assert(0); /* Place in the virtual signal map indexed on signum */ MAP_addTypedKey(&TS.vsig.cb_map, cb->un.sig.signum, cb); @@ -481,7 +503,8 @@ ES_registerFd ( if(TS.tid != pthread_self()) initialize(); Cb *cb; - if(!Cb_FdCreate(cb, fd, events, callback_f, ctxt)) assert(0); + if(!Cb_FdCreate(cb, fd, events, callback_f, ctxt)) + assert(0); /* Index to vector for quick processing */ PTRVEC_addTail(&TS.fd_vec, cb); @@ -505,7 +528,8 @@ ES_registerTimer ( if(TS.tid != pthread_self()) initialize(); Cb *cb; - if(!Cb_TimerCreate(cb, pause_ms, interval_ms, callback_f, ctxt)) assert(0); + if(!Cb_TimerCreate(cb, pause_ms, interval_ms, callback_f, ctxt)) + assert(0); /* Add to the timer vector */ PTRVEC_addTail(&TS.timer_vec, cb); @@ -525,17 +549,33 @@ ES_unregister (int key) if(TS.tid != pthread_self()) initialize(); Cb *cb = MAP_findTypedItem(&TS.key_map, key); - if(!cb) return -1; + if(!cb) { +#ifdef qqDEBUG + eprintf("WARNING: could not find callback with key= %d", key); +#endif + return -1; + } + + /* If the callback processing is currently active, do not delete it */ + if(TS.flags & TS_PROCESSING_FLG) { + if(!(cb->flags & CB_DELETED_FLG)) { + cb->flags |= CB_DELETED_FLG; + PTRVEC_addTail(&TS.deleted_vec, cb); + } + return 0; + } /* Remove from key table */ - if(!MAP_removeTypedItem(&TS.key_map, key)) assert(0);; + if(!MAP_removeTypedItem(&TS.key_map, key)) + assert(0); /* Different operations needed based on type */ switch(cb->type) { case ES_FD_TYPE: /* Remove from file descriptor vector */ - if(!PTRVEC_remove(&TS.fd_vec, cb)) assert(0); + if(!PTRVEC_remove(&TS.fd_vec, cb)) + assert(0); break; case ES_SIG_TYPE: @@ -543,7 +583,8 @@ ES_unregister (int key) unsigned ndx= signum2dflt_sa_ndx(cb->un.sig.signum); /* Remove from appropriate signals vector */ - if(!PTRVEC_remove(&TS.sig_vec_arr[ndx], cb)) assert(0); + if(!PTRVEC_remove(&TS.sig_vec_arr[ndx], cb)) + assert(0); /* If there are no more signals in this vector */ if(!PTRVEC_numItems(&TS.sig_vec_arr[ndx])) { @@ -551,17 +592,20 @@ ES_unregister (int key) assert(sigismember(&S.dflt_sa.set, cb->un.sig.signum)); /* Restore default signal handling */ - if (sigaction (cb->un.sig.signum, &S.dflt_sa.arr[ndx], NULL)) assert (0); + if (sigaction (cb->un.sig.signum, &S.dflt_sa.arr[ndx], NULL)) + assert (0); } } break; case ES_VSIG_TYPE: - if(!MAP_removeSpecificTypedItem(&TS.vsig.cb_map, cb->un.sig.signum, cb)) assert(0); + if(!MAP_removeSpecificTypedItem(&TS.vsig.cb_map, cb->un.sig.signum, cb)) + assert(0); break; case ES_TIMER_TYPE: /* Remove from timer vector */ - if(!PTRVEC_remove(&TS.timer_vec, cb)) assert(0); + if(!PTRVEC_remove(&TS.timer_vec, cb)) + assert(0); break; default: @@ -612,22 +656,23 @@ ES_run (void) * Whatever nonzero value one of the callbacks() returned. */ { + int rtn= -1; if(TS.tid != pthread_self()) initialize(); /* Loop forever */ for(;;) { + TS.flags |= TS_PROCESSING_FLG; int numFds= PTRVEC_numItems(&TS.fd_vec); struct pollfd pollItemArr[numFds]; Cb *cbArr[numFds]; - /* This sort provides fair queuing */ PTRVEC_sort(&TS.fd_vec, lastActivity_cmp); - /****** Load up the ZeroMQ pollItemArr *****/ + /****** Load up the pollItemArr *****/ unsigned i; Cb *cb; PTRVEC_loopFwd(&TS.fd_vec, i, cb) { @@ -694,8 +739,8 @@ ES_run (void) switch(errno) { case EFAULT: - eprintf("\tpoll() failed"); - return -1; + eprintf("ERROR: poll() failed"); + goto abort; case EINTR: /* Signal caused poll() to return, which is OK */ @@ -725,10 +770,14 @@ ES_run (void) assert(ES_SIG_TYPE == cb->type); - /* Call the callback function */ - int error= (* cb->un.sig.callback_f)(cb->ctxt, signum); + if(cb->flags & CB_DELETED_FLG) + continue; - if(error) return error; + /* Call the callback function */ + rtn= (* cb->un.sig.callback_f)(cb->ctxt, signum); + + if(rtn) + goto abort; } } } @@ -747,6 +796,9 @@ ES_run (void) PTRVEC_loopFwd(&TS.timer_vec, i, cb) { + if(cb->flags & CB_DELETED_FLG) + continue; + /* See how much time remains for this callback */ remaining_ms= msec2timeout(cb, time_ms); @@ -757,7 +809,7 @@ ES_run (void) ++cb->un.timer.count; /* Call the callback function */ - int error= (* cb->un.timer.callback_f)(cb->ctxt); + rtn= (* cb->un.timer.callback_f)(cb->ctxt); /* If this is a single-shot timer, get rid of it now */ if(!cb->un.timer.interval_ms) { @@ -767,9 +819,11 @@ ES_run (void) } /* If the callback returned non-zero, bail out */ - if(error) return error; + if(rtn) + goto abort; - } else break; /* time remaining will increase from here on out */ + } else + break; /* time remaining will increase from here on out */ } } @@ -783,31 +837,36 @@ ES_run (void) Cb *cb= cbArr[i]; + if(cb->flags & CB_DELETED_FLG) + continue; + #if ! (defined (_WIN32) || defined (__CYGWIN__)) cb->lastActivity_ms= clock_gettime_ms(CLOCK_MONOTONIC_COARSE); #else cb->lastActivity_ms= clock_gettime_ms(CLOCK_MONOTONIC); #endif - int error; - switch(cb->type) { + assert(ES_FD_TYPE == cb->type); - case ES_FD_TYPE: - /* Call the callback function */ - error= (* cb->un.fd.callback_f)(cb->ctxt, item->fd, item->revents); - break; - - default: - assert(0); - } + rtn= (* cb->un.fd.callback_f)(cb->ctxt, item->fd, item->revents); /* If the callback returned non-zero, bail out */ - if(error) return error; + if(rtn) + goto abort; + } + + { /*--- Free any callbacks marked for deletion ---*/ + Cb *cb; + TS.flags &= ~TS_PROCESSING_FLG; + while((cb= PTRVEC_remTail(&TS.deleted_vec))) { + if(ES_unregister(cb->key)) + assert(0); + } } } - /* Shouldn't ever get to here */ - assert(0); +abort: + return rtn; } pthread_t @@ -979,3 +1038,135 @@ abort: ez_pthread_mutex_unlock(&S.vsig.mtx); return rtn; } + +/*=====================================================================================*/ +/*===================== ez_xxx() ======================================================*/ +/*=====================================================================================*/ + +/***************************************************/ +ez_proto (int, ES_registerFd, + int fd, + short events, + int (*callback_f)(void *ctxt, int fd, short events), + void *ctxt + ) +{ + int rtn= ES_registerFd(fd, events, callback_f, ctxt); + if(-1 == rtn) { + _eprintf( +#ifdef DEBUG + fileName, lineNo, funcName, +#endif + "ES_registerFd() failed."); + abort(); + } + return rtn; +} + +/***************************************************/ + +ez_proto (int, ES_registerSignal, + int signum, + int (*callback_f)(void *ctxt, int signo), + void *ctxt + ) +{ + int rtn= ES_registerSignal(signum, callback_f, ctxt); + if(-1 == rtn) { + _eprintf( +#ifdef DEBUG + fileName, lineNo, funcName, +#endif + "ES_registerSignal() failed."); + abort(); + } + return rtn; +} + +/***************************************************/ + +ez_proto (int, ES_registerVSignal, + int signum, + int (*callback_f)(void *ctxt,int signo), + void *ctxt + ) +{ + int rtn= ES_registerVSignal(signum, callback_f, ctxt); + if(-1 == rtn) { + _eprintf( +#ifdef DEBUG + fileName, lineNo, funcName, +#endif + "ES_registerVSignal() failed."); + abort(); + } + return rtn; +} + +/***************************************************/ +ez_proto (int, ES_VSignal, + pthread_t tid, + int signum) +{ + int rtn= ES_VSignal(tid, signum); + if(rtn) { + _eprintf( +#ifdef DEBUG + fileName, lineNo, funcName, +#endif + "ES_VSignal() returned %d.", rtn); + abort(); + } + return rtn; +} + +/***************************************************/ +ez_proto (int, ES_registerTimer, + int64_t pause_ms, + int64_t interval_ms, + int (*callback_f)(void *ctxt), + void *ctxt + ) +{ + int rtn= ES_registerTimer(pause_ms, interval_ms, callback_f, ctxt); + if(-1 == rtn) { + _eprintf( +#ifdef DEBUG + fileName, lineNo, funcName, +#endif + "ES_registerTimer() failed."); + abort(); + } + return rtn; +} + +/***************************************************/ +ez_proto ( int, ES_unregister, int key) +{ + int rtn= ES_unregister(key); + if(-1 == rtn) { + _eprintf( +#ifdef DEBUG + fileName, lineNo, funcName, +#endif + "ES_unregister() failed."); + abort(); + } + return rtn; +} + +/***************************************************/ +ez_proto (int, ES_run) +{ + int rtn= ES_run(); + if(rtn) { + _eprintf( +#ifdef DEBUG + fileName, lineNo, funcName, +#endif + "ES_run() returned %d", rtn); + abort(); + } + return rtn; +} + diff --git a/es.h b/es.h index 493b83c..7951653 100644 --- a/es.h +++ b/es.h @@ -7,20 +7,23 @@ * timers. ****************************************************************************************/ +#ifndef _GNU_SOURCE +# define _GNU_SOURCE +#endif #include #include +#include "ez.h" + #ifdef __cplusplus extern "C" { #endif -int -ES_registerFd ( +ez_hdr_proto (int, ES_registerFd, int fd, short events, int (*callback_f)(void *ctxt, int fd, short events), - void *ctxt - ); + void *ctxt); /********************************************************************** * Register a function to be called when there is activity on the * file descriptor (which may be a file, socket, pipe, etc. under Unix). @@ -34,13 +37,18 @@ ES_registerFd ( * If successful, a positive integer which can be used to unregister the callback. * On failure, -1 is returned. */ +#ifdef DEBUG +# define ez_ES_registerFd(...) \ + _ez_ES_registerFd(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_ES_registerFd(...) \ + _ez_ES_registerFd(__VA_ARGS__) +#endif -int -ES_registerSignal ( +ez_hdr_proto (int, ES_registerSignal, int signum, int (*callback_f)(void *ctxt, int signo), - void *ctxt - ); + void *ctxt); /********************************************************************** * Register a function to be called when a particular Unix signal is * raised. Note: callback_f() is not called from a Unix signal handler, @@ -54,13 +62,18 @@ ES_registerSignal ( * If successful, a positive integer which can be used to unregister the callback. * On failure, -1 is returned. */ +#ifdef DEBUG +# define ez_ES_registerSignal(...) \ + _ez_ES_registerSignal(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_ES_registerSignal(...) \ + _ez_ES_registerSignal(__VA_ARGS__) +#endif -int -ES_registerVSignal ( +ez_hdr_proto (int, ES_registerVSignal, int signum, int (*callback_f)(void *ctxt,int signo), - void *ctxt - ); + void *ctxt); /********************************************************************** * Register a function to be called when a particular virtual signal is * raised. Virtual signals are implemented on top of the Unix signal, SIGUSR2. @@ -73,9 +86,17 @@ ES_registerVSignal ( * If successful, a positive integer which can be used to unregister the callback. * On failure, -1 is returned. */ +#ifdef DEBUG +# define ez_ES_registerVSignal(...) \ + _ez_ES_registerVSignal(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_ES_registerVSignal(...) \ + _ez_ES_registerVSignal(__VA_ARGS__) +#endif -int -ES_VSignal (pthread_t tid, int signum); +ez_hdr_proto (int, ES_VSignal, + pthread_t tid, + int signum); /********************************************************************** * Send a virtual signal to tid, which is multiplexed on SIGUSR2. * @@ -86,9 +107,15 @@ ES_VSignal (pthread_t tid, int signum); * 0: successful * -1: failures. */ +#ifdef DEBUG +# define ez_ES_VSignal(...) \ + _ez_ES_VSignal(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_ES_VSignal(...) \ + _ez_ES_VSignal(__VA_ARGS__) +#endif -int -ES_registerTimer ( +ez_hdr_proto (int, ES_registerTimer, int64_t pause_ms, int64_t interval_ms, int (*callback_f)(void *ctxt), @@ -109,11 +136,16 @@ ES_registerTimer ( * If successful, a positive integer which can be used to unregister the callback. * On failure, -1 is returned. */ +#ifdef DEBUG +# define ez_ES_registerTimer(...) \ + _ez_ES_registerTimer(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_ES_registerTimer(...) \ + _ez_ES_registerTimer(__VA_ARGS__) +#endif - - -int -ES_unregister (int key); +ez_hdr_proto (int, ES_unregister, + int key); /********************************************************************** * Unegister a previously registered callback. * @@ -123,10 +155,15 @@ ES_unregister (int key); * 0 for success. * -1 for failure (key not found) */ +#ifdef DEBUG +# define ez_ES_unregister(...) \ + _ez_ES_unregister(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_ES_unregister(...) \ + _ez_ES_unregister(__VA_ARGS__) +#endif - -int -ES_run (void); +ez_hdr_proto (int, ES_run); /********************************************************************** * For this thread, use poll() to process socket activity until one * of the registered callback_f() returns non-zero. @@ -134,6 +171,13 @@ ES_run (void); * RETURNS: * Whatever nonzero value callback_f() returned. */ +#ifdef DEBUG +# define ez_ES_run(...) \ + _ez_ES_run(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_ES_run(...) \ + _ez_ES_run(__VA_ARGS__) +#endif pthread_t ES_spawn_thread_sched( diff --git a/ez.h b/ez.h new file mode 100644 index 0000000..d7c9ec9 --- /dev/null +++ b/ez.h @@ -0,0 +1,128 @@ +/***************************************************************************** + * In an effort to make C programming both easier and more secure, I present + * the EZ method. + * + * Reasoning for this is simple; Many function calls can fail for a variety of + * reasons, some or even most of which are obscure. However, it is both + * insecure and counterproductive not to check for said failures. Unfortunately + * coding proper checks and/or recovery from failures will involve (often + * complex) logic constructs, and detracts from understanding the primary logic + * of your source code. + * + * Sometimes your app needs to recover, and so you must supply this code, but + * more often than not a "boilplate" approach is sufficient. The EZ method is a + * consistent convention to supply centralized and reusable "boilerplate" error + * handling on an _optional_ basis, both for existing library functions and + * your own. + * + * Modern programming languages address this problem by throwing "exceptions", + * which by default result in your program getting terminated. To avoid + * termination you must write code to "catch" such exceptions, but this code + * exists separated in source code from the function call, and tends to be both + * confusing to read and hideous to look at. If you thought "goto" statements + * were in poor taste, then this will make you vomit. + * + * Enter the EZ method; from a practical coding standpoint you merely prepend + * "ez_" to any function call for which you desire default error handling. When + * an error occurs a very helpful error message is printed (in DEBUG mode this + * includes the source code location from which the function was called), and + * your program is terminated. If your app needs to recover from such an error, + * simply erase the "ez_" prefix from the function call and supply the recovery + * code, where God intended it to be - right where you made the function call! + * + * In effect the EZ method provides the utility of throwing exceptions, but + * without the catch - Woohoo! + *****************************************************************************/ + +#ifndef EZ_H +#define EZ_H + + +/***************************************************************************** + * These macros ease the drudgery of writing prototypes for the _ez_XXX() + * wrappers of functions, and reduce the liklihood of bugs due to typing + * errors. + * + * The elipses is for your function's argument list. + *****************************************************************************/ + +#ifdef DEBUG + +#define ez_proto(rtn, funcname, ...) \ + rtn _ez_##funcname( \ + const char *fileName, \ + int lineNo, \ + const char *funcName, \ + ##__VA_ARGS__ \ + ) + +#define ez_hdr_proto(rtn, funcname, ...) \ + ez_proto(rtn, funcname, ##__VA_ARGS__); \ + rtn funcname(__VA_ARGS__) + +#else + +#define ez_proto(rtn, funcname, ...) \ + rtn _ez_##funcname(__VA_ARGS__) + +#define ez_hdr_proto(rtn, funcname, ...) \ + ez_proto(rtn, funcname, ##__VA_ARGS__); \ + rtn funcname(__VA_ARGS__) + +#endif + +/***************************************************************************** + * For example, if you have the following function prototype: + * + * int myfunc (struct foo *f, double bar) + * + * In the header file where the function prototype goes, + * you will need this: + * + * ez_hdr_proto (int, myfunc, struct foo *f, double bar); + * + * #ifdef DEBUG + * # define ez_myfunc(...) \ + * _ez_myfunc(__FILE__, __LINE__, __func__, ##__VA_ARGS__) + * #else + * # define ez_myfunc(...) \ + * _ez_myfunc(__VA_ARGS__) + * #endif + * + * This will expand to the standard function prototype as listed above, as well + * as the _ez_myfunc() prototype correct for either DEBUG version or production + * version, depending on whether or not DEBUG is #define'd. Also, there is now + * a macro ez_myfunc() which will expand to the correct _ez_myfunc() + * function call. + * + * In the implmentation (*.c) file, you will need to supply code for + * _ez_myfunc(), which looks like so: + * + * ez_proto(int, myfunc, struct foo *f, double bar) + * { + * // implementation goes here + * } + * + * Notice that the prototype section is is the same as what you placed in the + * corresponding header file, minus "_hdr" in the ez_hdr_proto() macro. + * + * For the case where you are supplying only the ez_XXX() version of an + * existing function found in some library 'liba2z', you can place the + * following in your own header file, "ez_liba2z.h": + * + * ez_proto(struct rtnType*, liba2z_funcname, struct foo *f, double bar); + * + * Everything else works similar to the previous examples. + * Now you can use the EZ error handling like so: + * + * #include "ez_liba2z.h" + * int main(int argc, char **argv) + * { + * struct foo Foo; + * double bar; + * struct rtnType *rtn= ez_liba2z_funcname(&Foo, bar); + * } + * + *****************************************************************************/ + +#endif diff --git a/ez_es.c b/ez_es.c deleted file mode 100644 index b95bd6b..0000000 --- a/ez_es.c +++ /dev/null @@ -1,171 +0,0 @@ -#include - -#include "util.h" -#include "ez_es.h" - -/***************************************************/ -int _ez_ES_registerFd ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - int fd, - short events, - int (*callback_f)(void *ctxt, int fd, short events), - void *ctxt - ) -{ - int rtn= ES_registerFd(fd, events, callback_f, ctxt); - if(-1 == rtn) { - _eprintf( -#ifdef DEBUG - fileName, lineNo, funcName, -#endif - "ES_registerFd() failed."); - abort(); - } - return rtn; -} - -/***************************************************/ - -int _ez_ES_registerSignal ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - int signum, - int (*callback_f)(void *ctxt, int signo), - void *ctxt - ) -{ - int rtn= ES_registerSignal(signum, callback_f, ctxt); - if(-1 == rtn) { - _eprintf( -#ifdef DEBUG - fileName, lineNo, funcName, -#endif - "ES_registerSignal() failed."); - abort(); - } - return rtn; -} - -/***************************************************/ - -int _ez_ES_registerVSignal ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - int signum, - int (*callback_f)(void *ctxt, int signo), - void *ctxt - ) -{ - int rtn= ES_registerVSignal(signum, callback_f, ctxt); - if(-1 == rtn) { - _eprintf( -#ifdef DEBUG - fileName, lineNo, funcName, -#endif - "ES_registerVSignal() failed."); - abort(); - } - return rtn; -} - -/***************************************************/ -int _ez_ES_VSignal ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - pthread_t tid, - int signum - ) -{ - int rtn= ES_VSignal(tid, signum); - if(rtn) { - _eprintf( -#ifdef DEBUG - fileName, lineNo, funcName, -#endif - "ES_VSignal() returned %d.", rtn); - abort(); - } - return rtn; -} - -/***************************************************/ -int _ez_ES_registerTimer ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - int64_t pause_ms, - int64_t interval_ms, - int (*callback_f)(void *ctxt), - void *ctxt - ) -{ - int rtn= ES_registerTimer(pause_ms, interval_ms, callback_f, ctxt); - if(-1 == rtn) { - _eprintf( -#ifdef DEBUG - fileName, lineNo, funcName, -#endif - "ES_registerTimer() failed."); - abort(); - } - return rtn; -} - -/***************************************************/ -int _ez_ES_unregister ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - int key - ) -{ - int rtn= ES_unregister(key); - if(-1 == rtn) { - _eprintf( -#ifdef DEBUG - fileName, lineNo, funcName, -#endif - "ES_unregister() failed."); - abort(); - } - return rtn; -} - -/***************************************************/ -int _ez_ES_run ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName -#endif - ) -{ - int rtn= ES_run(); - if(rtn) { - _eprintf( -#ifdef DEBUG - fileName, lineNo, funcName, -#endif - "ES_run() returned %d", rtn); - abort(); - } - return rtn; -} - diff --git a/ez_es.h b/ez_es.h deleted file mode 100644 index 09145d0..0000000 --- a/ez_es.h +++ /dev/null @@ -1,144 +0,0 @@ -/**************************************************************************************************************************** - * NOTE: look in "es.h" for function documentation. The ez_XXX() macros here only wrap the ES_XXX() functions - * for the purpose of boilerplate error handling. - */ - -#ifndef EZ_ES_H -#define EZ_ES_H - -#include "es.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef DEBUG -# define ez_ES_registerFd(fd, events, callback_f, ctxt) \ - _ez_ES_registerFd(__FILE__, __LINE__, __FUNCTION__, fd, events, callback_f, ctxt) -#else -# define ez_ES_registerFd(fd, events, callback_f, ctxt) \ - _ez_ES_registerFd(fd, events, callback_f, ctxt) -#endif -int _ez_ES_registerFd ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - int fd, - short events, - int (*callback_f)(void *ctxt, int fd, short events), - void *ctxt - ); - - - -#ifdef DEBUG -# define ez_ES_registerSignal(signum, callback_f, ctxt) \ - _ez_ES_registerSignal(__FILE__, __LINE__, __FUNCTION__, signum, callback_f, ctxt) -#else -# define ez_ES_registerSignal(signum, callback_f, ctxt) \ - _ez_ES_registerSignal(signum, callback_f, ctxt) -#endif -int _ez_ES_registerSignal ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - int signum, - int (*callback_f)(void *ctxt, int signo), - void *ctxt - ); - -#ifdef DEBUG -# define ez_ES_registerVSignal(signum, callback_f, ctxt) \ - _ez_ES_registerVSignal(__FILE__, __LINE__, __FUNCTION__, signum, callback_f, ctxt) -#else -# define ez_ES_registerVSignal(signum, callback_f, ctxt) \ - _ez_ES_registerVSignal(signum, callback_f, ctxt) -#endif -int _ez_ES_registerVSignal ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - int signum, - int (*callback_f)(void *ctxt, int signo), - void *ctxt - ); - -#ifdef DEBUG -# define ez_ES_VSignal(tid, signum) \ - _ez_ES_VSignal(__FILE__, __LINE__, __FUNCTION__, tid, signum) -#else -# define ez_ES_VSignal(tid, signum) \ - _ez_ES_VSignal(tid, signum) -#endif -int _ez_ES_VSignal ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - pthread_t tid, - int signum - ); - -#ifdef DEBUG -# define ez_ES_registerTimer(pause_ms, interval_ms, callback_f, ctxt) \ - _ez_ES_registerTimer(__FILE__, __LINE__, __FUNCTION__, pause_ms, interval_ms, callback_f, ctxt) -#else -# define ez_ES_registerTimer(pause_ms, interval_ms, callback_f, ctxt) \ - _ez_ES_registerTimer(pause_ms, interval_ms, callback_f, ctxt) -#endif -int _ez_ES_registerTimer ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - int64_t pause_ms, - int64_t interval_ms, - int (*callback_f)(void *ctxt), - void *ctxt - ); - - -#ifdef DEBUG -# define ez_ES_unregister(key) \ - {_ez_ES_unregister(__FILE__, __LINE__, __FUNCTION__, key); (key)= 0;} -#else -# define ez_ES_unregister(key) \ - {_ez_ES_unregister(key); (key)= 0;} -#endif -int _ez_ES_unregister ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - int key - ); - -#ifdef DEBUG -# define ez_ES_run() \ - _ez_ES_run(__FILE__, __LINE__, __FUNCTION__) -#else -# define ez_ES_run() \ - _ez_ES_run() -#endif -int _ez_ES_run ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName -#endif - ); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/ez_libanl.h b/ez_libanl.h index ba07d0f..d84b347 100644 --- a/ez_libanl.h +++ b/ez_libanl.h @@ -20,49 +20,40 @@ #define EZ_LIBANL_H /* Simplified interface to libanl functions */ -#define _GNU_SOURCE +#ifndef _GNU_SOURCE +# define _GNU_SOURCE +#endif #include +#include "ez.h" #ifdef __cplusplus extern "C" { #endif -#ifdef DEBUG -# define ez_getaddrinfo_a(mode, list, nItems, sevp) \ - _ez_getaddrinfo_a(__FILE__, __LINE__, __FUNCTION__, mode, list, nItems, sevp) -#else -# define ez_getaddrinfo_a(mode, list, nItems, sevp) \ - _ez_getaddrinfo_a(mode, list, nItems, sevp) -#endif -int _ez_getaddrinfo_a( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto(int, getaddrinfo_a, int mode, struct gaicb *list[], int nitems, - struct sigevent *sevp - ); - + struct sigevent *sevp); #ifdef DEBUG -# define ez_gai_suspend(list, nItems, timeout) \ - _ez_gai_suspend(__FILE__, __LINE__, __FUNCTION__, list, nItems, timeout) +# define ez_getaddrinfo_a(...) \ + _ez_getaddrinfo_a(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_gai_suspend(list, nItems, timeout) \ - _ez_gai_suspend(list, nItems, timeout) -#endif -int _ez_gai_suspend( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, +# define ez_getaddrinfo_a(...) \ + _ez_getaddrinfo_a(__VA_ARGS__) #endif + +ez_proto (int, gai_suspend, const struct gaicb * const list[], int nitems, - const struct timespec *timeout - ); + const struct timespec *timeout); +#ifdef DEBUG +# define ez_gai_suspend(...) \ + _ez_gai_suspend(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_gai_suspend(...) \ + _ez_gai_suspend(__VA_ARGS__) +#endif #ifdef __cplusplus diff --git a/ez_libc.c b/ez_libc.c index 19465dd..3cb390b 100644 --- a/ez_libc.c +++ b/ez_libc.c @@ -25,15 +25,9 @@ #include "ez_libc.h" /***************************************************/ -int _ez_fputs ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, fputs, const char *s, - FILE *stream - ) + FILE *stream) { int rtn= fputs (s, stream); if (EOF == rtn) { @@ -48,15 +42,9 @@ int _ez_fputs ( } /***************************************************/ -int _ez_fputc ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, fputc, int c, - FILE *stream - ) + FILE *stream) { int rtn= fputc (c, stream); if (EOF == rtn) { @@ -71,16 +59,10 @@ int _ez_fputc ( } /***************************************************/ -int _ez_fprintf ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, fprintf, FILE *stream, const char *fmt, - ... - ) + ...) { va_list args; @@ -94,7 +76,7 @@ int _ez_fprintf ( #ifdef DEBUG , fileName, lineNo, funcName #endif - , "vfprintf() failed"); + , "vfprintf() failed returning %d", rtn); abort(); } @@ -102,15 +84,9 @@ int _ez_fprintf ( } /***************************************************/ -FILE* _ez_popen ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (FILE*, popen, const char *command, - const char *type - ) + const char *type) { errno= 0; FILE *rtn= popen (command, type); @@ -126,15 +102,27 @@ FILE* _ez_popen ( } /***************************************************/ -FILE* _ez_fopen ( +ez_proto (FILE*, fdopen, + int fd, + const char *mode) +{ + FILE *rtn= fdopen (fd, mode); + if (!rtn) { + _sys_eprintf((const char*(*)(int))strerror #ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, + , fileName, lineNo, funcName #endif + , "fdopen(%d, \"%s\") failed", fd, mode); + abort(); + } + return rtn; +} + + +/***************************************************/ +ez_proto (FILE*, fopen, const char *pathname, - const char *mode - ) + const char *mode) { FILE *rtn= fopen (pathname, mode); if (!rtn) { @@ -149,14 +137,23 @@ FILE* _ez_fopen ( } /***************************************************/ -int _ez_fclose ( +ez_proto (pid_t, fork) +{ + int rtn= fork (); + if (-1 == rtn) { + _sys_eprintf((const char*(*)(int))strerror #ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, + , fileName, lineNo, funcName #endif - FILE *stream - ) + , "fork() failed"); + abort(); + } + return rtn; +} + +/***************************************************/ +ez_proto (int, fclose, + FILE *stream) { int rtn= fclose (stream); if (EOF == rtn) { @@ -171,14 +168,8 @@ int _ez_fclose ( } /***************************************************/ -int _ez_fflush ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - FILE *stream - ) +ez_proto (int, fflush, + FILE *stream) { int rtn= fflush (stream); if (EOF == rtn) { @@ -193,17 +184,11 @@ int _ez_fflush ( } /***************************************************/ -size_t _ez_fread ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (size_t, fread, void *ptr, size_t size, size_t nmemb, - FILE *stream - ) + FILE *stream) { size_t rtn= fread (ptr, size, nmemb, stream); if (ferror(stream)) { @@ -218,17 +203,11 @@ size_t _ez_fread ( } /***************************************************/ -size_t _ez_fwrite ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (size_t, fwrite, const void *ptr, size_t size, size_t nmemb, - FILE *stream - ) + FILE *stream) { size_t rtn= fwrite (ptr, size, nmemb, stream); if (ferror(stream)) { @@ -243,14 +222,8 @@ size_t _ez_fwrite ( } /***************************************************/ -int _ez_pclose ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - FILE *stream - ) +ez_proto (int, pclose, + FILE *stream) { int rtn= pclose (stream); if (-1 == rtn) { @@ -265,16 +238,25 @@ int _ez_pclose ( } /***************************************************/ -char* _ez_fgets ( +ez_proto (int, pipe, int pipefd[2]) +{ + int rtn= pipe (pipefd); + if (-1 == rtn) { + _sys_eprintf((const char*(*)(int))strerror #ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, + , fileName, lineNo, funcName #endif + , "pipe() failed"); + abort(); + } + return rtn; +} + +/***************************************************/ +ez_proto (char*, fgets, char *s, int size, - FILE *stream - ) + FILE *stream) { char *rtn= fgets (s, size, stream); if (!rtn && !feof(stream)) { @@ -289,14 +271,8 @@ char* _ez_fgets ( } /***************************************************/ -int _ez_remove ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - const char *pathname - ) +ez_proto (int, remove, + const char *pathname) { int rtn= remove (pathname); if (-1 == rtn) { @@ -311,15 +287,9 @@ int _ez_remove ( } /***************************************************/ -int _ez_rename ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, rename, const char *oldpath, - const char *newpath - ) + const char *newpath) { int rtn= rename (oldpath, newpath); if (-1 == rtn) { @@ -334,14 +304,8 @@ int _ez_rename ( } /***************************************************/ -DIR* _ez_opendir ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - const char *name - ) +ez_proto (DIR*, opendir, + const char *name) { DIR *rtn= opendir (name); if (!rtn) { @@ -356,14 +320,8 @@ DIR* _ez_opendir ( } /***************************************************/ -int _ez_closedir ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - DIR *dirp - ) +ez_proto (int, closedir, + DIR *dirp) { int rtn= closedir (dirp); if (-1 == rtn) { @@ -378,14 +336,40 @@ int _ez_closedir ( } /***************************************************/ -struct dirent* _ez_readdir ( +ez_proto (int, dup2, int oldfd, int newfd) +{ + int rtn= dup2 (oldfd, newfd); + if (-1 == rtn) { + _sys_eprintf((const char*(*)(int))strerror #ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, + , fileName, lineNo, funcName #endif - DIR *dirp - ) + , "dup2() failed"); + abort(); + } + return rtn; +} + +/***************************************************/ +ez_proto (int, execve, + const char *filename, + char *const argv[], + char *const envp[]) +{ + int rtn= execve(filename, argv, envp); + if (-1 == rtn) { + _sys_eprintf((const char*(*)(int))strerror +#ifdef DEBUG + , fileName, lineNo, funcName +#endif + , "execve() failed"); + abort(); + } + return rtn; +} + +/***************************************************/ +ez_proto (struct dirent*, readdir, DIR *dirp) { /* Pass on doctored format string and varargs to vfprintf() */ @@ -405,14 +389,7 @@ struct dirent* _ez_readdir ( } /***************************************************/ -int _ez_close ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - int fd - ) +ez_proto (int, close, int fd) { int rtn= close (fd); if (-1 == rtn) { @@ -427,16 +404,10 @@ int _ez_close ( } /***************************************************/ -ssize_t _ez_write ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (ssize_t, write, int fd, const void *buf, - size_t count - ) + size_t count) { ssize_t rtn= write (fd, buf, count); if (-1 == rtn) { @@ -451,15 +422,9 @@ ssize_t _ez_write ( } /***************************************************/ -int _ez_stat ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - const char *pathname, - struct stat *statbuf - ) +ez_proto (int, stat, + const char *pathname, + struct stat *statbuf) { int rtn= stat (pathname, statbuf); if (-1 == rtn) { @@ -474,15 +439,9 @@ int _ez_stat ( } /***************************************************/ -int _ez_mkdir ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, mkdir, const char *pathname, - mode_t mode - ) + mode_t mode) { int rtn= mkdir (pathname, mode); if (-1 == rtn) { @@ -497,14 +456,8 @@ int _ez_mkdir ( } /***************************************************/ -int _ez_rmdir ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - const char *pathname - ) +ez_proto (int, rmdir, + const char *pathname) { int rtn= rmdir (pathname); if (-1 == rtn) { @@ -519,14 +472,8 @@ int _ez_rmdir ( } /***************************************************/ -int _ez_unlink ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - const char *pathname - ) +ez_proto (int, unlink, + const char *pathname) { int rtn= unlink (pathname); if (-1 == rtn) { @@ -541,17 +488,11 @@ int _ez_unlink ( } /***************************************************/ -int _ez_getaddrinfo( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, getaddrinfo, const char *node, const char *service, const struct addrinfo *hints, - struct addrinfo **res - ) + struct addrinfo **res) { errno= 0; int rtn= getaddrinfo (node, service, hints, res); @@ -583,20 +524,14 @@ int _ez_getaddrinfo( } /***************************************************/ -int _ez_getnameinfo( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, getnameinfo, const struct sockaddr *addr, socklen_t addrlen, char *host, socklen_t hostlen, char *serv, socklen_t servlen, - int flags - ) + int flags) { errno= 0; int rtn= getnameinfo (addr, addrlen, host, hostlen, serv, servlen, flags); @@ -622,20 +557,14 @@ int _ez_getnameinfo( #ifdef DEBUG , fileName, lineNo, funcName #endif - , "getnameinfo() failed", rtn); + , "getnameinfo() failed"); abort(); } /***************************************************/ -int _ez_flock ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, flock, int fd, - int operation - ) + int operation) { errno= 0; int rtn= flock (fd, operation); @@ -658,16 +587,10 @@ int _ez_flock ( } /***************************************************/ -int _ez_open( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, open, const char *pathname, int flags, - mode_t mode - ) + mode_t mode) { errno= 0; int rtn= open (pathname, flags, mode); @@ -690,15 +613,9 @@ int _ez_open( } /***************************************************/ -int _ez_access( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, access, const char *pathname, - int mode - ) + int mode) { errno= 0; int rtn= access (pathname, mode); @@ -720,16 +637,10 @@ int _ez_access( } /***************************************************/ -char *_ez_strptime( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (char*, strptime, const char *s, const char *format, - struct tm *tm - ) + struct tm *tm) { char *rtn= strptime (s, format, tm); if(rtn) return rtn; @@ -744,14 +655,7 @@ char *_ez_strptime( } /***************************************************/ -int _ez_seteuid( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - uid_t euid - ) +ez_proto (int, seteuid, uid_t euid) { int rtn= seteuid (euid); if(0 == rtn) return 0; @@ -765,14 +669,7 @@ int _ez_seteuid( } /***************************************************/ -int _ez_setegid( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - gid_t egid - ) +ez_proto (int, setegid, gid_t egid) { int rtn= setegid (egid); if(0 == rtn) return 0; @@ -786,14 +683,7 @@ int _ez_setegid( } /***************************************************/ -struct group* _ez_getgrnam( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - const char *name - ) +ez_proto (struct group*, getgrnam, const char *name) { errno= 0; struct group *rtn= getgrnam (name); @@ -821,16 +711,10 @@ struct group* _ez_getgrnam( } /***************************************************/ -int _ez_chown( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, chown, const char *pathname, uid_t owner, - gid_t group - ) + gid_t group) { int rtn= chown (pathname, owner, group); if(0 == rtn) return rtn; @@ -844,16 +728,10 @@ int _ez_chown( } /***************************************************/ -int _ez_fchown( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, fchown, int fd, uid_t owner, - gid_t group - ) + gid_t group) { int rtn= fchown (fd, owner, group); if(0 == rtn) return rtn; @@ -867,15 +745,7 @@ int _ez_fchown( } /***************************************************/ -int _ez_fchmod( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - int fd, - mode_t mode - ) +ez_proto (int, fchmod, int fd, mode_t mode) { int rtn= fchmod (fd, mode); if(0 == rtn) return rtn; @@ -889,14 +759,7 @@ int _ez_fchmod( } /***************************************************/ -int _ez_setuid( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - uid_t uid - ) +ez_proto (int, setuid, uid_t uid) { int rtn= setuid (uid); if(0 == rtn) return 0; @@ -910,14 +773,7 @@ int _ez_setuid( } /***************************************************/ -int _ez_setgid( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - gid_t gid - ) +ez_proto (int, setgid, gid_t gid) { int rtn= setgid (gid); if(0 == rtn) return 0; @@ -929,3 +785,86 @@ int _ez_setgid( , "setgid(%d) failed", (int)gid); abort(); } + +/***************************************************/ +ez_proto (int, atexit, + void(*function)(void)) +{ + int rtn= atexit (function); + if(0 == rtn) return 0; + + _sys_eprintf((const char*(*)(int))strerror +#ifdef DEBUG + , fileName, lineNo, funcName +#endif + , "atexit() failed"); + abort(); +} + +/***************************************************/ +ez_proto (int, chdir, + const char *path) +{ + int rtn= chdir (path); + if(0 == rtn) return 0; + + _sys_eprintf((const char*(*)(int))strerror +#ifdef DEBUG + , fileName, lineNo, funcName +#endif + , "chdir(\"%s\") failed", path); + abort(); +} + +/***************************************************/ +ez_proto (int, mkstemp, + char *template) +{ + int rtn= mkstemp (template); + if(-1 != rtn) return rtn; + + _sys_eprintf((const char*(*)(int))strerror +#ifdef DEBUG + , fileName, lineNo, funcName +#endif + , "mkstemp(\"%s\") failed", template); + abort(); +} + +/***************************************************/ +ez_proto (int, mkstemps, + char *template, + int suffixlen) +{ + int rtn= mkstemps (template, suffixlen); + if(-1 != rtn) return rtn; + + _sys_eprintf((const char*(*)(int))strerror +#ifdef DEBUG + , fileName, lineNo, funcName +#endif + , "mkstemps(\"%s\") failed", template); + abort(); +} + + +/***************************************************/ +ez_proto (int, vfprintf, + FILE *stream, + const char *fmt, + va_list ap) +{ + va_list arglist; + va_copy(arglist, ap); + int rtn= vfprintf (stream, fmt, arglist); + if (0 > rtn) { + _sys_eprintf((const char*(*)(int))strerror +#ifdef DEBUG + , fileName, lineNo, funcName +#endif + , "vfprintf() failed"); + abort(); + } + return rtn; +} + diff --git a/ez_libc.h b/ez_libc.h index 816d217..9fae4b7 100644 --- a/ez_libc.h +++ b/ez_libc.h @@ -28,7 +28,9 @@ glibc calls with boilerplate error handling. #ifndef EZ_LIBC_H #define EZ_LIBC_H -#define _GNU_SOURCE +#ifndef _GNU_SOURCE +# define _GNU_SOURCE +#endif #include #include #include @@ -39,657 +41,530 @@ glibc calls with boilerplate error handling. #include #include +#include "ez.h" + #ifdef __cplusplus extern "C" { #endif -#ifdef DEBUG -# define ez_strptime(s, format, tm) \ - _ez_strptime(__FILE__, __LINE__, __FUNCTION__, s, format, tm) -#else -# define ez_strptime(s, format, tm) \ - _ez_strptime(s, format, tm) -#endif -char *_ez_strptime( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - const char *s, - const char *format, - struct tm *tm - ); - -#ifdef DEBUG -# define ez_access(pathname, mode) \ - _ez_access(__FILE__, __LINE__, __FUNCTION__, pathname, mode) -#else -# define ez_access(pathname, mode) \ - _ez_access(pathname, mode) -#endif -int _ez_access( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, access, const char *pathname, - int mode - ); - + int mode); #ifdef DEBUG -# define ez_open(pathname, flags, mode) \ - _ez_open(__FILE__, __LINE__, __FUNCTION__, pathname, flags, mode) +# define ez_access(...) \ + _ez_access(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_open(pathname, flags, mode) \ - _ez_open(pathname, flags, mode) +# define ez_access(...) \ + _ez_access(__VA_ARGS__) #endif -int _ez_open( + +ez_proto (int, atexit, + void(*function)(void)); #ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, +# define ez_atexit(...) \ + _ez_atexit(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_atexit(...) \ + _ez_atexit(__VA_ARGS__) #endif + +ez_proto (int, chdir, + const char *path); +#ifdef DEBUG +# define ez_chdir(...) \ + _ez_chdir(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_chdir(...) \ + _ez_chdir(__VA_ARGS__) +#endif + +ez_proto (int, chown, const char *pathname, - int flags, - mode_t mode - ); - - + uid_t owner, + gid_t group); #ifdef DEBUG -# define ez_fputs(s, stream) \ - _ez_fputs(__FILE__, __LINE__, __FUNCTION__, s, stream) +# define ez_chown(...) \ + _ez_chown(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_fputs(s, stream) \ - _ez_fputs(s, stream) +# define ez_chown(...) \ + _ez_chown(__VA_ARGS__) #endif -int _ez_fputs ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - const char *s, - FILE *stream - ); +ez_proto (int, close, + int fd); #ifdef DEBUG -# define ez_fputc(c, stream) \ - _ez_fputc(__FILE__, __LINE__, __FUNCTION__, c, stream) +# define ez_close(...) \ + _ez_close(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_fputc(c, stream) \ - _ez_fputc(c, stream) +# define ez_close(...) \ + _ez_close(__VA_ARGS__) #endif -int _ez_fputc ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - int c, - FILE *stream - ); +ez_proto (int, closedir, + DIR *dirp); #ifdef DEBUG -# define ez_fprintf(stream, fmt, ...) \ - _ez_fprintf(__FILE__, __LINE__, __FUNCTION__, stream, fmt, ##__VA_ARGS__) +# define ez_closedir(...) \ + _ez_closedir(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_fprintf(stream, fmt, ...) \ - _ez_fprintf(stream, fmt, ##__VA_ARGS__) +# define ez_closedir(...) \ + _ez_closedir(__VA_ARGS__) #endif -int _ez_fprintf ( + +ez_proto (int, dup2, int oldfd, int newfd); #ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, +# define ez_dup2(...) \ + _ez_dup2(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_dup2(...) \ + _ez_dup2(__VA_ARGS__) #endif + +ez_proto (int, execve, + const char *filename, + char *const argv[], + char *const envp[]); +#ifdef DEBUG +# define ez_execve(...) \ + _ez_execve(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_execve(...) \ + _ez_execve(__VA_ARGS__) +#endif + + +ez_proto (int, fchmod, + int fd, + mode_t mode); +#ifdef DEBUG +# define ez_fchmod(...) \ + _ez_fchmod(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_fchmod(...) \ + _ez_fchmod(__VA_ARGS__) +#endif + +ez_proto (int, fchown, + int fd, + uid_t owner, + gid_t group); +#ifdef DEBUG +# define ez_fchown(...) \ + _ez_fchown(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_fchown(...) \ + _ez_fchown(__VA_ARGS__) +#endif + +ez_proto (int, fclose, + FILE *stream); +#ifdef DEBUG +# define ez_fclose(...) \ + _ez_fclose(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_fclose(...) \ + _ez_fclose(__VA_ARGS__) +#endif + +ez_proto (int, fflush, + FILE *stream); +#ifdef DEBUG +# define ez_fflush(...) \ + _ez_fflush(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_fflush(...) \ + _ez_fflush(__VA_ARGS__) +#endif + +ez_proto (char*, fgets, + char *s, + int size, + FILE *stream); +#ifdef DEBUG +# define ez_fgets(...) \ + _ez_fgets(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_fgets(...) \ + _ez_fgets(__VA_ARGS__) +#endif + +ez_proto (FILE*, fdopen, + int fd, + const char *mode); +#ifdef DEBUG +# define ez_fdopen(...) \ + _ez_fdopen(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_fdopen(...) \ + _ez_fdopen(__VA_ARGS__) +#endif + +ez_proto (int, flock, + int fd, + int operation); +#ifdef DEBUG +# define ez_flock(...) \ + _ez_flock(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_flock(...) \ + _ez_flock(__VA_ARGS__) +#endif + +ez_proto (FILE*, fopen, + const char *pathname, + const char *mode); +#ifdef DEBUG +# define ez_fopen(...) \ + _ez_fopen(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_fopen(...) \ + _ez_fopen(__VA_ARGS__) +#endif + +ez_proto (pid_t, fork); +#ifdef DEBUG +# define ez_fork(...) \ + _ez_fork(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_fork(...) \ + _ez_fork(__VA_ARGS__) +#endif + +ez_proto (int, fprintf, FILE *stream, const char *fmt, - ... - ); - + ...); #ifdef DEBUG -# define ez_popen(command, type) \ - _ez_popen(__FILE__, __LINE__, __FUNCTION__, command, type) +# define ez_fprintf(...) \ + _ez_fprintf(__FILE__, __LINE__, __func__, __VA_ARGS__) #else -# define ez_popen(command, type) \ - _ez_popen(command, type) +# define ez_fprintf(...) \ + _ez_fprintf(__VA_ARGS__) #endif -FILE* _ez_popen ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - const char *command, - const char *type - ); +ez_proto (int, fputc, + int c, + FILE *stream); #ifdef DEBUG -# define ez_fopen(pathname, mode) \ - _ez_fopen(__FILE__, __LINE__, __FUNCTION__, pathname, mode) +# define ez_fputc(...) \ + _ez_fputc(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_fopen(pathname, mode) \ - _ez_fopen(pathname, mode) +# define ez_fputc(...) \ + _ez_fputc(__VA_ARGS__) #endif -FILE* _ez_fopen ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - const char *pathname, - const char *mode - ); +ez_proto (int, fputs, + const char *s, + FILE *stream); #ifdef DEBUG -# define ez_fclose(stream) \ - _ez_fclose(__FILE__, __LINE__, __FUNCTION__, stream) +# define ez_fputs(...) \ + _ez_fputs(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_fclose(stream) \ - _ez_fclose(stream) +# define ez_fputs(...) \ + _ez_fputs(__VA_ARGS__) #endif -int _ez_fclose ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - FILE *stream - ); -#ifdef DEBUG -# define ez_fflush(stream) \ - _ez_fflush(__FILE__, __LINE__, __FUNCTION__, stream) -#else -# define ez_fflush(stream) \ - _ez_fflush(stream) -#endif -int _ez_fflush ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - FILE *stream - ); - -#ifdef DEBUG -# define ez_fread(ptr, size, nmemb, stream) \ - _ez_fread(__FILE__, __LINE__, __FUNCTION__, ptr, size, nmemb, stream) -#else -# define ez_fread(ptr, size, nmemb, stream) \ - _ez_fread(ptr, size, nmemb, stream) -#endif -size_t _ez_fread( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (size_t, fread, void *ptr, size_t size, size_t nmemb, - FILE *stream - ); - + FILE *stream); #ifdef DEBUG -# define ez_fwrite(ptr, size, nmemb, stream) \ - _ez_fwrite(__FILE__, __LINE__, __FUNCTION__, ptr, size, nmemb, stream) +# define ez_fread(...) \ + _ez_fread(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_fwrite(ptr, size, nmemb, stream) \ - _ez_fwrite(ptr, size, nmemb, stream) -#endif -size_t _ez_fwrite( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, +# define ez_fread(...) \ + _ez_fread(__VA_ARGS__) #endif + +ez_proto (size_t, fwrite, const void *ptr, size_t size, size_t nmemb, - FILE *stream - ); - - + FILE *stream); #ifdef DEBUG -# define ez_pclose(stream) \ - _ez_pclose(__FILE__, __LINE__, __FUNCTION__, stream) +# define ez_fwrite(...) \ + _ez_fwrite(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_pclose(stream) \ - _ez_pclose(stream) -#endif -int _ez_pclose ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - FILE *stream - ); - -#ifdef DEBUG -# define ez_fgets(s, size, stream) \ - _ez_fgets(__FILE__, __LINE__, __FUNCTION__, s, size, stream) -#else -# define ez_fgets(s, size, stream) \ - _ez_fgets(s, size, stream) -#endif -char* _ez_fgets ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - char *s, - int size, - FILE *stream - ); - -#ifdef DEBUG -# define ez_remove(pathname) \ - _ez_remove(__FILE__, __LINE__, __FUNCTION__, pathname) -#else -# define ez_remove(pathname) \ - _ez_remove(pathname) -#endif -int _ez_remove ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - const char *pathname - ); - -#ifdef DEBUG -# define ez_rename(oldpath, newpath) \ - _ez_rename(__FILE__, __LINE__, __FUNCTION__, oldpath, newpath) -#else -# define ez_rename(oldpath, newpath) \ - _ez_rename(oldpath, newpath) -#endif -int _ez_rename ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - const char *oldpath, - const char *newpath - ); - -#ifdef DEBUG -# define ez_opendir(name) \ - _ez_opendir(__FILE__, __LINE__, __FUNCTION__, name) -#else -# define ez_opendir(name) \ - _ez_opendir(name) -#endif -DIR* _ez_opendir ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - const char *name - ); - -#ifdef DEBUG -# define ez_closedir(dirp) \ - _ez_closedir(__FILE__, __LINE__, __FUNCTION__, dirp) -#else -# define ez_closedir(dirp) \ - _ez_closedir(dirp) -#endif -int _ez_closedir ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - DIR *dirp - ); - -#ifdef DEBUG -# define ez_readdir(dirp) \ - _ez_readdir(__FILE__, __LINE__, __FUNCTION__, dirp) -#else -# define ez_readdir(dirp) \ - _ez_readdir(dirp) -#endif -struct dirent* _ez_readdir ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - DIR *dirp - ); - -#ifdef DEBUG -# define ez_close(fd) \ - _ez_close(__FILE__, __LINE__, __FUNCTION__, fd) -#else -# define ez_close(fd) \ - _ez_close(fd) -#endif -int _ez_close ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - int fd - ); - -#if 0 -// FIXME: this needs to be implemented and tested -#define ez_read(fd, buf, count) \ - _ez_read(__FILE__, __LINE__, __FUNCTION__, fd, buf, count) -ssize_t _ez_read ( - const char *fileName, - int lineNo, - const char *funcName, - int fd, - void *buf, - size_t count - ); +# define ez_fwrite(...) \ + _ez_fwrite(__VA_ARGS__) #endif -#ifdef DEBUG -# define ez_write(fd, buf, count) \ - _ez_write(__FILE__, __LINE__, __FUNCTION__, fd, buf, count) -#else -# define ez_write(fd, buf, count) \ - _ez_write(fd, buf, count) -#endif -ssize_t _ez_write ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - int fd, - const void *buf, - size_t count - ); - -#ifdef DEBUG -# define ez_stat(pathname, statbuf) \ - _ez_stat(__FILE__, __LINE__, __FUNCTION__, pathname, statbuf) -#else -# define ez_stat(pathname, statbuf) \ - _ez_stat(pathname, statbuf) -#endif -int _ez_stat ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - const char *pathname, - struct stat *statbuf - ); - -#ifdef DEBUG -# define ez_mkdir(pathname, mode) \ - _ez_mkdir(__FILE__, __LINE__, __FUNCTION__, pathname, mode) -#else -# define ez_mkdir(pathname, mode) \ - _ez_mkdir(pathname, mode) -#endif -int _ez_mkdir ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - const char *pathname, - mode_t mode - ); - -#ifdef DEBUG -# define ez_rmdir(pathname) \ - _ez_rmdir(__FILE__, __LINE__, __FUNCTION__, pathname) -#else -# define ez_rmdir(pathname) \ - _ez_rmdir(pathname) -#endif -int _ez_rmdir ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - const char *pathname - ); - -#ifdef DEBUG -# define ez_unlink(pathname) \ - _ez_unlink(__FILE__, __LINE__, __FUNCTION__, pathname) -#else -# define ez_unlink(pathname) \ - _ez_unlink(pathname) -#endif -int _ez_unlink ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - const char *pathname - ); - -#ifdef DEBUG -# define ez_unlink(pathname) \ - _ez_unlink(__FILE__, __LINE__, __FUNCTION__, pathname) -#else -# define ez_unlink(pathname) \ - _ez_unlink(pathname) -#endif -int _ez_unlink ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - const char *pathname - ); - -#ifdef DEBUG -# define ez_getaddrinfo(node, service, hints, res) \ - _ez_getaddrinfo(__FILE__, __LINE__, __FUNCTION__, node, service, hints, res) -#else -# define ez_getaddrinfo(node, service, hints, res) \ - _ez_getaddrinfo(node, service, hints, res) -#endif -int _ez_getaddrinfo( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, getaddrinfo, const char *node, const char *service, const struct addrinfo *hints, - struct addrinfo **res - ); - + struct addrinfo **res); #ifdef DEBUG -# define ez_getnameinfo(addr, addrlen, host, hostlen, serv, servlen, flags) \ - _ez_getnameinfo(__FILE__, __LINE__, __FUNCTION__, addr, addrlen, host, hostlen, serv, servlen, flags) +# define ez_getaddrinfo(...) \ + _ez_getaddrinfo(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_getnameinfo(addr, addrlen, host, hostlen, serv, servlen, flags) \ - _ez_getnameinfo(addr, addrlen, host, hostlen, serv, servlen, flags) -#endif -int _ez_getnameinfo( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, +# define ez_getaddrinfo(...) \ + _ez_getaddrinfo(__VA_ARGS__) #endif + +ez_proto (int, getnameinfo, const struct sockaddr *addr, socklen_t addrlen, char *host, socklen_t hostlen, char *serv, socklen_t servlen, - int flags - ); - + int flags); #ifdef DEBUG -# define ez_flock(fd, operation) \ - _ez_flock(__FILE__, __LINE__, __FUNCTION__, fd, operation) +# define ez_getnameinfo(...) \ + _ez_getnameinfo(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_flock(fd, operation) \ - _ez_flock(fd, operation) +# define ez_getnameinfo(...) \ + _ez_getnameinfo(__VA_ARGS__) #endif -int _ez_flock ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - int fd, - int operation - ); +ez_proto (struct group*, getgrnam, + const char *name); #ifdef DEBUG -# define ez_setuid(uid) \ - _ez_setuid(__FILE__, __LINE__, __FUNCTION__, uid) +# define ez_getgrnam(...) \ + _ez_getgrnam(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_setuid(uid) \ - _ez_setuid(uid) +# define ez_getgrnam(...) \ + _ez_getgrnam(__VA_ARGS__) #endif -int _ez_setuid( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - uid_t uid - ); -#ifdef DEBUG -# define ez_setgid(gid) \ - _ez_setgid(__FILE__, __LINE__, __FUNCTION__, gid) -#else -# define ez_setgid(gid) \ - _ez_setgid(gid) -#endif -int _ez_setgid( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - gid_t gid - ); - - -#ifdef DEBUG -# define ez_seteuid(euid) \ - _ez_seteuid(__FILE__, __LINE__, __FUNCTION__, euid) -#else -# define ez_seteuid(euid) \ - _ez_seteuid(euid) -#endif -int _ez_seteuid( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - uid_t euid - ); - -#ifdef DEBUG -# define ez_setegid(egid) \ - _ez_setegid(__FILE__, __LINE__, __FUNCTION__, egid) -#else -# define ez_setegid(egid) \ - _ez_setegid(egid) -#endif -int _ez_setegid( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - gid_t egid - ); - -#ifdef DEBUG -# define ez_getgrnam(name) \ - _ez_getgrnam(__FILE__, __LINE__, __FUNCTION__, name) -#else -# define ez_getgrnam(name) \ - _ez_getgrnam(name) -#endif -struct group* _ez_getgrnam( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - const char *name - ); - -#ifdef DEBUG -# define ez_chown(pathname, owner, group) \ - _ez_chown(__FILE__, __LINE__, __FUNCTION__, pathname, owner, group) -#else -# define ez_chown(pathname, owner, group) \ - _ez_chown(pathname, owner, group) -#endif -int _ez_chown( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, mkdir, const char *pathname, - uid_t owner, - gid_t group - ); - + mode_t mode); #ifdef DEBUG -# define ez_fchown(fd, owner, group) \ - _ez_fchown(__FILE__, __LINE__, __FUNCTION__, fd, owner, group) +# define ez_mkdir(...) \ + _ez_mkdir(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_fchown(fd, owner, group) \ - _ez_fchown(fd, owner, group) +# define ez_mkdir(...) \ + _ez_mkdir(__VA_ARGS__) #endif -int _ez_fchown( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - int fd, - uid_t owner, - gid_t group - ); +ez_proto (int, mkstemp, + char *tmpl); #ifdef DEBUG -# define ez_fchmod(fd, mode) \ - _ez_fchmod(__FILE__, __LINE__, __FUNCTION__, fd, mode) +# define ez_mkstemp(...) \ + _ez_mkstemp(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_fchmod(fd, mode) \ - _ez_fchmod(fd, mode) +# define ez_mkstemp(...) \ + _ez_mkstemp(__VA_ARGS__) #endif -int _ez_fchmod( + +ez_proto (int, mkstemps, char *tmpl, int suffixlen); #ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, +# define ez_mkstemps(...) \ + _ez_mkstemps(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_mkstemps(...) \ + _ez_mkstemps(__VA_ARGS__) #endif + + +ez_proto (int, open, + const char *pathname, + int flags, + mode_t mode); +#ifdef DEBUG +# define ez_open(...) \ + _ez_open(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_open(...) \ + _ez_open(__VA_ARGS__) +#endif + +ez_proto (DIR*, opendir, + const char *name); +#ifdef DEBUG +# define ez_opendir(...) \ + _ez_opendir(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_opendir(...) \ + _ez_opendir(__VA_ARGS__) +#endif + +ez_proto (int, pclose, + FILE *stream); +#ifdef DEBUG +# define ez_pclose(...) \ + _ez_pclose(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_pclose(...) \ + _ez_pclose(__VA_ARGS__) +#endif + +ez_proto (int, pipe, int pipefd[2]); +#ifdef DEBUG +# define ez_pipe(...) \ + _ez_pipe(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_pipe(...) \ + _ez_pipe(__VA_ARGS__) +#endif + + +ez_proto (FILE*, popen, + const char *command, + const char *type); +#ifdef DEBUG +# define ez_popen(...) \ + _ez_popen(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_popen(...) \ + _ez_popen(__VA_ARGS__) +#endif + +ez_proto (struct dirent*, readdir, + DIR *dirp); +#ifdef DEBUG +# define ez_readdir(...) \ + _ez_readdir(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_readdir(...) \ + _ez_readdir(__VA_ARGS__) +#endif + +ez_proto (int, remove, + const char *pathname); +#ifdef DEBUG +# define ez_remove(...) \ + _ez_remove(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_remove(...) \ + _ez_remove(__VA_ARGS__) +#endif + +ez_proto (int, rename, + const char *oldpath, + const char *newpath); +#ifdef DEBUG +# define ez_rename(...) \ + _ez_rename(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_rename(...) \ + _ez_rename(__VA_ARGS__) +#endif + +ez_proto (int, rmdir, + const char *pathname); +#ifdef DEBUG +# define ez_rmdir(...) \ + _ez_rmdir(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_rmdir(...) \ + _ez_rmdir(__VA_ARGS__) +#endif + +ez_proto (int, setegid, + gid_t egid); +#ifdef DEBUG +# define ez_setegid(...) \ + _ez_setegid(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_setegid(...) \ + _ez_setegid(__VA_ARGS__) +#endif + +ez_proto (int, seteuid, + uid_t euid); +#ifdef DEBUG +# define ez_seteuid(...) \ + _ez_seteuid(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_seteuid(...) \ + _ez_seteuid(__VA_ARGS__) +#endif + +ez_proto (int, setgid, + gid_t gid); +#ifdef DEBUG +# define ez_setgid(...) \ + _ez_setgid(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_setgid(...) \ + _ez_setgid(__VA_ARGS__) +#endif + +ez_proto (int, setuid, + uid_t uid); +#ifdef DEBUG +# define ez_setuid(...) \ + _ez_setuid(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_setuid(...) \ + _ez_setuid(__VA_ARGS__) +#endif + +ez_proto (int, stat, + const char *pathname, + struct stat *statbuf); +#ifdef DEBUG +# define ez_stat(...) \ + _ez_stat(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_stat(...) \ + _ez_stat(__VA_ARGS__) +#endif + +ez_proto (char*, strptime, + const char *s, + const char *format, + struct tm *tm); +#ifdef DEBUG +# define ez_strptime(...) \ + _ez_strptime(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_strptime(...) \ + _ez_strptime(__VA_ARGS__) +#endif + +ez_proto (int, unlink, + const char *pathname); +#ifdef DEBUG +# define ez_unlink(...) \ + _ez_unlink(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_unlink(...) \ + _ez_unlink(__VA_ARGS__) +#endif + +ez_proto (int, vfprintf, + FILE *stream, + const char *fmt, + va_list ap); +#ifdef DEBUG +# define ez_vfprintf(...) \ + _ez_vfprintf(__FILE__, __LINE__, __func__, __VA_ARGS__) +#else +# define ez_vfprintf(...) \ + _ez_vfprintf(__VA_ARGS__) +#endif + + +ez_proto (ssize_t, write, int fd, - mode_t mode - ); + const void *buf, + size_t count); +#ifdef DEBUG +# define ez_write(...) \ + _ez_write(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_write(...) \ + _ez_write(__VA_ARGS__) +#endif + +#if 0 +// FIXME: this needs to be implemented and tested +ez_proto (ssize_t read, + int fd, + void *buf, + size_t count); +#ifdef DEBUG +# define ez_read(...) \ + _ez_read(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_read(...) \ + _ez_read(__VA_ARGS__) +#endif +#endif #ifdef __cplusplus } diff --git a/ez_libdb.c b/ez_libdb.c index 6138972..b9ac1d5 100644 --- a/ez_libdb.c +++ b/ez_libdb.c @@ -23,16 +23,10 @@ #include "ez_libdb.h" /***************************************************/ -int _ez_db_create( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, create, DB **dbp, DB_ENV *dbenv, - u_int32_t flags - ) + u_int32_t flags) { int rtn= db_create (dbp, dbenv, flags); @@ -49,20 +43,14 @@ int _ez_db_create( } /***************************************************/ -int _ez_db_open( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, db_open, DB *db, DB_TXN *txnid, const char *file, const char *database, DBTYPE type, u_int32_t flags, - int mode - ) + int mode) { int rtn= db->open(db, txnid, file, database, type, flags, mode); @@ -79,18 +67,12 @@ int _ez_db_open( } /***************************************************/ -int _ez_db_put( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, db_put, DB *db, DB_TXN *txnid, DBT *key, DBT *data, - u_int32_t flags - ) + u_int32_t flags) { int rtn= db->put(db, txnid, key, data, flags); @@ -107,18 +89,12 @@ int _ez_db_put( } /***************************************************/ -int _ez_db_get( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, db_get, DB *db, DB_TXN *txnid, DBT *key, DBT *data, - u_int32_t flags - ) + u_int32_t flags) { int rtn= db->get(db, txnid, key, data, flags); @@ -139,17 +115,11 @@ int _ez_db_get( } /***************************************************/ -int _ez_db_del( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, db_del, DB *db, DB_TXN *txnid, DBT *key, - u_int32_t flags - ) + u_int32_t flags) { int rtn= db->del(db, txnid, key, flags); @@ -166,15 +136,7 @@ int _ez_db_del( } /***************************************************/ -int _ez_db_close( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - DB *db, - u_int32_t flags - ) +ez_proto (int, db_close, DB *db, u_int32_t flags) { int rtn= db->close(db, flags); @@ -191,15 +153,7 @@ int _ez_db_close( } /***************************************************/ -int _ez_db_fd( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - DB *db, - int *fdp - ) +ez_proto (int, db_fd, DB *db, int *fdp) { int rtn= db->fd(db, fdp); diff --git a/ez_libdb.h b/ez_libdb.h index 8e06b8c..683483e 100644 --- a/ez_libdb.h +++ b/ez_libdb.h @@ -20,145 +20,107 @@ #define EZ_LIBDB_H /* Simplified interface to libanl functions */ -#define _GNU_SOURCE +#ifndef _GNU_SOURCE +# define _GNU_SOURCE +#endif #include +#include "ez.h" + #ifdef __cplusplus extern "C" { #endif -#ifdef DEBUG -# define ez_db_create(dbp, dbenv, flags) \ - _ez_db_create(__FILE__, __LINE__, __FUNCTION__, dbp, dbenv, flags) -#else -# define ez_db_create(dbp, dbenv, flags) \ - _ez_db_create(dbp, dbenv, flags) -#endif -int _ez_db_create( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, create, DB **dbp, DB_ENV *dbenv, - u_int32_t flags - ); - + u_int32_t flags); #ifdef DEBUG -# define ez_db_open(db, txnid, file, database, type, flags, mode ) \ - _ez_db_open(__FILE__, __LINE__, __FUNCTION__, db, txnid, file, database, type, flags, mode) +# define ez_db_create(...) \ + _ez_db_create(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_db_open(db, txnid, file, database, type, flags, mode ) \ - _ez_db_open(db, txnid, file, database, type, flags, mode) -#endif -int _ez_db_open( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, +# define ez_db_create(...) \ + _ez_db_create(__VA_ARGS__) #endif + +ez_proto (int, db_open, DB *db, DB_TXN *txnid, const char *file, const char *database, DBTYPE type, u_int32_t flags, - int mode - ); - + int mode); #ifdef DEBUG -# define ez_db_put(db, txnid, key, data, flags) \ - _ez_db_put(__FILE__, __LINE__, __FUNCTION__, db, txnid, key, data, flags) +# define ez_db_open(...) \ + _ez_db_open(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_db_put(db, txnid, key, data, flags) \ - _ez_db_put(db, txnid, key, data, flags) -#endif -int _ez_db_put( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, +# define ez_db_open(...) \ + _ez_db_open(__VA_ARGS__) #endif + +ez_proto (int, db_put, DB *db, DB_TXN *txnid, DBT *key, DBT *data, - u_int32_t flags - ); - + u_int32_t flags); #ifdef DEBUG -# define ez_db_get(db, txnid, key, data, flags) \ - _ez_db_get(__FILE__, __LINE__, __FUNCTION__, db, txnid, key, data, flags) +# define ez_db_put(...) \ + _ez_db_put(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_db_get(db, txnid, key, data, flags) \ - _ez_db_get(db, txnid, key, data, flags) -#endif -int _ez_db_get( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, +# define ez_db_put(...) \ + _ez_db_put(__VA_ARGS__) #endif + +ez_proto (int, db_get, DB *db, DB_TXN *txnid, DBT *key, DBT *data, - u_int32_t flags - ); - + u_int32_t flags); #ifdef DEBUG -# define ez_db_del(db, txnid, key, flags) \ - _ez_db_del(__FILE__, __LINE__, __FUNCTION__, db, txnid, key, flags) +# define ez_db_get(...) \ + _ez_db_get(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_db_del(db, txnid, key, flags) \ - _ez_db_del(db, txnid, key, flags) -#endif -int _ez_db_del( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, +# define ez_db_get(...) \ + _ez_db_get(__VA_ARGS__) #endif + +ez_proto (int, db_del, DB *db, DB_TXN *txnid, DBT *key, - u_int32_t flags - ); - + u_int32_t flags); #ifdef DEBUG -# define ez_db_close(db, flags) \ - _ez_db_close(__FILE__, __LINE__, __FUNCTION__, db, flags) +# define ez_db_del(...) \ + _ez_db_del(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_db_close(db, flags) \ - _ez_db_close(db, flags) +# define ez_db_del(...) \ + _ez_db_del(__VA_ARGS__) #endif -int _ez_db_close( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - DB *db, - u_int32_t flags - ); -#ifdef DEBUG -# define ez_db_fd(db, fdp) \ - _ez_db_fd(__FILE__, __LINE__, __FUNCTION__, db, fdp) -#else -# define ez_db_fd(db, fdp) \ - _ez_db_fd(db, fdp) -#endif -int _ez_db_fd( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, db_close, DB *db, - int *fdp - ); + u_int32_t flags); +#ifdef DEBUG +# define ez_db_close(...) \ + _ez_db_close(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_db_close(...) \ + _ez_db_close(__VA_ARGS__) +#endif + +ez_proto (int, db_fd, + DB *db, + int *fdp); +#ifdef DEBUG +# define ez_db_fd(...) \ + _ez_db_fd(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_db_fd(...) \ + _ez_db_fd(__VA_ARGS__) +#endif #ifdef __cplusplus } diff --git a/ez_libpthread.c b/ez_libpthread.c index 8ff9470..bd95667 100644 --- a/ez_libpthread.c +++ b/ez_libpthread.c @@ -25,14 +25,7 @@ #include "util.h" /***************************************************/ -int _ez_pthread_mutex_lock( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - pthread_mutex_t *mutex - ) +ez_proto (int, pthread_mutex_lock, pthread_mutex_t *mutex) { int rtn= pthread_mutex_lock (mutex); if(0 == rtn) return 0; @@ -47,14 +40,7 @@ int _ez_pthread_mutex_lock( } /***************************************************/ -int _ez_pthread_mutex_unlock( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - pthread_mutex_t *mutex - ) +ez_proto (int, pthread_mutex_unlock, pthread_mutex_t *mutex) { int rtn= pthread_mutex_unlock (mutex); if(0 == rtn) return 0; @@ -69,17 +55,11 @@ int _ez_pthread_mutex_unlock( } /***************************************************/ -int _ez_pthread_create( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, pthread_create, pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), - void *arg - ) + void *arg) { int rtn= pthread_create (thread, attr, start_routine, arg); if(0 == rtn) return 0; @@ -94,14 +74,7 @@ int _ez_pthread_create( } /***************************************************/ -int _ez_pthread_cond_signal( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - pthread_cond_t *cond - ) +ez_proto (int, pthread_cond_signal, pthread_cond_t *cond) { int rtn= pthread_cond_signal (cond); if(0 == rtn) return 0; @@ -116,15 +89,9 @@ int _ez_pthread_cond_signal( } /***************************************************/ -int _ez_pthread_cond_wait( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, pthread_cond_wait, pthread_cond_t *cond, - pthread_mutex_t *mutex - ) + pthread_mutex_t *mutex) { int rtn= pthread_cond_wait (cond, mutex); if(0 == rtn) return 0; @@ -139,15 +106,9 @@ int _ez_pthread_cond_wait( } /***************************************************/ -int _ez_pthread_join( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, pthread_join, pthread_t thread, - void **retval - ) + void **retval) { int rtn= pthread_join (thread, retval); if(0 == rtn) return 0; diff --git a/ez_libpthread.h b/ez_libpthread.h index 26bc6be..5d0e86d 100644 --- a/ez_libpthread.h +++ b/ez_libpthread.h @@ -20,113 +20,81 @@ #define EZ_LIBPTHREAD_H /* Simplified interface to libpthread functions */ -#define _GNU_SOURCE +#ifndef _GNU_SOURCE +# define _GNU_SOURCE +#endif #include +#include "ez.h" + #ifdef __cplusplus extern "C" { #endif +ez_proto (int, pthread_mutex_lock, + pthread_mutex_t *mutex); #ifdef DEBUG -# define ez_pthread_mutex_lock(mutex) \ - _ez_pthread_mutex_lock(__FILE__, __LINE__, __FUNCTION__, mutex) +# define ez_pthread_mutex_lock(...) \ + _ez_pthread_mutex_lock(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_pthread_mutex_lock(mutex) \ - _ez_pthread_mutex_lock(mutex) +# define ez_pthread_mutex_lock(...) \ + _ez_pthread_mutex_lock(__VA_ARGS__) #endif -int _ez_pthread_mutex_lock( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - pthread_mutex_t *mutex - ); +ez_proto (int, pthread_mutex_unlock, + pthread_mutex_t *mutex); #ifdef DEBUG -# define ez_pthread_mutex_unlock(mutex) \ - _ez_pthread_mutex_unlock(__FILE__, __LINE__, __FUNCTION__, mutex) +# define ez_pthread_mutex_unlock(...) \ + _ez_pthread_mutex_unlock(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_pthread_mutex_unlock(mutex) \ - _ez_pthread_mutex_unlock(mutex) +# define ez_pthread_mutex_unlock(...) \ + _ez_pthread_mutex_unlock(__VA_ARGS__) #endif -int _ez_pthread_mutex_unlock( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - pthread_mutex_t *mutex - ); -#ifdef DEBUG -# define ez_pthread_create(thread, addr, start_routine, arg) \ - _ez_pthread_create(__FILE__, __LINE__, __FUNCTION__, thread, addr, start_routine, arg) -#else -# define ez_pthread_create(thread, addr, start_routine, arg) \ - _ez_pthread_create(thread, addr, start_routine, arg) -#endif -int _ez_pthread_create( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, pthread_create, pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), - void *arg - ); - + void *arg); #ifdef DEBUG -# define ez_pthread_cond_signal(cond) \ - _ez_pthread_cond_signal(__FILE__, __LINE__, __FUNCTION__, cond) +# define ez_pthread_create(...) \ + _ez_pthread_create(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_pthread_cond_signal(cond) \ - _ez_pthread_cond_signal(cond) +# define ez_pthread_create(...) \ + _ez_pthread_create(__VA_ARGS__) #endif -int _ez_pthread_cond_signal( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - pthread_cond_t *cond - ); +ez_proto (int, pthread_cond_signal, + pthread_cond_t *cond); #ifdef DEBUG -# define ez_pthread_cond_wait(cond, mutex) \ - _ez_pthread_cond_wait(__FILE__, __LINE__, __FUNCTION__, cond, mutex) +# define ez_pthread_cond_signal(...) \ + _ez_pthread_cond_signal(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_pthread_cond_wait(cond, mutex) \ - _ez_pthread_cond_wait(cond, mutex) -#endif -int _ez_pthread_cond_wait( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, +# define ez_pthread_cond_signal(...) \ + _ez_pthread_cond_signal(__VA_ARGS__) #endif + +ez_proto (int, pthread_cond_wait, pthread_cond_t *cond, - pthread_mutex_t *mutex - ); - + pthread_mutex_t *mutex); #ifdef DEBUG -# define ez_pthread_join(thread, retval) \ - _ez_pthread_join(__FILE__, __LINE__, __FUNCTION__, thread, retval) +# define ez_pthread_cond_wait(...) \ + _ez_pthread_cond_wait(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_pthread_join(thread, retval) \ - _ez_pthread_join(thread, retval) -#endif -int _ez_pthread_join( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, +# define ez_pthread_cond_wait(...) \ + _ez_pthread_cond_wait(__VA_ARGS__) #endif + +ez_proto (int, pthread_join, pthread_t thread, - void **retval - ); + void **retval); +#ifdef DEBUG +# define ez_pthread_join(...) \ + _ez_pthread_join(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_pthread_join(...) \ + _ez_pthread_join(__VA_ARGS__) +#endif #ifdef __cplusplus } diff --git a/ez_libz.c b/ez_libz.c index c6f97c5..21b470f 100644 --- a/ez_libz.c +++ b/ez_libz.c @@ -23,15 +23,9 @@ #include "util.h" /***************************************************/ -gzFile _ez_gzopen( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (gzFile, gzopen, const char *path, - const char *mode - ) + const char *mode) { gzFile rtn= gzopen(path, mode); if(rtn) return rtn; @@ -45,14 +39,7 @@ gzFile _ez_gzopen( } /***************************************************/ -int _ez_gzclose( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - gzFile file - ) +ez_proto (int, gzclose, gzFile file) { int err= gzclose(file); if(Z_OK == err) return Z_OK; @@ -91,16 +78,10 @@ int _ez_gzclose( } /***************************************************/ -int _ez_gzwrite( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, gzwrite, gzFile file, voidpc buf, - unsigned len - ) + unsigned len) { int n= gzwrite(file, buf, len); if(n == len) return n; @@ -124,16 +105,10 @@ int _ez_gzwrite( } /***************************************************/ -int _ez_gzread( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (int, gzread, gzFile file, voidp buf, - unsigned len - ) + unsigned len) { int n= gzread(file, buf, len); if(-1 != n) return n; @@ -157,15 +132,7 @@ int _ez_gzread( } /***************************************************/ -int _ez_gzflush( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - gzFile file, - int flush - ) +ez_proto (int, gzflush, gzFile file, int flush) { int err= gzflush(file, flush); if(Z_OK == err) return Z_OK; @@ -188,16 +155,10 @@ int _ez_gzflush( } /***************************************************/ -z_off_t _ez_gzseek( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (z_off_t, gzseek, gzFile file, z_off_t offset, - int whence - ) + int whence) { z_off_t rtn= gzseek(file, offset, whence); if(-1 != rtn) return rtn; @@ -221,16 +182,10 @@ z_off_t _ez_gzseek( } /***************************************************/ -char* _ez_gzgets ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (char*, gzgets, gzFile file, char *buf, - int len - ) + int len) { char *rtn= gzgets(file, buf, len); @@ -259,14 +214,8 @@ char* _ez_gzgets ( } /***************************************************/ -z_off_t _ez_gztell( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - gzFile file - ) +ez_proto (z_off_t, _ez_gztell, + gzFile file) { z_off_t rtn= gztell(file); if(-1 != rtn) return rtn; diff --git a/ez_libz.h b/ez_libz.h index e9775e3..536e12e 100644 --- a/ez_libz.h +++ b/ez_libz.h @@ -20,150 +20,106 @@ #define EZ_GZFILE_H /* Simplified interface to libz file functions */ -#define _GNU_SOURCE +#ifndef _GNU_SOURCE +# define _GNU_SOURCE +#endif #include +#include "ez.h" + #ifdef __cplusplus extern "C" { #endif -#ifdef DEBUG -# define ez_gzopen(path, mode) \ - _ez_gzopen(__FILE__, __LINE__, __FUNCTION__, path, mode) -#else -# define ez_gzopen(path, mode) \ - _ez_gzopen(path, mode) -#endif -gzFile _ez_gzopen( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif +ez_proto (gzFile, gzopen, const char *path, - const char *mode - ); - + const char *mode); #ifdef DEBUG -# define ez_gzclose(file) \ - _ez_gzclose(__FILE__, __LINE__, __FUNCTION__, file) +# define ez_gzopen(...) \ + _ez_gzopen(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_gzclose(file) \ - _ez_gzclose(file) +# define ez_gzopen(...) \ + _ez_gzopen(__VA_ARGS__) #endif -int _ez_gzclose( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - gzFile file - ); +ez_proto (int, gzclose, + gzFile file); #ifdef DEBUG -# define ez_gzwrite(file, buf, len) \ - _ez_gzwrite(__FILE__, __LINE__, __FUNCTION__, file, buf, len) +# define ez_gzclose(...) \ + _ez_gzclose(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_gzwrite(file, buf, len) \ - _ez_gzwrite(file, buf, len) -#endif -int _ez_gzwrite( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, +# define ez_gzclose(...) \ + _ez_gzclose(__VA_ARGS__) #endif + +ez_proto (int, gzwrite, gzFile file, voidpc buf, - unsigned len - ); - + unsigned len); #ifdef DEBUG -# define ez_gzread(file, buf, len) \ - _ez_gzread(__FILE__, __LINE__, __FUNCTION__, file, buf, len) +# define ez_gzwrite(...) \ + _ez_gzwrite(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_gzread(file, buf, len) \ - _ez_gzread(file, buf, len) -#endif -int _ez_gzread( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, +# define ez_gzwrite(...) \ + _ez_gzwrite(__VA_ARGS__) #endif + +ez_proto (int, gzread, gzFile file, voidp buf, - unsigned len - ); - + unsigned len); #ifdef DEBUG -# define ez_gzflush(file, flush) \ - _ez_gzflush(__FILE__, __LINE__, __FUNCTION__, file, flush) +# define ez_gzread(...) \ + _ez_gzread(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_gzflush(file, flush) \ - _ez_gzflush(file, flush) -#endif -int _ez_gzflush( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, +# define ez_gzread(...) \ + _ez_gzread(__VA_ARGS__) #endif + +ez_proto (int, gzflush, gzFile file, - int flush - ); - + int flush); #ifdef DEBUG -# define ez_gzseek(file, offset, whence) \ - _ez_gzseek(__FILE__, __LINE__, __FUNCTION__, file, offset, whence) +# define ez_gzflush(...) \ + _ez_gzflush(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_gzseek(file, offset, whence) \ - _ez_gzseek(file, offset, whence) -#endif -z_off_t _ez_gzseek( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, +# define ez_gzflush(...) \ + _ez_gzflush(__VA_ARGS__) #endif + +ez_proto (z_off_t, gzseek, gzFile file, z_off_t offset, - int whence - ); - + int whence); #ifdef DEBUG -# define ez_gztell(file) \ - _ez_gztell(__FILE__, __LINE__, __FUNCTION__, file) +# define ez_gzseek(...) \ + _ez_gzseek(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_gztell(file) \ - _ez_gztell(file) +# define ez_gzseek(...) \ + _ez_gzseek(__VA_ARGS__) #endif -z_off_t _ez_gztell( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, -#endif - gzFile file - ); +ez_proto (z_off_t, _ez_gztell, + gzFile file); #ifdef DEBUG -# define ez_gzgets(file, buf, len) \ - _ez_gzgets(__FILE__, __LINE__, __FUNCTION__, file, buf, len) +# define ez_gztell(...) \ + _ez_gztell(__FILE__, __LINE__, __func__, ##__VA_ARGS__) #else -# define ez_gzgets(file, buf, len) \ - _ez_gzgets(file, buf, len) -#endif -char* _ez_gzgets ( -#ifdef DEBUG - const char *fileName, - int lineNo, - const char *funcName, +# define ez_gztell(...) \ + _ez_gztell(__VA_ARGS__) #endif + +ez_proto (char*, gzgets, gzFile file, char *buf, - int len - ); + int len); +#ifdef DEBUG +# define ez_gzgets(...) \ + _ez_gzgets(__FILE__, __LINE__, __func__, ##__VA_ARGS__) +#else +# define ez_gzgets(...) \ + _ez_gzgets(__VA_ARGS__) +#endif #ifdef __cplusplus } diff --git a/pdns.c b/pdns.c index 7a9f7bf..05568f9 100644 --- a/pdns.c +++ b/pdns.c @@ -23,7 +23,7 @@ #include #include -#include "ez_es.h" +#include "es.h" #include "ez_libc.h" #include "ez_libpthread.h" #include "msgqueue.h"