コード例 #1
0
ファイル: togo_server.c プロジェクト: keheng/togo
static void * togo_mt_process(void* args)
{
	struct event_base *base_ev;
	struct event *ev;
	evutil_socket_t server_socketfd;
	struct sockaddr_in server_addr;

	togo_memzero(&server_addr, sizeof(server_addr));
	server_addr.sin_family = AF_INET;

	if (strcmp(togo_global_c->ip, TOGO_C_DEFAULT_IP) == 0) {
		server_addr.sin_addr.s_addr = INADDR_ANY;
	} else {
		server_addr.sin_addr.s_addr = inet_addr(togo_global_c->ip);
	}

	if (togo_global_c->port == 0) {
		server_addr.sin_port = htons(TOGO_C_DEFAULT_PORT);
	} else {
		server_addr.sin_port = htons(togo_global_c->port);
	}

	server_socketfd = socket(PF_INET, SOCK_STREAM, 0);
	if (server_socketfd < 0) {
		togo_log(ERROR, "Socket error.");
		togo_exit();
	}

	evutil_make_listen_socket_reuseable(server_socketfd);
	evutil_make_socket_nonblocking(server_socketfd);

	BOOL is_set = togo_wt_set_socket_opt(server_socketfd);
	if (is_set == FALSE) {
		togo_log(ERROR, "togo_wt_set_socket_opt error.");
		togo_exit();
	}

	if (bind(server_socketfd, (struct sockaddr *) &server_addr,
			sizeof(struct sockaddr)) < 0) {
		togo_log(ERROR, "bind error.");
		togo_exit();
	}

	listen(server_socketfd, 32);
	togo_log(INFO, "Togo Server Start.......");

	/* event_base */
	base_ev = event_base_new();
	ev = event_new(base_ev, server_socketfd, EV_TIMEOUT | EV_READ | EV_PERSIST,
			togo_mt_doaccept, base_ev);

	event_add(ev, NULL);
	event_base_dispatch(base_ev); //loop
	event_base_free(base_ev);

}
コード例 #2
0
ファイル: client.c プロジェクト: heyuanlong/stage
int main(int argc, char** argv)
{
    if( argc < 3 )
    {
        printf("please input 2 parameter\n");
        return -1;
    }


    //两个参数依次是服务器端的IP地址、端口号
    int sockfd = tcp_connect_server(argv[1], atoi(argv[2]));
    if( sockfd == -1)
    {
        perror("tcp_connect error ");
        return -1;
    }

    printf("connect to server successful\n");

    struct event_base* base = event_base_new();


    struct event *ev_sockfd = event_new(base, sockfd,
                                        EV_READ | EV_PERSIST,
                                        socket_read_cb, NULL);
    event_add(ev_sockfd, NULL);



    //监听终端输入事件
    struct event* ev_cmd = event_new(base, STDIN_FILENO,
                                      EV_READ | EV_PERSIST, cmd_msg_cb,
                                      (void*)&sockfd);

    event_add(ev_cmd, NULL);



    event_base_dispatch(base);

    printf("finished \n");
    return 0;
}
コード例 #3
0
ファイル: queue.c プロジェクト: iven/mychat
/* 
 * ===  FUNCTION  ======================================================================
 *         Name:  queue_new
 *  Description:  Create a new queue.
 * =====================================================================================
 */
    Queue *
