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