Ejemplo n.º 1
0
// Initializes TCP and LibEvent, then listens for connections on port
// and calls accept_cb when they occur.  Terminates cleanly on SIGINT.
// Returns 0 on clean shutdown; otherwise nonzero
int InitAndListenLoop(int port, evconnlistener_cb accept_cb, struct telex_conf *conf)
{
#ifdef WIN32
	WSADATA WSAData;
	WSAStartup(0x101, &WSAData);
#endif
	
	struct event_base *base;
	base = event_base_new();
	if (!base) {
		LogFatal("listener", "Could not initialize libevent");
		return 1;
	}

	conf->dns_base = evdns_base_new(base, 1);
	if (!conf->dns_base) {
		LogFatal("listener", "Could not initialize dns");
		return 1;
	}

	struct evconnlistener *listener;
	listener = listener_init_local(base, port, accept_cb, conf, NULL);
	if (!listener) {
		LogFatal("listener", "Could not create listener");
		return 1;
	}

	struct event *signal_event;
	signal_event = evsignal_new(base, SIGINT, sigint_cb, (void *)base);
	if (!signal_event || event_add(signal_event, NULL)<0) {
		LogFatal("listener", "Could not create/add signal event");
		return 1;
	}

	// handle events ...
	LogTrace("listener", "Starting dispatch");
	event_base_dispatch(base);

	evconnlistener_free(listener);
	event_free(signal_event);
	event_base_free(base);

	LogInfo("listener", "Shutdown complete");
	return 0;
}
Ejemplo n.º 2
0
/* Thread: main */
void
filescanner_deinit(void)
{
  int ret;

#ifdef USE_EVENTFD
  ret = eventfd_write(exit_efd, 1);
  if (ret < 0)
    {
      DPRINTF(E_FATAL, L_SCAN, "Could not send exit event: %s\n", strerror(errno));

      return;
    }
#else
  int dummy = 42;

  ret = write(exit_pipe[1], &dummy, sizeof(dummy));
  if (ret != sizeof(dummy))
    {
      DPRINTF(E_FATAL, L_SCAN, "Could not write to exit fd: %s\n", strerror(errno));

      return;
    }
#endif

  scan_exit = 1;

  ret = pthread_join(tid_scan, NULL);
  if (ret != 0)
    {
      DPRINTF(E_FATAL, L_SCAN, "Could not join filescanner thread: %s\n", strerror(errno));

      return;
    }

  inofd_event_unset();

#ifdef USE_EVENTFD
  close(exit_efd);
#else
  close(exit_pipe[0]);
  close(exit_pipe[1]);
#endif
  event_base_free(evbase_scan);
}
Ejemplo n.º 3
0
int main() {
    evbase_t *evbase = event_base_new();
    evhtp_t *htp = evhtp_new(evbase, NULL);

    fprintf(stdout, "Welcome to CAvatar.\n");

    // A place for our images
    mkdir(imgfolder, 0700);

    // A few static routes
    evhtp_set_cb(htp, "/", route_index, NULL);
    evhtp_set_cb(htp, "/favicon.ico", route_favicon, NULL);

    // Metas
    evhtp_set_regex_cb(htp, "[\\/](meta)[\\/]([0-9a-fA-F]{32})", route_meta, NULL);

    // Images
    evhtp_set_regex_cb(htp, "[\\/](avatar)[\\/]([0-9a-fA-F]{32})", route_image, NULL);
    evhtp_set_regex_cb(htp, "[\\/]([0-9a-fA-F]{32})", route_image, NULL);

    // 404 routes
    evhtp_set_regex_cb(htp, "[\\/](.{1,})", route_generic, NULL);
    evhtp_set_gencb(htp, route_generic, NULL);

    // libevhtp has a cool wrapper for pthreads
    evhtp_use_threads(htp, NULL, threads, NULL);

    // aaaand bind a socket..
    if (evhtp_bind_socket(htp, "0.0.0.0", port, 1024) < 0) {
        fprintf(stderr, "Could not bind to socket %d: %s\n", port, strerror(errno));
        exit(-1);
    }
    fprintf(stdout, "Binded to socket %d\n", port);

    // and listen!
    event_base_loop(evbase, 0);

    // free stuff after event loop
    evhtp_unbind_socket(htp);
    evhtp_free(htp);
    event_base_free(evbase);
    //MagickWandTerminus();

    return 0;
}
Ejemplo n.º 4
0
static void
thread_deferred_cb_skew(void *arg)
{
	struct timeval tv_timer = {1, 0};
	struct event_base *base = NULL;
	struct event_config *cfg = NULL;
	struct timeval elapsed;
	int elapsed_usec;
	int i;

	cfg = event_config_new();
	tt_assert(cfg);
	event_config_set_max_dispatch_interval(cfg, NULL, 16, 0);

	base = event_base_new_with_config(cfg);
	tt_assert(base);

	for (i = 0; i < QUEUE_THREAD_COUNT; ++i)
		deferred_data[i].queue = base;

	evutil_gettimeofday(&timer_start, NULL);
	event_base_once(base, -1, EV_TIMEOUT, timer_callback, NULL,
			&tv_timer);
	event_base_once(base, -1, EV_TIMEOUT, start_threads_callback,
			NULL, NULL);
	event_base_dispatch(base);

	evutil_timersub(&timer_end, &timer_start, &elapsed);
	TT_BLATHER(("callback count, %u", callback_count));
	elapsed_usec =
	    (unsigned)(elapsed.tv_sec*1000000 + elapsed.tv_usec);
	TT_BLATHER(("elapsed time, %u usec", elapsed_usec));

	/* XXX be more intelligent here.  just make sure skew is
	 * within .4 seconds for now. */
	tt_assert(elapsed_usec >= 600000 && elapsed_usec <= 1400000);

end:
	for (i = 0; i < QUEUE_THREAD_COUNT; ++i)
		THREAD_JOIN(load_threads[i]);
	if (base)
		event_base_free(base);
	if (cfg)
		event_config_free(cfg);
}
Ejemplo n.º 5
0
int
main(int argc, char **argv)
{
	struct event_base *base;
	struct evconnlistener *listener;
	struct event *signal_event;

	struct sockaddr_in sin;

	base = event_init();
	if (!base) {
		fprintf(stderr, "Could not initialize libevent!\n");
		return 1;
	}

	memset(&sin, 0, sizeof(sin));
	sin.sin_family = AF_INET;
	sin.sin_port = htons(PORT);

	listener = evconnlistener_new_bind(base, listener_cb, (void *)base,
	    LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE, -1,
	    (struct sockaddr*)&sin,
	    sizeof(sin));

	if (!listener) {
		fprintf(stderr, "Could not create a listener!\n");
		return 1;
	}

	signal_event = evsignal_new(base, SIGINT, signal_cb, (void *)base);

	if (!signal_event || event_add(signal_event, NULL)<0) {
		fprintf(stderr, "Could not create/add a signal event!\n");
		return 1;
	}

	event_base_dispatch(base);

	evconnlistener_free(listener);
	event_free(signal_event);
	event_base_free(base);

	printf("done\n");
	return 0;
}
Ejemplo n.º 6
0
void
worker_deinit(void)
{
  int ret;

  g_initialized = 0;
  commands_base_destroy(cmdbase);

  ret = pthread_join(tid_worker, NULL);
  if (ret != 0)
    {
      DPRINTF(E_FATAL, L_MAIN, "Could not join worker thread: %s\n", strerror(errno));
      return;
    }

  // Free event base (should free events too)
  event_base_free(evbase_worker);
}
Ejemplo n.º 7
0
void CTcpServer::start()
{
	eventPool_.setThreadNum(2);
	eventPool_.start();
	struct sockaddr_in sin;
	memset(&sin, 0, sizeof(sockaddr_in));
	sin.sin_family = AF_INET;
	sin.sin_port = htons(9995);

	struct event_base* base = event_base_new();
	listener_ = evconnlistener_new_bind(base, listenCallback, this, 
															LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE,
															-1, (sockaddr*)&sin, sizeof(sin));

	event_base_dispatch(base);
	evconnlistener_free(listener_);
	event_base_free(base);
}
Ejemplo n.º 8
0
WorkerThread::~WorkerThread()
{
	if(notfiy_recv_fd_!=-1)
		close(notfiy_recv_fd_);
	if(notfiy_send_fd_!=-1)
		close(notfiy_send_fd_);
	if(pthread_event_base_!=NULL)
		event_base_free(pthread_event_base_);
	if(pnotify_event_!=NULL)
		event_free(pnotify_event_);
	if(ptimeout_event_)
		event_free(ptimeout_event_);

    // for(auto pos=map_tcp_conns_.begin();pos!=map_tcp_conns_.end();++pos)
    // 	delete pos->second;
    // for(auto pos=map_udp_conns_.begin();pos!=map_udp_conns_.end();++pos)
    // 	delete pos->second;
}
Ejemplo n.º 9
0
TcpListener::~TcpListener()
{
    if (clients_.size() > 0)
    {
        clients_.clear();
    }
    if (listener_)
    {
        evconnlistener_free(listener_);
        listener_ = nullptr;
    }
    
    if (base_)
    {
        event_base_free(base_);
        base_ = nullptr;
    }
}
Ejemplo n.º 10
0
static void closeAndFreeClient(client_t *client) {
	if (client != NULL) {
		closeClient(client);
		if (client->buf_ev != NULL) {
			bufferevent_free(client->buf_ev);
			client->buf_ev = NULL;
		}
		if (client->evbase != NULL) {
			event_base_free(client->evbase);
			client->evbase = NULL;
		}
		if (client->output_buffer != NULL) {
			evbuffer_free(client->output_buffer);
			client->output_buffer = NULL;
		}
		free(client);
	}
}
Ejemplo n.º 11
0
int main(){
	//делаем соект
	static evutil_socket_t master_socket=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
	if(-1==master_socket)
		std::cout << "socket():\n"<<errno<<std::endl;
	else{
		//делаем структуру
		struct sockaddr_in sa;
		sa.sin_family=AF_INET;
		sa.sin_port=htons(12345);
		sa.sin_addr.s_addr=htonl(INADDR_ANY);
		//биндим
		if(bind(master_socket,(sockaddr*)&sa,sizeof(sa))==-1)
			std::cout << "bind:\n"<<errno<<std::endl;
		else if(listen(master_socket,SOMAXCONN)==-1)
			std::cout << "listen:\n"<<errno<<std::endl;
		else{
			//повторное использование мастер сокета
			int optval = 1;
			setsockopt(master_socket,SOL_SOCKET,SO_REUSEADDR,&optval,sizeof(optval));
			//не  блокирующий
			set_non_block(master_socket);
			                                                               
			//делаем ядро
			struct event_base * base=event_base_new();
	
			//регистрируем события
			struct event * evn=event_new(base,master_socket,EV_READ|EV_PERSIST,cb_master,event_self_cbarg());
			event_add(evn,NULL);

			//запускаем цикл
			event_base_dispatch(base);
			
			//очищаем
			event_base_free(base);
			event_free(evn);
			//закрываем
			shutdown(master_socket,SHUT_RDWR);
			close(master_socket);
	
		}
	}
	return 0;
}
Ejemplo n.º 12
0
/** \brief SCConfLogReopenAsyncRedis() Open or re-opens connection to redis for logging.
 *  \param log_ctx Log file context allocated by caller
 */
