示例#1
1
static void
listen_cb(struct evconnlistener *listener, evutil_socket_t fd,
    struct sockaddr *sa, int socklen, void *arg)
{
	struct event_base *base = arg;
	struct bufferevent *bev;
	const char s[] = TEST_STR;
	bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
	bufferevent_write(bev, s, sizeof(s));
	bufferevent_setcb(bev, NULL, sender_writecb, sender_errorcb, NULL);
	bufferevent_enable(bev, EV_WRITE);
}
示例#2
0
文件: tty.c 项目: jnbek/tmux
void
tty_start_tty(struct tty *tty)
{
    struct termios	 tio;
    int		 mode;

    if (tty->fd == -1)
        return;

    if ((mode = fcntl(tty->fd, F_GETFL)) == -1)
        fatal("fcntl failed");
    if (fcntl(tty->fd, F_SETFL, mode|O_NONBLOCK) == -1)
        fatal("fcntl failed");

    bufferevent_enable(tty->event, EV_READ|EV_WRITE);

    if (tcgetattr(tty->fd, &tty->tio) != 0)
        fatal("tcgetattr failed");
    memcpy(&tio, &tty->tio, sizeof tio);
    tio.c_iflag &= ~(IXON|IXOFF|ICRNL|INLCR|IGNCR|IMAXBEL|ISTRIP);
    tio.c_iflag |= IGNBRK;
    tio.c_oflag &= ~(OPOST|ONLCR|OCRNL|ONLRET);
    tio.c_lflag &= ~(IEXTEN|ICANON|ECHO|ECHOE|ECHONL|ECHOCTL|
                     ECHOPRT|ECHOKE|ECHOCTL|ISIG);
    tio.c_cc[VMIN] = 1;
    tio.c_cc[VTIME] = 0;
    if (tcsetattr(tty->fd, TCSANOW, &tio) != 0)
        fatal("tcsetattr failed");
    tcflush(tty->fd, TCIOFLUSH);

    tty_putcode(tty, TTYC_SMCUP);

    tty_putcode(tty, TTYC_SGR0);
    memcpy(&tty->cell, &grid_default_cell, sizeof tty->cell);

    tty_putcode(tty, TTYC_RMKX);
    tty_putcode(tty, TTYC_ENACS);
    tty_putcode(tty, TTYC_CLEAR);

    tty_putcode(tty, TTYC_CNORM);
    if (tty_term_has(tty->term, TTYC_KMOUS))
        tty_puts(tty, "\033[?1000l");

    tty->cx = UINT_MAX;
    tty->cy = UINT_MAX;

    tty->rlower = UINT_MAX;
    tty->rupper = UINT_MAX;

    tty->mode = MODE_CURSOR;

    tty->flags |= TTY_STARTED;
}
示例#3
0
文件: le-proxy.c 项目: sambuc/netbsd
static void
drained_writecb(struct bufferevent *bev, void *ctx)
{
	struct bufferevent *partner = ctx;

	/* We were choking the other side until we drained our outbuf a bit.
	 * Now it seems drained. */
	bufferevent_setcb(bev, readcb, NULL, eventcb, partner);
	bufferevent_setwatermark(bev, EV_WRITE, 0, 0);
	if (partner)
		bufferevent_enable(partner, EV_READ);
}
示例#4
0
void on_accept(int fd,short,void* arg){
	struct event_base* base = reinterpret_cast<struct event_base*>(arg);
	struct sockaddr_in peer_addr;
	memset(&peer_addr,0,sizeof(peer_addr));
	socklen_t len=0;
	int clientfd = accept(fd,(struct sockaddr*)&peer_addr,&len);
	evutil_make_socket_nonblocking(clientfd);
	auto bv = bufferevent_socket_new(base,clientfd,BEV_OPT_CLOSE_ON_FREE);
	bufferevent_setcb(bv,readcb,writecb,eventcb,base);
	bufferevent_enable(bv,EV_READ );
	
}
示例#5
0
void
chldreadcb(struct bufferevent *b, void *arg)
{
	char *line, *sp, *ap;
	int n, i, total, nprocs = *(int *)arg;

	if((line=evbuffer_readline(b->input)) != nil){
		sp = line;

		if((ap = strsep(&sp, "\t")) == nil)
			panic("report error\n");
		n = atoi(ap);
		if(n - nreport > NBUFFER)
			panic("a process fell too far behind\n");

		n %= NBUFFER;

		for(i=0; i<params.nbuckets + 3 && (ap=strsep(&sp, "\t")) != nil; i++)
			reportbuf[n][i] += atoi(ap);

		if(++nreportbuf[n] >= nprocs){
			/* Timestamp it.  */
			printf("%d\t",(int)time(nil));
			for(i = 0; i < params.nbuckets + 3; i++)
				printf("%d\t", reportbuf[n][i]);

			/* Compute the total rate of succesful requests. */
			total = 0;
			for(i=3; i<params.nbuckets+1; i++)
				total += reportbuf[n][i];

			printf("%d\n", mkrate(&lastreporttv, total));

			/* Aggregate. */
			counts.errors += reportbuf[n][0];
			counts.timeouts += reportbuf[n][1];
			counts.closes += reportbuf[n][2];
			for(i=0; i<params.nbuckets; i++){
				counts.successes += reportbuf[n][i + 3];
				counts.counters[i] += reportbuf[n][i + 3];
			}

			/* Clear it. Advance nreport. */
			memset(reportbuf[n], 0,(params.nbuckets + 3) * sizeof(int));
			nreportbuf[n] = 0;
			nreport++;
		}

		free(line);
	}

	bufferevent_enable(b, EV_READ);
}
static void accept_conn_cb(struct evconnlistener *listener,
    evutil_socket_t fd, struct sockaddr *address, int socklen,
    void *ctx)
{
        /* We got a new connection! Set up a bufferevent for it. */
        struct event_base *base = evconnlistener_get_base(listener);
        struct bufferevent *bev = bufferevent_socket_new(
                base, fd, BEV_OPT_CLOSE_ON_FREE);
 
        bufferevent_setcb(bev, echo_read_cb, NULL, echo_event_cb, NULL);
        bufferevent_enable(bev, EV_READ|EV_WRITE);
}
示例#7
0
文件: network.c 项目: kasicass/kircd
static void
network_listen_callback(int listen_fd, short events, void *arg)
{
    int fd = KSOCK_svr_accept(listen_fd);
    struct bufferevent *bufev;

    printf("fd %d conn...\n", fd);

    bufev = bufferevent_new(fd, network_read_callback,
                            NULL, network_error_callback, (void *)fd);
    bufferevent_enable(bufev, EV_READ);
}
static void accept_conn_callback(
    struct evconnlistener *listener,
    evutil_socket_t fd,
    struct sockaddr *address,
    int socklen,
    void *context)
{
    struct event_base *base = evconnlistener_get_base(listener);    
    struct bufferevent *bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
    bufferevent_setcb(bev, echo_read_cb, NULL, echo_event_cb, NULL);
    bufferevent_enable(bev, EV_READ | EV_WRITE);
}
示例#9
0
void BaseServer::listener_callback(struct evconnlistener *listener, int fd, struct sockaddr *sa, int socklen, void *arg)
{
    event_base *base = (event_base*)arg;
    struct bufferevent* bev = bufferevent_socket_new(base,fd,BEV_OPT_CLOSE_ON_FREE);
    assert(bev);
    bufferevent_setwatermark(bev,EV_READ,0,0);
    bufferevent_setwatermark(bev,EV_WRITE,0,0);

    bufferevent_setcb(bev,read_callback,write_callback,NULL,NULL);
    bufferevent_enable(bev,EV_READ);

}
示例#10
0
文件: utils.c 项目: antenore/redsocks
struct bufferevent* red_connect_relay(struct sockaddr_in *addr, evbuffercb writecb, everrorcb errorcb, void *cbarg)
{
	struct bufferevent *retval = NULL;
	int on = 1;
	int relay_fd = -1;
	int error;

