コード例 #1
0
ファイル: bufferevent_sock.c プロジェクト: NeilHappy/libevent
struct bufferevent *
bufferevent_socket_new(struct event_base *base, evutil_socket_t fd,
    int options)
{
	struct bufferevent_private *bufev_p;
	struct bufferevent *bufev;

#ifdef _WIN32
	if (base && event_base_get_iocp_(base))
		return bufferevent_async_new_(base, fd, options);
#endif

	if ((bufev_p = mm_calloc(1, sizeof(struct bufferevent_private)))== NULL)
		return NULL;

	if (bufferevent_init_common_(bufev_p, base, &bufferevent_ops_socket,
				    options) < 0) {
		mm_free(bufev_p);
		return NULL;
	}
	bufev = &bufev_p->bev;
	evbuffer_set_flags(bufev->output, EVBUFFER_FLAG_DRAINS_TO_FD);

	event_assign(&bufev->ev_read, bufev->ev_base, fd,
	    EV_READ|EV_PERSIST, bufferevent_readcb, bufev);
	event_assign(&bufev->ev_write, bufev->ev_base, fd,
	    EV_WRITE|EV_PERSIST, bufferevent_writecb, bufev);

	evbuffer_add_cb(bufev->output, bufferevent_socket_outbuf_cb, bufev);

	evbuffer_freeze(bufev->input, 0);
	evbuffer_freeze(bufev->output, 1);

	return bufev;
}
コード例 #2
0
ファイル: httplib.c プロジェクト: jzyuchen/Study
static int http_dispatch_uri_handler_cb(struct http_connection *hc)
{
	if (!hc || !hc->hs || !hc->uri)
		return -1;

	struct http_uri *hu = hc->hs->uris;

	while(hu != NULL) {
		if (strcmp(hu->uri, hc->uri) == 0) {
			break;
		} else {
			hu = hu->next;
		}
	}

	if (hu && hu->handler_cb) {
		event_assign(hc->ev_write, hc->hs->base, hc->fd, EV_WRITE, hu->handler_cb, hc);
	} else {
		event_assign(hc->ev_write, hc->hs->base, hc->fd, EV_WRITE, http_404_cb, hc);
	}

	event_add(hc->ev_write, NULL);

	return 0;
}
コード例 #3
0
void
bufferevent_init_generic_timeout_cbs_(struct bufferevent *bev)
{
	event_assign(&bev->ev_read, bev->ev_base, -1, EV_FINALIZE,
	    bufferevent_generic_read_timeout_cb, bev);
	event_assign(&bev->ev_write, bev->ev_base, -1, EV_FINALIZE,
	    bufferevent_generic_write_timeout_cb, bev);
}
コード例 #4
0
ファイル: fs_node.c プロジェクト: frodosens/fsnet
fs_bool
fs_node_bind_event(struct fs_node* node,
                   fs_id node_id,
                   int socket,
                   struct sockaddr* sa,
                   socklen_t socklen,
                   struct fs_server* server,
                   struct event_base* event_base ){
    
    int ret = 0;
    if(node->read_ev){
        event_free(node->read_ev);
    }
    if(node->write_ev){
        event_free(node->write_ev);
    }
    node->node_id = node_id;
    node->socket = socket;
    node->server = server;
    node->read_ev = (struct event*)fs_malloc(sizeof(struct event));
    node->write_ev = (struct event*)fs_malloc(sizeof(struct event));
    
    const char bOper = 1;
    evutil_make_socket_nonblocking(node->socket);
    setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, (const char*)&bOper, sizeof(const char));
    
    ret = event_assign(node->read_ev, event_base,
                       node->socket, EV_READ | EV_PERSIST,
                       libevent_cb_node_onrecv_data, node);
    
    ret |= event_assign(node->write_ev, event_base,
                       node->socket, EV_WRITE | EV_PERSIST,
                       libevent_cb_node_onsend_data, node);
    
    
    
    if(ret != 0){
        goto fail;
    }
    
    node->recv_buffer = fs_create_output_stream(1024);
    node->send_buffer = fs_create_output_stream(1024);
    
    pthread_mutex_init(&node->write_mutex, NULL);
    pthread_mutex_init(&node->close_mutex, NULL);
    event_add(node->read_ev, NULL);
    event_add(node->write_ev, NULL);
    
    goto success;
    