queue_new ( void )
{
    Queue *queue = (Queue *) calloc(1, sizeof(Queue));
    if ((queue == NULL) || ((queue->lock = event_new(1)) == NULL)) {
        perror("queue_new");
        return NULL;
    }
    return queue;
}       /* -----  end of function queue_new  ----- */
コード例 #4
0
ファイル: libevent.c プロジェクト: ztuowen/tunsocks
static void sys_timer_add_internal(struct event_base *base, int msec, void (*cb)(void))
{
    struct event *ev;
    struct timeval interval;

    ev = event_new(base, -1, EV_PERSIST, interval_cb, cb);
    interval.tv_sec = msec / 1000;
    interval.tv_usec = (msec % 1000) * 1000;
    event_add(ev, &interval);
}
コード例 #5
0
ファイル: ao_null.c プロジェクト: CrashSerious/PS3Roar
static int init(void) {
	LOG_DEBUG(2,"Initialising null audio driver\n");
	last_pause_cycle = current_cycle;
	last_pause_ms = current_time();
	flush_event = event_new();
	flush_event->dispatch = flush_frame;
	flush_event->at_cycle = current_cycle + (10 * CYCLES_PER_MS);
	event_queue(&MACHINE_EVENT_LIST, flush_event);
	return 0;
}
コード例 #6
0
ファイル: unittests.c プロジェクト: AndreyKrysyuk/KP52OP
static void getEventsForLastHour_NoOne_countZero(void ** state){
    callback rc = reaction;
    turniket_t turniket = turniket_create(rc);
    worker_t worker1 = worker_new("Andrey Krysyuk", ALLOWED);
    worker_t worker2 = worker_new("Olga Yashan", ALLOWED);
    event_t event1 = event_new(worker1, 1000, INSIDE);
    event_t event2 = event_new(worker2, 1200, INSIDE);

    turniket_addEvent(turniket, event1);
    turniket_addEvent(turniket, event2);
    list_t * forLastHour = list_new();
    int count = turniket_getEventsForLastHour(turniket, forLastHour, 1500);
    assert_int_equal(count , 0);
    turniket_delete(turniket);
    event_delete(event1);
    event_delete(event2);
    worker_delete(worker1);
    worker_delete(worker2);
}
コード例 #7
0
static int create_server_socket(dtls_listener_relay_server_type* server) {

  FUNCSTART;

  if(!server) return -1;

  clean_server(server);

  ioa_socket_raw udp_listen_fd = -1;

  udp_listen_fd = socket(server->addr.ss.ss_family, SOCK_DGRAM, 0);
  if (udp_listen_fd < 0) {
    perror("socket");
    return -1;
  }

  server->udp_listen_s = create_ioa_socket_from_fd(server->e, udp_listen_fd, NULL, UDP_SOCKET, LISTENER_SOCKET, NULL, &(server->addr));

  server->udp_listen_s->listener_server = server;

  set_sock_buf_size(udp_listen_fd,UR_SERVER_SOCK_BUF_SIZE);

  if(sock_bind_to_device(udp_listen_fd, (unsigned char*)server->ifname)<0) {
    TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO,"Cannot bind listener socket to device %s\n",server->ifname);
  }

  if(addr_bind(udp_listen_fd,&server->addr)<0) {
	  perror("Cannot bind local socket to addr");
	  char saddr[129];
	  addr_to_string(&server->addr,(u08bits*)saddr);
	  TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO,"Cannot bind UDP/DTLS listener socket to addr %s\n",saddr);
	  return -1;
  }

  server->udp_listen_ev = event_new(server->e->event_base,udp_listen_fd,
				    EV_READ|EV_PERSIST,udp_server_input_handler,server);

  event_add(server->udp_listen_ev,NULL);

  if(addr_get_from_sock(udp_listen_fd, &(server->addr))) {
    perror("Cannot get local socket addr");
    return -1;
  }

  if(!no_udp && !no_dtls)
	  addr_debug_print(server->verbose, &server->addr,"UDP/DTLS listener opened on ");
  else if(!no_dtls)
	  addr_debug_print(server->verbose, &server->addr,"DTLS listener opened on ");
  else if(!no_udp)
	  addr_debug_print(server->verbose, &server->addr,"UDP listener opened on ");

  FUNCEND;
  
  return 0;
}
コード例 #8
0
ファイル: ev1.c プロジェクト: ChampionL/socket
int main(){
	int fd1 = tcp_listen(1314);
	int fd2 = tcp_listen(1315);
	int len1,len2;
	int fd11 = accept(fd1,NULL,&len1);
	int fd21 = accept(fd2,NULL,&len2);
	int flag = fcntl(fd11,F_GETFL,0);
	fcntl(fd11,F_SETFL,flag|O_NONBLOCK);//需要将其设置为非阻塞形式
	flag = fcntl(fd21,F_GETFL,0);
	fcntl(fd21,F_SETFL,flag|O_NONBLOCK);
	struct event_base * base = event_base_new();//创建event_base,在创建event时候需要使用。
	struct event * ev1,*ev2;
	struct timeval tv={5,0};
	ev1 = event_new(base,fd11,EV_READ|EV_PERSIST,cb_func_read,NULL);//使用event_new创建事件
	ev2 = event_new(base,fd21,EV_READ|EV_PERSIST,cb_func_read,NULL);//都是对读感兴趣,一次active之后,事件将不处于pending状态,需要重新使其处于pending状态,使用能够EV_PERSIST
	
	event_add(ev1,NULL);//添加event
	event_add(ev2,NULL);

	event_base_dispatch(base);//开启事件循环
	/*event_base_loop,event_base_loop开始监听事件循环伪代码如下所示,按照事件的优先级来处理,每个事件都拥有一个优先级,优先级数目可以在开始时候设置。
    while (any events are registered with the loop,
        or EVLOOP_NO_EXIT_ON_EMPTY was set) {

    if (EVLOOP_NONBLOCK was set, or any events are already active)
        If any registered events have triggered, mark them active.
    else
        Wait until at least one event has triggered, and mark it active.

    for (p = 0; p < n_priorities; ++p) {
       if (any event with priority of p is active) {
          Run all active events with priority of p.
          break; //Do not run any events of a less important priority 
       }
    }

    if (EVLOOP_ONCE was set or EVLOOP_NONBLOCK was set)
       break;
    }
    */
	return 0;
}
コード例 #9
0
ファイル: event_loop.cpp プロジェクト: halybang/w
 std::unique_ptr<IEventHandle> EventLoop::call_in(DateTimeInterval interval, std::function<void()> callback, bool repeat) {
   auto handle = std::unique_ptr<TimeoutEventHandle_libevent>(new TimeoutEventHandle_libevent);
   short events = EV_TIMEOUT;
   if (repeat) events |= EV_PERSIST;
   event* ev = event_new(p_->base, -1, events, TimeoutEventHandle_libevent::handle_event_cb, handle.get());
   handle->ev = ev;
   handle->callback = std::move(callback);
   struct timeval tv = interval.to_timeval();
   event_add(ev, &tv);
   return std::move(handle);
 }