	relay_fd = socket(AF_INET, SOCK_STREAM, 0);
	if (relay_fd == -1) {
		log_errno(LOG_ERR, "socket");
		goto fail;
	}

	error = fcntl_nonblock(relay_fd);
	if (error) {
		log_errno(LOG_ERR, "fcntl");
		goto fail;
	}

	error = setsockopt(relay_fd, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof(on));
	if (error) {
		log_errno(LOG_WARNING, "setsockopt");
		goto fail;
	}

	error = connect(relay_fd, (struct sockaddr*)addr, sizeof(*addr));
	if (error && errno != EINPROGRESS) {
		log_errno(LOG_NOTICE, "connect");
		goto fail;
	}

	retval = bufferevent_new(relay_fd, NULL, writecb, errorcb, cbarg);
	if (!retval) {
		log_errno(LOG_ERR, "bufferevent_new");
		goto fail;
	}

	error = bufferevent_enable(retval, EV_WRITE); // we wait for connection...
	if (error) {
		log_errno(LOG_ERR, "bufferevent_enable");
		goto fail;
	}

	return retval;

fail:
	if (relay_fd != -1)
		redsocks_close(relay_fd);
	if (retval)
		bufferevent_free(retval);
	return NULL;
}
示例#11
0
static void drone_rampup_timer_cb(evutil_socket_t fd, short what, void *arg) {
    struct job *job = arg;
    Drone__JobRequest *request = job->request;
    struct session *session;
    struct bufferevent *bev;
    struct sockaddr_in echo_sin;
    struct timeval timeout;
    u_int64_t sessions;
    u_int64_t i;

    if (job->client == NULL)
        return;

    if ((request->sessions - job->cur_sessions) > request->rampup_sessions)
        sessions = request->rampup_sessions;
    else
        sessions = request->sessions - job->cur_sessions;

    memset(&echo_sin, 0, sizeof(echo_sin));
    echo_sin.sin_family = AF_INET;
    echo_sin.sin_addr.s_addr = htonl(request->ipv4);
    echo_sin.sin_port = htons(request->port);

    for (i = 0; i < sessions; i++) {
        bev = bufferevent_socket_new(job->client->base, -1,
                BEV_OPT_CLOSE_ON_FREE);

        session = malloc(sizeof(struct session));

        bufferevent_setcb(bev, drone_read_cb, NULL, drone_event_cb, session);
        bufferevent_enable(bev, EV_READ | EV_WRITE);

        timeout.tv_sec = request->timeout;
        timeout.tv_usec = 0;
        bufferevent_set_timeouts(bev, NULL, &timeout);

        if (bufferevent_socket_connect(bev, (struct sockaddr *) &echo_sin,
                sizeof(echo_sin)) < 0) {
            bufferevent_free(bev);
            free(session);
            perror("Error during connection");
            return;
        }

        session->job = job;
        session->bev = bev;
        session->remaining_data = 0;

        job->sessions[job->cur_sessions] = session;
        job->cur_sessions++;
    }
}
示例#12
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;
    }
}
示例#13
0
	static void