success:
    return fs_true;
fail:
    if(node->read_ev) event_free(node->read_ev);
    if(node->write_ev) event_free(node->write_ev);
    return fs_false;
}
コード例 #5
0
ファイル: bufferevent_sock.c プロジェクト: whm2300/libevent
struct bufferevent *
bufferevent_socket_new(struct event_base *base, evutil_socket_t fd,
    int options)
{
	struct bufferevent_private *bufev_p;
	struct bufferevent *bufev;

#ifdef WIN32
	if (base && event_base_get_iocp(base))
		return bufferevent_async_new(base, fd, options);
#endif

	if ((bufev_p = mm_calloc(1, sizeof(struct bufferevent_private)))== NULL)
		return NULL;

	if (bufferevent_init_common(bufev_p, base, &bufferevent_ops_socket,
				    options) < 0) {
		mm_free(bufev_p);
		return NULL;
	}
	bufev = &bufev_p->bev;
	//设置将evbuffer的数据向fd传 
	evbuffer_set_flags(bufev->output, EVBUFFER_FLAG_DRAINS_TO_FD);

    //设置读写回调
	event_assign(&bufev->ev_read, bufev->ev_base, fd,
	    EV_READ|EV_PERSIST, bufferevent_readcb, bufev);
	event_assign(&bufev->ev_write, bufev->ev_base, fd,
	    EV_WRITE|EV_PERSIST, bufferevent_writecb, bufev);

    //设置evbuffer的回调函数,使得外界给写缓冲区添加数据时,能触发  
    //写操作,这个回调对于写事件的监听是很重要的  
	evbuffer_add_cb(bufev->output, bufferevent_socket_outbuf_cb, bufev);

	/* 虽然这里冻结了,但实际上Libevent在读数据或者写数据之前会解冻的读完或者写完数据后,又会马上冻结。
	 * 这主要防止数据被意外修改。用户一般不会直接调用evbuffer_freeze或者evbuffer_unfreeze函数。
	 * 一切的冻结和解冻操作都由Libevent内部完成。还有一点要注意,因为这里只是把写缓冲区的头部冻结了。
	 * 所以还是可以往写缓冲区的尾部追加数据。同样,此时也是可以从读缓冲区读取数据。这个是必须的。
	 * 因为在Libevent内部不解冻的时候,用户需要从读缓冲区中获取数据(这相当于从socket fd中读取数据),
	 * 用户也需要把数据写到写缓冲区中(这相当于把数据写入到socket fd中)。*/

    //冻结读缓冲区的尾部,未解冻之前不能往读缓冲区追加数据  
    //也就是说不能从socket fd中读取数据  
	evbuffer_freeze(bufev->input, 0);

	//冻结写缓冲区的头部,未解冻之前不能把写缓冲区的头部数据删除  
    //也就是说不能把数据写到socket fd  
	evbuffer_freeze(bufev->output, 1);

	return bufev;
}
コード例 #6
0
ファイル: redsocks.c プロジェクト: Emong/redsocks
/* There is no way to get `EVLIST_INSERTED` event flag outside of libevent, so
 * here are tracking functions. */
