Ejemplo n.º 1
0
Archivo: ser.c Proyecto: muupu/asyevent
void on_accept(int sock, short event, void* arg)
{
    struct sockaddr_in cli_addr;
    int newfd, sin_size;
    // read_ev must allocate from heap memory, otherwise the program would crash from segmant fault
    // 如果是在栈上分配,那么当函数返回时变量占用的内存会被释放,
    // 因此事件主循环event_base_dispatch会访问无效的内存而导致进程崩溃(即crash)
    struct sock_ev* ev = (struct sock_ev*)malloc(sizeof(struct sock_ev));
    ev->read_ev = (struct event*)malloc(sizeof(struct event));
    ev->write_ev = (struct event*)malloc(sizeof(struct event));
    sin_size = sizeof(struct sockaddr_in);
    // 4. accept:接受客户端请求,建立连接
    // 如果accept成功返回,则服务器与客户已经正确建立连接了,此时服务器通过accept返回的套接字来完成与客户的通信。
    newfd = accept(sock, (struct sockaddr*)&cli_addr, &sin_size);
    // 在代表客户的描述字newfd上监听可读事件,当有数据到达时调用on_read函数
    event_set(ev->read_ev, newfd, EV_READ|EV_PERSIST, on_read, ev); // ev作为参数传递给了on_read函数
    event_base_set(base, ev->read_ev);
    event_add(ev->read_ev, NULL);
}
Ejemplo n.º 2
0
/*
 * Setup a worker thread
 */
static rstatus_t
thread_setup(struct thread_worker *t)
{
    rstatus_t status;

    t->base = event_base_new();
    if (t->base == NULL) {
        log_error("event init failed: %s", strerror(errno));
        return MC_ERROR;
    }

    /* listen for notifications from other threads */
    event_set(&t->notify_event, t->notify_receive_fd, EV_READ | EV_PERSIST,
              thread_libevent_process, t);
    event_base_set(t->base, &t->notify_event);

    status = event_add(&t->notify_event, 0);
    if (status < 0) {
        log_error("event add failed: %s", strerror(errno));
        return MC_ERROR;
    }

    status = thread_setup_stats(t);
    if (status != MC_OK) {
        return status;
    }

    t->kbuf = klog_buf_create();
    if (t->kbuf == NULL) {
        log_error("klog buf create failed: %s", strerror(errno));
        return MC_ENOMEM;
    }

    conn_cq_init(&t->new_cq);

    t->suffix_cache = cache_create("suffix", CAS_SUFFIX_SIZE, sizeof(char *));
    if (t->suffix_cache == NULL) {
        log_error("cache create of suffix cache failed: %s", strerror(errno));
        return MC_ENOMEM;
    }

    return MC_OK;
}
Ejemplo n.º 3
0
//int main (int argc, char **argv){
int main (void){
    struct event ev;
    int socket;
    char device[] = "/dev/simplex.0";

    socket = open (device, O_RDWR | O_NONBLOCK, 0);

    if (socket == -1) {
        perror("open");
        exit (1);
    }

    fprintf(stderr, "polling device %s\n", device);
    event_init();
    event_set(&ev, socket, EV_READ, server_read, &ev);
    event_add(&ev, NULL);
    event_dispatch();
    return (0);
}
Ejemplo n.º 4
0
void
gen_traffic_accept(int fd, short events, void *arg)
{
	struct listener		*l;
	struct sockaddr_storage	 ss;
	struct timeval		 pause;
	struct reader		*r;
	socklen_t		 len;
	int			 s;

	l = arg;
	pause.tv_sec = 1; pause.tv_usec = 0;

	len = sizeof(ss);
	s = accept(fd, (struct sockaddr *)&ss, &len);
	if (s == -1) {
		switch (errno) {
		case EINTR:
		case EWOULDBLOCK:
		case ECONNABORTED:
			return;
		case EMFILE:
		case ENFILE:
			event_del(&l->ev);
			evtimer_add(&l->pause, &pause);
			return;
		default:
			err(1, "%s", "accept");
		}
	}

	if (ioctl(s, FIONBIO, &on) == -1)
		err(1, "%s", "reader ioctl(FIONBIO)");

	r = calloc(1, sizeof(*r));
	if (r == NULL)
		errx(1, "%s", "cannot calloc reader");

	r->fd = s;

	event_set(&r->ev, s, EV_READ | EV_PERSIST, gen_traffic_request, r);
	event_add(&r->ev, NULL);
}
Ejemplo n.º 5
0
void tmate_encoder_init(struct tmate_encoder *encoder,
			tmate_encoder_write_cb *callback,
			void *userdata)
{
	msgpack_packer_init(&encoder->pk, encoder, &on_encoder_write);
	encoder->buffer = evbuffer_new();
	encoder->ready_callback = callback;
	encoder->userdata = userdata;

	if (!encoder->buffer)
		tmate_fatal("Can't allocate buffer");

	event_set(&encoder->ev_buffer, -1,
		  EV_READ | EV_PERSIST, on_encoder_buffer_ready, encoder);

	event_add(&encoder->ev_buffer, NULL);

	encoder->ev_active = false;
}
Ejemplo n.º 6
0
/**
 * init the plugin with the parsed config
 */