drained_writecbout(struct bufferevent *bev_out, void *ctx_in)
{
	fprintf(stderr, "drained_writecbout adjust the wartermark of <proxy->server>\n");
	struct bufferevent *partner_in = ctx_in;

	/* We were choking the other side until we drained our outbuf a bit.
	 * Now it seems drained. */
	bufferevent_setcb(bev_out, readcbout, NULL, eventcbout, partner_in);
	bufferevent_setwatermark(bev_out, EV_WRITE, 0, 0);
	if (partner_in)
		bufferevent_enable(partner_in, EV_READ);
}
示例#14
0
/* Send a byte to the server. */
static void
client_event_cb(struct bufferevent *bev, short events, void *ctx)
{
	if (events & BEV_EVENT_CONNECTED) {
		unsigned char tmp = 'A';
		bufferevent_write(bev, &tmp, 1);
	} else if (events & BEV_EVENT_ERROR) {
		puts("Client socket got error!");
		exit(2);
	}

	bufferevent_enable(bev, EV_READ);
}
示例#15
0
文件: vpnns.c 项目: cernekee/ocproxy
static void watcher_new_conn(struct evconnlistener *listener,
			     evutil_socket_t fd, struct sockaddr *address,
			     int socklen, void *vctx)
{
	struct watcher_ctx *ctx = vctx;
	struct bufferevent *bev;

	ctx->refcount++;
	bev = bufferevent_socket_new(ctx->event_base, fd,
				     BEV_OPT_CLOSE_ON_FREE);
	bufferevent_setcb(bev, NULL, NULL, watcher_conn_closed, vctx);
	bufferevent_enable(bev, EV_READ | EV_WRITE);
}
示例#16
0
文件: http.c 项目: cracksoft/scanssh
void
http_makeconnect(struct bufferevent *bev, struct argument *arg)
{
	extern struct addr *socks_dst_addr;
	ip_addr_t address;

	socks_resolveaddress("www.google.com", &address);

	evbuffer_add_printf(EVBUFFER_OUTPUT(bev),
	    "CONNECT %s:80 HTTP/1.0\r\n"
	    "\r\n", addr_ntoa(socks_dst_addr), SSHUSERAGENT);
	bufferevent_enable(bev, EV_WRITE);
}
示例#17
0
	static void
