#define EVENT_LOG_DEBUG 0#define EVENT_LOG_MSG   1#define EVENT_LOG_WARN  2#define EVENT_LOG_ERR   3/* Deprecated; see note at the end of this section */#define _EVENT_LOG_DEBUG EVENT_LOG_DEBUG#define _EVENT_LOG_MSG   EVENT_LOG_MSG#define _EVENT_LOG_WARN  EVENT_LOG_WARN#define _EVENT_LOG_ERR   EVENT_LOG_ERRtypedef void (*event_log_cb)(int severity, const char *msg);void event_set_log_callback(event_log_cb cb);

#include <event2/event.h>#include <stdio.h>static void discard_cb(int severity, const char *msg){    /* This callback does nothing. */}static FILE *logfile = NULL;static void write_to_file_cb(int severity, const char *msg){    const char *s;    if (!logfile)        return;    switch (severity) {        case _EVENT_LOG_DEBUG: s = "debug"; break;        case _EVENT_LOG_MSG:   s = "msg";   break;        case _EVENT_LOG_WARN:  s = "warn";  break;        case _EVENT_LOG_ERR:   s = "error"; break;        default:               s = "?";     break; /* never reached */    }    fprintf(logfile, "[%s] %s\n", s, msg);}/* Turn off all logging from Libevent. */void suppress_logging(void){    event_set_log_callback(discard_cb);}/* Redirect all Libevent log messages to the C stdio file ‘f‘. */void set_logfile(FILE *f){    logfile = f;    event_set_log_callback(write_to_file_cb);}

#include <event2/event.h>#include <sys/types.h>#include <stdlib.h>/* This union‘s purpose is to be as big as the largest of all the * types it contains. */union alignment {    size_t sz;    void *ptr;    double dbl;};/* We need to make sure that everything we return is on the right   alignment to hold anything, including a double. */#define ALIGNMENT sizeof(union alignment)/* We need to do this cast-to-char* trick on our pointers to adjust   them; doing arithmetic on a void* is not standard. */#define OUTPTR(ptr) (((char*)ptr)+ALIGNMENT)#define INPTR(ptr) (((char*)ptr)-ALIGNMENT)static size_t total_allocated = 0;static void *replacement_malloc(size_t sz){    void *chunk = malloc(sz + ALIGNMENT);    if (!chunk) return chunk;    total_allocated += sz;    *(size_t*)chunk = sz;    return OUTPTR(chunk);}static void *replacement_realloc(void *ptr, size_t sz){    size_t old_size = 0;    if (ptr) {        ptr = INPTR(ptr);        old_size = *(size_t*)ptr;    }    ptr = realloc(ptr, sz + ALIGNMENT);    if (!ptr)        return NULL;    *(size_t*)ptr = sz;    total_allocated = total_allocated - old_size + sz;    return OUTPTR(ptr);}static void replacement_free(void *ptr){    ptr = INPTR(ptr);    total_allocated -= *(size_t*)ptr;    free(ptr);}void start_counting_bytes(void){    event_set_mem_functions(replacement_malloc,                            replacement_realloc,                            replacement_free);}

• 替换掉Libevent的内存管理函数会影响之后所有涉及到分配内存,调整已分配内存大小,释放内存的调用.所以(如果你想用自己的内存管理函数)你要确保在你调用Libevent函数之前已经替换了这些函数.否则的话,有可能你用C库的malloc分配了一块内存,但是在释放内存的时候却调用了自己提供的free()函数.

• 你的malloc和realloc函数应该返回和C库一样进行内存对其的内存块.

• 你的realloc函数应该能正确处理realloc(NULL,sz).(也就是把realloc(NULL,sz)当作malloc(sz))

• 你的realloc函数应该能正确处理realloc(ptr,0).(也就是把realloc(NULL,sz)当作free(ptr))

• 你的free函数没有必要处理free(NULL).

• 你的malloc函数没有必要处理malloc(0).

• 你提供的内存管理函数应该是线程安全的,如果你想在多个线程内使用Libevent.

• Libevent使用这些函数分配内存并返回给你.所以如果你想释放一块由你自己版本的malloc和realloc函数分配的内存,你必须用自己版本的free函数释放这部分内存

event_set_mem_functions()声明于<event2/event.h>.该函数首次出现于Libevent 2.0.1-alpha.

Libevent可以编译为不支持event_set_mem_functions().如果这样的话,在程序内使用event_set_mem_functions() 将无法编译或链接.在Libevent 2.0.2-alpha及之后的版本,你可以通过检查是否定义了EVENT_SET_MEM_FUNCTIONS_IMPLEMENTED宏来判断event_set_mem_functions()是否存在.

锁和线程

#ifdef WIN32int evthread_use_windows_threads(void);#define EVTHREAD_USE_WINDOWS_THREADS_IMPLEMENTED#endif#ifdef _EVENT_HAVE_PTHREADSint evthread_use_pthreads(void);#define EVTHREAD_USE_PTHREADS_IMPLEMENTED#endif

#define EVTHREAD_WRITE  0x04#define EVTHREAD_READ   0x08#define EVTHREAD_TRY    0x10#define EVTHREAD_LOCKTYPE_RECURSIVE 1#define EVTHREAD_LOCKTYPE_READWRITE 2#define EVTHREAD_LOCK_API_VERSION 1struct evthread_lock_callbacks {       int lock_api_version;       unsigned supported_locktypes;       void *(*alloc)(unsigned locktype);       void (*free)(void *lock, unsigned locktype);       int (*lock)(unsigned mode, void *lock);       int (*unlock)(unsigned mode, void *lock);};int evthread_set_lock_callbacks(const struct evthread_lock_callbacks *);void evthread_set_id_callback(unsigned long (*id_fn)(void));struct evthread_condition_callbacks {        int condition_api_version;        void *(*alloc_condition)(unsigned condtype);        void (*free_condition)(void *cond);        int (*signal_condition)(void *cond, int broadcast);        int (*wait_condition)(void *cond, void *lock,            const struct timeval *timeout);};int evthread_set_condition_callbacks(        const struct evthread_condition_callbacks *);