static void tracked_event_set(
        struct tracked_event *tev, evutil_socket_t fd, short events,
        void (*callback)(evutil_socket_t, short, void *), void *arg)
{
    event_assign(&tev->ev, get_event_base(), fd, events, callback, arg);
    timerclear(&tev->inserted);
}
コード例 #7
0
ファイル: signal.c プロジェクト: Breakster/iSoul
int
evsig_init_(struct event_base *base)
{
	/*
	 * Our signal handler is going to write to one end of the socket
	 * pair to wake up our event loop.  The event loop then scans for
	 * signals that got delivered.
	 */
	if (evutil_make_internal_pipe_(base->sig.ev_signal_pair) == -1) {
#ifdef _WIN32
		/* Make this nonfatal on win32, where sometimes people
		   have localhost firewalled. */
		event_sock_warn(-1, "%s: socketpair", __func__);
#else
		event_sock_err(1, -1, "%s: socketpair", __func__);
#endif
		return -1;
	}

	if (base->sig.sh_old) {
		mm_free(base->sig.sh_old);
	}
	base->sig.sh_old = NULL;
	base->sig.sh_old_max = 0;

	event_assign(&base->sig.ev_signal, base, base->sig.ev_signal_pair[0],
		EV_READ | EV_PERSIST, evsig_cb, base);

	base->sig.ev_signal.ev_flags |= EVLIST_INTERNAL;
	event_priority_set(&base->sig.ev_signal, 0);

	base->evsigsel = &evsigops;

	return 0;
}
コード例 #8
0
ファイル: game_event.c プロジェクト: a1406/txgg
int game_add_connect_event(struct sockaddr *sa, int socklen, CLIENT_MAP *client_map)
{
	int ret;
	struct event *event_conn = &client_map->event_recv;
	int fd = 0;
	
	fd = create_new_socket(0);
	if (0 != event_assign(event_conn, base, fd, EV_READ|EV_PERSIST, cb_recv, client_map)) {
		log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "%s %d: event_new failed[%d]", __FUNCTION__, __LINE__, errno);				
		goto fail;
	}
	event_add(event_conn, NULL);
	
	ret = evutil_socket_connect(&fd, sa, socklen);
	if (ret < 0) {
		log4c_category_log(mycat, LOG4C_PRIORITY_ERROR, "%s %d: evutil_socket_connect failed[%d]", __FUNCTION__, __LINE__, errno);		
		goto fail;
	}

	game_set_socket_opt(fd);
	
	return (fd);
