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);
}