static int network_mysqld_master_plugin_apply_config(chassis *chas, chassis_plugin_config *config) {
    network_mysqld_con *con;
    network_socket *listen_sock;

    if (!config->address) config->address = g_strdup(":4041");
    if (!config->master_username) config->master_username = g_strdup("root");
    if (!config->master_password) config->master_password = g_strdup("secret");

    /**
     * create a connection handle for the listen socket
     */
    con = network_mysqld_con_new();
    network_mysqld_add_connection(chas, con);
    con->config = config;

    config->listen_con = con;

    listen_sock = network_socket_new();
    con->server = listen_sock;

    /* set the plugin hooks as we want to apply them to the new connections too later */
    network_mysqld_server_connection_init(con);

    /* FIXME: network_socket_set_address() */
    if (0 != network_address_set_address(listen_sock->dst, config->address)) {
        return -1;
    }

    /* FIXME: network_socket_bind() */
    if (0 != network_socket_bind(listen_sock)) {
        return -1;
    }

    /**
     * call network_mysqld_con_accept() with this connection when we are done
     */
    event_set(&(listen_sock->event), listen_sock->fd, EV_READ|EV_PERSIST, network_mysqld_con_accept, con);
    event_base_set(chas->event_base, &(listen_sock->event));
    event_add(&(listen_sock->event), NULL);

    return 0;
}
Ejemplo n.º 7
0
int32_t iothread_start( struct iothread * self, uint8_t index, iothreads_t parent )
{
    self->index = index;
    self->parent = parent;

    self->sets = evsets_create();
    if ( self->sets == NULL )
    {
        iothread_stop(self);
        return -1;
    }

    self->cmdevent = event_create();
    self->queue = msgqueue_create( MSGQUEUE_DEFAULT_SIZE );
    if ( self->queue == NULL || self->cmdevent == NULL )
    {
        iothread_stop(self);
        return -2;
    }

    // 初始化命令事件
    event_set( self->cmdevent, msgqueue_popfd(self->queue), EV_READ|EV_PERSIST );
    event_set_callback( self->cmdevent, iothread_on_command, self );
    evsets_add( self->sets, self->cmdevent, 0 );

    // 启动线程
    pthread_attr_t attr;
    pthread_attr_init( &attr );
    //    assert( pthread_attr_setstacksize( &attr, THREAD_DEFAULT_STACK_SIZE ) );
    pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_DETACHED );

    int32_t rc = pthread_create(&(self->id), &attr, iothread_main, self);
    pthread_attr_destroy( &attr );

    if ( rc != 0 )
    {
        iothread_stop(self);
        return -3;
    }

    return 0;
}
Ejemplo n.º 8
0
void network_init(unsigned short port)
{
    struct KSOCK_svr_opt opt;
    struct event *ev;
    int listen_fd;

    opt.addr    = KSOCK_INADDR_ANY;
    opt.port    = port;
    opt.backlog = 5;
    listen_fd = KSOCK_svr_listen_tcp(&opt);

    event_init();
    ev = malloc(sizeof(struct event));
    event_set(ev, listen_fd, EV_READ|EV_PERSIST,
              network_listen_callback, ev);
    event_add(ev, NULL);

    g_data.listen_fd = listen_fd;
    printf("listen port: %d\n", port);
}
Ejemplo n.º 9
0
void on_accept(int sock,short event,void *arg)
{
    struct sockaddr_in cli_addr;
    int newfd = -1;
    socklen_t sockaddrlen=sizeof(struct sockaddr);
    int err = 0;
    sock_ev* ev = new sock_ev;
    ev->read_ev = new struct event;
    ev->write_ev = new struct event;

    newfd = accept(sock,(struct sockaddr *)&cli_addr,&sockaddrlen);
    if ( -1 == newfd ) {
        debug_log("accept client failed",errno);
        return ;
    }
     
    event_set(ev->read_ev,newfd,EV_READ|EV_PERSIST,on_read,ev);
    event_base_set(base,ev->read_ev);
    event_add(ev->read_ev,NULL);
}
Ejemplo n.º 10
0
struct tmuxpeer *
proc_add_peer(struct tmuxproc *tp, int fd,
    void (*dispatchcb)(struct imsg *, void *), void *arg)
{
	struct tmuxpeer	*peer;

	peer = xcalloc(1, sizeof *peer);
	peer->parent = tp;

	peer->dispatchcb = dispatchcb;
	peer->arg = arg;

	imsg_init(&peer->ibuf, fd);
	event_set(&peer->event, fd, EV_READ, proc_event_cb, peer);

	log_debug("add peer %p: %d (%p)", peer, fd, arg);

	proc_update_event(peer);
	return (peer);
}
Ejemplo n.º 11
0
static gboolean
lua_tcp_make_connection (struct lua_tcp_cbdata *cbd)
{
	int fd;

	rspamd_inet_address_set_port (cbd->addr, cbd->port);
	fd = rspamd_inet_address_connect (cbd->addr, SOCK_STREAM, TRUE);

	if (fd == -1) {
		msg_info ("cannot connect to %s", rspamd_inet_address_to_string (cbd->addr));
		return FALSE;
	}
	cbd->fd = fd;

	event_set (&cbd->ev, cbd->fd, EV_WRITE, lua_tcp_handler, cbd);
	event_base_set (cbd->ev_base, &cbd->ev);
	event_add (&cbd->ev, &cbd->tv);

	return TRUE;
}
Ejemplo n.º 12
0
bool SocketListen::socket_listen(string ip, int port)
{
	struct sockaddr_in sin;
	sin.sin_family = AF_INET;
	sin.sin_port = htons(port);
	sin.sin_addr.s_addr = INADDR_ANY;

	int fd = socket(AF_INET, SOCK_STREAM, 0);
    fd_listen_ = fd;
	if (fd == INVALID_SOCKET || fd == SOCKET_ERROR)
	{
		std::cout << __func__ << " create socket error" << std::endl;
		return false;
	}

	int reuseaddr = 1; 
	int key = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&reuseaddr, sizeof(reuseaddr));
	if (key != 0)
	{
		std::cout << __func__<< " setsockopt error errno = "<< errno << " key = "<< key <<std::endl;
		return false;
	}

	if ( bind(fd, (struct sockaddr*)&sin, sizeof(sin) ) != 0)
	{
		std::cout << __func__<< " bind error errno = "<< errno << std::endl;
		return false;
	}
	if (listen(fd, 65535) != 0)
	{
		std::cout << __func__<< " listen error errno = "<< errno << std::endl;
		return false;
	}
	evutil_make_socket_nonblocking(fd);
	event_set(&ev_, fd, EV_READ | EV_PERSIST, OnAccept, this);
	event_base_set(base_, &ev_);
	event_add(&ev_, 0);
	char info[100];
	sprintf(info, "Listen Port %d", port);
	CreateThread(info);
}
Ejemplo n.º 13
0
/*
 * Set up a thread's information.
 */
