Beispiel #1
0
int
main(int argc, char **argv)
{
	struct timeval one_second = { 1, 0 };
	struct event *timeout_event, *sigint_event;

	base = event_base_new();
	durations = histogram_new(100);
	delays = histogram_new(100);

	/* add prepare and check watchers; no need to hang on to their pointers,
	 * since they will be freed for us in event_base_free. */
	evwatch_prepare_new(base, &on_prepare, NULL);
	evwatch_check_new(base, &on_check, NULL);

	/* set a persistent one second timeout */
	timeout_event = event_new(base, -1, EV_PERSIST, &on_timeout, NULL);
	if (!timeout_event)
		return EXIT_FAILURE;
	event_add(timeout_event, &one_second);

	/* set a handler for interrupt, so we can quit cleanly */
	sigint_event = evsignal_new(base, SIGINT, &on_sigint, NULL);
	if (!sigint_event)
		return EXIT_FAILURE;
	event_add(sigint_event, NULL);

	/* run the event loop until interrupted */
	event_base_dispatch(base);

	/* clean up */
	event_free(timeout_event);
	event_free(sigint_event);
	event_base_free(base);
	histogram_free(durations);
	histogram_free(delays);

	return EXIT_SUCCESS;
}
Beispiel #2
0
void
multi_tcp_free(struct multi_tcp *mtcp)
{
    if (mtcp)
    {
        event_free(mtcp->es);
        if (mtcp->esr)
        {
            free(mtcp->esr);
        }
        free(mtcp);
    }
}
Beispiel #3
0
int main(void) {
	srand(time(NULL));
	cmockaTest();
	puts("\nPress ANY KEY to continue...");
	getch();
	system("cls");

	queue_t * myQueue = queue_new();
	user_t * me = user_new("Me");
	user_t * firstuser = user_new("First");
	user_t * seconduser = user_new("Second");
	user_t * users[] = { me, firstuser, seconduser };
	int usersSize = sizeof(users) / sizeof(users[0]);

	event_t * firstEvent = event_new("10 measurements \\ everything OK (1st event)");
	event_t * secondEvent = event_new("last 5 measurements \\ not everything OK (2d event)");
	event_t * thirdEvent = event_new("last 5 measurements \\ everything NOT OK (3d event)");

	event_addAlertSingle(me, firstEvent, alert_fantasy);
	event_addAlertSingle(me, secondEvent, alert_master);
	event_addAlertSeveral(users, usersSize, thirdEvent, alert_common);
	while (!kbhit()) {
		event_start(firstEvent, secondEvent, thirdEvent, myQueue);
	}

	event_free(firstEvent);
	event_free(secondEvent);
	event_free(thirdEvent);

	for (int i = 0; i < usersSize; i++) {
		user_free(users[i]);
	}
	queue_free(myQueue);

	getch();
	puts("Press ANY KEY to exit the program...");
	getch();
	return 0;
}
Beispiel #4
0
void Worker::finishWriting(int fd) {

    assert(clients.find(fd) != clients.end());
    event_del(clients[fd]->writeEvent);

    event_free(clients[fd]->writeEvent);
    clients[fd]->writeEvent = nullptr;

    if (!clients[fd]->readEvent) {
        /* Close client */
        closeClient(fd);
    }
}
Beispiel #5
0
void Timer::reset()
{
	if (NULL != _event)
	{
		event_free(_event);
		_event = NULL;
	}

//	_interval = 0;
//	_round = 0;
//	_curRound = 0;
//	_handler = NULL;
}
Beispiel #6
0
void socket_unit(void) {
	int i;
	for (i = 0; i < MAX_SOCKET; i++) {
		struct socket *sock = &S.slot[i];
		if (sock->type != SOCKET_TYPE_RESERVE) {
			struct socket_message ret;
			socket_force_close(sock, &ret);
		}
	}
	close(S.sendctl_fd);
	close(S.recvctl_fd);
	event_free(S.event_fd);
}
Beispiel #7
0
int
main(int argc, char **argv)
{
	struct event_base *base;
	struct evconnlistener *listener;
	struct event *signal_event;

	struct sockaddr_in sin;
#ifdef WIN32
	WSADATA wsa_data;
	WSAStartup(0x0201, &wsa_data);
#endif

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

    const char* method = event_base_get_method(base);
    printf("method:%s\n",method);
	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;
}
Beispiel #8
0
int
serv_loop ()
{
	int fd ;
	int i ;
	struct event_base *base ;
	struct event *event ;

	base = event_base_new () ;
	if (NULL == base) {
		fprintf (LOG_STREAM, "[ERROR] even_base_new in 'serv_loop' failed\n") ;
		return -1 ;
	}

	event = event_new (base, g_listen, EV_READ | EV_ET | EV_PERSIST,
					on_accept, event_self_cbag ()) ;
	if (NULL == event) {
		fprintf (LOG_STREAM, "[ERROR] event_new in 'serv_loop' failed\n") ;
		event_base_free (base) ;
		return -1 ;
	}

	if (-1 == event_add (event, NULL)) {
		fprintf (LOG_STREAM, "[ERROR] event_add in 'serv_loop' failed\n") ;
		event_base_free (base) ;
		event_free (event) ;
		return -1 ;
	}

	if (-1 == event_base_loop (base, EVLOOP_NO_EXIT_ON_EMPTY)) {
		fprintf (LOG_STREAM, "[ERROR] event_base_loop 'serv_loop' failed\n") ;
		event_base_free (base) ;
		event_free (event) ;
		return -1 ;
	}

	return 0 ;
}
Beispiel #9
0
static void nc_conn_free(struct nc_conn *conn)
{
	if (!conn)
		return;

	if (conn->write_q) {
		clist *tmp = conn->write_q;

		while (tmp) {
			struct buffer *buf;

			buf = tmp->data;
			tmp = tmp->next;

			free(buf->p);
			free(buf);
		}

		clist_free(conn->write_q);
	}

	if (conn->ev) {
		event_del(conn->ev);
		event_free(conn->ev);
	}
	if (conn->write_ev) {
		event_del(conn->write_ev);
		event_free(conn->write_ev);
	}

	if (conn->fd >= 0)
		close(conn->fd);

	free(conn->msg.data);

	memset(conn, 0, sizeof(*conn));
	free(conn);
}
static void
readFromPipe (evutil_socket_t   fd,
              short             eventType,
              void            * veh)
{
    char              ch;
    int               ret;
    tr_event_handle * eh = veh;

    dbgmsg ("readFromPipe: eventType is %hd", eventType);

    /* read the command type */
    ch = '\0';
    do
    {
        ret = piperead (fd, &ch, 1);
    }
    while (!eh->die && ret < 0 && errno == EAGAIN);

    dbgmsg ("command is [%c], ret is %d, errno is %d", ch, ret, (int)errno);

    switch (ch)
    {
        case 'r': /* run in libevent thread */
        {
            struct tr_run_data data;
            const size_t       nwant = sizeof (data);
            const ssize_t      ngot = piperead (fd, &data, nwant);
            if (!eh->die && (ngot == (ssize_t)nwant))
            {
                dbgmsg ("invoking function in libevent thread");
              (data.func)(data.user_data);
            }
            break;
        }

        case '\0': /* eof */
        {
            dbgmsg ("pipe eof reached... removing event listener");
            event_free (eh->pipeEvent);
            break;
        }

        default:
        {
            assert (0 && "unhandled command type!");
            break;
        }
    }
}
Beispiel #11
0
Datei: server.c Projekt: hyper/rq
// When the system is shutting down, it will close all listening servers.
void server_shutdown(server_t *server)
{
	assert(server);
	assert(server->sysdata);
	logger(server->sysdata->logging, 1, "Closing socket %d.", server->handle);

	assert(server->event);
	event_free(server->event);
	server->event = NULL;
	
	assert(server->handle != INVALID_HANDLE);
	close(server->handle);
	server->handle = INVALID_HANDLE;
}
/* Assign information to a SockInfo structure */
static void setsock(SockInfo*f, curl_socket_t s, CURL*e, int act, GlobalInfo*g)
{
  int kind =
     (act&CURL_POLL_IN?EV_READ:0)|(act&CURL_POLL_OUT?EV_WRITE:0)|EV_PERSIST;

  f->sockfd = s;
  f->action = act;
  f->easy = e;
  if (f->evset)
    event_free(f->ev);
  f->ev = event_new(g->evbase, f->sockfd, kind, event_cb, g);
  f->evset = 1;
  event_add(f->ev, NULL);
}
static
void
task_destroy(struct async_network_task_s *task)
{
    pthread_mutex_lock(&lock);
    g_hash_table_remove(tasks_ht, task);
    if (task->event) {
        event_free(task->event);
        task->event = NULL;
    }
    free(task->host);
    g_slice_free(struct async_network_task_s, task);
    pthread_mutex_unlock(&lock);
}
Beispiel #14
0
void 
gda_transaction_status_free_events (GdaTransactionStatus *tstatus, GdaTransactionStatusEvent *event,
				    gboolean free_after)
{
	GList *node;

	g_return_if_fail (GDA_IS_TRANSACTION_STATUS (tstatus));
	node = g_list_find (tstatus->events, event);
	g_return_if_fail (node);

	if (free_after) {
		GList *list = g_list_last (tstatus->events);
		GList *tmp;
		while (list != node) {
			event_free ((GdaTransactionStatusEvent *)(list->data));
			tmp = list->prev;
			tstatus->events = g_list_delete_link (tstatus->events, list);
			list = tmp;
		}
	}
	event_free (event);
	tstatus->events = g_list_delete_link (tstatus->events, node);
}
Beispiel #15
0
void
fs_node_close(struct fs_node* node){
    
    if(fs_node_is_closed(node))
        return;
    
    fs_node_set_closed(node);
    
    if(node->recv_buffer){
        fs_stream_free_output(node->recv_buffer);
        node->recv_buffer = NULL;
    }
    
    if(node->send_buffer){
        pthread_mutex_lock(&node->write_mutex);
        fs_stream_free_output(node->send_buffer);
        node->send_buffer = NULL;
        pthread_mutex_unlock(&node->write_mutex);
    }
    pthread_mutex_destroy(&node->write_mutex);
    pthread_mutex_destroy(&node->close_mutex);
    
    fs_node_close_socket(node);
    
    if(node->read_ev != NULL){
        event_free(node->read_ev);
        node->read_ev = NULL;
    }
    if(node->write_ev != NULL){
        event_free(node->write_ev);
        node->write_ev = NULL;
    }
    if(fs_node_is_from_listener(node)){
        fs_server_on_node_shudown(node->server, node->node_id);
    }

}
Beispiel #16
0
void _bosh_conn_destroy(_bosh_conn conn)
{
    if (_test_fns)
    {
        _test_fns->conn_destroy(conn);
        return;
    }

    assert(conn);
    _bosh_conn_ctx conn_ctx = conn->ctx;

    PUSH_CONN_NDC;
    JW_LOG_TRACE_FUNCTION_NO_ARGS;

    assert(conn_ctx);
    if (conn->easy)
    {
        CURL *easy = conn->easy;
        conn->easy = NULL;
        if (conn->active)
        {
            curl_multi_remove_handle(conn_ctx->multi, easy);
        }
        curl_easy_cleanup(easy);
    }
    conn->active = false;

    if (conn->sock_ev)
    {
        event_free(conn->sock_ev);
        conn->sock_ev = NULL;
    }

    if (conn->req_buf)
    {
        evbuffer_free(conn->req_buf);
        conn->req_buf = NULL;
    }

    if (conn->resp_buf)
    {
        evbuffer_free(conn->resp_buf);
        conn->resp_buf = NULL;
    }

    jw_data_free(conn);

    POP_CONN_NDC;
}
Beispiel #17
0
int main()
{
    struct event_base *eb;
    struct event *ev1, *ev2;

    pthread_t pid;

    /*init event_base*/
    eb = event_base_new();
    assert(eb);

    ev1 = evsignal_new(eb, SIGUSR1, signal_handler, (void*)0x1);
    assert(ev1);
    assert(evsignal_add(ev1, NULL) == 0);

    ev2 = evsignal_new(eb, SIGUSR2, signal_handler, (void*)0x2);
    assert(ev2);
    assert(evsignal_add(ev2, NULL) == 0);

    assert(pthread_create(&pid, NULL, emit_signal, NULL) == 0);

    /*start loop*/
    assert(event_base_loop(eb, EVLOOP_ONCE) == 0);

    assert(pthread_join(pid, NULL) == 0);

    assert(evsignal_del(ev1) == 0);
    assert(evsignal_del(ev2) == 0);
    event_free(ev1);
    event_free(ev2);

    /*destroy event_base*/
    event_base_free(eb);

    return 0;
}
Beispiel #18
0
static void
olibc_msg_q_destroy_internal (olibc_msg_q_hdl msg_q_hdl)
{
    if (!msg_q_hdl) {
        return;
    }

    printf("\n In internal q destroy");
    if (msg_q_hdl->timer_event_handle) {
        evtimer_del(msg_q_hdl->timer_event_handle);
        event_free(msg_q_hdl->timer_event_handle);
        msg_q_hdl->timer_event_handle = NULL;
    }

    if (msg_q_hdl->event_handle) {
        event_del(msg_q_hdl->event_handle);
        event_free(msg_q_hdl->event_handle);
        msg_q_hdl->event_handle = NULL;
    }

    olibc_free((void **)&msg_q_hdl->msg_q_nodes);

    olibc_free((void **)&msg_q_hdl);
}
Beispiel #19
0
// MUST be idempotent and MUST work with half-initialized objects
void
NeubotPollable::detach(void)
{
	neubot_info("pollable: detach()");

	// poller: continue to point to the poller

	this->timeout = -1.0;

	if (this->evread != NULL) {
		event_free(this->evread);
		this->evread = NULL;
	}
	if (this->evwrite != NULL) {
		event_free(this->evwrite);
		this->evwrite = NULL;
	}

	//
	// We don't close the file descriptor because the Neubot pollable
	// class does not close the file description as well.
	//
	this->fileno = NEUBOT_SOCKET_INVALID;
}
Beispiel #20
0
static getdns_return_t
getdns_libevent_clear(getdns_eventloop *loop, getdns_eventloop_event *el_ev)
{
	struct event *my_ev = (struct event *)el_ev->ev;
	(void)loop;

	assert(my_ev);

	if (event_del(my_ev) != 0)
		return GETDNS_RETURN_GENERIC_ERROR;

	event_free(my_ev);
	el_ev->ev = NULL;
	return GETDNS_RETURN_GOOD;
}
Beispiel #21
0
void loose_cb(evutil_socket_t sock, short ev, void *arg) {
    UNUSED(sock);
    UNUSED(ev);
    UNUSED(arg);

    int seqno, times;

    fscanf(stdin, "%d %d", &seqno, &times);
    getchar();
    if (feof(stdin)) {
        event_free(loose_evt);
    } else {
        loose_add(seqno, times);
    }
}
Beispiel #22
0
void btc_node_release_events(btc_node *node)
{
    if (node->event_bev)
    {
        bufferevent_free(node->event_bev);
        node->event_bev = NULL;
    }

    if (node->timer_event)
    {
        event_del(node->timer_event);
        event_free(node->timer_event);
        node->timer_event = NULL;
    }
}
Beispiel #23
0
void clean_up( void ) {
	sound_free();
	game_list_free();
	submenu_free();
	platform_free();
	menu_free();
	hint_free();
	font_free();
	bg_free();
	location_free();
	event_free();
	snap_free();
	video_free();
	sdl_free();
}
/**
 * Call the GSource callback.
 *
 * @param source
 * @param callback callback function, which may be NULL
 * @param user_data ignored
 * @return result TRUE or FALSE
 */