コード例 #10
0
ファイル: Libevent_glue.c プロジェクト: wakamori/aspen
//## cevent cevent.new(cevent_base event_base, int evd, int event, eventCBArg cbArg);
static KMETHOD cevent_new(KonohaContext *kctx, KonohaStack *sfp)
{
	struct cevent *ev = (struct cevent *) sfp[0].asObject;
	struct cevent_base *cEvent_base = (struct cevent_base *)sfp[1].asObject;
	evutil_socket_t evd = (evutil_socket_t)sfp[2].intValue;
	short event = (short)(sfp[3].intValue & 0xffff);
	keventCBArg *cbArg = (keventCBArg *)sfp[4].asObject;	//deliver callback method

	ev->event = event_new(cEvent_base->event_base, evd, event, cevent_callback_1st, cbArg);
	KReturn(ev);
}
コード例 #11
0
ファイル: reactor.cpp プロジェクト: VIRGIL-YAN/remotingclient
void Reactor::start() {
	struct timeval tv = {1,0};
	//int evthread_use_windows_threads(void);//win上设置,多线程安全
	this->mBase = event_base_new();

	struct event* timer = event_new(this->mBase, -1, EV_TIMEOUT|EV_PERSIST, processTimeEclapsed, this);
	event_add(timer, &tv);

	event_base_dispatch(this->mBase);
	event_base_free(this->mBase);
}
コード例 #12
0
ファイル: serv.cpp プロジェクト: eturin/linux
void cb_master(evutil_socket_t fd, short what, void *ptr){
	struct event * evn=(event *)ptr;
	evutil_socket_t slave_socket=accept(fd,NULL,NULL);
	if(slave_socket==-1)
		std::cout<<"accept:\n"<<errno<<std::endl;
	else{
		//регистрируем события
		struct event * evn_new=event_new(evn->ev_base,slave_socket,EV_READ|EV_PERSIST,cb_slave,event_self_cbarg());
		event_add(evn_new,NULL);
		std::cout<<"Hi\n";
	}
}
コード例 #13
0
ファイル: config.c プロジェクト: schoentoon/mcstatus-miner
void dispatch_config(struct event_base* base) {
  dns = evdns_base_new(base, 1);
  struct server* node = global_config.servers;
  while (node) {
    struct timeval tv;
    tv.tv_sec = node->interval;
    tv.tv_usec = 0;
    node->timer = event_new(base, -1, EV_PERSIST, timer_callback, node);
    event_add(node->timer, &tv);
    node = node->next;
  };
};
コード例 #14
0
ファイル: main.cpp プロジェクト: AssassinPig/my_src
void run()
{
	evutil_socket_t listener;
	struct sockaddr_in sin;
	struct event_base *base;
	struct event* listener_event;
	struct event *signal_event;

	base = event_base_new();

	if(!base)
	{
		return;	
	}
	
	signal_event = evsignal_new(base, SIGINT, signal_cb, (void *)base);
	if (!signal_event || event_add(signal_event, NULL)<0) {
		//printf(stderr, "Could not create/add a signal event!\n");
		printf("Could not create/add a signal event!\n");
		return ;
	}	  

	sin.sin_family = AF_INET;
	sin.sin_addr.s_addr = 0;
	sin.sin_port = htons(LISTEN_PORT);
	
	listener = socket(AF_INET, SOCK_STREAM, 0);
	evutil_make_socket_nonblocking(listener);
	
#ifndef WIN32
	{
		int one = 1;
		setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));	
	}