static void setup_thread(LIBEVENT_THREAD *me) {
	//初始化worker线程的libevent
    me->base = event_init();
    if (! me->base) {
        fprintf(stderr, "Can't allocate event base\n");
        exit(1);
    }

    /* Listen for notifications from other threads */
	//设置事件,监听与主线程的通信,事件处理函数为thread_libevent_process
    event_set(&me->notify_event, me->notify_receive_fd,
              EV_READ | EV_PERSIST, thread_libevent_process, me);
    event_base_set(me->base, &me->notify_event);

	//将事件添加到libevent的事件循环中
    if (event_add(&me->notify_event, 0) == -1) {
        fprintf(stderr, "Can't monitor libevent notify pipe\n");
        exit(1);
    }

	//创建一个空队列,用于接收主线程发送过来的CQ_ITEM
    me->new_conn_queue = malloc(sizeof(struct conn_queue));
    if (me->new_conn_queue == NULL) {
        perror("Failed to allocate memory for connection queue");
        exit(EXIT_FAILURE);
    }
	//初始化CQ_ITEM队列
    cq_init(me->new_conn_queue);

    if (pthread_mutex_init(&me->stats.mutex, NULL) != 0) {
        perror("Failed to initialize mutex");
        exit(EXIT_FAILURE);
    }

    me->suffix_cache = cache_create("suffix", SUFFIX_SIZE, sizeof(char*),
                                    NULL, NULL);
    if (me->suffix_cache == NULL) {
        fprintf(stderr, "Failed to create suffix cache\n");
        exit(EXIT_FAILURE);
    }
}
Ejemplo n.º 14
0
void
pcap_event_init(client_conn_t * conn)
{
    struct bpf_program filterp;
    bpf_u_int32     maskp,
                    netp;
    char            errbuf[PCAP_ERRBUF_SIZE];

    if (pcap_lookupnet(conn->start_header.dev, &netp, &maskp, errbuf) < 0)
	goto pcap_err;

    if ((conn->descr =
	 pcap_open_live(conn->start_header.dev,
			conn->start_header.snaplen, 1, 100,
			errbuf)) == NULL)
	goto pcap_err;

    if (conn->start_header.bpf != NULL) {
	if (pcap_compile(conn->descr, &filterp,
			 conn->start_header.bpf, 0, netp) < 0)
	    goto pcap_err;

	pcap_setfilter(conn->descr, &filterp);
    }

    if (pcap_setnonblock(conn->descr, 1, errbuf) < 0)
	goto pcap_err;

    if ((conn->pcap_fd = pcap_get_selectable_fd(conn->descr)) <= 0)
	goto pcap_err;

    event_set(&conn->pcap_event, conn->pcap_fd,
	      EV_READ | EV_PERSIST, (void *) pcap_driver, (void *) conn);
    event_add(&conn->pcap_event, 0);
    return;

  pcap_err:
    LOG("pcap err %s\n", errbuf);
    free_client_conn(conn);
    return;
}
Ejemplo n.º 15
0
struct NeubotPoller *
NeubotPoller_construct(void)
{
	struct NeubotPoller *self;
	struct event_base *base;
	int retval;

	base = event_init();
	if (base == NULL)
		return (NULL);

	if (evdns_init() != 0)
		return (NULL);

	self = (struct NeubotPoller *) calloc(1, sizeof(*self));
	if (self == NULL)
		return (NULL);

	self->base = base;
	self->dnsbase = evdns_get_global_base();
	if (self->dnsbase == NULL)
		abort();

#ifndef WIN32
	event_set(&self->evsignal, SIGINT, EV_SIGNAL,
	    NeubotPoller_sigint, self);

	retval = event_add(&self->evsignal, NULL);
	if (retval != 0)
		goto failure;
#endif

	return (self);

      failure:
#ifndef WIN32
	event_del(&self->evsignal);
#endif
	free(self);
	return (NULL);
}
Ejemplo n.º 16
0
int connect_server(struct jsonrpc_server *server) 
{	
	struct sockaddr_in  server_addr;
	struct hostent      *hp;

	server_addr.sin_family = AF_INET;
	server_addr.sin_port   = htons(server->port);

	hp = gethostbyname(server->host);
	if (hp == NULL) {
		LM_ERR("gethostbyname(%s) failed with h_errno=%d.\n", server->host, h_errno);
		handle_server_failure(server);
		return -1;
	}
	memcpy(&(server_addr.sin_addr.s_addr), hp->h_addr, hp->h_length);

	int sockfd = socket(AF_INET,SOCK_STREAM,0);

	if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr_in))) {
		LM_WARN("Failed to connect to %s on port %d... %s\n", server->host, server->port, strerror(errno));
		handle_server_failure(server);
		return -1;
	}

	if (set_non_blocking(sockfd) != 0)
	{
		LM_WARN("Failed to set socket (%s:%d) to non blocking.\n", server->host, server->port);
		handle_server_failure(server);
		return -1;
	}

	server->socket = sockfd;
	server->status = JSONRPC_SERVER_CONNECTED;

	struct event *socket_ev = pkg_malloc(sizeof(struct event));
	CHECK_MALLOC(socket_ev);
	event_set(socket_ev, sockfd, EV_READ | EV_PERSIST, socket_cb, server);
	event_add(socket_ev, NULL);
	server->ev = socket_ev;
	return 0;
}
Ejemplo n.º 17
0
  void set_event(void)
  {
    struct event evfifo;
    struct stat st;
    const char *fifo = "event.fifo";
    int socket;
   
    if (lstat (fifo, &st) == 0) {
      if ((st.st_mode & S_IFMT) == S_IFREG) {
        errno = EEXIST;
        perror("lstat");
        exit (1);
      }
    }

    unlink (fifo);
    if (mkfifo (fifo, 0600) == -1) {
      perror("mkfifo");
      exit (1);
    }

    /* Linux pipes are broken, we need O_RDWR instead of O_RDONLY */
    socket = open (fifo, O_RDWR | O_NONBLOCK, 0);

    if (socket == -1) {
      perror("open");
      exit (1);
    }

    fprintf(stderr, "Write data to %s\n", fifo);
    /* Initalize the event library */
    event_init();

    arg_t arg;
    arg.t = this;
    arg.e = &evfifo;
    event_set(&evfifo, socket, EV_READ, Test::run, &arg);

    event_add(&evfifo, NULL);
    event_dispatch();
  }