static int SCConfLogReopenAsyncRedis(LogFileCtx *log_ctx)
{
    SCLogRedisContext * ctx = log_ctx->redis;
    const char *redis_server = log_ctx->redis_setup.server;
    int redis_port = log_ctx->redis_setup.port;

    /* only try to reconnect once per second */
    if (ctx->tried >= time(NULL)) {
        return -1;
    }

    ctx->async = redisAsyncConnect(redis_server, redis_port);

    if (ctx->ev_base != NULL) {
        event_base_free(ctx->ev_base);
    }

    if (ctx->async == NULL) {
        SCLogError(SC_ERR_MEM_ALLOC, "Error allocate redis async.");
        ctx->tried = time(NULL);
        return -1;
    }

    if (ctx->async != NULL && ctx->async->err) {
        SCLogError(SC_ERR_SOCKET, "Error setting to redis async: [%s].", ctx->async->errstr);
        ctx->tried = time(NULL);
        return -1;
    }

    ctx->ev_base = event_base_new();

    if (ctx->ev_base == NULL) {
        ctx->tried = time(NULL);
        redisAsyncFree(ctx->async);
        ctx->async = NULL;
        return -1;
    }

    redisLibeventAttach(ctx->async, ctx->ev_base);

    log_ctx->redis = ctx;
    log_ctx->Close = SCLogFileCloseRedis;
    return 0;
}
Ejemplo n.º 13
0
int main()
{
    processpool p_pool(DFLNUM);
    p_pool.set_hook(global_process_fun);
    p_pool.create_processpool();

    int sockfd = my_socket::create_socket_for_server();

    struct event_base * base = event_base_new();
    assert(NULL != base);

    struct event * sock_ev = event_new(base, sockfd,
                                EV_READ | EV_PERSIST,
                                accept_cb, (void *)&p_pool);
    assert(NULL != sock_ev);
    event_add(sock_ev, NULL);

    int i = 0;
    struct event * events[DFLNUM];
    for( ; i < DFLNUM; ++i)
    {
        ar_in[i].id = i;
        ar_in[i].p_pro_pool = &p_pool;

        events[i] = event_new(base, p_pool[i].get_fd(),
                            EV_READ | EV_PERSIST,
                            pipe_cb, (void *)&ar_in[i]);
        assert(NULL != events[i]);

        event_add(events[i], NULL);
    }

    event_base_dispatch(base);

    event_free(sock_ev);
    for(i = 0; i < DFLNUM; ++i)
    {
        event_free(events[i]);
    }
    event_base_free(base);
    cout << "server stop" << endl;

    return 0;
}
/**
 * @author sohu-inc.com
 * 后端检测线程释放销毁
 * @param detect_thread
 */
