void initLibraries() { #ifdef _DEBUG event_enable_debug_mode(); // may cause memory leak #endif event_set_fatal_callback(libeventError); #ifdef _WIN32 #ifdef MEM_DEBUG _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF); #endif WSADATA data; int err = WSAStartup(0, &data); err = WSAStartup(data.wVersion, &data); assert(err == 0); #endif #ifdef EVTHREAD_USE_WINDOWS_THREADS_IMPLEMENTED evthread_use_windows_threads(); // may cause memory leak #endif #ifdef EVTHREAD_USE_PTHREADS_IMPLEMENTED evthread_use_pthreads(); #endif srand(static_cast<unsigned int>(time(NULL))); // stdlib :) }
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; }
EventBase::EventBase(const char* method) { // enable locking for libevent structure if (evthread_use_pthreads()) { throw std::exception(); } #ifdef DEBUG evthread_enable_lock_debuging(); event_enable_debug_mode(); #endif struct event_config *config; config = event_config_new(); int i = 0; const char** availMethods = event_get_supported_methods(); for (i = 0; availMethods[i] != NULL; i++) { if (strcmp(availMethods[i], method)) { event_config_avoid_method(config, availMethods[i]); } } base_ = event_base_new_with_config(config); if (!base_) { throw BadBaseException(); } event_base_get_method(base_); event_config_free(config); }
void TS3::telnetClientThread(TS3 * parent, std::string server) { int port = 10011; parent->_base = event_base_new(); parent->_dns_base = evdns_base_new(parent->_base, 1); evthread_use_pthreads(); evthread_make_base_notifiable(parent->_base); parent->_msg_event = event_new(parent->_base, -1, EV_READ, sendTS3message, parent); event_add(parent->_msg_event, nullptr); parent->_bev = bufferevent_socket_new(parent->_base, -1, BEV_OPT_CLOSE_ON_FREE); bufferevent_setcb(parent->_bev, telnetMessage, nullptr, telnetEvent, parent); bufferevent_enable(parent->_bev, EV_READ|EV_WRITE); timeval t; t.tv_sec = 60; t.tv_usec = 0; bufferevent_set_timeouts(parent->_bev, &t, nullptr); bufferevent_socket_connect_hostname( parent->_bev, parent->_dns_base, AF_UNSPEC, server.c_str(), port); // FIXME needs a reliable restart mechanism auto result = event_base_dispatch(parent->_base); if (result == -1) LOG(ERROR) << "Failed to start event loop"; }
void EventLoop::initialize() { // We need to initialize Libevent differently depending on the // operating system threading support. #if defined(EVTHREAD_USE_PTHREADS_IMPLEMENTED) if (evthread_use_pthreads() < 0) { LOG(FATAL) << "Failed to initialize, evthread_use_pthreads"; } #elif defined(EVTHREAD_USE_WINDOWS_THREADS_IMPLEMENTED) if (evthread_use_windows_threads() < 0) { LOG(FATAL) << "Failed to initialize, evthread_use_windows_threads"; } #else #error "Libevent must be compiled with either pthread or Windows thread support" #endif // This enables debugging of libevent calls. We can remove this // when the implementation settles and after we gain confidence. event_enable_debug_mode(); // TODO(jmlvanre): Allow support for 'epoll' once SSL related // issues are resolved. struct event_config* config = event_config_new(); event_config_avoid_method(config, "epoll"); base = event_base_new_with_config(config); if (base == NULL) { LOG(FATAL) << "Failed to initialize, event_base_new"; } }
void run(char *conf_file) { struct running rr; struct event *sig1_ev,*sig2_ev,*sig_hup; evthread_use_pthreads(); setup_running(&rr); register_interface_types(&rr); register_source_types(&rr); run_config(&rr,conf_file); start_stats_timer(&rr); ref_release(&(rr.ic_running)); event_add(sq_consumer(rr.sq),0); event_add(si_consumer(rr.si),0); sq_release(rr.sq); evsignal_add(sig1_ev=evsignal_new(rr.eb,SIGINT,user_quit,&rr),0); evsignal_add(sig2_ev=evsignal_new(rr.eb,SIGTERM,user_quit,&rr),0); evsignal_add(sig_hup=evsignal_new(rr.eb,SIGHUP,hupev,&rr),0); rr.sigkill_timer = event_new(rr.eb,-1,EV_PERSIST,sigkill_self,&rr); log_info(("Starting event loop")); event_base_loop(rr.eb,0); log_info(("Event loop finished")); event_del(sig1_ev); event_del(sig2_ev); event_del(sig_hup); event_free(sig1_ev); event_free(sig2_ev); event_free(sig_hup); closedown(&rr); log_info(("Bye!")); config_finished(); }
int main(int argc, char* argv[]) { #ifdef _WIN32 WORD wVersionRequested; WSADATA wsaData; wVersionRequested = MAKEWORD(2, 2); WSAStartup(wVersionRequested, &wsaData); evthread_use_windows_threads(); #else evthread_use_pthreads(); #endif //_WIN32 ygo::Game _game; ygo::mainGame = &_game; if(!ygo::mainGame->Initialize()) return 0; for(int i = 1; i < argc; ++i) { /*command line args: * -j: join host (host info from system.conf) * -d: deck edit * -r: replay */ if(argv[i][0] == '-' && argv[i][1] == 'e') { ygo::dataManager.LoadDB(&argv[i][2]); } else if(!strcmp(argv[i], "-j") || !strcmp(argv[i], "-d") || !strcmp(argv[i], "-r") || !strcmp(argv[i], "-s")) { exit_on_return = true; irr::SEvent event; event.EventType = irr::EET_GUI_EVENT; event.GUIEvent.EventType = irr::gui::EGET_BUTTON_CLICKED; if(!strcmp(argv[i], "-j")) { event.GUIEvent.Caller = ygo::mainGame->btnLanMode; ygo::mainGame->device->postEventFromUser(event); //TODO: wait for wLanWindow show. if network connection faster than wLanWindow, wLanWindow will still show on duel scene. event.GUIEvent.Caller = ygo::mainGame->btnJoinHost; ygo::mainGame->device->postEventFromUser(event); } else if(!strcmp(argv[i], "-d")) { event.GUIEvent.Caller = ygo::mainGame->btnDeckEdit; ygo::mainGame->device->postEventFromUser(event); } else if(!strcmp(argv[i], "-r")) { event.GUIEvent.Caller = ygo::mainGame->btnReplayMode; ygo::mainGame->device->postEventFromUser(event); ygo::mainGame->lstReplayList->setSelected(0); event.GUIEvent.Caller = ygo::mainGame->btnLoadReplay; ygo::mainGame->device->postEventFromUser(event); } else if(!strcmp(argv[i], "-s")) { event.GUIEvent.Caller = ygo::mainGame->btnServerMode; ygo::mainGame->device->postEventFromUser(event); ygo::mainGame->lstSinglePlayList->setSelected(0); event.GUIEvent.Caller = ygo::mainGame->btnLoadSinglePlay; ygo::mainGame->device->postEventFromUser(event); } } } ygo::mainGame->MainLoop(); #ifdef _WIN32 WSACleanup(); #else #endif //_WIN32 return EXIT_SUCCESS; }
/// Create a new poller onion_poller *onion_poller_new(int aprox_n){ evthread_use_pthreads(); onion_poller *ret=onion_low_calloc(1,sizeof(onion_poller)); ret->base=event_base_new(); sem_init(&ret->sem, 0, 1); return ret; }
core::curl_handler::curl_handler() { #ifdef _WIN32 evthread_use_windows_threads(); #else evthread_use_pthreads(); #endif }
void base_server_init(const Setup *setup) { base_conf_init(setup); /*cout << "event method: " << event_base_get_method(main_base) << endl;*/ evthread_use_pthreads(); thread_init(); main_base = get_main_thread()->get_event_base(); conn_init(); clock_handler(0, 0, 0); }
bool InitHTTPServer() { if (!InitHTTPAllowList()) return false; if (gArgs.GetBoolArg("-rpcssl", false)) { uiInterface.ThreadSafeMessageBox( "SSL mode for RPC (-rpcssl) is no longer supported.", "", CClientUIInterface::MSG_ERROR); return false; } // Redirect libevent's logging to our own log event_set_log_callback(&libevent_log_cb); // Update libevent's log handling. Returns false if our version of // libevent doesn't support debug logging, in which case we should // clear the BCLog::LIBEVENT flag. if (!UpdateHTTPServerLogging(g_logger->WillLogCategory(BCLog::LIBEVENT))) { g_logger->DisableCategory(BCLog::LIBEVENT); } #ifdef WIN32 evthread_use_windows_threads(); #else evthread_use_pthreads(); #endif raii_event_base base_ctr = obtain_event_base(); /* Create a new evhttp object to handle requests. */ raii_evhttp http_ctr = obtain_evhttp(base_ctr.get()); struct evhttp* http = http_ctr.get(); if (!http) { LogPrintf("couldn't create evhttp. Exiting.\n"); return false; } evhttp_set_timeout(http, gArgs.GetArg("-rpcservertimeout", DEFAULT_HTTP_SERVER_TIMEOUT)); evhttp_set_max_headers_size(http, MAX_HEADERS_SIZE); evhttp_set_max_body_size(http, MAX_SIZE); evhttp_set_gencb(http, http_request_cb, nullptr); if (!HTTPBindAddresses(http)) { LogPrintf("Unable to bind any endpoint for RPC server\n"); return false; } LogPrint(BCLog::HTTP, "Initialized HTTP server\n"); int workQueueDepth = std::max((long)gArgs.GetArg("-rpcworkqueue", DEFAULT_HTTP_WORKQUEUE), 1L); LogPrintf("HTTP: creating work queue of depth %d\n", workQueueDepth); workQueue = new WorkQueue<HTTPClosure>(workQueueDepth); // transfer ownership to eventBase/HTTP via .release() eventBase = base_ctr.release(); eventHTTP = http_ctr.release(); return true; }
void MessageManager::StartServer(ServerCallback *callback) { int len; string inKeyPath = Config::Inst()->GetPathHome() + "/config/keys" + NOVAD_LISTEN_FILENAME; evutil_socket_t IPCParentSocket; struct event_base *base; struct event *listener_event; struct sockaddr_un msgLocal; evthread_use_pthreads(); base = event_base_new(); if (!base) { LOG(ERROR, "Failed to set up socket base", ""); return; } if((IPCParentSocket = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) { LOG(ERROR, "Failed to create socket for accept()", "socket: "+string(strerror(errno))); return; } evutil_make_socket_nonblocking(IPCParentSocket); msgLocal.sun_family = AF_UNIX; memset(msgLocal.sun_path, '\0', sizeof(msgLocal.sun_path)); strncpy(msgLocal.sun_path, inKeyPath.c_str(), inKeyPath.length()); unlink(msgLocal.sun_path); len = strlen(msgLocal.sun_path) + sizeof(msgLocal.sun_family); if(::bind(IPCParentSocket, (struct sockaddr *)&msgLocal, len) == -1) { LOG(ERROR, "Failed to bind to socket", "bind: "+string(strerror(errno))); close(IPCParentSocket); return; } if(listen(IPCParentSocket, SOMAXCONN) == -1) { LOG(ERROR, "Failed to listen for UIs", "listen: "+string(strerror(errno))); close(IPCParentSocket); return; } struct CallbackArg *cbArg = new struct CallbackArg; cbArg->m_base = base; cbArg->m_callback = callback; listener_event = event_new(base, IPCParentSocket, EV_READ|EV_PERSIST, DoAccept, (void*)cbArg); event_add(listener_event, NULL); event_base_dispatch(base); LOG(ERROR, "Main accept dispatcher returned. This should not occur.", ""); return; }
DelayedEventQueue::DelayedEventQueue() { #ifndef _WIN32 evthread_use_pthreads(); #else evthread_use_windows_threads(); #endif _eventLoop = event_base_new(); _thread = NULL; _isStarted = false; }
void Loop::init() { #if (defined _WIN32) || (defined WIN32) || (defined _WIN64) || (defined WIN64) WSADATA wsadata; WSAStartup(MAKEWORD(2, 2), &wsadata); evthread_use_windows_threads(); #else evthread_use_pthreads(); #endif//_WIN32 }
Global::Global() { SSL_library_init(); ERR_load_CRYPTO_strings(); SSL_load_error_strings(); OpenSSL_add_all_algorithms(); RAND_poll(); #ifndef _NO_LIBEVENT_THREADS evthread_use_pthreads(); #endif event_base = event_base_new(); dns_base = evdns_base_new(event_base, 1); };
CEventThread::CEventThread(int32_t iThreadType, int32_t iThreadId) :CThread(iThreadType, iThreadId) { evthread_use_pthreads(); m_pEventBase = event_base_new(); struct timeval sTm; sTm.tv_sec =630720000; sTm.tv_usec = 0; event *pEvent = event_new(m_pEventBase, -1, EV_PERSIST, &OnStaticTimeOut, NULL); evtimer_add(pEvent, &sTm); }
/* called after g_module_check_init(), after shadow searches for __shadow_plugin_init__ */ void __shadow_plugin_init__(ShadowFunctionTable* shadowlibFuncs) { /* save the shadow functions we will use */ scallion.shadowlibFuncs = shadowlibFuncs; /* tell shadow which functions it should call to manage nodes */ shadowlibFuncs->registerPlugin(&_scallion_new, &_scallion_free, &_scallion_notify); shadowlibFuncs->log(SHADOW_LOG_LEVEL_INFO, __FUNCTION__, "finished registering scallion plug-in state"); /* setup openssl locks */ #define OPENSSL_THREAD_DEFINES #include <openssl/opensslconf.h> #if defined(OPENSSL_THREADS) /* thread support enabled */ /* make sure openssl uses Shadow's random sources and make crypto thread-safe */ const RAND_METHOD* shadowRandomMethod = NULL; CRYPTO_lock_func shadowLockFunc = NULL; CRYPTO_id_func shadowIdFunc = NULL; int nLocks = CRYPTO_num_locks(); gboolean success = shadowlibFuncs->cryptoSetup(nLocks, (gpointer*)&shadowLockFunc, (gpointer*)&shadowIdFunc, (gconstpointer*)&shadowRandomMethod); if(!success) { /* ok, lets see if we can get shadow function pointers through LD_PRELOAD */ shadowRandomMethod = RAND_get_rand_method(); shadowLockFunc = CRYPTO_get_locking_callback(); shadowIdFunc = CRYPTO_get_id_callback(); } CRYPTO_set_locking_callback(shadowLockFunc); CRYPTO_set_id_callback(shadowIdFunc); RAND_set_rand_method(shadowRandomMethod); shadowlibFuncs->log(SHADOW_LOG_LEVEL_INFO, __FUNCTION__, "finished initializing crypto thread state"); #else /* no thread support */ shadowlibFuncs->log(SHADOW_LOG_LEVEL_CRITICAL, __FUNCTION__, "please rebuild openssl with threading support. expect segfaults."); #endif /* setup libevent locks */ #ifdef EVTHREAD_USE_PTHREADS_IMPLEMENTED if(evthread_use_pthreads()) { shadowlibFuncs->log(SHADOW_LOG_LEVEL_CRITICAL, __FUNCTION__, "error in evthread_use_pthreads()"); } shadowlibFuncs->log(SHADOW_LOG_LEVEL_MESSAGE, __FUNCTION__, "finished initializing event thread state evthread_use_pthreads()"); #else shadowlibFuncs->log(SHADOW_LOG_LEVEL_CRITICAL, __FUNCTION__, "please rebuild libevent with threading support, or link with event_pthread. expect segfaults."); #endif }
LibEventInit::LibEventInit() { event_set_log_callback(my_libevent_log_cb); #ifdef OS_WIN evthread_use_windows_threads(); #else evthread_use_pthreads(); #endif evdns_set_log_fn(logfn); if (CONFIG->enableEventDebug){ MYDEBUG("enable libevent debug"); event_enable_debug_mode(); } }
//<!************************************************************************ TcpTransport::TcpTransport(TcpRemotingClient *pTcpRemointClient, READ_CALLBACK handle /* = NULL */) : m_tcpConnectStatus(e_connectInit), m_ReadDatathread(NULL), m_readcallback(handle), m_tcpRemotingClient(pTcpRemointClient) { m_startTime = UtilAll::currentTimeMillis(); #ifdef WIN32 evthread_use_windows_threads(); #else evthread_use_pthreads(); #endif m_eventBase = NULL; m_bufferEvent = NULL; }
void LinkScheduler::run() { LOG(INFO, "start"); evthread_use_pthreads(); event_set_log_callback(LinkScheduler::event_log_callback); event_set_fatal_callback(LinkScheduler::event_fatal_callback); _base = event_base_new(); _printStateEvent = evtimer_new(_base, on_print_state, this); struct timeval t = {Conf::instance()->schedulerPrintStateInterval, 0 }; evtimer_add(_printStateEvent, &t); event_base_dispatch(_base); abort(); }
int main (int argc, char **argv) { signal(SIGPIPE, SIG_IGN); event_enable_debug_mode(); int result = evthread_use_pthreads(); if (result < 0) { printf("Could not use pthreads with libevent\n"); exit(1); } struct event_base *base = event_base_new(); if (base == NULL) { printf("Could not create libevent base\n"); exit(1); } result = evthread_make_base_notifiable(base); if (result) { printf("Could not initialize libevent base\n"); exit(1); } riak_context ctx_data[10]; for(int i = 0; i < 10; i++) { riak_context *ctx = &ctx_data[i]; riak_context_init(ctx); if (ctx->err) { printf("Error: %s\n", ctx->errstr); return 1; } result = riak_context_connect(ctx, "httpbin.org", "80"); // result = riak_context_connect(ctx, "localhost", "6074"); if (result) { printf("Could not connect to host\n"); exit(1); } result = riak_libevent_init(ctx, base); if (result) { printf("Could not initialize libevent\n"); exit(1); } riak_send(ctx, "GET / HTTP/1.1\r\nHost: httpbin.org\r\n\r\n", result_fn); } event_base_dispatch(base); // cleanup event_base_free(base); return 0; }
bool HttpService::Init() { bool ret = false; do { evthread_use_pthreads(); base_ = event_base_new(); if (!base_) { LOG_ERROR("create event base failed!"); break; } dnsbase_ = evdns_base_new(base_, 1); if (!dnsbase_) { LOG_ERROR("create dnsbase failed!"); break; } http_server_ = evhttp_new(base_); if (!http_server_) { LOG_ERROR("create evhttp failed!"); break; } evhttp_set_allowed_methods(http_server_, EVHTTP_REQ_CONNECT | EVHTTP_REQ_GET | EVHTTP_REQ_POST | EVHTTP_REQ_HEAD | EVHTTP_REQ_PUT | EVHTTP_REQ_DELETE); if (evhttp_accept_socket(http_server_, sock_) != 0) { LOG_ERROR("accept socket failed!"); break; } evhttp_set_gencb(http_server_, HttpGenericCallback, this); ret = true; } while(0); return ret; }
/* 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; }
void StartTorControl() { assert(!gBase); #ifdef WIN32 evthread_use_windows_threads(); #else evthread_use_pthreads(); #endif gBase = event_base_new(); if (!gBase) { LogPrintf("tor: Unable to create event_base\n"); return; } torControlThread = std::thread(std::bind(&TraceThread<void (*)()>, "torcontrol", &TorControlThread)); }
void StartTorControl(boost::thread_group& threadGroup, CScheduler& scheduler) { assert(!base); #ifdef WIN32 evthread_use_windows_threads(); #else evthread_use_pthreads(); #endif base = event_base_new(); if (!base) { LogPrintf("tor: Unable to create event_base\n"); return; } torControlThread = boost::thread(boost::bind(&TraceThread<void (*)()>, "torcontrol", &TorControlThread)); }
JtEventServer::JtEventServer() : base(NULL), m_Started(0) { #if (defined(WIN32) || defined(WIN64)) WSADATA wsa_data; WSAStartup(0x0201, &wsa_data); evthread_use_windows_threads(); tid = INVALID_HANDLE_VALUE; #else evthread_use_pthreads(); tid = -1; #endif pEventPairPipe = NULL; m_Started = 0; InHandling = 0; }
void async_network_task_push(struct async_network_task_s *task) { static int thread_started = 0; if (!thread_started) { pthread_t t; evthread_use_pthreads(); event_b = event_base_new(); evdns_b = evdns_base_new(event_b, 0); evdns_base_resolv_conf_parse(evdns_b, DNS_OPTIONS_ALL, "/etc/resolv.conf"); if (config.randomize_dns_case == 0) evdns_base_set_option(evdns_b, "randomize-case:", "0"); pthread_create(&t, NULL, network_worker_thread, NULL); pthread_detach(t); thread_started = 1; } switch (task->type) { case ASYNC_NETWORK_TCP_CONNECT: handle_tcp_connect_stage1(task); break; case ASYNC_NETWORK_TCP_CONNECT_WITH_NETADDRESS: handle_tcp_connect_with_net_address(task); break; case ASYNC_NETWORK_DISCONNECT: handle_disconnect_stage1(task); break; case ASYNC_NETWORK_TCP_READ: handle_tcp_read_stage1(task); break; case ASYNC_NETWORK_TCP_WRITE: handle_tcp_write_stage1(task); break; case ASYNC_NETWORK_UDP_RECV: handle_udp_recv_stage1(task); break; case ASYNC_NETWORK_UDP_SEND: handle_udp_send_stage1(task); break; case ASYNC_NETWORK_HOST_RESOLVE: handle_host_resolve_stage1(task); break; } }
int main () { int sockfd; struct bufferevent *p_event; struct sockaddr_in addr; memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(PORT); if (inet_pton(AF_INET, SVRADDR, &addr.sin_addr) <= 0) { printf("inet_pton"); exit(1); } evthread_use_pthreads(); if ((p_base = event_base_new()) == NULL) { printf("event_base_new "); return 1; } /* we do not need invoke socket function to create socket */ if ((p_event = bufferevent_socket_new(p_base, -1, BEV_OPT_CLOSE_ON_FREE | BEV_OPT_THREADSAFE)) == NULL) { printf("bufferevent_socket_new "); return 1; } g_bev = p_event; /* client actually connecte to server at this time. */ if ((sockfd = bufferevent_socket_connect(p_event, (struct sockaddr *) &addr, sizeof(addr))) < 0) { printf("bufferevent_socket_connect "); return 1; } /* EV_WRITE is default enabled, EV_READ is default disabled */ /* So If we disable READ, evbuffer callback will not be added to base (read and write) */ bufferevent_setcb(p_event, buff_input_cb, NULL, buff_ev_cb, p_base); bufferevent_enable(p_event, EV_READ | EV_WRITE); event_base_dispatch(p_base); return 0; }
static int init_server(arguments *args) { printf("Starting server...\n"); if (evthread_use_pthreads() == -1) { printf("Error occured while turning on pthreads using\n"); return -1; } signal(SIGINT, int_handler); struct evconnlistener* listener; struct sockaddr_in sin; base = event_base_new(); if (!base) { printf("Error while creating event base\n"); free(args); return -1; } thread_pool* thpool = thread_pool_init(args->ncpu, args->doc_root); memset(&sin, 0, sizeof(sin)); sin.sin_family = AF_INET; sin.sin_addr.s_addr = htonl(INADDR_ANY); sin.sin_port = htons((unsigned short)args->port); listener = evconnlistener_new_bind(base, accept_connection_cb, (void*)thpool, (LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE), -1, (struct sockaddr*) &sin, sizeof(sin)); free(args); if (!listener) { printf("Error while creating listener\n"); thread_pool_destroy(thpool); event_base_free(base); return -1; } evconnlistener_set_error_cb(listener, accept_error_cb); printf("Server is running\nUse Ctrl+C to stop server\n"); event_base_dispatch(base); evconnlistener_free(listener); thread_pool_destroy(thpool); event_base_free(base); return 0; }
void General::initThreads() { if ( s_initThreads ) { return; } s_initThreads = true; #ifdef WIN32 evthread_use_windows_threads(); #else evthread_use_pthreads(); #endif //event_enable_debug_logging(EVENT_DBG_ALL); }