Ejemplo n.º 18
0
int
evsignal_init(struct event_base *base)
{
	int i;

	/* 
	 * 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_socketpair(
		    AF_UNIX, SOCK_STREAM, 0, base->sig.ev_signal_pair) == -1) {
#ifdef WIN32
		/* Make this nonfatal on win32, where sometimes people
		   have localhost firewalled. */
		event_warn("%s: socketpair", __func__);
#else
		event_err(1, "%s: socketpair", __func__);
#endif
		return -1;
	}

	FD_CLOSEONEXEC(base->sig.ev_signal_pair[0]);
	FD_CLOSEONEXEC(base->sig.ev_signal_pair[1]);
	base->sig.sh_old = NULL;
	base->sig.sh_old_max = 0;
	base->sig.evsignal_caught = 0;
	memset(&base->sig.evsigcaught, 0, sizeof(sig_atomic_t)*NSIG);
	/* initialize the queues for all events */
	for (i = 0; i < NSIG; ++i)
		TAILQ_INIT(&base->sig.evsigevents[i]);

        evutil_make_socket_nonblocking(base->sig.ev_signal_pair[0]);

	event_set(&base->sig.ev_signal, base->sig.ev_signal_pair[1],
		EV_READ | EV_PERSIST, evsignal_cb, &base->sig.ev_signal);
	base->sig.ev_signal.ev_base = base;
	base->sig.ev_signal.ev_flags |= EVLIST_INTERNAL;

	return 0;
}
Ejemplo n.º 19
0
void on_accept(int fd, short ev, void *arg)
{
	int client_fd;
	struct sockaddr_in client_addr;
	socklen_t client_len = sizeof(client_addr);
	struct client *client;
	client_fd = accept(fd, (struct sockaddr *)&client_addr, &client_len);
	if (client_fd == -1) {
		warn("accept failed");
		return;
	}
	if (setnonblock(client_fd) < 0) {
		warn("failed to set client socket non-blocking");
	}
	client = calloc(1, sizeof(*client));
	if (client == NULL) {
		err(1, "malloc failed");
	}
	event_set(&client->ev_read, client_fd, EV_READ|EV_PERSIST, on_read, client);
	event_add(&client->ev_read, NULL);
}
Ejemplo n.º 20
0
void connection_accept(int fd, short event, void *arg)
{
    struct sockaddr_in clientaddr;
    socklen_t len = sizeof(clientaddr);
    int cfd;

    if ((cfd = accept(fd, (struct sockaddr *)&clientaddr, &len)) < 0 )
	return;

    struct client_state *cs = calloc(1, sizeof(struct client_state));
    cs->state = FSM_ENTER;
    cs->evb = evbuffer_new();

    event_set(&cs->ev, cfd, EV_READ, (void *) connection_client, cs);
    event_add(&cs->ev, &tv);
    clients++;

    if (clients >= MAX_CLIENTS) {
	event_del(&ev);
    }
}
Ejemplo n.º 21
0
/**
 * setup the notification-fd of a event-thread
 *
 * all event-threads listen on the same notification pipe
 *
 * @see chassis_event_handle()
 */ 