#endif
	
	if(bind(listener, (struct sockaddr*)&sin, sizeof(sin)) < 0)
	{
		perror("bind");
		return;
	}
	
	if(listen(listener, 16)<0)
	{
		perror("listen");
		return;
	}
	
	listener_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept, (void*)base);
	event_add(listener_event, NULL);
	event_base_dispatch(base);	
	event_free(signal_event);
}
コード例 #15
0
ファイル: worker.cpp プロジェクト: marinae/cache-server
void Worker::addClient(int fd) {

    assert(clients.find(fd) == clients.end());

    /* Create new event for client socket */
    struct event *ev;
    ev = event_new(base, fd, EV_READ | EV_PERSIST, read_cb, (void *)this);
    event_add(ev, nullptr);

    clients[fd] = new Client(ev, nullptr);
    printf("[worker #%d]:\tnew client (%d)\n", myID, fd);
}
コード例 #16
0
ファイル: reactor.cpp プロジェクト: VIRGIL-YAN/remotingclient
void Reactor::addReadable(evutil_socket_t socket)
{
	struct event* event_read = event_new(mBase, socket, EV_READ|EV_PERSIST, enableRead, this);
	if(event_read == NULL) {
		//throw myException() << boost::errinfo_api_function("event_new error in ClientEvent::createReadandWrite") << boost::errinfo_at_line(20);
		std::cout << "create read error" << std::endl;
	}
	int ret = event_add(event_read, 0);
	if (ret < 0) {
		printf("add write error\n");
	}
}
コード例 #17
0
ファイル: event_thread.cpp プロジェクト: EastQ/libnsq
 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);
      
 }