fail:
	if (fd > 0) {
		evutil_closesocket(fd);		
	}
	if (event_conn) {
		event_del(event_conn);		
	}
	return (-1);	
}
コード例 #9
0
ファイル: timer2_ev.c プロジェクト: Baoxiyi-Github/Libevent
int main(int argc, char **argv)
{
        struct event timeout[N];
        struct ST_EventWithDescription stEvent[N];
        int time_interval[N];
        int i = 0;

        struct timeval tv;
        struct event_base *base;
        int flag = 0;

        setTimeIntervalArr(time_interval, N);

        if(argc == 2 && !strcmp(argv[1], "-p"))
            flag = EV_PERSIST;
        else
            flag = 0;
        base = event_base_new();
        evutil_timerclear(&tv);

        for(i = 0; i < N; ++i)
        {
            char buf[BUFFER] = {0};
            sprintf(buf, "task_%d", i+1);
            setParam(stEvent+i, timeout+i, time_interval[i], buf);
            event_assign(timeout+i, base, -1, flag, timeout_cb,(void *)(stEvent+i));
            event_add(timeout+i, &tv);
        }

        evutil_gettimeofday(&lasttime, NULL);
        event_base_dispatch(base);
    return 0;
}
コード例 #10
0
ファイル: evpri-test.c プロジェクト: 00datman/ompi
static void
t1func(evutil_socket_t fd, short what, void *arg)
{
    struct event *t1 = (struct event*)arg;
    struct event *t2;

    fprintf(stderr, "CAUGHT EVENT\n");
    fflush(stderr);
    event_del(t1);
    free(t1);
    loops++;
    if (loops < 10) {
        t2 = (struct event*)malloc(sizeof(struct event));
        if (event_assign(t2, base, -1, EV_WRITE, t1func, t2) < 0) {
            die("event_assign_term");
        }
        if (event_priority_set(t2, TERMPRI) < 0) {
            die("event_priority_set_term");
        }
        fprintf(stderr, "EVENT %d DEFINED\n", loops);
        fflush(stderr);
        event_active(t2, EV_WRITE, 1);
        fprintf(stderr, "EVENT %d ACTIVATED\n", loops);
        fflush(stderr);
    }
}
コード例 #11
0
ファイル: test_lookup.c プロジェクト: kalloc/tester
void makeDNSTask(struct DNSTask * dnstask) {
    int type;
    struct ares_options options;
    int optmask;


    switch (dnstask->role) {
        case DNS_TASK:
            gettimeofday(&dnstask->CheckDt, NULL);
            optmask = ARES_OPT_FLAGS;
            options.servers = getNulledMemory(sizeof (struct in_addr));
            options.nservers = 1;
            options.flags = ARES_FLAG_NOCHECKRESP;
            optmask |= ARES_OPT_SERVERS;
            memcpy(options.servers, &dnstask->task->resolv->NSIP, sizeof (struct in_addr));
            ares_init_options(&dnstask->channel, &options, optmask);
            MSToTimeval(dnstask->task->Record.TimeOut, tv);
            type = dnstask->taskType;
            break;
        default:
            return;
            break;
    }


    ares_query(dnstask->channel, getPTR(dnstask->task->Record.HostName), C_IN, type, DNSTaskResolvCallback, dnstask);
    ares_getsock(dnstask->channel, &dnstask->fd, 1);
    event_assign(&dnstask->ev, base, dnstask->fd, EV_READ | EV_TIMEOUT, OnEventDNSTask, dnstask);
    event_add(&dnstask->ev, &tv);
}
コード例 #12
0
ファイル: EventWatcher.cpp プロジェクト: chenbaihu/cpp_coding
bool PipedEventWatcher::DoInit() 
{
    assert(pipe_[0] == 0);
    if (evutil_socketpair(AF_LOCAL, SOCK_STREAM, 0, pipe_) < 0) {
        log_error("evutil_socketpair failed");
        goto failed;
    }

    if (evutil_make_socket_nonblocking(pipe_[0]) < 0
        || evutil_make_socket_nonblocking(pipe_[1]) < 0) {
        log_error("evutil_make_socket_nonblockingfailed");
        goto failed;
    }

    event_assign(&event_, 
                 event_base_, 
                 pipe_[1],
                 EV_READ | EV_PERSIST,
                 PipedEventWatcher::HandlerFn,
                 this);
    return true;
failed:
    Close();
    return false;
}
コード例 #13
0
static void php_http_client_curl_event_timer(CURLM *multi, long timeout_ms, void *timer_data)
{
	php_http_client_curl_event_context_t *context = timer_data;
	struct timeval timeout;

#if DBG_EVENTS
	fprintf(stderr, "(%ld)", timeout_ms);
#endif

	switch (timeout_ms) {
	case -1:
		if (event_initialized(context->timeout) && event_pending(context->timeout, EV_TIMEOUT, NULL)) {
			event_del(context->timeout);
		}
		break;
	case 0:
		php_http_client_curl_event_handler(context, CURL_SOCKET_TIMEOUT, 0);
		break;
	default:
		if (!event_initialized(context->timeout)) {
			event_assign(context->timeout, context->evbase, CURL_SOCKET_TIMEOUT, 0, php_http_client_curl_event_timeout_callback, context);
		}

		timeout.tv_sec = timeout_ms / 1000;
		timeout.tv_usec = (timeout_ms % 1000) * 1000;

		if (!event_pending(context->timeout, EV_TIMEOUT, &timeout)) {
			event_add(context->timeout, &timeout);
		}
		break;
	}
}
コード例 #14
0
static ZEND_RESULT_CODE php_http_client_curl_event_wait(void *context, struct timeval *custom_timeout)
{
	php_http_client_curl_event_context_t *ctx = context;
	struct timeval timeout;

#if DBG_EVENTS
	fprintf(stderr, "W");
#endif

	if (!event_initialized(ctx->timeout)) {
		if (0 > event_assign(ctx->timeout, ctx->evbase, CURL_SOCKET_TIMEOUT, 0, php_http_client_curl_event_timeout_callback, ctx)) {
			return FAILURE;
		}
	} else if (custom_timeout && timerisset(custom_timeout)) {
		if (0 > event_add(ctx->timeout, custom_timeout)) {
			return FAILURE;
		}
	} else if (!event_pending(ctx->timeout, EV_TIMEOUT, NULL)) {
		php_http_client_curl_get_timeout(ctx->client->ctx, 1000, &timeout);
		if (0 > event_add(ctx->timeout, &timeout)) {
			return FAILURE;
		}
	}

	if (0 > event_base_loop(ctx->evbase, EVLOOP_ONCE)) {
		return FAILURE;
	}

	return SUCCESS;
}
コード例 #15
0
ファイル: signal-test.c プロジェクト: enlight/Libevent
int
main(int argc, char **argv)
{
	struct event signal_int;
	struct event_base* base;
#ifdef WIN32
	WORD wVersionRequested;
	WSADATA wsaData;
	int	err;

	wVersionRequested = MAKEWORD(2, 2);

	err = WSAStartup(wVersionRequested, &wsaData);
#endif

	/* Initalize the event library */
	base = event_base_new();

	/* Initalize one event */
	event_assign(&signal_int, base, SIGINT, EV_SIGNAL|EV_PERSIST, signal_cb,
	    &signal_int);

	event_add(&signal_int, NULL);

	event_base_dispatch(base);
	event_base_free(base);

	return (0);
}
コード例 #16
0
ファイル: TcpServer.cpp プロジェクト: BalLooN1874/Libevent
void EventLoopThread::threadFunc()
{
	struct event_base* base = event_base_new();
	int iret = evutil_socketpair(AF_INET, SOCK_STREAM, 0, wakeFd_);
	std::cout << "socket pair ret:" << iret << std::endl;
	std::cout << "thread id:" << std::this_thread::get_id() << std::endl;
	iret = event_assign(&ev_, base, wakeFd_[1], EV_READ | EV_PERSIST, WakeupCallback, this);
	if (0 != iret)
	{
		std::cout << "event assign error" << iret << std::endl;
	}

	iret = event_add(&ev_, nullptr);
	if (0 != iret)
	{
		std::cout << "event add error:" << iret << std::endl;
	}
	{
		std::unique_lock<std::mutex> ul(mutex_);
		base_ = base;
		cond_.notify_one();
	}
	event_base_dispatch(base);
	std::cout << "event loop exiting...\n";
}
コード例 #17
0
ファイル: client.cpp プロジェクト: AlanXie1991/Server
void Client::UnsetWriteEvent() 
{
    short event = event_get_events(m_event);
    event_del(m_event);
    event_assign(m_event, m_server->m_server_base, m_sockfd, event & (~EV_WRITE), Client::ClientEventCallback, this);
    event_add(m_event, NULL);
}
コード例 #18
0
ファイル: time-test1.c プロジェクト: hzsunzixiang/programming
int
main(int argc, char **argv)
{
	struct event timeout;
	struct timeval tv;
	struct event_base *base;
	int flags;


	if (argc == 2 && !strcmp(argv[1], "-p")) {
		event_is_persistent = 1;
		flags = EV_PERSIST;
	} else {
		event_is_persistent = 0;
		flags = 0;
	}

	/* Initalize the event library */
	base = event_base_new();

	/* Initalize one event */
	event_assign(&timeout, base, -1, flags, timeout_cb, (void*) &timeout);

	evutil_timerclear(&tv);
	tv.tv_sec = 2;
	event_add(&timeout, &tv);

	evutil_gettimeofday(&lasttime, NULL);

	event_base_dispatch(base);
	return 0;

	return (0);
}
コード例 #19
0
static int lcb_io_update_timer(struct lcb_io_opt_st *iops,
                               void *timer,
                               lcb_uint32_t usec,
                               void *cb_data,
                               void (*handler)(lcb_socket_t sock,
                                               short which,
                                               void *cb_data))
{
    short flags = EV_TIMEOUT | EV_PERSIST;
    struct timeval tmo;
    if (flags == event_get_events(timer) &&
            handler == event_get_callback(timer)) {
        /* no change! */
        return 0;
    }

    if (event_pending(timer, EV_TIMEOUT, 0)) {
        event_del(timer);
    }

    event_assign(timer, ((struct libevent_cookie *)iops->v.v2.cookie)->base, -1, flags, handler, cb_data);
    tmo.tv_sec = usec / 1000000;
    tmo.tv_usec = usec % 1000000;
    return event_add(timer, &tmo);
}
コード例 #20
0
ファイル: task_thread.c プロジェクト: myoldman/nginx-1.2.0
/**
 * setup task thread
 * @param   me   
 *
 ************************************************************/