int chassis_event_threads_init_thread(chassis_event_thread_t *thread, chassis *chas) {
    thread->event_base = event_base_new();
    thread->chas = chas;

    int fds[2];
    if (pipe(fds)) {
        int err;
        err = errno;
        g_log_dbproxy(g_error, "evutil_socketpair() failed: %s (%d)", 
                g_strerror(err),
                err);
    }
    thread->notify_receive_fd = fds[0];
    thread->notify_send_fd = fds[1];

    event_set(&(thread->notify_fd_event), thread->notify_receive_fd, EV_READ | EV_PERSIST, chassis_event_handle, thread);
    event_base_set(thread->event_base, &(thread->notify_fd_event));
    event_add(&(thread->notify_fd_event), NULL);

    return 0;
}
Ejemplo n.º 22
0
void on_read(int sock, short event, void* arg)
{
    struct event* write_ev;
    int size;
    
    char* buffer = (char*)malloc(MEM_SIZE);
    size = (int)recv(sock, buffer, MEM_SIZE, 0);
    buffer[size] = '\0';
    printf("receive data:%s, size:%d\n", buffer, size);
    if (size == 0) {
        buffer[0] = '\0';
        event_del((struct event*)arg);
        free(arg);
        close(sock);
        return;
    }
    write_ev = (struct event*) malloc(sizeof(struct event));;
    event_set(write_ev, sock, EV_WRITE, on_write, buffer);
    event_base_set(base, write_ev);
    event_add(write_ev, NULL);
}
Ejemplo n.º 23
0
//Initialize sockets and related events
static int 
init_pro_network() {
    
    // Send buffer for talking to acceptors
    to_acceptors = udp_sendbuf_new(PAXOS_ACCEPTORS_NET);
    if(to_acceptors == NULL) {
        printf("Error creating proposer->acceptors network sender\n");
        return PROPOSER_ERROR;
    }
    
    // Message receive event
    for_proposer = udp_receiver_new(PAXOS_PROPOSERS_NET);
    if (for_proposer == NULL) {
        printf("Error creating proposer network receiver\n");
        return PROPOSER_ERROR;
    }
    event_set(&proposer_msg_event, for_proposer->sock, EV_READ|EV_PERSIST, pro_handle_newmsg, NULL);
    event_add(&proposer_msg_event, NULL);
    
    return 0;
}
Ejemplo n.º 24
0
/*
 * Set up a thread's information.
 */