drained_writecbin(struct bufferevent *bev_in, void *ctx_out)
{
	fprintf(stderr, "drained_writecbin adjust the wartermark of <client-proxy>\n");
	struct bufferevent *partner_out= ctx_out;

	/* We were choking the other side until we drained our outbuf a bit.
	 * Now it seems drained. */
	bufferevent_setcb(bev_in, readcbin, NULL, eventcbin, partner_out);
	bufferevent_setwatermark(bev_in, EV_WRITE, 0, 0);
	if (partner_out)
		bufferevent_enable(partner_out, EV_READ);
}
示例#18
0
static void direct_relay_readcb_helper(redsocks_client *client, struct bufferevent *from, struct bufferevent *to)
{
	if (EVBUFFER_LENGTH(to->output) < to->wm_write.high) {
		if (bufferevent_write_buffer(to, from->input) == -1)
			redsocks_log_errno(client, LOG_ERR, "bufferevent_write_buffer");
		if (bufferevent_enable(from, EV_READ) == -1)
			redsocks_log_errno(client, LOG_ERR, "bufferevent_enable");
	}
	else {
		if (bufferevent_disable(from, EV_READ) == -1)
			redsocks_log_errno(client, LOG_ERR, "bufferevent_disable");
	}
}
示例#19
0
文件: socks.c 项目: stxh/tunsocks
static void
socks_request_cb(struct bufferevent *bev, void *ctx)
{
	struct socks_data *data = ctx;

	if (evbuffer_get_length(bufferevent_get_input(bev)) < data->req_len) {
		bufferevent_enable(bev, EV_READ);
		bufferevent_setwatermark(bev, EV_READ, data->req_len, 2048);
		bufferevent_setcb(bev, socks_request_cb, NULL,
					socks_request_error, ctx);
	} else
		data->req_cb(ctx);
}
示例#20
0
文件: server.cpp 项目: ITSTONE/icomet
int Server::psub(struct evhttp_request *req){
	bufferevent_enable(req->evcon->bufev, EV_READ);

	PresenceSubscriber *psub = new PresenceSubscriber();
	psub->req = req;
	psub->serv = this;
	psubs.push_back(psub);
	log_info("%s:%d psub, psubs: %d", req->remote_host, req->remote_port, psubs.size);

	evhttp_send_reply_start(req, HTTP_OK, "OK");
	evhttp_connection_set_closecb(req->evcon, on_psub_disconnect, psub);
	return 0;
}
示例#21
0
static int create_control_socket_event(struct event_base * base, control_thread_context_t * context, struct bufferevent ** control_event)
{
    struct bufferevent * new_event = NULL;
    int sock_fd = -1;
    struct timeval read_timeout = { 0 };

    /* Get the connection's socket */
    if (IDEVICE_E_SUCCESS != idevice_connection_get_fd(context->control_connection, &sock_fd)) {
        error("ERROR: Failed to get the socket for the reverse proxy's control connection\n");
        goto cleanup;
    }

    /* libevent needs sockets to be non-blocking */
    if (0 != evutil_make_socket_nonblocking(sock_fd)) {
        error("ERROR: Failed to make the reverse proxy's control socket non-blocking\n");
        goto cleanup;
    }

    /* Create a new bufferevent for the control socket */
    new_event = bufferevent_socket_new(base, sock_fd, 0);
    if (NULL == new_event) {
        error("ERROR: Failed to initialize the reverse proxy's control socket\n");
        goto cleanup;
    }

    /* Init the new bufferevent */
    bufferevent_setcb(new_event, rproxy_control_read_cb, NULL, rproxy_control_event_cb, (void*)context);
    read_timeout.tv_sec = CONTROL_RECV_TIMEOUT;
    read_timeout.tv_usec = 0;
    bufferevent_set_timeouts(new_event, &read_timeout, NULL);

    /* Each control message is a 32bit unsigned int, so tell libevent to call
     * our read callback only when there is enough data */
    bufferevent_setwatermark(new_event, EV_READ, sizeof(uint32_t), 0);

    /* Enable both read & write events */
    if (0 != bufferevent_enable(new_event, EV_READ | EV_WRITE)) {
        error("ERROR: Failed to enable the proxy's control socket\n");
        goto cleanup;
    }

    *control_event = new_event;
    return 0;

cleanup:
    if (new_event) {
        bufferevent_free(new_event);
    }

    return -1;
}
int
main ()
{
    int sockfd;
    struct bufferevent *p_event;
    struct sockaddr_in addr;

    ff = fopen("/tmp/log", "w");
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(PORT);

    if (inet_pton(AF_INET, SVRADDR, &addr.sin_addr) <= 0) {
        printf("inet_pton");
        exit(1);
    }

    if ((p_base = event_base_new()) == NULL) {
        printf("event_base_new ");
        return 1;
    }

    /* we do not need invoke socket function to create socket */
    if ((p_event = bufferevent_socket_new(p_base, -1, BEV_OPT_CLOSE_ON_FREE)) == NULL) {
        printf("bufferevent_socket_new ");
        return 1;
    }

    /* client actually connecte to server at this time. */
    if ((sockfd = bufferevent_socket_connect(p_event, (struct sockaddr *) &addr,
                                             sizeof(addr))) < 0) {
        printf("bufferevent_socket_connect ");
        return 1;
    }

    /* EV_WRITE is default enabled, EV_READ is default disabled */
    /* So If we disable READ, evbuffer callback will not be added to base (read and write) */
    bufferevent_setcb(p_event, buff_input_cb, NULL, eventcb, p_base);
    bufferevent_enable(p_event, EV_WRITE);

    /* edge-triggered */
    /* default read low-water  mark is 0. */
    /* default read high-water mark is unlimited. */

    /* If the underlying data received over 20, remove the READ event from base */
    bufferevent_setwatermark(p_event, EV_READ, 10, 20);

    event_base_dispatch(p_base);

    return 0;
}
示例#23
0
文件: server.cpp 项目: Trizalio/tp_hl
void listener_cb(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *sa, int socklen, void *user_data)
{
    struct event_base *base = (event_base*)user_data;
    struct bufferevent *bev;

    bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
    if (!bev) {
        std::cout << "Error constructing bufferevent!\n";
        event_base_loopbreak(base);
        return;
    }
    bufferevent_setcb(bev, conn_readcb, NULL, conn_eventcb, NULL);
    int res = bufferevent_enable(bev, EV_READ);
}
示例#24
0
static void on_accept(struct evconnlistener* l, evutil_socket_t* fd, struct sockaddr* addr, int socklen, void *arg)
{
	struct tcp_receiver* r = arg;
	struct event_base* b = evconnlistener_get_base(l);
	struct bufferevent *bev = bufferevent_socket_new(b, fd, BEV_OPT_CLOSE_ON_FREE);
	/*设置读事件函数和错误函数*/
	bufferevent_setcb(bev, on_read, NULL, on_error, arg);
	/*设置监视的socket事件*/
	bufferevent_enable(bev, EV_READ|EV_WRITE);
	/*添加到事件管理器中*/
	carray_push_back(r->bevs, bev);

	paxos_log_info("Accepted connection from %s:%d", inet_ntoa(((struct sockaddr_in*)addr)->sin_addr), ntohs(((struct sockaddr_in*)addr)->sin_port));
}
static
void authenticate_tcp_channel(struct bufferevent *bev, void *_)
{
    debug("tcp channel: authentication reading data");
    struct evbuffer *input  = bufferevent_get_input(bev);
    size_t len      = evbuffer_get_length(input);
    size_t wanted   = sizeof(struct MessageResponse);
    if(len < wanted)
        return;

    debug("tcp channel: authentication checking message");
    struct MessageResponse *res =
        (struct MessageResponse *) evbuffer_pullup(input, wanted);

    if(res->type != RESPONSE)
    {
        debug(  "tcp channel: invalid authentication message %s",
                message_get_type_string((struct Message *) res));

        bufferevent_free(bev);
        return;
    }

    union Channel *current = find_channel(&res->response);
    if(!current)
    {
        debug("tcp channel: authentication failed");
        bufferevent_free(bev);
        return;
    }

    evbuffer_drain(input, wanted);
    debug("tcp channel: authenticated");
    assert(current->base.proto == IPPROTO_TCP);
    current->tcp.channel_buffers = bev;
    bufferevent_setcb(  current->tcp.peer_buffers,
                        read_tcp_peer,
                        NULL,
                        error_on_tcp_peer,
                        current);

    bufferevent_enable(current->tcp.peer_buffers, EV_READ | EV_WRITE);
    bufferevent_setcb(  bev,
                        read_tcp_channel,
                        NULL,
                        error_on_tcp_channel,
                        current);

    read_tcp_channel(bev, current);
}
示例#26
0
文件: main.c 项目: jamal/telegenic
static void
accept_conn_cb(struct evconnlistener *listener, evutil_socket_t fd,
	struct sockaddr *address, int socklen, void *ctx)
{
	log_debug("New client connection");