コード例 #18
0
ファイル: vpnns.c プロジェクト: cernekee/ocproxy
static void do_packet_loop(int vpn_fd, int tun_fd)
{
	struct packet_loop_ctx ctx;

	if (fcntl(vpn_fd, F_SETFL, O_RDWR | O_NONBLOCK) < 0)
		pdie("can't set O_NONBLOCK on VPN fd");
	if (fcntl(tun_fd, F_SETFL, O_RDWR | O_NONBLOCK) < 0)
		pdie("can't set O_NONBLOCK on tun fd");

	ctx.vpn_fd = vpn_fd;
	ctx.tun_fd = tun_fd;

	ctx.event_base = event_base_new();
	if (!ctx.event_base)
		die("can't initialize libevent\n");

	ctx.vpn_event = event_new(ctx.event_base, vpn_fd, EV_READ | EV_PERSIST,
				  &write_pkt, &ctx);
	ctx.tun_event = event_new(ctx.event_base, tun_fd, EV_READ | EV_PERSIST,
				  &write_pkt, &ctx);
	ctx.sig_event = event_new(ctx.event_base, SIGHUP, EV_SIGNAL,
				  &pkt_loop_signal, &ctx);

	if (!ctx.vpn_event || !ctx.tun_event || !ctx.sig_event)
		die("can't create event structs\n");
	if (event_add(ctx.vpn_event, NULL) ||
	    event_add(ctx.tun_event, NULL) ||
	    event_add(ctx.sig_event, NULL))
		die("can't register event structs\n");

	event_base_dispatch(ctx.event_base);

	event_del(ctx.sig_event);
	event_free(ctx.sig_event);
	event_del(ctx.tun_event);
	event_free(ctx.tun_event);
	event_del(ctx.vpn_event);
	event_free(ctx.vpn_event);
	event_base_free(ctx.event_base);
}
コード例 #19
0
ファイル: nfs4-cat.c プロジェクト: rbalint/libnfs
/*
 * This callback is invoked when others (the nfsv4 server) initiates a
 * NFSv4 CALLBACK sessions to us.
 * We accept() the connection and create a local rpc server context
 * for the callback protocol.
 */