static void setup_thread(LIBEVENT_THREAD *me) {
    if (! me->base) {
        me->base = event_init();
        if (! me->base) {
            fprintf(stderr, "Can't allocate event base\n");
            exit(1);
        }
    }

    /* Listen for notifications from other threads */
    event_set(&me->notify_event, me->notify_receive_fd,
              EV_READ | EV_PERSIST, thread_libevent_process, me);
    event_base_set(me->base, &me->notify_event);

    if (event_add(&me->notify_event, 0) == -1) {
        fprintf(stderr, "Can't monitor libevent notify pipe\n");
        exit(1);
    }

    cq_init(&me->new_conn_queue);
}
Ejemplo n.º 25
0
static void setup_dispatcher(struct event_base *main_base,
                             void (*dispatcher_callback)(int, short, void *))
{
    memset(&dispatcher_thread, 0, sizeof(dispatcher_thread));
    dispatcher_thread.type = DISPATCHER;
    dispatcher_thread.base = main_base;
    dispatcher_thread.thread_id = pthread_self();
    if (!create_notification_pipe(&dispatcher_thread)) {
        exit(1);
    }
    /* Listen for notifications from other threads */
    event_set(&dispatcher_thread.notify_event, dispatcher_thread.notify[0],
              EV_READ | EV_PERSIST, dispatcher_callback, &dispatcher_callback);
    event_base_set(dispatcher_thread.base, &dispatcher_thread.notify_event);

    if (event_add(&dispatcher_thread.notify_event, 0) == -1) {
        settings.extensions.logger->log(EXTENSION_LOG_WARNING, NULL,
                                        "Can't monitor libevent notify pipe\n");
        exit(1);
    }
}
Ejemplo n.º 26
0
int main ()
{
    struct event ev_accept;

    g_print("server_proc_main init .\n");

    int listenfd = create_socket( NULL, 9009, SOCK_STREAM);
    if (listenfd < 0)
    {
        g_print("tcp_listen failed!\n");
        return -1;
    }	

    g_print("listenfd is %d\n", listenfd);
    // initialize libevent.
    event_init ();

    /* We now have a listeing socket, we create a read event to
     * be notified when a client connects. */
    time_slot_t *ts = (time_slot_t *)calloc(1,sizeof(time_slot_t));

    ts->tv.tv_sec=1;
    ts->tv.tv_usec=0;
    evtimer_set(&ts->ev_timeout, timeout_cb, ts /*&ev_timeout*/);
    evtimer_add(&ts->ev_timeout, &ts->tv);
    
    event_set (&ev_accept, listenfd, EV_READ | EV_PERSIST,
               conn_accept, NULL);

    struct timeval tvaccept;
    tvaccept.tv_sec=3;
    tvaccept.tv_usec=3;

    event_add (&ev_accept, &tvaccept);

    
    event_dispatch ();

    return 0;
}
Ejemplo n.º 27
0
void conn_accept (int sockfd, short event, void* arg)
{
    if(event == EV_TIMEOUT)
    {
        g_print("%d :accept timeout %d\n", sockfd, event);
        return;
    }

    g_print("%d :accept %d\n", sockfd, event);
    struct sockaddr_in cliaddr;

    g_print("%s(): fd = %d, event = %d.\n", __func__, sockfd, event);

    socklen_t len = sizeof (struct sockaddr_in);
 
    /* Accept the new connection. */
    int connfd = accept (sockfd, (struct sockaddr*)&cliaddr, &len);
    if (connfd < 0)
    {
        g_print("accept failed! (%s)\n", strerror(errno));
        return;
    }

    connection_t *conn = conn_new(); 

    conn->sockfd = connfd;

    conn->tv.tv_sec = 5;
    //timeout_set(&conn->ev_read, timeout_cb, conn);
    event_set(&conn->ev_read, connfd, EV_READ, conn_input, conn);
    if (event_add (&conn->ev_read, NULL) == -1)
    {
        return;
    }

    timeout_add(&conn->ev_read, &conn->tv);

    g_print("Accepted connection from %s, socket=%d\n",
            inet_ntoa(cliaddr.sin_addr), connfd);
}
Ejemplo n.º 28
0
/*
 * Set up a thread's information.
 */
