/** * create a global context */ chassis *chassis_new() { chassis *chas; if (0 != chassis_check_version(event_get_version(), _EVENT_VERSION)) { g_critical("%s: chassis is build against libevent %s, but now runs against %s", G_STRLOC, _EVENT_VERSION, event_get_version()); return NULL; } chas = g_new0(chassis, 1); chas->modules = g_ptr_array_new(); chas->stats = chassis_stats_new(); /* create a new global timer info */ chassis_timestamps_global_init(NULL); chas->threads = chassis_event_threads_new(); chas->event_hdr_version = g_strdup(_EVENT_VERSION); chas->shutdown_hooks = chassis_shutdown_hooks_new(); return chas; }
void CInitBase::Init(void) { m_pCfg = event_config_new(); if (NULL == m_pCfg) { Q_EXCEPTION(Q_RTN_FAILE, "%s", "event_config_new error."); } #ifdef Q_IOCP evthread_use_windows_threads(); event_config_set_flag(m_pCfg, EVENT_BASE_FLAG_STARTUP_IOCP); #endif m_pBase = event_base_new_with_config(m_pCfg); if (NULL == m_pBase) { Q_EXCEPTION(Q_RTN_FAILE, "%s", "event_base_new error."); } #ifdef Q_IOCP Q_Printf("event version %s, using %s", event_get_version(), "IOCP"); #else Q_Printf("event version %s, using %s", event_get_version(), event_base_get_method(m_pBase)); #endif }
/** * create a global context */ chassis *chassis_new() { chassis *chas; int i; GTimeVal now; if (0 != chassis_check_version(event_get_version(), _EVENT_VERSION)) { g_critical("%s: chassis is build against libevent %s, but now runs against %s", G_STRLOC, _EVENT_VERSION, event_get_version()); return NULL; } /* add by vinchen/CFR£¬init libevent to be thread_safe */ if (0 != chassis_libevent_init()){ g_critical("%s: chassis_libevent_init error, libevent version : %s", G_STRLOC, event_get_version()); return NULL; } chas = g_new0(chassis, 1); chas->modules = g_ptr_array_new(); chas->stats = chassis_stats_new(); /* create a new global timer info */ chassis_timestamps_global_init(NULL); chas->threads = chassis_event_threads_new(); chas->event_hdr_version = g_strdup(_EVENT_VERSION); chas->shutdown_hooks = chassis_shutdown_hooks_new(); /* * Init for query_response_time */ for (i = 0; i < OVERALL_POWER_COUNT; i++){ chas->counter[i] = 0; chas->total[i] = 0; } for (i = 0; i < OVERALL_POWER_COUNT; i++){ if (i < OVERALL_POWER_HALF) /* 2^(-15) ~ 2^(-1) */ chas->time[i] = 1.00/(1 << (OVERALL_POWER_HALF - i)) * MILLION; else /* 2^0 ~ 2^15 */ chas->time[i] = (guint64)(1 << (i - OVERALL_POWER_HALF)) * MILLION; } g_get_current_time(&now); chas->start_time = now; chas->query_mutex = g_mutex_new(); return chas; }
main() { // daemon ( 1, 0 ); printf ( "%s\n", event_get_version() ); event_init(); int sock = socket( AF_INET, SOCK_STREAM, 0 ); (void) fcntl( sock, F_SETFD, 1 ); int i = 1; if ( setsockopt( sock, SOL_SOCKET, SO_REUSEADDR, (void*) &i, sizeof(i) ) < 0 ) { exit ( -1 ); } struct sockaddr_in server_addr; uint32_t ip; inet_pton ( AF_INET, localhost, &ip ); server_addr.sin_addr.s_addr = ip; server_addr.sin_port = htons ( localport ); server_addr.sin_family = AF_INET; if ( bind( sock, (struct sockaddr*)&server_addr, sizeof(struct sockaddr) ) < 0 ) { fprintf ( stderr, "bind\n" ); exit ( -1 ); } if ( listen( sock, 1024 ) < 0 ) { exit ( -1 ); } struct event listen_read_event; event_set ( &listen_read_event, sock, EV_READ|EV_PERSIST, listener_accept, NULL ); event_add ( &listen_read_event, NULL ); event_dispatch(); }
void show_version(void) { struct utsname u; const char *fmt = " %s: %s\n"; fprintf(stderr, "%s %s\n", __progname, vertag); fprintf(stderr, "Run-time versions:\n"); fprintf(stderr, fmt, "assl", assl_verstring()); #ifdef NEED_LIBCLENS fprintf(stderr, fmt, "clens", clens_verstring()); #endif /* NEED_LIBCLENS */ fprintf(stderr, fmt, "clog", clog_verstring()); fprintf(stderr, fmt, "curl", curl_version()); fprintf(stderr, fmt, "event", event_get_version()); fprintf(stderr, fmt, "exude", exude_verstring()); fprintf(stderr, fmt, "openssl", SSLeay_version(SSLEAY_VERSION)); fprintf(stderr, fmt, "shrink", shrink_verstring()); fprintf(stderr, fmt, "xmlsd", xmlsd_verstring()); fprintf(stderr, "O/S identification: "); if (uname(&u) == -1) fprintf(stderr, "INVALID\n"); else fprintf(stderr, "%s-%s-%s %s\n", u.sysname, u.machine, u.release, u.version); }
/** get the event system in use */ static void get_event_sys(const char** n, const char** s, const char** m) { #ifdef USE_WINSOCK *n = "event"; *s = "winsock"; *m = "WSAWaitForMultipleEvents"; #elif defined(USE_MINI_EVENT) *n = "mini-event"; *s = "internal"; *m = "select"; #else struct event_base* b; *s = event_get_version(); # ifdef HAVE_EVENT_BASE_GET_METHOD *n = "libevent"; b = event_base_new(); *m = event_base_get_method(b); # elif defined(HAVE_EV_LOOP) || defined(HAVE_EV_DEFAULT_LOOP) *n = "libev"; b = (struct event_base*)ev_default_loop(EVFLAG_AUTO); *m = ev_backend2str(ev_backend((struct ev_loop*)b)); # else *n = "unknown"; *m = "not obtainable"; b = NULL; # endif # ifdef HAVE_EVENT_BASE_FREE event_base_free(b); # endif #endif }
int setupListeners() { evthread_use_pthreads(); evBase = event_base_new(); const char **methods = event_get_supported_methods(); lprintf("Starting Libevent %s. Supported methods are:\n", event_get_version()); for (int i=0;methods[i] != NULL; i++){ lprintf("\t%s\n",methods[i]); } free((char**)methods); lprintf("Using %s.\n",event_base_get_method(evBase)); struct event *signalEvent; signalEvent = evsignal_new(evBase, SIGINT, signalCallback, (void*) evBase); if (!signalEvent || event_add(signalEvent, NULL) < 0){ lprintf("Could not create / add a signal event!\n"); return -1; } lprintf("done\n"); try{ contConnection = new ControllerLink(); mtc = new MTCModel(); for (int i=0;i<MAX_XL3_CON;i++){ xl3s[i] = new XL3Model(i); } tubii = new TUBIIModel(); } catch(int e){ return -1; } return 0; }
static void levent_init(struct lldpd *cfg) { /* Setup libevent */ log_debug("event", "initialize libevent"); event_set_log_callback(levent_log_cb); if (!(cfg->g_base = event_base_new())) fatalx("unable to create a new libevent base"); log_info("event", "libevent %s initialized with %s method", event_get_version(), event_base_get_method(cfg->g_base)); /* Setup SNMP */ #ifdef USE_SNMP if (cfg->g_snmp) { agent_init(cfg, cfg->g_snmp_agentx); cfg->g_snmp_timeout = evtimer_new(cfg->g_base, levent_snmp_timeout, cfg); if (!cfg->g_snmp_timeout) fatalx("unable to setup timeout function for SNMP"); if ((cfg->g_snmp_fds = malloc(sizeof(struct ev_l))) == NULL) fatalx("unable to allocate memory for SNMP events"); TAILQ_INIT(levent_snmp_fds(cfg)); } #endif /* Setup loop that will run every X seconds. */ log_debug("event", "register loop timer"); if (!(cfg->g_main_loop = event_new(cfg->g_base, -1, 0, levent_update_and_send, cfg))) fatalx("unable to setup main timer"); event_active(cfg->g_main_loop, EV_TIMEOUT, 1); /* Setup unix socket */ log_debug("event", "register Unix socket"); TAILQ_INIT(&lldpd_clients); evutil_make_socket_nonblocking(cfg->g_ctl); if ((cfg->g_ctl_event = event_new(cfg->g_base, cfg->g_ctl, EV_READ|EV_PERSIST, levent_ctl_accept, cfg)) == NULL) fatalx("unable to setup control socket event"); event_add(cfg->g_ctl_event, NULL); /* Signals */ log_debug("event", "register signals"); signal(SIGHUP, SIG_IGN); evsignal_add(evsignal_new(cfg->g_base, SIGUSR1, levent_dump, cfg->g_base), NULL); evsignal_add(evsignal_new(cfg->g_base, SIGINT, levent_stop, cfg->g_base), NULL); evsignal_add(evsignal_new(cfg->g_base, SIGTERM, levent_stop, cfg->g_base), NULL); }
static void print_version(void) { fprintf(stdout, "ucmq :\n"); fprintf(stdout, "\tversion - v%s\n", VERSION); fprintf(stdout, "\tstorage mode - file\n"); fprintf(stdout, "\tbuild date - %s %s\n", __DATE__, __TIME__); fprintf(stdout, "dependency packages :\n"); fprintf(stdout, "\tlibevent - v%s\n", event_get_version()); }
/** Return a string representation of the version of the currently running * version of Libevent. */ const char * tor_libevent_get_version_str(void) { #ifdef HAVE_EVENT_GET_VERSION return event_get_version(); #else return "pre-1.0c"; #endif }
/** Return the version number of the currently running version of Libevent. * See le_version_t for info on the format. */ static le_version_t tor_get_libevent_version(const char **v_out) { const char *v; le_version_t r; #if defined(HAVE_EVENT_GET_VERSION_NUMBER) v = event_get_version(); r = event_get_version_number(); #elif defined (HAVE_EVENT_GET_VERSION) v = event_get_version(); r = tor_decode_libevent_version(v); #else v = "pre-1.0c"; r = LE_OLD; #endif if (v_out) *v_out = v; return r; }
options::STATUS options::process_command_line(int argc, char *argv[]) { namespace po = boost::program_options; po::options_description desc("Allowed options"); desc.add_options() ("help", "display help message") ("version", "display sfrp version and exit") ("fullversion", "display sfrp and libevent version and exit") ("copyright", "display copyright and exit") ("file,f", po::value<std::string>(), "configuration file"); try{ po::variables_map vm; po::store(po::parse_command_line(argc, argv, desc), vm); po::notify(vm); if(vm.count("version")){ std::cout<<SFRP_VERSION<<std::endl; return INFO; } if(vm.count("fullversion")){ std::cout<<"sfrp version: "<<SFRP_VERSION<<"_"<<std::endl; std::cout<<"libevent version: "<<event_get_version()<<std::endl; return INFO; } // // Don't print the copyright when showing the version print_short_copyright(); if(vm.count("help")) { std::cout<<desc<<std::endl; return INFO; } if(vm.count("copyright")){ print_copyright(); return INFO; } if(vm.count("file")) { config_file_ = vm["file"].as<std::string>(); } } catch(po::error e){ std::cout<<e.what()<<std::endl<<std::endl; std::cout<<desc<<std::endl; return ERROR; } return RUN; }
int chassis_frontend_print_version() { /* allow to pass down a build-tag at build-time which gets hard-coded into the binary */ #ifndef CHASSIS_BUILD_TAG #define CHASSIS_BUILD_TAG PACKAGE_STRING #endif g_print(" chassis: %s" CHASSIS_NEWLINE, CHASSIS_BUILD_TAG); g_print(" glib2: %d.%d.%d" CHASSIS_NEWLINE, GLIB_MAJOR_VERSION, GLIB_MINOR_VERSION, GLIB_MICRO_VERSION); g_print(" libevent: %s" CHASSIS_NEWLINE, event_get_version()); return 0; }
/** * create a global context */ chassis *chassis_new() { chassis *chas; gint ret = 0; if (0 != chassis_check_version(event_get_version(), _EVENT_VERSION)) { g_critical("%s: chassis is build against libevent %s, but now runs against %s", G_STRLOC, _EVENT_VERSION, event_get_version()); return NULL; } chas = g_new0(chassis, 1); chas->modules = g_ptr_array_new(); chas->stats = chassis_stats_new(); /* create a new global timer info */ chassis_timestamps_global_init(NULL); chas->threads = g_ptr_array_new(); chas->event_hdr_version = g_strdup(_EVENT_VERSION); chas->shutdown_hooks = chassis_shutdown_hooks_new(); chas->proxy_filter = sql_filter_new(0); chas->proxy_reserved = sql_reserved_query_new(); chas->daemon_mode = 0; chas->max_files_number = 0; chas->auto_restart = 0; chas->opts = NULL;//need to free if (0 != ret) { g_critical("create thread exit semphore failed. %s", G_STRLOC); return NULL; } return chas; }
struct tmuxproc * proc_start(const char *name, struct event_base *base, int forkflag, void (*signalcb)(int)) { struct tmuxproc *tp; struct utsname u; #ifdef TMATE_SLAVE if (forkflag) fatal("can't fork"); #else if (forkflag) { switch (fork()) { case -1: fatal("fork failed"); case 0: break; default: return (NULL); } if (daemon(1, 0) != 0) fatal("daemon failed"); clear_signals(0); if (event_reinit(base) != 0) fatalx("event_reinit failed"); } log_open(name); #endif #ifdef HAVE_SETPROCTITLE setproctitle("%s (%s)", name, socket_path); #endif if (uname(&u) < 0) memset(&u, 0, sizeof u); log_debug("%s started (%ld): socket %s, protocol %d", name, (long)getpid(), socket_path, PROTOCOL_VERSION); log_debug("on %s %s %s; libevent %s (%s)", u.sysname, u.release, u.version, event_get_version(), event_get_method()); tp = xcalloc(1, sizeof *tp); tp->name = xstrdup(name); #ifndef TMATE_SLAVE tp->signalcb = signalcb; set_signals(proc_signal_cb, tp); #endif return (tp); }
static void display_libevent_info( void ) { int i; const char **methods = event_get_supported_methods(); if ( NULL == methods ) { ED2KD_LOGERR("failed to get supported libevent methods"); return; } ED2KD_LOGNFO("using libevent %s. available methods are:", event_get_version()); for ( i=0; methods[i] != NULL; ++i ) { ED2KD_LOGNFO(" %s", methods[i]); } }
/** Initialize the Libevent library and set up the event base. */ void tor_libevent_initialize(void) { tor_assert(the_event_base == NULL); #ifdef __APPLE__ if (MACOSX_KQUEUE_IS_BROKEN || tor_get_libevent_version(NULL) < V_OLD(1,1,'b')) { setenv("EVENT_NOKQUEUE","1",1); } #endif #ifdef HAVE_EVENT2_EVENT_H { struct event_config *cfg = event_config_new(); tor_assert(cfg); /* In 0.2.2, we don't use locking at all. Telling Libevent not to try to * turn it on can avoid a needless socketpair() attempt. */ event_config_set_flag(cfg, EVENT_BASE_FLAG_NOLOCK); the_event_base = event_base_new_with_config(cfg); event_config_free(cfg); } #else the_event_base = event_init(); #endif if (!the_event_base) { log_err(LD_GENERAL, "Unable to initialize Libevent: cannot continue."); exit(1); } #if defined(HAVE_EVENT_GET_VERSION) && defined(HAVE_EVENT_GET_METHOD) /* Making this a NOTICE for now so we can link bugs to a libevent versions * or methods better. */ log(LOG_NOTICE, LD_GENERAL, "Initialized libevent version %s using method %s. Good.", event_get_version(), tor_libevent_get_method()); #else log(LOG_NOTICE, LD_GENERAL, "Initialized old libevent (version 1.0b or earlier)."); log(LOG_WARN, LD_GENERAL, "You have a *VERY* old version of libevent. It is likely to be buggy; " "please build Tor with a more recent version."); #endif }
/* add by vinchen/CFR libevent to be thread_safe https://raw.github.com/libevent/libevent/patches-2.0/whatsnew-2.0.txt */ int chassis_libevent_init() { int ret; #ifdef WIN32 ret = evthread_use_windows_threads(); #else ret = evthread_use_pthreads(); #endif #ifdef _VINCHEN_TEST g_message("libevent version is %s\n", event_get_version()); #endif // _VINCHEN_TEST return ret; }
/* * Print version information to stderr. */ static void main_version(void) { fprintf(stderr, "%s %s (built %s)\n", PNAME, version, build_date); fprintf(stderr, "Copyright (c) 2009-2012, " "Daniel Roethlisberger <*****@*****.**>\n"); fprintf(stderr, "http://www.roe.ch/SSLsplit\n"); if (features[0]) { fprintf(stderr, "Features: %s\n", features); } nat_version(); ssl_openssl_version(); fprintf(stderr, "compiled against libevent %s\n", LIBEVENT_VERSION); fprintf(stderr, "rtlinked against libevent %s\n", event_get_version()); fprintf(stderr, "%d CPU cores detected\n", sys_get_cpu_cores()); }
int libevent_version_ok(void) { ev_uint32_t v_compile_maj; ev_uint32_t v_run_maj; v_compile_maj = LIBEVENT_VERSION_NUMBER & 0xffff0000; v_run_maj = event_get_version_number() & 0xffff0000; if (v_compile_maj != v_run_maj) { fprintf(stderr, "Incompatible libevent versions: have %s, built with %s\n", event_get_version(), LIBEVENT_VERSION); return 0; } return 1; }
int main(int argc, char **argv) { struct event ev; struct event *t1; event_enable_debug_mode(); fprintf(stderr, "Libevent %s\n", event_get_version()); fflush(stderr); if (!(base = event_base_new())) die("event_base_new"); if (event_base_priority_init(base, 8) < 0) die("event_base_priority_init"); if (event_assign(&ev, base, SIGTERM, EV_SIGNAL|EV_PERSIST, cbfunc, NULL)<0) die("event_assign"); if (event_priority_set(&ev, SIGPRI) < 0) die("event_priority_set"); if (event_add(&ev, NULL) < 0) die("event_add"); fprintf(stderr, "SIGNAL EVENT DEFINED\n"); fflush(stderr); t1 = (struct event*)malloc(sizeof(struct event)); if (event_assign(t1, base, -1, EV_WRITE, t1func, t1) < 0) { die("event_assign_term"); } if (event_priority_set(t1, TERMPRI) < 0) { die("event_priority_set_term"); } event_active(t1, EV_WRITE, 1); fprintf(stderr, "FIRST TERMINATION EVENT DEFINED\n"); fflush(stderr); /* event_dispatch(base); */ while (run) { event_base_loop(base, EVLOOP_ONCE); } fprintf(stderr, "EXITED LOOP - FREEING BASE\n"); fflush(stderr); event_base_free(base); return 0; }
/** Initialize the Libevent library and set up the event base. */ void tor_libevent_initialize(tor_libevent_cfg *torcfg) { tor_assert(the_event_base == NULL); /* some paths below don't use torcfg, so avoid unused variable warnings */ (void)torcfg; { int attempts = 0; struct event_config *cfg; ++attempts; cfg = event_config_new(); tor_assert(cfg); /* Telling Libevent not to try to turn locking on can avoid a needless * socketpair() attempt. */ event_config_set_flag(cfg, EVENT_BASE_FLAG_NOLOCK); if (torcfg->num_cpus > 0) event_config_set_num_cpus_hint(cfg, torcfg->num_cpus); /* We can enable changelist support with epoll, since we don't give * Libevent any dup'd fds. This lets us avoid some syscalls. */ event_config_set_flag(cfg, EVENT_BASE_FLAG_EPOLL_USE_CHANGELIST); the_event_base = event_base_new_with_config(cfg); event_config_free(cfg); } if (!the_event_base) { /* LCOV_EXCL_START */ log_err(LD_GENERAL, "Unable to initialize Libevent: cannot continue."); exit(1); // exit ok: libevent is broken. /* LCOV_EXCL_STOP */ } log_info(LD_GENERAL, "Initialized libevent version %s using method %s. Good.", event_get_version(), tor_libevent_get_method()); }
void ub_get_event_sys(struct ub_event_base* base, const char** n, const char** s, const char** m) { #ifdef USE_WINSOCK (void)base; *n = "event"; *s = "winsock"; *m = "WSAWaitForMultipleEvents"; #elif defined(USE_MINI_EVENT) (void)base; *n = "mini-event"; *s = "internal"; *m = "select"; #else struct event_base* b = AS_EVENT_BASE(base); *s = event_get_version(); # if defined(HAVE_EV_LOOP) || defined(HAVE_EV_DEFAULT_LOOP) *n = "libev"; if (!b) b = (struct event_base*)ev_default_loop(EVFLAG_AUTO); # ifdef EVBACKEND_SELECT *m = ub_ev_backend2str(ev_backend((struct ev_loop*)b)); # else *m = "not obtainable"; # endif # elif defined(HAVE_EVENT_BASE_GET_METHOD) *n = "libevent"; if (!b) b = event_base_new(); *m = event_base_get_method(b); # else *n = "unknown"; *m = "not obtainable"; (void)b; # endif # ifdef HAVE_EVENT_BASE_FREE if (b && b != AS_EVENT_BASE(base)) event_base_free(b); # endif #endif }
int _tmain(int argc, _TCHAR* argv[]) { // #ifdef WIN32 WSADATA wsa_data; WSAStartup(0x0202, &wsa_data); #endif MediaCreateSdp::GetInstance("\\test.h264"); struct sockaddr_in sa; memset(&sa, 0, sizeof(sa)); sa.sin_family = AF_INET; sa.sin_port = htons(1000); sa.sin_addr.s_addr = htonl(0); const char* ver = event_get_version(); printf("%s\n", ver); Network* work = new Network(sa); work->NetPrepare(TCP); work->StartServer(MediaSession::Recv, MediaSession::Send); //_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF|_CRTDBG_LEAK_CHECK_DF); return 0; }
struct tmuxproc * proc_start(const char *name) { struct tmuxproc *tp; struct utsname u; log_open(name); setproctitle("%s (%s)", name, socket_path); if (uname(&u) < 0) memset(&u, 0, sizeof u); log_debug("%s started (%ld): version %s, socket %s, protocol %d", name, (long)getpid(), VERSION, socket_path, PROTOCOL_VERSION); log_debug("on %s %s %s; libevent %s (%s)", u.sysname, u.release, u.version, event_get_version(), event_get_method()); tp = xcalloc(1, sizeof *tp); tp->name = xstrdup(name); return (tp); }
/** * create a global context */ chassis *chassis_new() { chassis *chas; if (0 != chassis_check_version(event_get_version(), _EVENT_VERSION)) { g_log_dbproxy(g_critical, "chassis is build against libevent %s, but now runs against %s", _EVENT_VERSION, event_get_version()); return NULL; } chas = g_new0(chassis, 1); chas->modules = g_ptr_array_new(); chas->stats = chassis_stats_new(); /* create a new global timer info */ chassis_timestamps_global_init(NULL); chas->threads = g_ptr_array_new(); chas->event_hdr_version = g_strdup(_EVENT_VERSION); chas->shutdown_hooks = chassis_shutdown_hooks_new(); chas->proxy_filter = sql_filter_new(0); chas->proxy_reserved = sql_reserved_query_new(); chas->daemon_mode = 0; chas->max_files_number = 0; chas->auto_restart = 0; chas->opts = NULL;//need to free chas->db_connect_timeout = 3.0;//default timeout 3.0s return chas; }
void TNonblockingIOThread::run() { threadId_ = Thread::get_current(); assert(eventBase_ == 0); eventBase_ = event_base_new(); // Print some libevent stats if (number_ == 0) { GlobalOutput.printf("TNonblockingServer: using libevent %s method %s", event_get_version(), event_base_get_method(eventBase_)); } registerEvents(); GlobalOutput.printf("TNonblockingServer: IO thread #%d entering loop...", number_); if (useHighPriority_) { setCurrentThreadHighPriority(true); } // Run libevent engine, never returns, invokes calls to eventHandler event_base_loop(eventBase_, 0); if (useHighPriority_) { setCurrentThreadHighPriority(false); } // cleans up our registered events cleanupEvents(); GlobalOutput.printf("TNonblockingServer: IO thread #%d run() done!", number_); }
void internal_parc_initializeLibevent(void) { if (_libeventInitialized) { return; } _libeventInitialized = 1; // 0x AA BB CC XX // AA = major // BB = minor // CC = patchlevel // uint32_t version = event_get_version_number(); trapIllegalValueIf(version < 0x02001000UL, "Libevent version must be at least 2.0.16, got %s", event_get_version()); // Make sure libevent uses our memory allocator. // Libevent allocates an internal object the first time a base is allocated // that it never releases. In order to ensure our outstanding memory counters // start at zero we trigger this allocation before interposing our memory allocator. // // Create a scheduler event base, an event, then free both of them. // struct event_base *evbase = event_base_new(); assertNotNull(evbase, "Libevent event_base_new returned NULL"); struct event *event = event_new(evbase, -1, 0, NULL, NULL); assertNotNull(event, "Libevent event_new returned NULL"); event_del(event); event_base_free(evbase); event_set_mem_functions(internal_parc_alloc, internal_parc_realloc, internal_parc_free); }
bool BnxDriver::ParseArgs(int argc, char *argv[]) { int c; while ((c = getopt(argc, argv, "c:hv")) != -1) { switch (c) { case 'c': SetConfigFile(optarg); break; case 'v': BnxOutStream << BnxBot::GetVersionString() << "\n\n"; BnxOutStream << "libevent: " << event_get_version() << '\n'; #ifdef USE_PCRE BnxOutStream << "pcre: " << pcre_version() << BnxEndl; #endif // USE_PCRE return false; case 'h': default: Usage(); return false; } } return true; }
/** * free the global scope * * closes all open connections, cleans up all plugins * * @param chas global context */ void chassis_free(chassis *chas) { guint i; #ifdef HAVE_EVENT_BASE_FREE const char *version; #endif if (!chas) return; /* call the destructor for all plugins */ for (i = 0; i < chas->modules->len; i++) { chassis_plugin *p = chas->modules->pdata[i]; g_assert(p->destroy); p->destroy(p->config); } chassis_shutdown_hooks_call(chas->shutdown_hooks); /* cleanup the global 3rd party stuff before we unload the modules */ for (i = 0; i < chas->modules->len; i++) { chassis_plugin *p = chas->modules->pdata[i]; chassis_plugin_free(p); } g_ptr_array_free(chas->modules, TRUE); if (chas->base_dir) g_free(chas->base_dir); if (chas->log_path) g_free(chas->log_path); if (chas->user) g_free(chas->user); if (chas->stats) chassis_stats_free(chas->stats); chassis_timestamps_global_free(NULL); GPtrArray *threads = chas->threads; if (threads) { for (i = 0; i < threads->len; ++i) { chassis_event_thread_free(threads->pdata[i]); } g_ptr_array_free(threads, TRUE); } if (chas->instance_name) g_free(chas->instance_name); #ifdef HAVE_EVENT_BASE_FREE /* only recent versions have this call */ version = event_get_version(); /* libevent < 1.3e doesn't cleanup its own fds from the event-queue in signal_init() * calling event_base_free() would cause a assert() on shutdown */ if (version && (strcmp(version, "1.3e") >= 0)) { if (chas->event_base) event_base_free(chas->event_base); } #endif g_free(chas->event_hdr_version); chassis_shutdown_hooks_free(chas->shutdown_hooks); lua_scope_free(chas->sc); network_backends_free(chas->backends); if (chas->proxy_filter != NULL) { sql_filter_free(chas->proxy_filter); } if (chas->proxy_reserved != NULL) { sql_reserved_query_free(chas->proxy_reserved); } g_free(chas); }