static void setup_task_thread(task_thread_t *me) {

	if( me == NULL ){
		LM_ERR( " in setup_task_thread task_thread me is null \n");
		return;
	}
    me->base = event_base_new();
    if (! me->base) {
        fprintf(stderr, "Can't allocate event base\n");
        exit(1);
    }

    /* Listen for notifications from other threads */
    event_assign(&me->notify_event, me->base, me->notify_receive_fd,
              EV_READ | EV_PERSIST, me->ttm->thread_libevent_process, me);
    
    if (event_add(&me->notify_event, 0) == -1) {
        fprintf(stderr, "Can't monitor libevent notify pipe\n");
        exit(1);
    }
    
    me->new_task_queue = (task_queue_t*)malloc(sizeof(task_queue_t));
    if (me->new_task_queue == NULL) {
        LM_ERR("Failed to allocate memory for connection queue");
        exit(EXIT_FAILURE);
    }
    task_queue_init(me->new_task_queue);
	/*
    if (pthread_mutex_init(&me->stats.mutex, NULL) != 0) {
        perror("Failed to initialize mutex");
        exit(EXIT_FAILURE);
    }
    */
}
コード例 #21
0
ファイル: regress_thread.c プロジェクト: jimmy-kuo/websearch
static void
thread_basic(void *arg)
{
	THREAD_T threads[NUM_THREADS];
	struct event ev;
	struct timeval tv;
	int i;
	struct basic_test_data *data = arg;
	struct event_base *base = data->base;

	struct event *notification_event = NULL;
	struct event *sigchld_event = NULL;

	EVTHREAD_ALLOC_LOCK(count_lock, 0);
	tt_assert(count_lock);

	tt_assert(base);
	if (evthread_make_base_notifiable(base)<0) {
		tt_abort_msg("Couldn't make base notifiable!");
	}

#ifndef WIN32
	if (data->setup_data && !strcmp(data->setup_data, "forking")) {
		pid_t pid;
		int status;
		sigchld_event = evsignal_new(base, SIGCHLD, sigchld_cb, base);
		/* This piggybacks on the th_notify_fd weirdly, and looks
		 * inside libevent internals.  Not a good idea in non-testing
		 * code! */
		notification_event = event_new(base,
		    base->th_notify_fd[0], EV_READ|EV_PERSIST, notify_fd_cb,
		    NULL);
		event_add(sigchld_event, NULL);
		event_add(notification_event, NULL);

		if ((pid = fork()) == 0) {
			event_del(notification_event);
			if (event_reinit(base) < 0) {
				TT_FAIL(("reinit"));
				exit(1);
			}
			event_assign(notification_event, base,
			    base->th_notify_fd[0], EV_READ|EV_PERSIST,
			    notify_fd_cb, NULL);
			event_add(notification_event, NULL);
	 		goto child;
		}

		event_base_dispatch(base);

		if (waitpid(pid, &status, 0) == -1)
			tt_abort_perror("waitpid");
		TT_BLATHER(("Waitpid okay\n"));

		tt_assert(got_sigchld);
		tt_int_op(notification_fd_used, ==, 0);

		goto end;
	}
コード例 #22
0
ファイル: emp_server.c プロジェクト: myoldman/nginx-1.2.0
/** 
* connect to as server 
* @param   s: the the connection 
************************************************************/
int emp_server_connect(connection_t *connection) {
	int r = 0, res = 0;
	char iabuf[INET_ADDRSTRLEN];
  	const char *ipaddr = (const char*)ast_inet_ntoa(iabuf, sizeof(iabuf), connection->sin.sin_addr);
  	if (ipaddr == NULL) 
   		 ipaddr = "n/a";
	
	for (;;) {
		if (connect(connection->sfd, (struct sockaddr *) &connection->sin, sizeof(connection->sin)) < 0) {
			++r;
			if (errno == EISCONN) {
				pthread_mutex_lock(&connection->lock);
				connection->sfd = socket(AF_INET, SOCK_STREAM, 0);

				// set socket to nonblock
			/*	
				int flags = 1;
				if ((flags = fcntl(s->sfd, F_GETFL, 0)) < 0 || fcntl(s->sfd, F_SETFL, flags | O_NONBLOCK) < 0) {
				                LM_ERR("setting O_NONBLOCK fail \n");
				                close(s->sfd);
				                continue;
				   }
			*/
				struct event_base *base = connection->event.ev_base;
				if (event_del(&connection->event) == -1) {
					pthread_mutex_unlock(&connection->lock);
					LM_ERR("event_del failed \n");
					continue;
				}
				
				event_assign(&connection->event, base, connection->sfd, EV_READ | EV_PERSIST, server_message_got, (void *)connection);
				
				if (event_add(&connection->event, 0) == -1) {
					pthread_mutex_unlock(&connection->lock);
					LM_ERR("event_del failed \n");
					continue;
				}
				
				pthread_mutex_unlock(&connection->lock);
			}

			LM_DBG("%d> emp_server@%s: Connect failed, Retrying (%04d) %s\n",
				connection->sfd, ipaddr, r, strerror(errno));

			if (proxy_config.maxretries && (r > proxy_config.maxretries)) {
				res = 1;
				break;
			} else
				sleep(proxy_config.retryinterval);
		} else {
			LM_DBG("%d> emp_server@%s connect to emp_server\n", connection->sfd, ipaddr);
			res = 0;
			break;
		}

	}

	return res;
}
コード例 #23
0
ファイル: client.cpp プロジェクト: AlanXie1991/Server
void Client::NotWantRead()
{
    m_want_read = false;
    short event = event_get_events(m_event);
    event_del(m_event);
    event_assign(m_event, m_server->m_server_base, m_sockfd, event & (~EV_READ), Client::ClientEventCallback, this);
    event_add(m_event, NULL); 
}
コード例 #24
0
ファイル: impl_ioserver.cpp プロジェクト: mybestcool/xhnet
	void CIOServer::Reset_Event(::event* ev, evutil_socket_t sock, short flag, event_callback_fn cb, void* p)
	{
		int err = event_assign(ev, m_evbase, sock, flag, cb, p);
		if ( err!=0 )
		{
			//int test = 9;
		}
	}
コード例 #25
0
ファイル: evpri-test.c プロジェクト: 00datman/ompi
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;
}
コード例 #26
0
static void lcb_io_delete_timer(struct lcb_io_opt_st *iops,
                                void *event)
{
    (void)iops;
    if (event_pending(event, EV_TIMEOUT, 0) != 0 && event_del(event) == -1) {
        iops->v.v2.error = EINVAL;
    }
    event_assign(event, ((struct libevent_cookie *)iops->v.v2.cookie)->base, -1, 0, NULL, NULL);
}
コード例 #27
0
ファイル: test_tls.c プロジェクト: v2tmobile/libusual
static const char *wait_for_event(struct Worker *w, short flags)
{
	event_assign(&w->ev, w->evbase, w->socket, flags, worker_cb, w);
	tt_assert(event_add(&w->ev, NULL) == 0);
	w->pending = 1;
	return "OK";
end:
	return "event_add failed";
}
コード例 #28
0
ファイル: TimerEvent.cpp プロジェクト: angel0sl/FServer
TimerEvent::TimerEvent(event_base* evBase, int milliSecs, bool repeated)
{
	short flag = 0;
	if (repeated)
		flag |= EV_PERSIST;
	m_timeval.tv_sec = milliSecs / 1000;
	m_timeval.tv_usec = (milliSecs % 1000) * 1000;
	event_assign(&m_event, evBase, -1, flag, TimerCallback, (void*)this);
}
コード例 #29
0
ファイル: bufferevent_sock.c プロジェクト: NeilHappy/libevent
static void
be_socket_setfd(struct bufferevent *bufev, evutil_socket_t fd)
{
	BEV_LOCK(bufev);
	EVUTIL_ASSERT(bufev->be_ops == &bufferevent_ops_socket);

	event_del(&bufev->ev_read);
	event_del(&bufev->ev_write);

	event_assign(&bufev->ev_read, bufev->ev_base, fd,
	    EV_READ|EV_PERSIST, bufferevent_readcb, bufev);
	event_assign(&bufev->ev_write, bufev->ev_base, fd,
	    EV_WRITE|EV_PERSIST, bufferevent_writecb, bufev);

	if (fd >= 0)
		bufferevent_enable(bufev, bufev->enabled);

	BEV_UNLOCK(bufev);
}
コード例 #30
0
static void libcouchbase_io_delete_event(struct libcouchbase_io_opt_st *iops,
                                          libcouchbase_socket_t sock,
                                          void *event)
{
    (void)iops; (void)sock;
    if (event_del(event) == -1) {
        iops->error = EINVAL;
    }
    event_assign(event, ((struct libevent_cookie *)iops->cookie)->base, -1, 0, NULL, NULL);
}