static gboolean result_queue_source_dispatch(GSource *source, GSourceFunc callback, gpointer user_data)
{
        struct result_queue *queue;
        struct event *ev;

        g_return_val_if_fail(source, FALSE);
        g_return_val_if_fail(callback==source_callback, FALSE);

        queue = RESULT_QUEUE(source);
        while( (ev=(struct event *)g_async_queue_try_pop(queue->async_queue)) != NULL) {
                callback(ev);
                event_free(ev);
        }
        return TRUE;
}
NetworkWrapper::~NetworkWrapper()
{
	if (m_stEvtlistener)
	{
		evconnlistener_free(m_stEvtlistener);
	}
	if (gstEvtBase)
	{
		event_base_free(gstEvtBase);
	}
	if (m_stSigEvt)
	{
		event_free(m_stSigEvt);
	}
}
Beispiel #26
0
static void redisLibeventCleanup(void *privdata)
{

	if (privdata) {

		struct redisLibeventEvents *e = (struct redisLibeventEvents *) privdata;
		if (e->allocated) {
			e->allocated = 0;
			if (e->rev) {
				if(e->rev_set)
					event_del(e->rev);
				event_free(e->rev);
				e->rev = NULL;
			}
			if (e->wev) {
				if(e->wev_set)
					event_del(e->wev);
				event_free(e->wev);
				e->wev = NULL;
			}
			turn_free(privdata, sizeof(struct redisLibeventEvents));
		}
	}
}
Beispiel #27
0
void event_cb(struct bufferevent *bev, short event, void *arg)
{

    if (event & BEV_EVENT_EOF)
        printf("connection closed\n");
    else if (event & BEV_EVENT_ERROR)
        printf("some other error\n");

    //这将自动close套接字和free读写缓冲区
    bufferevent_free(bev);

    struct event *ev = (struct event*)arg;
    //因为socket已经没有,所以这个event也没有存在的必要了
    event_free(ev);
}
static void
send_resp(evutil_socket_t fd, short what
          __attribute__ ((__unused__)), void *arg)
{
  struct is_data *data = arg;
  ssize_t len;

  len = send(fd, &data->resp, sizeof data->resp, 0);
  if (len != (int) sizeof data->resp) {
    penn_perror("error writing packet");
    exit(EXIT_FAILURE);
  }
  event_free(data->ev);
  free(data);
}
Beispiel #29
0
static void
pxy_conn_ctx_free(pxy_conn_ctx_t *ctx)
{
#ifdef DEBUG_PROXY
	if (OPTS_DEBUG(ctx->opts)) {
		log_dbg_printf("%p             pxy_conn_ctx_free\n",
		                (void*)ctx);
	}
#endif /* DEBUG_PROXY */
	pxy_thrmgr_detach(ctx->thrmgr, ctx->thridx);
	if (ctx->src_str) {
		free(ctx->src_str);
	}
	if (ctx->dst_str) {
		free(ctx->dst_str);
	}
	if (ctx->http_method) {
		free(ctx->http_method);
	}
	if (ctx->http_uri) {
		free(ctx->http_uri);
	}
	if (ctx->http_host) {
		free(ctx->http_host);
	}
	if (ctx->http_content_type) {
		free(ctx->http_content_type);
	}
	if (ctx->ssl_names) {
		free(ctx->ssl_names);
	}
	if (ctx->ssl_orignames) {
		free(ctx->ssl_orignames);
	}
	if (ctx->origcrt) {
		X509_free(ctx->origcrt);
	}
	if (ctx->ev) {
		event_free(ctx->ev);
	}
	if (ctx->sni) {
		free(ctx->sni);
	}
	if (WANT_CONTENT_LOG(ctx)) {
		log_content_close(&ctx->logctx);
	}
	free(ctx);
}
Beispiel #30
0
/*
 * sntp_addremove_fd() is invoked by the intres blocking worker code
 * to read from a pipe, or to stop same.
 */
void sntp_addremove_fd(
	int	fd,
	int	is_pipe,
	int	remove_it
	)
{
	u_int		idx;
	blocking_child *c;
	struct event *	ev;

#ifdef HAVE_SOCKETPAIR
	if (is_pipe) {
		/* sntp only asks for EV_FEATURE_FDS without HAVE_SOCKETPAIR */
		msyslog(LOG_ERR, "fatal: pipes not supported on systems with socketpair()");
		exit(1);
	}
#endif

	c = NULL;
	for (idx = 0; idx < blocking_children_alloc; idx++) {
		c = blocking_children[idx];
		if (NULL == c)
			continue;
		if (fd == c->resp_read_pipe)
			break;
	}
	if (idx == blocking_children_alloc)
		return;

	if (remove_it) {
		ev = c->resp_read_ctx;
		c->resp_read_ctx = NULL;
		event_del(ev);
		event_free(ev);

		return;
	}

	ev = event_new(base, fd, EV_READ | EV_PERSIST,
		       &worker_resp_cb, c);
	if (NULL == ev) {
		msyslog(LOG_ERR,
			"sntp_addremove_fd: event_new(base, fd) failed!");
		return;
	}
	c->resp_read_ctx = ev;
	event_add(ev, NULL);
}