static void setup_thread(LIBEVENT_THREAD *me) {
    me->base = event_init();
    if (! me->base) {
        fprintf(stderr, "Can't allocate event base\n");
        exit(1);
    }

#ifdef DUP_AWARE
    event_priority_init(NUM_PRIORITIES);
#endif

    /* Listen for notifications from other threads */
    event_set(&me->notify_event, me->notify_receive_fd,
              EV_READ | EV_PERSIST, thread_libevent_process, me);
    event_base_set(me->base, &me->notify_event);

    if (event_add(&me->notify_event, 0) == -1) {
        fprintf(stderr, "Can't monitor libevent notify pipe\n");
        exit(1);
    }

    me->new_conn_queue = malloc(sizeof(struct conn_queue));
    if (me->new_conn_queue == NULL) {
        perror("Failed to allocate memory for connection queue");
        exit(EXIT_FAILURE);
    }
    cq_init(me->new_conn_queue);

    if (pthread_mutex_init(&me->stats.mutex, NULL) != 0) {
        perror("Failed to initialize mutex");
        exit(EXIT_FAILURE);
    }

    me->suffix_cache = cache_create("suffix", SUFFIX_SIZE, sizeof(char*),
                                    NULL, NULL);
    if (me->suffix_cache == NULL) {
        fprintf(stderr, "Failed to create suffix cache\n");
        exit(EXIT_FAILURE);
    }
}
Ejemplo n.º 29
0
/*
 * Set up a thread's information.
 */
