Beispiel #1
0
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);

}
Beispiel #2
0
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;
}
Beispiel #3
0
/* 
 * ===  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  ----- */
Beispiel #4
0
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);
}
Beispiel #5
0
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;
}
Beispiel #6
0
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);
}
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;
}
Beispiel #8
0
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;
}
Beispiel #9
0
 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);
 }
Beispiel #10
0
//## 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);
}
Beispiel #11
0
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);
}
Beispiel #12
0
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";
	}
}
Beispiel #13
0
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;
  };
};
Beispiel #14
0
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);
}
Beispiel #15
0
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);
}
Beispiel #16
0
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");
	}
}
Beispiel #17
0
 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);
      
 }
Beispiel #18
0
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);
}
Beispiel #19
0
/*
 * 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);
}
Beispiel #20
0
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;
    }
}
Beispiel #21
0
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;
}
Beispiel #22
0
/// 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;
}
Beispiel #23
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 #24
0
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);
}
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);
    }
    
}
Beispiel #26
0
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;
}
Beispiel #27
0
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);
}
/*
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);
}
Beispiel #29
0
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 {
Beispiel #30
0
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;
}