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);
}