void backend_detect_thread_free(backend_detect_thread_t *detect_thread) {
	gboolean is_thread = FALSE;

	if (!detect_thread)
		return;

	is_thread = (detect_thread->thr != NULL);

	g_debug("[%s]: will join detect thread if needed.", G_STRLOC);
	if (detect_thread->thr != NULL) {
		g_thread_join(detect_thread->thr);
		detect_thread->thr = NULL;
	}

	g_debug("[%s]: deleting the event_base of detect thread", G_STRLOC);
	if (is_thread && detect_thread->event_base) {
		event_base_free(detect_thread->event_base);
		detect_thread->event_base = NULL;
	}

	if (detect_thread->backend != NULL) {
		// 这里应用的是上层传来的指针,不用释放backend指向的内存,
		// 只是将backend置为NULL即可
		detect_thread->backend = NULL;
	}

	if (detect_thread->chas) {
		// 这里应用的是上层传来的指针,不用释放chas指向的内存,
		// 只是将chas置为NULL即可
		detect_thread->chas = NULL;
	}

	if (detect_thread->name != NULL) {
		g_string_free(detect_thread->name, TRUE);
		detect_thread->name = NULL;
	}

	if (detect_thread->task != NULL) {
		detection_task_free(detect_thread->task);
		detect_thread->task = NULL;
	}

	g_free(detect_thread);
}
Ejemplo n.º 15
0
void
lgtd_cleanup(void)
{
    lgtd_lifx_discovery_close();
    lgtd_listen_close_all();
    lgtd_command_pipe_close_all();
    lgtd_client_close_all();
    lgtd_lifx_broadcast_close();
    lgtd_lifx_gateway_close_all();
    lgtd_timer_stop_all();
    lgtd_close_signal_handling();
    event_base_free(lgtd_ev_base);
#if LIBEVENT_VERSION_NUMBER >= 0x02010100
    libevent_global_shutdown();
#endif
    if (lgtd_opts.pidfile) {
        unlink(lgtd_opts.pidfile);
    }
}
Ejemplo n.º 16
0
void EvHttpSyncClient::close()
{
    FX_DEBUG("Close client");
    if (m_pConn)
    {
        evhttp_connection_free(m_pConn);
        m_pConn = NULL;
    }

    if (m_evbase && m_bOwnEventBase) 
    {
        event_base_loopbreak(m_evbase);
        event_base_free(m_evbase);
    }
    m_evbase = NULL;

    m_lastState = ST_DISCONNECTED;
    m_pLastRequest = NULL;
}
Ejemplo n.º 17
0
static char *getUserInput(KonohaContext *kctx, char *buff, const char *cid, const char *host, int port)
{
	struct event_base *base = event_base_new();
	struct evhttp *httpd = evhttp_new(base);
	if(evhttp_bind_socket(httpd, host, port) < 0) {
		PLATAPI LoggerModule.syslog_i(5/*LOG_NOTICE*/, "{\"Method\": \"DScriptError\", \"CId\": \"%s\", \"Body\": \"couldn't bind socket\"}", cid);
		exit(1);
	}

	UserInput ui = {};
	ui.base = base;
	ui.buff = buff;
	evhttp_set_gencb(httpd, userInput2Buff, (void *)&ui);
	event_base_dispatch(base);
	evhttp_free(httpd);
	event_base_free(base);

	return buff;
}
Ejemplo n.º 18
0
/*!
 * @brief Free any associated resources with the client
 */