static void setup_thread(LIBEVENT_THREAD *me) {
    me->base = event_init();
    if (! me->base) {
        fprintf(stderr, "Can't allocate event base\n");
        exit(1);
    }

    /* Listen for notifications from other threads */
    //为管道设置读事件监听,thread_libevent_process为回调函数
    event_set(&me->notify_event, me->notify_receive_fd,
              EV_READ | EV_PERSIST, thread_libevent_process, me);
    event_base_set(me->base, &me->notify_event);

    if (event_add(&me->notify_event, 0) == -1) {
        fprintf(stderr, "Can't monitor libevent notify pipe\n");
        exit(1);
    }

    //为新线程创建连接CQ链表
    me->new_conn_queue = malloc(sizeof(struct conn_queue));
    if (me->new_conn_queue == NULL) {
        perror("Failed to allocate memory for connection queue");
        exit(EXIT_FAILURE);
    }
    //初始化线程控制器内的CQ链表
    cq_init(me->new_conn_queue);

    if (pthread_mutex_init(&me->stats.mutex, NULL) != 0) {
        perror("Failed to initialize mutex");
        exit(EXIT_FAILURE);
    }

    //创建cache
    me->suffix_cache = cache_create("suffix", SUFFIX_SIZE, sizeof(char*),
                                    NULL, NULL);
    if (me->suffix_cache == NULL) {
        fprintf(stderr, "Failed to create suffix cache\n");
        exit(EXIT_FAILURE);
    }
}
Ejemplo n.º 30
0
int main(int argc, char **argv)
{
    int listen_fd;
    struct sockaddr_in listen_addr;
    struct event ev_accept;
    int reuseaddr_on;

    /* Initialize libevent. */
    event_init();

    /* Create our listening socket. */
    listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (listen_fd < 0)
        err(1, "listen failed");
    memset(&listen_addr, 0, sizeof(listen_addr));
    listen_addr.sin_family = AF_INET;
    listen_addr.sin_addr.s_addr = INADDR_ANY;
    listen_addr.sin_port = htons(SERVER_PORT);
    if (bind(listen_fd, (struct sockaddr *)&listen_addr, sizeof(listen_addr)) < 0)
        err(1, "bind failed");
    if (listen(listen_fd, 5) < 0)
        err(1, "listen failed");
    reuseaddr_on = 1;
    setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr_on, sizeof(reuseaddr_on));

    /* Set the socket to non-blocking, this is essential in event
     * based programming with libevent. */
    if (setnonblock(listen_fd) < 0)
        err(1, "failed to set server socket to non-blocking");

    /* We now have a listening socket, we create a read event to
     * be notified when a client connects. */
    event_set(&ev_accept, listen_fd, EV_READ | EV_PERSIST, on_accept, NULL);
    event_add(&ev_accept, NULL);

    /* Start the event loop. */
    event_dispatch();

    return 0;
}