	struct event_base *base = evconnlistener_get_base(listener);
	struct bufferevent *bev = bufferevent_socket_new(
		base, fd, BEV_OPT_CLOSE_ON_FREE);
	struct conn_client *client = conn_alloc_client(bev);

	bufferevent_setcb(bev, read_cb, write_cb, event_cb, client);
	bufferevent_enable(bev, EV_READ|EV_WRITE);
}
示例#27
0
void
chldreadcb(struct bufferevent *b, void *arg)
{
    char *line, *sp, *ap;
    int n, i, nprocs = *(int *)arg;

    if((line=evbuffer_readline(b->input)) != nil){
        sp = line;

        if((ap = strsep(&sp, "\t")) == nil)
            panic("report error\n");
        n = atoi(ap);
        if(n - nreport > NBUFFER)
            panic("a process fell too far behind\n");

        n %= NBUFFER;

        for(i=0; i<params.nbuckets + num_cols && (ap=strsep(&sp, "\t")) != nil; i++)
            reportbuf[n][i] += atoi(ap);

        if(++nreportbuf[n] >= nprocs){
            /* Timestamp it.  */
            printf("%d\t",(int)time(nil));
            for(i = 0; i < params.nbuckets + num_cols; i++)
                printf("%d\t", reportbuf[n][i]);
            printf("%ld\n", mkrate(&lastreporttv, reportbuf[n][0]));
            reset_time(&lastreporttv);

            /* Aggregate. */
            counts.conn_successes += reportbuf[n][0];
            counts.conn_errors += reportbuf[n][1];
            counts.conn_timeouts += reportbuf[n][2];
            counts.conn_closes += reportbuf[n][3];
            counts.http_successes += reportbuf[n][4];
            counts.http_errors += reportbuf[n][5];

            for(i=0; i<params.nbuckets; i++)
                counts.counters[i] += reportbuf[n][i + num_cols];

            /* Clear it. Advance nreport. */
            memset(reportbuf[n], 0,(params.nbuckets + num_cols) * sizeof(int));
            nreportbuf[n] = 0;
            nreport++;
        }

        free(line);
    }

    bufferevent_enable(b, EV_READ);
}
示例#28
0
 void CTcpHandler::TcpAdd(CCommand *pCmd)
 {
     CTcpAddCommand *pConnectCmd = dynamic_cast<CTcpAddCommand *>(pCmd);
     CEventThread *pThread = dynamic_cast<CEventThread *>(GetThread()); 
     m_pBufevt = bufferevent_socket_new(pThread->GetEventBase(), 
             pConnectCmd->m_iFd, BEV_OPT_THREADSAFE);
     bufferevent_setcb(m_pBufevt, CNetThread::OnStaticRead, CNetThread::OnStaticWrite, CNetThread::OnStaticError, this);
     bufferevent_enable(m_pBufevt, EV_READ|EV_PERSIST|EV_ET);		
     bufferevent_setwatermark(m_pBufevt, EV_READ, 
                               OnRead(NULL, 0), 0);
     OnConnect();
     //告诉listen线程
     SetTimeout();
 }