static void client_accept(evutil_socket_t s, short events, void *private_data)
{
	struct client *client = private_data;
        struct server *server;
        struct sockaddr_storage ss;
        socklen_t len = sizeof(ss);
        int fd;
        
        server = malloc(sizeof(struct server));
        if (server == NULL) {
                fprintf(stderr, "failed to malloc server structure\n");
                exit(10);
        }
        memset(server, 0, sizeof(*server));
        server->next = server_list;
        server_list = server;

        if ((fd = accept(s, (struct sockaddr *)&ss, &len)) < 0) {
                free_server(server);
                fprintf(stderr, "accept failed\n");
                exit(10);
        }
        evutil_make_socket_nonblocking(fd);

        server->rpc = rpc_init_server_context(fd);
        if (server->rpc == NULL) {
                free_server(server);
                fprintf(stderr, "Failed to create server rpc context\n");
                exit(10);
        }

        rpc_register_service(server->rpc, NFS4_CALLBACK, NFS_CB,
                             pt, sizeof(pt) / sizeof(pt[0]));

        server->read_event = event_new(base, fd, EV_READ|EV_PERSIST,
                                       server_io, server);
        server->write_event = event_new(base, fd, EV_WRITE|EV_PERSIST,
                                        server_io, server);
        update_events(server->rpc, server->read_event, server->write_event);
}
コード例 #20
0
ファイル: servetick.c プロジェクト: mdavidsaver/h2test
static
void newconn(struct evconnlistener *lev, evutil_socket_t sock, struct sockaddr *cli, int socklen, void *raw)
{
    server *serv = raw;
    session *sess;
    printf("New client\n");
    sess = calloc(1, sizeof(*sess));
    if(sess) {
        sess->serv = serv;
        sess->S.build_stream = buildstream;
        sess->S.cleanup = &cleanup_session;
        /* periodic timer */
        sess->pingtimer = event_new(serv->base, -1, EV_PERSIST, pingconn, sess);
        assert(sess->pingtimer);
        sess->S.bev = bufferevent_socket_new(serv->base, sock, BEV_OPT_CLOSE_ON_FREE);
        if(sess->S.bev) {
            h2session_setup_bev(&sess->S);
            bufferevent_enable(sess->S.bev, EV_READ);

            if(prepare_h2_session(sess)) {
                bufferevent_free(sess->S.bev);
                free(sess);
                printf("Client failed\n");
                return;

            } else {
                nghttp2_settings_entry iv[] = {
                    {NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS, 100},
                    {NGHTTP2_SETTINGS_ENABLE_PUSH, 0}
                };
                int rv;

                if ((rv=nghttp2_submit_settings(sess->S.h2sess, NGHTTP2_FLAG_NONE, iv, ARRLEN(iv))) ||
                        (rv=nghttp2_session_send(sess->S.h2sess)))
                {
                    printf("submit error: %s", nghttp2_strerror(rv));
                    cleanup_session(&sess->S);
                } else {
                    const struct timeval itvl = {5,0};
                    printf("Connection ready\n");
                    evtimer_add(sess->pingtimer, &itvl);
                }
            }
        }
    }
    if(!sess || !sess->S.bev) {
        fprintf(stderr, "No memory\n");
        free(sess);
        close(sock);
        return;
    }
}
コード例 #21
0
ファイル: session.cpp プロジェクト: wf34/led
bool
Session::open(struct event_base* base) {
    reqFd_ = ::open(getFifo().c_str(), O_RDWR | O_NONBLOCK);

	if (reqFd_ == -1)
        return false;

    ev_ = event_new(base, reqFd_,
                    EV_READ|EV_PERSIST,
                    Session::readFromPipe, this); 
    event_add(ev_, NULL);
    return true;
}
コード例 #22
0
ファイル: poller_libevent.c プロジェクト: Nov11/onion
/// Adds a slot to the poller
int onion_poller_add(onion_poller *poller, onion_poller_slot *el){
	el->ev=event_new(poller->base, el->fd, el->type, event_callback, el);
	if (el->timeout>0){
		struct timeval tv;
		tv.tv_sec=el->timeout/1000;
		tv.tv_usec=1000*(el->timeout%1000);
		event_add(el->ev, &tv);
	}
	else{
		event_add(el->ev, NULL);
	}
	return 1;
}
コード例 #23
0
ファイル: main.c プロジェクト: Konimiks/hello-world
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;
}
コード例 #24
0
ファイル: unittests.c プロジェクト: AndreyKrysyuk/KP52OP
static void getEventsForLastHour_fourEvents_countTwo(void ** state){
    callback rc = reaction;
    turniket_t turniket = turniket_create(rc);
    worker_t worker1 = worker_new("Andrey Krysyuk", ALLOWED);
    worker_t worker2 = worker_new("Olga Yashan", ALLOWED);
    event_t event1 = event_new(worker1, 1230, INSIDE);
    event_t event2 = event_new(worker2, 1200, INSIDE);
    event_t event3 = event_new(worker1, 1250, OUTSIDE);
    event_t event4 = event_new(worker2, 1255, OUTSIDE);
    turniket_addEvent(turniket, event1);
    turniket_addEvent(turniket, event2);
    turniket_addEvent(turniket, event3);
    turniket_addEvent(turniket, event4);
    list_t * forLastHour = list_new();
    int count = turniket_getEventsForLastHour(turniket, forLastHour, 1300);
    assert_int_equal(count , 2);
    turniket_delete(turniket);
    event_delete(event1);
    event_delete(event2);
    event_delete(event3);
    event_delete(event4);
}
コード例 #25
0
void throttleObject::connectToThrottlePubPort(zeromqConnect &connector, struct event_base * base, event_callback_fn fn, void * arg)
{    
    for(int i=0; i<m_throttle_workerNum; i++)
    {
        recvAdReq_t *recvAdReq = new recvAdReq_t();
        recvAdReq->m_recvAdReqFromThrottleHandler = connector.establishConnect(true,"tcp", ZMQ_SUB, 
									m_throttle_ip.c_str(), m_throttle_pubPort+i, &recvAdReq->m_recvAdReqFromThrottleFd);    
        recvAdReq->m_recvAdReqFromThrottleEvent = event_new(base, recvAdReq->m_recvAdReqFromThrottleFd, EV_READ|EV_PERSIST, fn, arg); 
        event_add(recvAdReq->m_recvAdReqFromThrottleEvent, NULL);   
        m_recvAdReqVector.push_back(recvAdReq);
    }
    
}
コード例 #26
0
ファイル: event_write.c プロジェクト: dong777/libevent_sample
int
main()
{
    pipe(pp);
    struct event_base *base = event_base_new();
    
    /* test flag EV_WRITE|EV_PERSIST, cb_1 will be called again and again */
    ev1 = event_new(base, pp[1], EV_WRITE | EV_PERSIST, cb_1, NULL);
    event_add(ev1, NULL);
    event_base_dispatch(base);

    return 0;
}
コード例 #27
0
ファイル: async_file.cpp プロジェクト: Chocolatbuddha/sems
async_file::async_file(unsigned int buf_len)
  : AmMutex(true), fifo_buffer(buf_len),
    evbase(NULL),closed(false),error(false),write_thresh(MIN_WRITE_SIZE)
{
  if (buf_len <= MIN_WRITE_SIZE) {
    ERROR("application error: async_file with buffer size <=128k (%u), "
	  "using %u write threshold\n", buf_len, buf_len/2);
    write_thresh = buf_len / 2;
  }

  evbase = async_file_writer::instance()->get_evbase();
  ev_write = event_new(evbase,-1,0,write_cb,this);
}
コード例 #28
0
/*
void cb_func(evutil_socket_t fd,short what,void *arg)
{
	const char* data = arg;
	//打印事件的类型和传递过来的数据
printf("Got an event on socket %d:%s%s%s%s [%s]",(int)fd,(what & EV_TIMEOUT)? : "timeout" : " ";,(what&EV_READ)? : "read" : " ",(what&EV_WRITE)? : "write" : " ",(what&EV_SIGNAL)? : "signal" : " ",data);
}

*/
void main_loop(evutil_socket_t fd2)
{
	struct event *ev1,*ev2;
	struct timeval five_seconds = {5,0};
	struct event_base *base = event_base_new();
	//ev1 = event_new(base,fd1,EV_TIMEOUT|EV_READ|EV_PERSIST,cb_func,(char*)"Reading event");
	ev1 = evtimer_new(base,cb_func,(char*)"timeout event");

	ev2 = event_new(base,fd2,EV_READ|EV_WRITE|EV_PERSIST,cb_func,(char*)"writing event");
	event_add(ev1,&five_seconds);
	event_add(ev2,NULL);
	event_base_dispatch(base);
}
コード例 #29
0
ファイル: regress_et.c プロジェクト: ghewgill/libevent
static void
test_edgetriggered(void *et)
{
	struct event *ev = NULL;
	struct event_base *base = NULL;
	const char *test = "test string";
	evutil_socket_t pair[2] = {-1,-1};
	int supports_et;

	if (evutil_socketpair(LOCAL_SOCKETPAIR_AF, SOCK_STREAM, 0, pair) == -1) {
		tt_abort_perror("socketpair");
	}

	called = was_et = 0;

	send(pair[0], test, (int)strlen(test)+1, 0);
	shutdown(pair[0], SHUT_WR);

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

	if (!strcmp(event_base_get_method(base), "epoll") ||
	    !strcmp(event_base_get_method(base), "epoll (with changelist)") ||
	    !strcmp(event_base_get_method(base), "kqueue"))
		supports_et = 1;
	else
		supports_et = 0;

	TT_BLATHER(("Checking for edge-triggered events with %s, which should %s"
				"support edge-triggering", event_base_get_method(base),
				supports_et?"":"not "));

	/* Initalize one event */
	ev = event_new(base, pair[1], EV_READ|EV_ET|EV_PERSIST, read_cb, &ev);

	event_add(ev, NULL);

	/* We're going to call the dispatch function twice.  The first invocation
	 * will read a single byte from pair[1] in either case.  If we're edge
	 * triggered, we'll only see the event once (since we only see transitions
	 * from no data to data), so the second invocation of event_base_loop will
	 * do nothing.  If we're level triggered, the second invocation of
	 * event_base_loop will also activate the event (because there's still
	 * data to read). */
	event_base_loop(base,EVLOOP_NONBLOCK|EVLOOP_ONCE);
	event_base_loop(base,EVLOOP_NONBLOCK|EVLOOP_ONCE);

	if (supports_et) {
		tt_int_op(called, ==, 1);
		tt_assert(was_et);
	} else {
コード例 #30
0
ファイル: ao_sun.c プロジェクト: CrashSerious/PS3Roar
static int init(void) {
	unsigned int rate = SAMPLE_RATE;
	audio_info_t device_info;
	const char *device = "/dev/audio";

	LOG_DEBUG(2,"Initialising Sun audio driver\n");
	channels = CHANNELS;
	sound_fd = open(device, O_WRONLY);
	if (sound_fd == -1) {
		LOG_ERROR("Couldn't open audio device %s: %s!\n", device, strerror(errno));
		return 1;
	}
	AUDIO_INITINFO(&device_info);
	device_info.play.sample_rate = SAMPLE_RATE;
	device_info.play.channels = CHANNELS;
	device_info.play.precision = 8;
	device_info.play.encoding = AUDIO_ENCODING_LINEAR;
	if (ioctl(sound_fd, AUDIO_SETINFO, &device_info) < 0) {
		LOG_ERROR("Failed to configure audio device %s: %s",
				device, strerror(errno));
		return 1;
	}
	if (device_info.play.channels != channels) {
		LOG_ERROR("Couldn't set desired (%d) audio channels.  Got %d.\n", channels, device_info.play.channels);
		return 1;
	}
	if (device_info.play.encoding != AUDIO_ENCODING_LINEAR) {
		LOG_ERROR("Couldn't set desired audio format.\n");
		return 1;
	}
	if (device_info.play.sample_rate != rate) {
		LOG_ERROR("Couldn't set desired (%dHz) audio rate.  Got %dHz.\n", rate, device_info.play.sample_rate);
		return 1;
	}
	LOG_DEBUG(2, "Set up audio device at %dHz, %d channels.\n", rate, channels);
	buffer = (Sample *)malloc(FRAME_SIZE * sizeof(Sample));
	flush_event = event_new();
	flush_event->dispatch = flush_frame;

	memset(buffer, 0x80, FRAME_SIZE);
	wrptr = buffer;
	frame_cycle_base = current_cycle;
	frame_cycle = 0;
	flush_event->at_cycle = frame_cycle_base + FRAME_CYCLES;
	event_queue(&MACHINE_EVENT_LIST, flush_event);
	lastsample = 0x00;
	ioctl(sound_fd, I_FLUSH, FLUSHW);
	ioctl(sound_fd, AUDIO_GETINFO, &device_info);
	samples_written = device_info.play.samples;
	return 0;
}