For an example of how to use these functions, see evthread_pthread.c andevthread_win32.c in the Libevent source distribution.

void evthread_enable_lock_debugging(void);#define evthread_enable_lock_debuging() evthread_enable_lock_debugging()

void event_enable_debug_mode(void);

void event_debug_unassign(struct event *ev);

#include <event2/event.h>#include <event2/event_struct.h>#include <stdlib.h>void cb(evutil_socket_t fd, short what, void *ptr){    /* We pass ‘NULL‘ as the callback pointer for the heap allocated     * event, and we pass the event itself as the callback pointer     * for the stack-allocated event. */    struct event *ev = ptr;    if (ev)        event_debug_unassign(ev);}/* Here‘s a simple mainloop that waits until fd1 and fd2 are both * ready to read. */void mainloop(evutil_socket_t fd1, evutil_socket_t fd2, int debug_mode){    struct event_base *base;    struct event event_on_stack, *event_on_heap;    if (debug_mode)       event_enable_debug_mode();    base = event_base_new();    event_on_heap = event_new(base, fd1, EV_READ, cb, NULL);    event_assign(&event_on_stack, base, fd2, EV_READ, cb, &event_on_stack);    event_add(event_on_heap, NULL);    event_add(&event_on_stack, NULL);    event_base_dispatch(base);    event_free(event_on_heap);    event_base_free(base);}

 Interface

#define LIBEVENT_VERSION_NUMBER 0x02000300#define LIBEVENT_VERSION "2.0.3-alpha"const char *event_get_version(void);ev_uint32_t event_get_version_number(void);

上述宏定义了Libevent的编译时(compile-time)版本.而上述函数返回的是运行时(run-time)版本.注意：如果你的程序是动态链接了Libevent的话,这些版本(指compile-time version和run-time version)可能会是不同的.

你可以获取两种格式的Libevet版本：适合于向使用者展示的字符串格式,或者是适合于数字比较的4-byte整数格式.整数格式的用高字节表示主版本号,第二个字节表示副版本号,第三个字节表示补丁版本号,低字节代表release状态(0表示是release版本,非零表示是开发版本).

所以Libevent 2.0.1-alpha的release版本用数字表示就是[02 00 01 00],或者0x02000100.介于2.0.1-alpha和2.0.2-alpha之间的开发版的数字版本号可能为[02 00 01 08]或0x02000108.

Example: Compile-time checks

#include <event2/event.h>#if !defined(LIBEVENT_VERSION_NUMBER) || LIBEVENT_VERSION_NUMBER < 0x02000100#error "This version of Libevent is not supported; Get 2.0.1-alpha or later."#endifintmake_sandwich(void){        /* Let‘s suppose that Libevent 6.0.5 introduces a make-me-a           sandwich function. */#if LIBEVENT_VERSION_NUMBER >= 0x06000500        evutil_make_me_a_sandwich();        return 0;#else        return -1;#endif}

Example: Run-time checks

#include <event2/event.h>#include <string.h>intcheck_for_old_version(void){    const char *v = event_get_version();    /* This is a dumb way to do it, but it is the only thing that works       before Libevent 2.0. */    if (!strncmp(v, "0.", 2) ||        !strncmp(v, "1.1", 3) ||        !strncmp(v, "1.2", 3) ||        !strncmp(v, "1.3", 3)) {        printf("Your version of Libevent is very old.  If you run into bugs,"               " consider upgrading.\n");        return -1;    } else {        printf("Running with Libevent version %s\n", v);        return 0;    }}intcheck_version_match(void){    ev_uint32_t v_compile, v_run;    v_compile = LIBEVENT_VERSION_NUMBER;    v_run = event_get_version_number();    if ((v_compile & 0xffff0000) != (v_run & 0xffff0000)) {        printf("Running with a Libevent version (%s) very different from the "               "one we were built with (%s).\n", event_get_version(),               LIBEVENT_VERSION);        return -1;    }    return 0;}

这部分介绍的宏和函数定义于<event2/event.h>.event_get_version()首次出现于Libevent 1.0c,其余的首次出现于Libevent 2.0.1-alpha.

释放全局的Libevent结构

即便你已经释放了所有的你分配的对象,还是有一些全局的结构遗留(未被释放)了.通常这不是什么问题:一旦进程退出,系统会清理这些资源的.不过不释放这些结构可能导致调试工具认为Libevent内存泄露.如果你希望确保Libevent释放了所有的内部使用的全局数据结构,你可以调用：

Interface

void libevent_global_shutdown(void);

这个函数不会释放掉任何Libevent函数返回给你的结构.如果你希望在进程退出前释放掉所有内存的话,你需要自己手动释放events,event_bases,bufferevents等.

调用libevent_global_shutdown()可能会导致别的Libevent函数有一些意想不到的问题.所以除非这是最后一个你想使用的Libevent函数了,否则不要调用他.有一个例外是libevent_global_shutdown()是幂等(idempotent)的(也就是可以多次调用的):在libevent_global_shutdown()被调用之后你还是可以再一次调用它.

这个函数声明于<event2/event.h>.它是于Libevent 2.1.1-alpha引入的.