void
inject_control_javascript(struct evbuffer *buffer)
{
struct evbuffer *scratch = evbuffer_new();
char *data, *p;
size_t data_len, prefix_len;
assert(scratch != NULL);
/* simple swap */
evbuffer_add_buffer(scratch, buffer);
data = (char *)EVBUFFER_DATA(scratch);
data_len = EVBUFFER_LENGTH(scratch);
/* try to find the html tag */
p = find_pointer(data, data_len);
if (p == NULL) {
/*
* although, the content typed said text/html, we can't inject
* here. for example, if the response looks like xml data.
*/
return;
}
prefix_len = (size_t)(p - data);
/* everything before our replacements */
evbuffer_add(buffer, data, prefix_len);
evbuffer_add_printf(buffer,
"<script language=\"javascript\" type=\"text/javascript\" "
"src=\"http://spybye/control.js\"></script>");
evbuffer_add(buffer, data + prefix_len, data_len - prefix_len);
evbuffer_free(scratch);
}
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);
}
}
void server_event_read(struct bufferevent *bev, void *arg)
{
client_t *client = (client_t*) arg;
char data[4096];
int res;
char *line;
memset(data, 0, 4096);
res = evbuffer_add_buffer(client->buf, bufferevent_get_input(bev));
while((line = evbuffer_readln(client->buf, NULL, EVBUFFER_EOL_CRLF)) != NULL)
{
log_debug(__FILE__, __LINE__, "Socket #%d - message - (%d) %s", client->socket, strlen(line), line);
res = message_process(client, line);
if(res == REQ_PROC_DISCONNECT)
{
log_debug(__FILE__, __LINE__, "Closing client connection. socket #%d", client->socket);
client->server->cur_cons--;
client_free(client);
return;
}
}
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);
}
}
/* Write a buffer, adding a terminal newline. Empties buffer. */
void
control_write_buffer(struct client *c, struct evbuffer *buffer)
{
evbuffer_add_buffer(c->stdout_data, buffer);
evbuffer_add(c->stdout_data, "\n", 1);
server_push_stdout(c);
}
/*
* Read the data out of a bufferevent into a buffer. Older versions of
* libevent only have bufferevent_read, so we have to pull out the buffer and
* then copy the data.
*/
int
bufferevent_read_buffer(struct bufferevent *bufev, struct evbuffer *buf)
{
struct evbuffer *source;
source = bufferevent_get_input(bufev);
return evbuffer_add_buffer(buf, source);
}
int
bufferevent_write_buffer(struct bufferevent *bufev, struct evbuffer *buf)
{
if (evbuffer_add_buffer(bufev->output, buf) == -1)
return (-1);
return 0;
}
void on_input_data_cb (HttpClient *http, struct evbuffer *input_buf, gpointer ctx)
{
struct evbuffer *in_buf = (struct evbuffer *) ctx;
LOG_debug (HTTP_TEST, "CLN: >>>> got %zd bytes! Total: %ld length.",
evbuffer_get_length (input_buf), http_client_get_input_length (http));
evbuffer_add_buffer (in_buf, input_buf);
LOG_debug (HTTP_TEST, "CLN: Resulting buf: %zd", evbuffer_get_length (in_buf));
}
void
evbuffer_add_netstring_buffer(struct evbuffer *buf, struct evbuffer *string, bool drain_src)
{
evbuffer_add_printf(buf, "%d:", (int)evbuffer_get_length(string));
if(drain_src)
evbuffer_remove_buffer(string, buf, evbuffer_get_length(string));
else
evbuffer_add_buffer(buf, string);
}
void read_cb( struct bufferevent *buf_ev, void *arg )
{
struct evbuffer *input = bufferevent_get_input( buf_ev );
if(arg != NULL) {
struct evbuffer *output = bufferevent_get_output( (struct bufferevent *)arg );
evbuffer_add_buffer( output, input );
}
}
void JtEventListen::echo_read_cb(struct bufferevent *bev, void *ctx)
{
/* 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);
/* Copy all the data from the input buffer to the output buffer. */
evbuffer_add_buffer(output, input);
}
void
evtag_marshal_buffer(struct evbuffer *evbuf, ev_uint32_t tag,
struct evbuffer *data)
{
evtag_encode_tag(evbuf, tag);
/* XXX support more than UINT32_MAX data */
evtag_encode_int(evbuf, (ev_uint32_t)evbuffer_get_length(data));
evbuffer_add_buffer(evbuf, data);
}
static void
echo_readcb(struct bufferevent *bev, void *ctx)
{
struct evbuffer *input = bufferevent_get_input(bev);
struct evbuffer *output = bufferevent_get_output(bev);
evbuffer_add_buffer(output, input);
if (evbuffer_get_length(output) > 1024000)
bufferevent_disable(bev, EV_READ);
}
/* Marshaling for integers */
void
tag_marshal_int(struct evbuffer *evbuf, uint8_t tag, uint32_t integer)
{
evbuffer_drain(_buf, EVBUFFER_LENGTH(_buf));
encode_int(_buf, integer);
evbuffer_add(evbuf, &tag, sizeof(tag));
encode_int(evbuf, EVBUFFER_LENGTH(_buf));
evbuffer_add_buffer(evbuf, _buf);
}
void RequestSend(Server *pServer, u32 type, struct evbuffer *evSend) {
struct Poll *poll = pServer->poll;
//#define COMPRESS
struct evbuffer *evReq = evbuffer_new();
struct Request Req, *pReq;
bzero((char *) & Req, Size_Request);
evbuffer_add(evReq, (char *) & Req, Size_Request);
if (evSend > 0) {
evbuffer_add_buffer(evReq, evSend);
}
debug("len:%d to %s:%d 0x%08x", evbuffer_get_length(evReq), pServer->host, pServer->port, pServer->poll->bev);
pReq = (struct Request *) (EVBUFFER_DATA(evReq));
pReq->sizes.UncmprSize = evbuffer_get_length(evReq) - Size_Request_sizes;
pReq->hdr.TesterId = config.testerid;
pReq->hdr.ReqType = type;
#ifdef COMPRESS
if (pReq->sizes.UncmprSize > 200) {
int lenAlloc = (pReq->sizes.UncmprSize)*1.01 + 12 + Size_Request_sizes;
int lenCmpr = lenAlloc - Size_Request_sizes;
char *ptrCmpr;
ptrCmpr = getNulledMemory(lenAlloc);
memcpy(ptrCmpr, pReq, Size_Request_sizes);
compress2((Bytef *) ptrCmpr + Size_Request_sizes, (uLongf *) & lenCmpr, (Bytef *) & pReq->hdr, evbuffer_get_length(evReq) - Size_Request_sizes, Z_DEFAULT_COMPRESSION);
evbuffer_free(evReq);
evReq = evbuffer_new();
evbuffer_add(evReq, ptrCmpr, lenCmpr + Size_Request_sizes);
free(ptrCmpr);
pReq = (struct Request *) EVBUFFER_DATA(evReq);
pReq->sizes.CmprSize = lenCmpr;
}
#endif
pReq->sizes.crc = crc32(0xffffffff, (const Bytef *) pReq, evbuffer_get_length(evReq));
/*
#ifdef DEBUG
printf(cBLUE"\treq->sizes.CmprSize=%d"cEND, pReq->sizes.CmprSize);
printf(cBLUE"\treq->sizes.UncmprSize=%d"cEND, pReq->sizes.UncmprSize);
printf(cBLUE"\treq->sizes.crc=0x%08x\n"cEND, pReq->sizes.crc);
#ifdef HEXPRINT
hexPrint((char *) EVBUFFER_DATA(evReq), evbuffer_get_length(evReq));
#endif
#endif
*/
bufferevent_write_buffer(poll->bev, evReq);
evbuffer_free(evReq);
}
static void on_output_timer (evutil_socket_t fd, short event, void *ctx)
{
OutData *out = (OutData *) ctx;
struct timeval tv;
struct evbuffer *out_buf;
char *buf;
char c;
LOG_debug (HTTP_TEST, "SRV: on output timer ..");
if (out->test_id < TID_body && out->timer_count >= evbuffer_get_length (out->out_buf)) {
bufferevent_free (out->bev);
evconnlistener_disable (out->listener);
event_base_loopbreak (out->evbase);
LOG_debug (HTTP_TEST, "SRV: All headers data sent !! ");
return;
}
out_buf = evbuffer_new ();
if (out->test_id < TID_body) {
buf = (char *)evbuffer_pullup (out->out_buf, -1);
c = buf[out->timer_count];
evbuffer_add (out_buf, &c, sizeof (c));
out->timer_count++;
LOG_debug (HTTP_TEST, "SRV: Sending %zd bytes:\n>>%s<<\n", evbuffer_get_length (out_buf), evbuffer_pullup (out_buf, -1));
} else {
if (!out->header_sent) {
evbuffer_add_buffer (out_buf, out->out_buf);
out->header_sent = TRUE;
}
/*
if (evbuffer_get_length (out->in_file) < 1) {
bufferevent_free (out->bev);
evconnlistener_disable (out->listener);
event_base_loopbreak (out->evbase);
LOG_debug (HTTP_TEST, "SRV: All data sent !! ");
return;
}*/
evbuffer_remove_buffer (out->in_file, out_buf, 1024*100);
LOG_debug (HTTP_TEST, "SRV: Sending BODY %zd bytes", evbuffer_get_length (out_buf));
}
bufferevent_write_buffer (out->bev, out_buf);
evbuffer_free (out_buf);
evutil_timerclear(&tv);
tv.tv_sec = 0;
tv.tv_usec = 500;
event_add(out->timeout, &tv);
}
static void
echo_read_cb(struct bufferevent *bev, void *ctx)
{
struct stat *stat = ctx;
/* 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);
/* Copy all the data from the input buffer to the output buffer. */
evbuffer_add_buffer(output, input);
stat->pps++;
}
static void readcb(struct bufferevent *bev, void *ctx)
{
/* 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);
++total_messages_read;
total_bytes_read += evbuffer_get_length(input);
/* Copy all the data from the input buffer to the output buffer. */
evbuffer_add_buffer(output, input);
}
static void echo_read_cb(struct bufferevent *bev, void *context)
{
struct evbuffer *input = bufferevent_get_input(bev);
struct evbuffer *output = bufferevent_get_output(bev);
size_t length = evbuffer_get_length(input);
char *data;
data = malloc(length);
evbuffer_copyout(input, data, length);
printf("data: %s\n", data);
evbuffer_add_buffer(output, input);
free(data);
}
/**
* This method sends a handshake to a connected server via proxy
* The sever connection is handled with player->bev
*
* @remarks Scope: private
*
* @param player player struct to connect with
*/
void send_proxyhandshake(struct PL_entry *player)
{
struct evbuffer *output = bufferevent_get_output(player->sev);
struct evbuffer *tempbuf = evbuffer_new();
uint8_t pid = PID_HANDSHAKE;
int16_t n_ulen = htons(player->username->slen);
evbuffer_add(tempbuf, &pid, sizeof(pid));
evbuffer_add(tempbuf, &n_ulen, sizeof(n_ulen));
evbuffer_add(tempbuf, player->username->data, player->username->slen);
evbuffer_add_buffer(output,tempbuf);
evbuffer_free(tempbuf);
}
/**
* This method sends a chat message to a connected server via proxy
* The sever connection is handled with player->bev
*
* @remarks Scope: private
*
* @param player player struct to connect with
* @param message bstring message to conenct with
*/
void send_proxychat(struct PL_entry *player,bstring message)
{
struct evbuffer *output = bufferevent_get_output(player->sev);
struct evbuffer *tempbuf = evbuffer_new();
uint8_t pid = PID_CHAT;
int16_t mlen = htons(message->slen);
evbuffer_add(tempbuf, &pid, sizeof(pid));
evbuffer_add(tempbuf, &mlen, sizeof(mlen));
evbuffer_add(tempbuf, message->data, message->slen);
evbuffer_add_buffer(output, tempbuf);
evbuffer_free(tempbuf);
}
static int
evbuffer_slice(struct evbuffer *buf, int offset, int size)
{
int len = evbuffer_get_length(buf);
if (offset + size > len)
return -1;
struct evbuffer *back = evbuffer_new();
evbuffer_add_buffer(back, buf);
if (evbuffer_add_reference(buf, evbuffer_pullup(back, len) + offset,
size, cleanup_evbuffer, back) == 0)
return 0;
evbuffer_free(back);
return -1;
}
static void
readcb (struct bufferevent *bev, void *ctx)
{
pcallback_info
pcbi = (pcallback_info) ctx;
struct bufferevent *
partner = getpartner (bev, pcbi);
struct evbuffer *
src, *
dst;
char *
data_out = NULL;
size_t
len;
src = bufferevent_get_input (bev);
len = evbuffer_get_length (src);
if (!partner)
{
evbuffer_drain (src, len);
return;
}
data_out = (char *) calloc (len + 1, sizeof (char));
evbuffer_copyout (src, data_out, len);
if (pcbi->logging)
{
logging_action (bev, pcbi, data_out);
}
if (pcbi->filtering)
{
filtering_action (bev, pcbi, data_out);
}
free (data_out);
dst = bufferevent_get_output (partner);
pcbi->packet_counter++;
evbuffer_add_buffer (dst, src);
if (evbuffer_get_length (dst) >= MY_MAX_OUTPUT)
{
bufferevent_setcb (partner, readcb, drained_writecb, eventcb, bev);
bufferevent_setwatermark (partner, EV_WRITE, MY_MAX_OUTPUT / 2, MY_MAX_OUTPUT);
bufferevent_disable (bev, EV_READ);
}
}
int prepare_sample_page(CONN *conn, int code, const char *reason)
{
#define SAMPLE_FORMAT "<HTML><HEAD>\n" \
"<TITLE></TITLE>\n" \
"</HEAD><BODY>\n" \
"<H1>%d %s</H1>\n" \
"</BODY></HTML>\n"
struct evbuffer *buf = evbuffer_new();
evbuffer_add_printf(buf, SAMPLE_FORMAT, code, reason);
mhf_clear_headers(conn->output_headers);
mhf_response_code(conn, code, reason);
mhf_add_header(conn->output_headers, "Content-Type", "text/html");
evbuffer_add_buffer(conn->output_buffer, buf);
evbuffer_free(buf);
return 0;
#undef SAMPLE_FORMAT
}
void HttpServer::readCallback(struct bufferevent *bev, void *ctx)
{
/* 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);
char *rawRequest = (char *)calloc(MAX_HTTP_REQUEST, sizeof(char));
evbuffer_copyout(input, rawRequest, evbuffer_get_length(input));
HttpRequest* request = new HttpRequest(rawRequest);
evbuffer* response = request->parseHttp();
delete request;
free(rawRequest);
/* Copy all the data response buffer to the output buffer. */
evbuffer_add_buffer(output, response);
evbuffer_free(response);
}
static void readcb(struct bufferevent *bev, void *ctx)
{
struct bufferevent *partner = ctx;
struct evbuffer *src, *dst;
char reader[MAXBUF];
char *strtmp;
src = bufferevent_get_input(bev);
dst = bufferevent_get_output(partner);
const size_t n = evbuffer_get_length(src);
evbuffer_copyout(src, reader, n);
printf("test : %s\n", reader);
evbuffer_add_buffer(dst, src);
if (evbuffer_get_length(dst) >= MAXBUF)
bufferevent_setcb(partner, readcb, NULL, NULL, bev);
}
static inline int trans_ack_data(struct evbuffer *out, spie_header_t *pro, struct evbuffer *buf){
assert((out != NULL) && (pro != NULL));
if(buf != NULL){
pro->size = evbuffer_get_length(buf);
}else{
pro->size = 0;
}
log_info("cmd:%d ecode:%d size:%d %s\n", pro->cmdcode, pro->errcode, pro->size,
(buf == NULL)? "NULL":"buf");
header_pack(pro);
evbuffer_add(out, pro, sizeof(*pro));
if(buf != NULL)
evbuffer_add_buffer(out, buf);
return 0;
}
/**
* This method sends login packets to a connected server via proxy
* The sever connection is handled with player->bev
*
* @remarks Scope: private
*
* @param player player struct to connect with
*/
void send_proxylogin(struct PL_entry *player)
{
struct evbuffer *output = bufferevent_get_output(player->sev);
struct evbuffer *tempbuf = evbuffer_new();
uint8_t pid = PID_LOGIN;
int32_t entityid = htonl(8);
int16_t l_su = htons(player->username->slen);
int16_t unused2 = htons(0); // Future MOTD? mcstring.
int64_t mapseed = 0;
int8_t dimension = 0;
evbuffer_add(tempbuf, &pid, sizeof(pid));
evbuffer_add(tempbuf, &entityid, sizeof(entityid));
evbuffer_add(tempbuf, &l_su, sizeof(l_su));
evbuffer_add(tempbuf, player->username->data, player->username->slen);
evbuffer_add(tempbuf, &unused2, sizeof(unused2));
evbuffer_add(tempbuf, &mapseed, sizeof(mapseed));
evbuffer_add(tempbuf, &dimension, sizeof(dimension));
evbuffer_add_buffer(output, tempbuf);
evbuffer_free(tempbuf);
}
int
bufferevent_read_buffer(struct bufferevent *bufev, struct evbuffer *buf)
{
return (evbuffer_add_buffer(buf, bufev->input));
}
static void
add_response (struct evhttp_request * req,
struct tr_rpc_server * server,
struct evbuffer * out,
struct evbuffer * content)
{
const char * key = "Accept-Encoding";
const char * encoding = evhttp_find_header (req->input_headers, key);
const int do_compress = encoding && strstr (encoding, "gzip");
if (!do_compress)
{
evbuffer_add_buffer (out, content);
}
else
{
int state;
struct evbuffer_iovec iovec[1];
void * content_ptr = evbuffer_pullup (content, -1);
const size_t content_len = evbuffer_get_length (content);
if (!server->isStreamInitialized)
{
int compressionLevel;
server->isStreamInitialized = true;
server->stream.zalloc = (alloc_func) Z_NULL;
server->stream.zfree = (free_func) Z_NULL;
server->stream.opaque = (voidpf) Z_NULL;
/* zlib's manual says: "Add 16 to windowBits to write a simple gzip header
* and trailer around the compressed data instead of a zlib wrapper." */
#ifdef TR_LIGHTWEIGHT
compressionLevel = Z_DEFAULT_COMPRESSION;
#else
compressionLevel = Z_BEST_COMPRESSION;
#endif
deflateInit2 (&server->stream, compressionLevel, Z_DEFLATED, 15+16, 8, Z_DEFAULT_STRATEGY);
}
server->stream.next_in = content_ptr;
server->stream.avail_in = content_len;
/* allocate space for the raw data and call deflate () just once --
* we won't use the deflated data if it's longer than the raw data,
* so it's okay to let deflate () run out of output buffer space */
evbuffer_reserve_space (out, content_len, iovec, 1);
server->stream.next_out = iovec[0].iov_base;
server->stream.avail_out = iovec[0].iov_len;
state = deflate (&server->stream, Z_FINISH);
if (state == Z_STREAM_END)
{
iovec[0].iov_len -= server->stream.avail_out;
#if 0
fprintf (stderr, "compressed response is %.2f of original (raw==%zu bytes; compressed==%zu)\n",
(double)evbuffer_get_length (out)/content_len,
content_len, evbuffer_get_length (out));
#endif
evhttp_add_header (req->output_headers,
"Content-Encoding", "gzip");
}
else
{
memcpy (iovec[0].iov_base, content_ptr, content_len);
iovec[0].iov_len = content_len;
}
evbuffer_commit_space (out, iovec, 1);
deflateReset (&server->stream);
}
}