static void sstp_client_free(sstp_client_st *client)
{
    /* Destory the HTTPS stream */
    if (client->stream)
    {
        sstp_stream_destroy(client->stream);
        client->stream = NULL;
    }

    /* Shutdown the SSL context */
    if (client->ssl_ctx)
    {
        SSL_CTX_free(client->ssl_ctx);
        client->ssl_ctx = NULL;
    }

    /* Close the PPPD layer */
    if (client->pppd)
    {
        sstp_pppd_free(client->pppd);
        client->pppd = NULL;
    }

    /* Close the IPC */
    if (client->event)
    {
        sstp_event_free(client->event);
        client->event = NULL;
    }

    /* Free the route context */
    if (client->route_ctx)
    {
        sstp_route_done(client->route_ctx);
        client->route_ctx = NULL;
    }

    /* Free the options */
    sstp_option_free(&client->option);

    /* Free the event base */
    event_base_free(client->ev_base);
}
Ejemplo n.º 19
0
/** \brief SCLogFileCloseRedis() Closes redis log more
 *  \param log_ctx Log file context allocated by caller
 */
void SCLogFileCloseRedis(LogFileCtx *log_ctx)
{
    SCLogRedisContext * ctx = log_ctx->redis;
    if (ctx == NULL) {
        return;
    }
    /* asynchronous */
    if (log_ctx->redis_setup.is_async) {
#if HAVE_LIBEVENT == 1
        if (ctx->async) {
            if (ctx->connected > 0) {
                SCLogAsyncRedisSendQuit(ctx);
            }
            if (ctx->ev_base != NULL) {
                event_base_free(ctx->ev_base);
                ctx->ev_base = NULL;
            }
        }
#endif
    }

    /* synchronous */
    if (!log_ctx->redis_setup.is_async) {
        if (ctx->sync) {
            redisReply *reply;
            int i;
            for (i = 0; i < ctx->batch_count; i++) {
                redisGetReply(ctx->sync, (void **)&reply);
                if (reply) {
                    freeReplyObject(reply);
                }
            }
            redisFree(ctx->sync);
            ctx->sync = NULL;
        }
        ctx->tried = 0;
        ctx->batch_count = 0;
    }

    if (ctx != NULL) {
        SCFree(ctx);
    }
}
Ejemplo n.º 20
0
void* TcpClient::ConnectThread(void *pParam)
{
    TcpClient *pClient = (TcpClient *)pParam;

    struct sockaddr_in sin;
    sin.sin_family = AF_INET;
    inet_pton(AF_INET, pClient->m_cIPAddr, (void*)&sin.sin_addr);
    sin.sin_port = htons(pClient->m_nPort);

    int nCycle = 15;
    while (pClient->m_bConnecting)
    {
        if (nCycle < 15)
        {
            nCycle++;
            Sleep(1000);
            continue;
        }
        Tprintf(L"Connecting\n");
        nCycle = 0;
        struct event_base *base = event_base_new();
        assert(base != NULL);
#if defined (WIN32)
        evthread_use_windows_threads();
#else
        evthread_use_pthreads();
#endif
        evthread_make_base_notifiable(base);
        struct bufferevent *bev = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE | BEV_OPT_THREADSAFE);
        bufferevent_setcb(bev, read_cb, NULL, event_cb, pClient);
        bufferevent_enable(bev, EV_READ | EV_WRITE | EV_PERSIST);
        //连接
        if (bufferevent_socket_connect(bev, (SOCKADDR*)&sin, sizeof(SOCKADDR)) < 0)
        {
            bufferevent_free(bev);
            return NULL;
        }
        event_base_dispatch(base);

        event_base_free(base);
    }
    return NULL;
}
Ejemplo n.º 21
0
//超时事件测试
void timer_test()
{
     // 初始化  
       base=event_init();  
       struct event evTime;  
      // 设置定时事件  
        evtimer_set(&evTime, onTime, &evTime);  
        struct timeval tv;  
        tv.tv_sec = 10;  
        tv.tv_usec = 0;  
      // 添加定时事件  
        event_add(&evTime, &tv); 
		//设置为base事件
		event_base_set(base, &evTime); 
        // 事件调度循环  
       event_dispatch(); 
	    
	    event_base_free(base);
}
Ejemplo n.º 22
0
int JtEventServer::EventLoop()
{
	//默认存在一个定时器
	//////JtEventTimer *Timer = new JtEventTimer();
	//////Timer->OnAddToServer(this);

	pEventPairPipe = new JtEventPairPipe();
	pEventPairPipe->AddToServer(this);
	
	//jtprintf("[%s]event_base_dispatch before\n", __FUNCTION__);

	Started();

	//int res = event_base_loop(base,EVLOOP_NO_EXIT_ON_EMPTY);
	int res = event_base_dispatch(base);
	if(res==0)
	{
		jtprintf("[%s]event_base_dispatch out res %d\n", __FUNCTION__, res);
	}
	else if(res==-1)
	{
		jtprintf("[%s]event_base_dispatch error res %d\n", __FUNCTION__, res);
	}
	else if(res==1)
	{
		jtprintf("[%s]event_base_dispatch no event res %d\n", __FUNCTION__, res);
	}
	else
	{
		jtprintf("[%s]event_base_dispatch res %d\n", __FUNCTION__, res);
	}
	
	/////delete Timer;
	delete pEventPairPipe;
	pEventPairPipe = NULL;
	//必须先移除所有的事件,然后再调用event_base_free
	event_base_free(base);

	base = NULL;
	//

	return 0;
}
Ejemplo n.º 23
0
void
server_free(server *s) {
	int i;

	/* shutdown worker threads */
	for(i=0; i<s->cfg->workers; i++) {
		worker_free(s->w[i]);
	}

	/* free */
	event_del(s->signal);
	event_free(s->signal);
	event_base_free(s->base);
	close(s->fd);
	free(s->w);
	conf_free(s->cfg);
	log_free(s->log);
	free(s);
}
Ejemplo n.º 24
0
int main ()
{

	SSL_library_init ();
	ERR_load_crypto_strings ();
	SSL_load_error_strings ();
	OpenSSL_add_all_algorithms();

    event_enable_debug_mode ();
    evbase = event_base_new ();
    dnsbase = evdns_base_new (evbase, 1);

    perform_ssl_connection ();

    event_base_dispatch (evbase);
    event_base_free (evbase);

    return 0;
}
Ejemplo n.º 25
0
GuNET_Server_Error_t GuNET_Server_Free(GuNET_Server_t * server) {
	GuNET_Server_Client_t * cur;
	check(!server, GuNET_SERVER_ERROR_INVALID_ARGS);

	cur = server->clients;
	while (cur != NULL ) {
		GuNET_Server_Client_free(cur);
		cur = cur->next;
	}

	evutil_closesocket(server->fd);
	event_free(server->signal);
	event_free(server->listen);
	event_base_free(server->base);

	free(server);

	return GuNET_SERVER_ERROR_NONE;
}
Ejemplo n.º 26
0
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
}
Ejemplo n.º 27
0
pmix_event_base_t* pmix_start_progress_thread()
{
    pmix_event_base_t *ev_base;
    /* Setup threading */
    evthread_use_pthreads();
    /* Create base for events */
    if (NULL == (ev_base = (pmix_event_base_t*)event_base_new())) {
        PMIX_ERROR_LOG(PMIX_ERR_OUT_OF_RESOURCE);
        return NULL;
    }

    /* add an event it can block on */
    if (0 > pipe(block_pipe)) {
        PMIX_ERROR_LOG(PMIX_ERR_IN_ERRNO);
        return NULL;
    }
    /* Make sure the pipe FDs are set to close-on-exec so that
       they don't leak into children */
    if (pmix_fd_set_cloexec(block_pipe[0]) != PMIX_SUCCESS ||
        pmix_fd_set_cloexec(block_pipe[1]) != PMIX_SUCCESS) {
        PMIX_ERROR_LOG(PMIX_ERR_IN_ERRNO);
        close(block_pipe[0]);
        close(block_pipe[1]);
        event_base_free(ev_base);
        return NULL;
    }
    event_assign(&block_ev, ev_base, block_pipe[0],
                 EV_READ, wakeup, NULL);
    event_add(&block_ev, 0);
    evlib_active = true;
    block_active = true;

    /* fork off a thread to progress it */
    if (0 > pthread_create(&engine, NULL, progress_engine, (void*)ev_base)) {
        PMIX_ERROR_LOG(PMIX_ERROR);
        return NULL;
    }
    if (!thread_initalized) {
        thread_initalized = true;
    }
    return ev_base;
}
Ejemplo n.º 28
0
void *httpserver_dispatch(void *arg) {
#ifndef MULTI_THREAD_SUPPORT
	struct event_base *base = (struct event_base *)arg;
	struct event *signal_event;
	signal_event = evsignal_new(base, SIGINT, signal_cb, (void *)base);

	if (!signal_event || event_add(signal_event, NULL)<0) {
		fprintf(stderr, "Could not create/add a signal event!\n");
		return NULL;
	}
#endif
	event_base_dispatch((struct event_base *) arg);

#ifndef MULTI_THREAD_SUPPORT
	//evconnlistener_free(lmg_listener);
	event_free(signal_event);
#endif
	event_base_free((struct event_base *) arg);
	return NULL;
}
Ejemplo n.º 29
0
	void TcpServer::Destroy()
	{
		if(_fd_listen != 0)
		{
			shutdown(_fd_listen, SD_BOTH);
			closesocket(_fd_listen);
			_fd_listen = 0;
		}
		if(_worker.get() != NULL)
		{
			event_base_loopbreak(_base);
			_worker->Wait();
			_worker.reset();
		}
		if(_base != NULL)
		{
			event_base_free(_base);
			_base = NULL;
		}
	}
Ejemplo n.º 30
0
void attach_namespace (int client, struct arguments arguments) {
	w(evutil_make_socket_closeonexec(client));
	w(evutil_make_socket_nonblocking(client));

	struct event_config *ev_config = p(event_config_new());
	w(event_config_require_features(ev_config, EV_FEATURE_FDS));
	struct event_base *ev_base = p(event_base_new_with_config(ev_config));
	event_config_free(ev_config);

	struct event *ev_client = p(event_new(ev_base, client, EV_READ|EV_PERSIST, client_func, NULL));

	struct arg arg = { .event = ev_client, .command = arguments.command };

	w(event_assign(ev_client, ev_base, client, EV_READ|EV_PERSIST, client_func, &arg));
	event_add(ev_client, NULL);

	w(event_base_dispatch(ev_base));

	event_base_free(ev_base);
}