示例#29
0
文件: socks.c 项目: stxh/tunsocks
static void
socks_accept(struct evconnlistener *evl, evutil_socket_t new_fd,
			struct sockaddr *addr, int socklen, void *ctx)
{
	struct event_base *base = evconnlistener_get_base(evl);
	struct bufferevent *bev;

	LWIP_DEBUGF(SOCKS_DEBUG, ("%s: Accepting socks connection\n", __func__));

	bev = bufferevent_socket_new(base, new_fd, BEV_OPT_CLOSE_ON_FREE);
	bufferevent_setcb(bev, socks_version, NULL, socks_error, ctx);
	bufferevent_setwatermark(bev, EV_READ, 1, 2048);
	bufferevent_enable(bev, EV_READ|EV_WRITE);
}
示例#30
0
void NFCNet::listener_cb(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *sa, int socklen, void *user_data)
{
    //怕你们重了
    NFCNet* pNet = (NFCNet*)user_data;
    bool bClose = pNet->CloseNetObject(fd);
    if (bClose)
    {
        //error
        return;
    }

    if (pNet->mmObject.size() >= pNet->mnMaxConnect)
    {
        //应该T掉,拒绝
        return;
    }

    struct event_base *base = pNet->base;
    //创建一个基于socket的bufferevent
    struct bufferevent *bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
    if (!bev)
    {
        //应该T掉,拒绝
        fprintf(stderr, "Error constructing bufferevent!");
        //event_base_loopbreak(base);
        return;
    }

    //我获得一个新连接。为其创建一个bufferevent--FD需要管理
    struct sockaddr_in* pSin = (sockaddr_in*)sa;

    NetObject* pObject = new NetObject(pNet, fd, *pSin, bev);
    pObject->GetNet()->AddNetObject(fd, pObject);

    //为bufferevent设置各种回调
    bufferevent_setcb(bev, conn_readcb, conn_writecb, conn_eventcb, (void*)pObject);

    //开启bufferevent的读写
    bufferevent_enable(bev, EV_READ|EV_WRITE);

    //模拟客户端已连接事件
    conn_eventcb(bev, BEV_EVENT_CONNECTED, (void*)pObject);
    //////////////////////////////////////////////////////////////////////////

    struct timeval tv;
    /* 设置读超时120秒, 可做为心跳机制, 120秒没收到消息就T */
    tv.tv_sec = 120;
    tv.tv_usec = 0;
    bufferevent_set_timeouts(bev, &tv, NULL);
}