void readcb(struct bufferevent *bev, void *ctx) { struct evbuffer *input, *output; char *line; size_t n; int i; input=bufferevent_get_input(bev); output=bufferevent_get_output(bev); while( (line=evbuffer_readln(input, &n, EVBUFFER_EOL_LF))) { for(i=0;i<n;++i) { line[i]=rot13_char(line[i]); } evbuffer_add(output, line, n); evbuffer_add(output, "\n", 1); free(line); } if(evbuffer_get_length(input)>=MAX_LINE) { char buf[1024]; while(evbuffer_get_length(input)) { int n=evbuffer_remove(input, buf, sizeof(buf)); for(i=0;i<n;++i) { buf[i]=rot13_char(buf[i]); } evbuffer_add(output, buf, n); } evbuffer_add(output, "\n", 1); } }
static void respond_to_number(struct bufferevent *bev, void *ctx) { struct evbuffer *b = bufferevent_get_input(bev); char *line; int n; line = evbuffer_readln(b, NULL, EVBUFFER_EOL_LF); if (! line) return; n = atoi(line); if (n <= 0) TT_FAIL(("Bad number: %s", line)); TT_BLATHER(("The number was %d", n)); if (n == 1001) { ++test_is_done; bufferevent_free(bev); /* Should trigger close on other side. */ return; } if (!strcmp(ctx, "client") && n == renegotiate_at) { SSL_renegotiate(bufferevent_openssl_get_ssl(bev)); } ++n; evbuffer_add_printf(bufferevent_get_output(bev), "%d\n", n); TT_BLATHER(("Done reading; now writing.")); bufferevent_enable(bev, EV_WRITE); bufferevent_disable(bev, EV_READ); }
/* Called to write data info the BIO */ static int bio_bufferevent_write(BIO *b, const char *in, int inlen) { struct bufferevent *bufev = b->ptr; struct evbuffer *output; size_t outlen; BIO_clear_retry_flags(b); if (!b->ptr) return -1; output = bufferevent_get_output(bufev); outlen = evbuffer_get_length(output); /* Copy only as much data onto the output buffer as can fit under the * high-water mark. */ if (bufev->wm_write.high && bufev->wm_write.high <= (outlen+inlen)) { if (bufev->wm_write.high <= outlen) { /* If no data can fit, we'll need to retry later. */ BIO_set_retry_write(b); return -1; } inlen = bufev->wm_write.high - outlen; } EVUTIL_ASSERT(inlen > 0); evbuffer_add(output, in, inlen); return inlen; }
static void echo_writecb(struct bufferevent *bev, void *ctx) { struct evbuffer *output = bufferevent_get_output(bev); if (evbuffer_get_length(output) < 512000) bufferevent_enable(bev, EV_READ); }
static void echo_read_cb(struct bufferevent *bev, void *ctx) { char * line; char* retval; size_t len; /* This callback is invoked when there is data to read on bev. */ struct evbuffer *input = bufferevent_get_input(bev); struct evbuffer *output = bufferevent_get_output(bev); struct evbuffer_iovec v[2]; line = evbuffer_readln(input, &len, EVBUFFER_EOL_CRLF); retval = (char*)command_parser(line); //command_parser(line); evbuffer_reserve_space(output, strlen(retval), v, 2); evbuffer_add(output, retval, strlen(retval)); evbuffer_commit_space(output, v, 1); //evbuffer_add_buffer(output, input); //evbuffer_copyout(input, line, buffer_len); /* Copy all the data from the input buffer to the output buffer. */ printf("%s\n",line); free(line); }
/* if data are sent from output buffer of bev, this function is called, * it is not active all the time, but only in some situations (bev has too many data in output buffer) * we can find out if all data are written to network and free memory */ void write_callback(struct bufferevent *bev, void *ptr) { struct bev_arg *bev_arg=ptr; /* if bufferevent send all data to socket */ if (evbuffer_get_length(bufferevent_get_output(bev))==0) { /* if remote socket exist */ if (bev_arg->remote) { /* * now enable EV_READ on remote socket bufferevent so we can receive data from it * and disable write_callback fn for self */ struct bufferevent *bev_remote=bev_arg->remote->bev; bufferevent_enable(bev_remote, EV_READ); bufferevent_setcb(bev, read_callback, NULL, event_callback, (void *)bev_arg); } else { /* if remote socket is closed and we dont have any data in output buffer, free self */ bev_arg->listener->nr_conn--; bufferevent_free(bev); free(bev_arg); } } }
static ad_conn_t *conn_new(ad_server_t *server, struct bufferevent *buffer) { if (server == NULL || buffer == NULL) { return NULL; } // Create a new connection container. ad_conn_t *conn = NEW_OBJECT(ad_conn_t); if (conn == NULL) return NULL; // Initialize with default values. conn->server = server; conn->buffer = buffer; conn->in = bufferevent_get_input(buffer); conn->out = bufferevent_get_output(buffer); conn_reset(conn); // Bind callback bufferevent_setcb(buffer, conn_read_cb, conn_write_cb, conn_event_cb, (void *)conn); bufferevent_setwatermark(buffer, EV_WRITE, 0, 0); bufferevent_enable(buffer, EV_WRITE); bufferevent_enable(buffer, EV_READ); // Run callbacks with AD_EVENT_INIT event. conn->status = call_hooks(AD_EVENT_INIT | AD_EVENT_WRITE, conn); return conn; }
static void echo_read_cb(struct bufferevent *bev, void *ctx) { struct evbuffer *input = bufferevent_get_input(bev); size_t str_len = 0; char* str_input = evbuffer_readln(input,&str_len,EVBUFFER_EOL_ANY); char* val = NULL; enum CMD_TYPE cmdtype = parse_cmd(str_input, str_len, &val); if (cmdtype == CMD_QUIT){ bufferevent_free(bev); return; } struct evbuffer *ret = evbuffer_new(); switch (cmdtype) { case CMD_GET: case CMD_ECHO: evbuffer_add(ret,val,strlen(val)); break; case CMD_ERR: evbuffer_add(ret,"(ERR)",5); break; case CMD_OK: evbuffer_add(ret,"(OK)",4); break; case CMD_NULL: evbuffer_add(ret,"(NULL)",6);break; default: evbuffer_add(ret,"(UNKNOWN)",9);break; } evbuffer_add(ret,"\n",1); evbuffer_add_buffer(bufferevent_get_output(bev), ret); }
static void encrypt_mem(redsocks_client * client, char * data, size_t len, struct bufferevent * to, int decrypt) { ss_client *sclient = (void*)(client + 1); struct evbuffer_iovec vec; struct evbuffer * buf_out = bufferevent_get_output(to); size_t required; int rc; if (!len || !data) return; if (decrypt) required = ss_calc_buffer_size(&sclient->d_ctx, len); else required = ss_calc_buffer_size(&sclient->e_ctx, len); if (required && evbuffer_reserve_space(buf_out, required, &vec, 1) == 1) { if (decrypt) rc = ss_decrypt(&sclient->d_ctx, data, len, vec.iov_base, &vec.iov_len); else rc = ss_encrypt(&sclient->e_ctx, data, len, vec.iov_base, &vec.iov_len); if (!rc) vec.iov_len = 0; evbuffer_commit_space(buf_out, &vec, 1); } }
static void readcbout(struct bufferevent *bev_out, void *ctx_in) { struct bufferevent *partner_in = ctx_in; struct evbuffer *src, *dst; size_t len; src = bufferevent_get_input(bev_out); len = evbuffer_get_length(src); if (!partner_in) { fprintf(stderr, "partner_in == NULL"); evbuffer_drain(src, len); return; } dst = bufferevent_get_output(partner_in); evbuffer_add_buffer(dst, src); if (evbuffer_get_length(dst) >= MAX_OUTPUT_C2P) { /* We're giving the other side data faster than it can * pass it on. Stop reading here until we have drained the * other side to MAX_OUTPUT_C2P/2 bytes. */ fprintf(stderr, "adjust the wartermark of <client-proxy>\n"); bufferevent_setcb(partner_in, readcbin, drained_writecbin, eventcbin, bev_out); bufferevent_setwatermark(partner_in, EV_WRITE, MAX_OUTPUT_C2P/2, MAX_OUTPUT_C2P); bufferevent_disable(bev_out, EV_READ); } }
static void ss_relay_readcb(struct bufferevent *buffev, void *_arg) { redsocks_client *client = _arg; struct bufferevent * from = buffev; struct bufferevent * to = client->client; size_t input_size = evbuffer_get_contiguous_space(bufferevent_get_input(from)); size_t output_size = evbuffer_get_length(bufferevent_get_output(to)); assert(buffev == client->relay); redsocks_touch_client(client); if (client->state == ss_connected) { /* decrypt and forward data to client side */ if (output_size < to->wm_write.high) { if (input_size) decrypt_buffer(client, from, to); 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"); } } else { redsocks_drop_client(client); } }
static void ss_relay_writecb(struct bufferevent *buffev, void *_arg) { redsocks_client *client = _arg; struct bufferevent * from = client->client; struct bufferevent * to = buffev; size_t input_size = evbuffer_get_contiguous_space(bufferevent_get_input(from)); size_t output_size = evbuffer_get_length(bufferevent_get_output(to)); assert(buffev == client->relay); redsocks_touch_client(client); if (process_shutdown_on_write_(client, from, to)) return; if (client->state == ss_connected) { /* encrypt and forward data received from client side */ if (output_size < to->wm_write.high) { if (input_size) encrypt_buffer(client, from, to); if (!(client->client_evshut & EV_READ) && bufferevent_enable(from, EV_READ) == -1) redsocks_log_errno(client, LOG_ERR, "bufferevent_enable"); } } else { redsocks_drop_client(client); } }
static void ssh_relay_event_cb(struct bufferevent *bev, short what, void *ptr) { obfsproxyssh_client_session_t *session = ptr; struct evbuffer *buf; assert(bev == session->ssh_ev); if (what & (BEV_EVENT_EOF | BEV_EVENT_ERROR)) { session->ssh_is_valid = 0; libssh2_channel_free(session->ssh_channel); session->ssh_channel = NULL; libssh2_session_free(session->ssh_session); session->ssh_session = NULL; buf = bufferevent_get_output(session->socks_ev); if (0 == session->socks_is_valid || 0 == evbuffer_get_length(buf)) session_free(session); else { bufferevent_disable(session->socks_ev, EV_READ); bufferevent_setcb(session->socks_ev, NULL, socks_relay_teardown_cb, socks_event_cb, session); } } }
void on_event(struct bufferevent *bev, short event, void *arg){ struct evbuffer *output = bufferevent_get_output(bev); struct event_base *base = bufferevent_get_base(bev); char buf[MAXLEN]; //printf("event begin:%d\n", event); /*if(event & BEV_EVENT_READING){ printf("Read?\n"); }*/ /*if(event & BEV_EVENT_WRITING){ printf("Write?\n"); }*/ if(event & BEV_EVENT_EOF){ //printf("EOF.\n"); printf("Logged out.\n"); pthread_cancel(tid); pthread_cancel(disptid); bufferevent_free(bev); event_base_loopexit(base, NULL); } if(event & BEV_EVENT_ERROR){ printf("Error!\n"); } if(event & BEV_EVENT_TIMEOUT){ printf("Timeout!\n"); } if(event & BEV_EVENT_CONNECTED){ printf("Connected.\n"); buf[0] = 0x80; buf[1] = user & 0xFF; *((package *)(&buf[2])) = pkg[user]; evbuffer_add(output, buf, sizeof(pkg[user]) + 2); } }
/////////////////////////////////////////////// // coro socket interface /////////////////////////////////////////////// int sock_flush(int fd) { coro_sock *sock = find_sock_by_fd(fd); if ( !sock ) { return -1; } bufferevent_disable(sock->bev, EV_READ); evbuffer *buf = bufferevent_get_output(sock->bev); uthread_t cur = coro_current_uthread(); size_t left = 0; int ret = 0; do { coro_sock *sock = find_sock_by_fd(fd); if ( !sock ) { return -1; } left = evbuffer_get_length(buf); if ( left > 0 ) { set_pending_status(sock, set_wait_write_status, cur, set_wait_write_status); sock->writequeue->push(cur); int status = coro_schedule_uthread(cur, 0); if ( status < 0 ) { ret = status; break; } } } while(left); return ret; }
void cmd_get(struct bufferevent *bev, void *ctx, int argc, char **argv) { struct evbuffer *output = bufferevent_get_output(bev), *buf = evbuffer_new(); if (*argv == NULL) { evbuffer_add_reference(output, "ERROR\r\n", 7, NULL, NULL); return; } do { answer_key(buf, *argv); if (evbuffer_get_length(buf) == 0) continue; #ifdef CONVERT_TO_UTF8 buf = evbuffer_b2u(buf); if (buf == NULL) { // Failed to convert buf = evbuffer_new(); continue; } #endif evbuffer_add_printf(output, "VALUE %s 0 %ld\r\n", *argv, evbuffer_get_length(buf)); evbuffer_add_buffer(output, buf); evbuffer_add_printf(output, "\r\n"); } while (*++argv); evbuffer_add_reference(output, "END\r\n", 5, NULL, NULL); evbuffer_free(buf); }
/* private helper callbacks */ static void nbd_client_handler(struct bufferevent* bev, void* client) { struct evbuffer* in = bufferevent_get_input(bev); struct evbuffer* out = bufferevent_get_output(bev); while (evbuffer_get_length(in)) { switch (((struct nbd_client*) client)->state) { case NBD_HANDSHAKE_SENT: if (__check_zero_handshake(in, client)) return; break; case NBD_ZERO_RECEIVED: if (__check_opt_header(bev, in, out, client)) return; break; case NBD_DATA_PUSHING: if (__check_request(bev, in, out, client)) return; break; case NBD_DISCONNECTED: fprintf(stderr, "DISCONNECTED STATE.\n"); nbd_ev_handler(bev, BEV_EVENT_EOF, client); default: return; }; } }
static void readcb(struct bufferevent *bev, void *ctx) { struct bufferevent *partner = ctx; struct evbuffer *src, *dst; size_t len; src = bufferevent_get_input(bev); len = evbuffer_get_length(src); if (!partner) { evbuffer_drain(src, len); return; } dst = bufferevent_get_output(partner); evbuffer_add_buffer(dst, src); if (evbuffer_get_length(dst) >= MAX_OUTPUT) { /* We're giving the other side data faster than it can * pass it on. Stop reading here until we have drained the * other side to MAX_OUTPUT/2 bytes. */ bufferevent_setcb(partner, readcb, drained_writecb, eventcb, bev); bufferevent_setwatermark(partner, EV_WRITE, MAX_OUTPUT/2, MAX_OUTPUT); bufferevent_disable(bev, EV_READ); } }
static void nbd_new_conn(struct evconnlistener *conn, evutil_socket_t sock, struct sockaddr *addr, int len, void * handle) { struct event_base* eb = evconnlistener_get_base(conn); struct bufferevent* bev = bufferevent_socket_new(eb, sock, BEV_OPT_CLOSE_ON_FREE); struct evbuffer* out = bufferevent_get_output(bev); struct nbd_new_handshake hdr = { .magic = htobe64(GAMMARAY_NBD_MAGIC), .protocol = htobe64(GAMMARAY_NBD_NEW_PROTOCOL), .global_flags = htobe16(NBD_FLAG_FIXED_NEWSTYLE) }; struct nbd_client* client = (struct nbd_client*) malloc(sizeof(struct nbd_client)); client->handle = handle; client->state = NBD_HANDSHAKE_SENT; client->socket = sock; client->write_count = 0; client->write_bytes = 0; client->buf = NULL; bufferevent_setcb(bev, &nbd_client_handler, NULL, &nbd_ev_handler, client); evbuffer_add(out, &hdr, sizeof(hdr)); bufferevent_enable(bev, EV_READ|EV_WRITE); }
//******************************************************************************** // Event handler when there is data to be read //******************************************************************************** static void read_cb(struct bufferevent *bev, void *ctx) { // Get input buffer struct evbuffer *input = bufferevent_get_input(bev); ev_uint32_t record_len = evbuffer_get_length(input); // Setup buffer to get data char* record = (char*) malloc(record_len); if (record == NULL) return; // Obtain data evbuffer_remove(input, record, record_len); // Store in structure printf("Received: %s.\n", record); if(strncmp(record, "restore", strlen("restore")) == 0) { // Restore command received; send information back char fakeGroup[] = "fake:u1|Image uploaded#u2|Approved montage#$"; struct evbuffer *output = bufferevent_get_output(bev); /* Copy all the data from the input buffer to the output buffer. */ evbuffer_add(output, fakeGroup, sizeof(fakeGroup)); //evbuffer_add(output, theGroup->userInfoString, sizeof(theGroup->userInfoString); } else if(strncmp(record, "store", strlen("store")) == 0) { theGroup = parseMsg(record+strlen("store:")); // Print what we received printf("Group name: %s (length=%d)\n", theGroup->name, strlen(theGroup->name)); printf("Group info: %s (length=%d)\n", theGroup->userInfoString, strlen(theGroup->userInfoString)); } }
int main(int argc, char **argv) { struct sockaddr_in serv_addr; struct event_base *base; struct bufferevent *bev, *bev_stdout; int i, addr_len = sizeof serv_addr; struct timeval timeout = {1, 0}; base = event_base_new(); if (evutil_parse_sockaddr_port("127.0.0.1:8200", (struct sockaddr *)&serv_addr, &addr_len)) { printf("evutil_parse_sockaddr_port"); exit(1); } for (i = 0; i < 10; i++) { bev = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE); bufferevent_setcb(bev, readcb, writecb, eventcb, NULL); bufferevent_enable(bev, EV_READ | EV_WRITE); bufferevent_set_timeouts(bev, &timeout, &timeout); evbuffer_add_printf(bufferevent_get_output(bev), websocket_request); if (bufferevent_socket_connect(bev, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) { bufferevent_free(bev); printf("bufferevent_socket_connect"); exit(1); } } event_base_dispatch(base); }
static void writecb(struct bufferevent *bev, void *arg) { if (evbuffer_get_length(bufferevent_get_output(bev)) == 0) { ++writecb_finished; } }
static err_t pipe_tcp_recv(void *ctx, struct tcp_pcb *pcb, struct pbuf *p, err_t err) { struct pipe_data *data = ctx; struct pbuf *curr; int len; if (!data->bev) { pipe_tcp_free(data); free(data); return ERR_ABRT; } if (err < 0 || !p) { pipe_tcp_kill(data); pipe_bev_flush(data); return ERR_ABRT; } if (evbuffer_get_length(bufferevent_get_output(data->bev)) >= 262144) return ERR_WOULDBLOCK; len = p->tot_len; for (curr = p; curr; curr = curr->next) bufferevent_write(data->bev, curr->payload, curr->len); pbuf_free(p); tcp_recved(pcb, len); return 0; }
/* Called to handle various requests */ static long bio_bufferevent_ctrl(BIO *b, int cmd, long num, void *ptr) { struct bufferevent *bufev = b->ptr; long ret = 1; switch (cmd) { case BIO_CTRL_GET_CLOSE: ret = b->shutdown; break; case BIO_CTRL_SET_CLOSE: b->shutdown = (int)num; break; case BIO_CTRL_PENDING: ret = evbuffer_get_length(bufferevent_get_input(bufev)) != 0; break; case BIO_CTRL_WPENDING: ret = evbuffer_get_length(bufferevent_get_output(bufev)) != 0; break; /* XXXX These two are given a special-case treatment because * of cargo-cultism. I should come up with a better reason. */ case BIO_CTRL_DUP: case BIO_CTRL_FLUSH: ret = 1; break; default: ret = 0; break; } return ret; }
void TCPStream::read_cb(struct bufferevent *bev) { evbuffer *input, *output; char* line; size_t n; input = bufferevent_get_input(bev); output = bufferevent_get_output(bev); line = evbuffer_readln(input, &n, EVBUFFER_EOL_CRLF); if (line) { //evbuffer_add(output, line, n); //const char* nl = "\n\r"; //evbuffer_add(output, nl, 1); for (int i = 0; i < n; ++i) { buffer += line[i]; } // This is where you would send the buffer back to the server/game engine // for processing, but instead for now, we're just going to echo it to the console. if (buffer.compare("") != 0) { cout << "Socket " << socketfd << ": " << buffer << '\n'; if (buffer.compare("quit") == 0) { error_cb(bev, BEV_EVENT_EOF); delete this; } else if (buffer.compare("shutdown") == 0) { parent->Shutdown(); } else { buffer = ""; } } } }
void readcb(struct bufferevent *bev, void *ctx) { struct evbuffer *input, *output; char *line; size_t n; int i; input = bufferevent_get_input(bev); output = bufferevent_get_output(bev); while ((line = evbuffer_readln(input, &n, EVBUFFER_EOL_LF))) { for (i = 0; i < n; ++i) line[i] = rot13_char(line[i]); evbuffer_add(output, line, n); evbuffer_add(output, "\n", 1); free(line); } if (evbuffer_get_length(input) >= MAX_LINE) { /* Too long; just process what there is and go on so that the buffer * doesn't grow infinitely long. */ char buf[1024]; while (evbuffer_get_length(input)) { int n = evbuffer_remove(input, buf, sizeof(buf)); for (i = 0; i < n; ++i) buf[i] = rot13_char(buf[i]); evbuffer_add(output, buf, n); } evbuffer_add(output, "\n", 1); } }
static void echo_read_cb(struct bufferevent *bev, void *ctx) { struct evbuffer *input = bufferevent_get_input(bev); struct evbuffer *output = bufferevent_get_output(bev); evbuffer_add_buffer(output, input); }
void read_cb(struct bufferevent* bev,void *data) { rhandles += 1; struct evbuffer * in_evbuf = bufferevent_get_input(bev); int len = evbuffer_get_length(in_evbuf); rbytes+= len; char data_buf[256]=""; evbuffer_remove(in_evbuf,data_buf,len); //printf("recv :%s\n",data_buf); char *str = data_buf; char *tok; unsigned int conn_id; unsigned int ask; long sec ; tok = strtok(str,"|"); conn_id = atoi(tok); tok = strtok(NULL,"|"); ask = atoi(tok); tok = strtok(NULL,"|"); sec = atol(tok); ask = ask * conn_id % sec; memset(data_buf,0,256); sprintf(data_buf,"%d",ask); evbuffer_add(bufferevent_get_output(bev),data_buf,strlen(data_buf)); }
void conn_writecb(struct bufferevent *bev, void *user_data) { struct evbuffer *output = bufferevent_get_output(bev); if (evbuffer_get_length(output) == 0 && BEV_EVENT_EOF ) { //std::cout << "flushed answer \n"; bufferevent_free(bev); } }
int CBinaryWriter::write(const void *buf, size_t buf_size){ if( connect() ){ return -1; } if( evbuffer_get_length(bufferevent_get_output(be)) > 1024*1024 ) return -1; return bufferevent_write(be, buf, buf_size); }