/*
*
should use evbuffer_free(evb); to free this evbuffer
* */
static struct http_response * http_req(char * ip, int port, char * verb, char * path, char * data){
char port_str[6];
sprintf(port_str, "%d", port);
int cs = client_socket(ip, port_str);
char * request_buffer = alloca(100 + strlen(path)); // in stack do not need free
char response_buffer[1024*8];
sprintf(request_buffer, "%s %s HTTP/1.0\r\nContent-Length: %d\r\n\r\n%s\r\n\r\n", verb, path, strlen(data), data);
//sprintf(request_buffer, "GET %s HTTP/1.0\r\nUser-Agent: curl/7.19.7 (i486-pc-linux-gnu) libcurl/7.19.7 OpenSSL/0.9.8k zlib/1.2.3.3 libidn/1.15\r\n\r\n", path);
fprintf(stderr, "%s", request_buffer);
int rst = tcptowrite(cs, request_buffer, strlen(request_buffer) , 30000);
printf("tcptowrite rst: %d", rst);
int readed = 0;
struct evbuffer *evb = evbuffer_new();
/*evbuffer_read(evb, cs, 30);*/
while ((readed = tcptoread(cs, response_buffer, 1024*8, 30000)) > 0){
printf("readed len: %d \n", readed);
evbuffer_add(evb, response_buffer, readed);
}
struct evbuffer_ptr evbptr = evbuffer_search(evb, "\r\n\r\n", 4, NULL);
struct evbuffer *headers = evbuffer_new();
evbuffer_remove_buffer(evb, headers, evbptr.pos);
/*evbuffer_drain(evb, evbptr.pos);*/
tcpclose(cs);
int code = parse_response_status_code(headers);
return http_response_new(code, headers, evb);
}
static void
test_evbuffer_remove_buffer_with_empty(void *ptr)
{
struct evbuffer *src = evbuffer_new();
struct evbuffer *dst = evbuffer_new();
char buf[2];
evbuffer_validate(src);
evbuffer_validate(dst);
/* setup the buffers */
/* we need more data in src than we will move later */
evbuffer_add_reference(src, buf, sizeof(buf), no_cleanup, NULL);
evbuffer_add_reference(src, buf, sizeof(buf), no_cleanup, NULL);
/* we need one buffer in dst and one empty buffer at the end */
evbuffer_add(dst, buf, sizeof(buf));
evbuffer_add_reference(dst, buf, 0, no_cleanup, NULL);
evbuffer_validate(src);
evbuffer_validate(dst);
/* move three bytes over */
evbuffer_remove_buffer(src, dst, 3);
evbuffer_validate(src);
evbuffer_validate(dst);
end:
evbuffer_free(src);
evbuffer_free(dst);
}
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);
}
int
remove_data_from_buf(void) {
struct evbuffer *bufin = evbuffer_new();
struct evbuffer *bufout = evbuffer_new();
evbuffer_add(bufin, "bufin", 5);
evbuffer_add(bufout, "bufout", 6);
evbuffer_remove_buffer(bufin, bufout, 5);
assert(evbuffer_get_length(bufout)==11);
assert(evbuffer_get_length(bufin)==0);
}
static void drain_body(struct request_ctx *req, struct bufferevent *bev)
{
struct evbuffer *buf;
struct evbuffer *saved;
int before, after;
if (req->chunked && req->chunk_size == -1) {
/* Transfer-Encoding: chunked but we don't have size yet. */
if (read_chunk_size(req, bev) != 0) {
verbose(ERROR, "%s(): could not read chunk size!\n", __func__);
}
}
buf = bufferevent_get_input(bev);
saved = NULL;
before = evbuffer_get_length(buf);
if (req->chunked && req->chunk_size > 0 && req->chunk_left < before) {
/*
* Save the real buffer away and give the callback
* a temporary one, just the chunk that remains.
*/
saved = buf;
buf = evbuffer_new();
evbuffer_remove_buffer(saved, buf, req->chunk_left);
before = evbuffer_get_length(buf);
}
req->cb_ops->read(buf, req->cb_arg);
after = evbuffer_get_length(buf);
req->consumed += before - after;
req->chunk_left -= (before - after);
if (req->chunk_size > 0 && req->chunk_left == 0) {
/* We've consumed the whole chunk.
* Signal that we need another one.
*/
req->chunk_size = -1;
}
if (saved != NULL) {
/* saved is actually the buffer in bev */
evbuffer_prepend_buffer(saved, buf);
evbuffer_free(buf);
}
if ((req->chunked && req->chunk_size == 0) ||
(req->content_length > 0 && req->consumed == req->content_length)) {
set_read_state(req, READ_DONE);
}
}
int decode_in_ev(Gzb64* gzb64, struct evbuffer* input)
{
int contiguous;
while(evbuffer_get_length(input) > 0 )
{
contiguous = evbuffer_get_contiguous_space(input);
if( contiguous < evbuffer_get_length(input) )
{
evbuffer_remove_buffer(input, gzb64->decode_input_buffer, contiguous);
decode(gzb64, false);
} else
{
/* last (only) block */
evbuffer_remove_buffer(input, gzb64->decode_input_buffer, contiguous);
}
}
return decode(gzb64, true);
}
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
ret(struct bufferevent *bev, struct evbuffer *rsps) {
struct evbuffer *output = bufferevent_get_output(bev);
evbuffer_add_printf(output,
"HTTP/1.1 200 OK\r\n"
"Content-Type: text/html\r\n"
"Access-Control-Allow-Origin: *\r\n"
"Connection: close\r\n"
"Cache-Control: no-cache\r\n"
"Content-Length: %d\r\n\r\n", (int) evbuffer_get_length(rsps));
evbuffer_remove_buffer(rsps, output, 102400);
}
CDBuffer*
CD_BufferRemoveBuffer (CDBuffer* self)
{
struct evbuffer* buffer = evbuffer_new();
CDBuffer* result;
evbuffer_remove_buffer(self->raw, buffer, CD_BufferLength(self));
result = CD_WrapBuffer(buffer);
result->external = false;
return result;
}
static void
test_evbuffer(void *ptr)
{
static char buffer[512], *tmp;
struct evbuffer *evb = evbuffer_new();
struct evbuffer *evb_two = evbuffer_new();
size_t sz_tmp;
int i;
evbuffer_validate(evb);
evbuffer_add_printf(evb, "%s/%d", "hello", 1);
evbuffer_validate(evb);
tt_assert(evbuffer_get_length(evb) == 7);
tt_assert(!memcmp((char*)EVBUFFER_DATA(evb), "hello/1", 1));
evbuffer_add_buffer(evb, evb_two);
evbuffer_validate(evb);
evbuffer_drain(evb, strlen("hello/"));
evbuffer_validate(evb);
tt_assert(evbuffer_get_length(evb) == 1);
tt_assert(!memcmp((char*)EVBUFFER_DATA(evb), "1", 1));
evbuffer_add_printf(evb_two, "%s", "/hello");
evbuffer_validate(evb);
evbuffer_add_buffer(evb, evb_two);
evbuffer_validate(evb);
tt_assert(evbuffer_get_length(evb_two) == 0);
tt_assert(evbuffer_get_length(evb) == 7);
tt_assert(!memcmp((char*)EVBUFFER_DATA(evb), "1/hello", 7) != 0);
memset(buffer, 0, sizeof(buffer));
evbuffer_add(evb, buffer, sizeof(buffer));
evbuffer_validate(evb);
tt_assert(evbuffer_get_length(evb) == 7 + 512);
tmp = (char *)evbuffer_pullup(evb, 7 + 512);
tt_assert(tmp);
tt_assert(!strncmp(tmp, "1/hello", 7));
tt_assert(!memcmp(tmp + 7, buffer, sizeof(buffer)));
evbuffer_validate(evb);
evbuffer_prepend(evb, "something", 9);
evbuffer_validate(evb);
evbuffer_prepend(evb, "else", 4);
evbuffer_validate(evb);
tmp = (char *)evbuffer_pullup(evb, 4 + 9 + 7);
tt_assert(!strncmp(tmp, "elsesomething1/hello", 4 + 9 + 7));
evbuffer_validate(evb);
evbuffer_drain(evb, -1);
evbuffer_validate(evb);
evbuffer_drain(evb_two, -1);
evbuffer_validate(evb);
for (i = 0; i < 3; ++i) {
evbuffer_add(evb_two, buffer, sizeof(buffer));
evbuffer_validate(evb_two);
evbuffer_add_buffer(evb, evb_two);
evbuffer_validate(evb);
evbuffer_validate(evb_two);
}
tt_assert(evbuffer_get_length(evb_two) == 0);
tt_assert(evbuffer_get_length(evb) == i * sizeof(buffer));
/* test remove buffer */
sz_tmp = (size_t)(sizeof(buffer)*2.5);
evbuffer_remove_buffer(evb, evb_two, sz_tmp);
tt_assert(evbuffer_get_length(evb_two) == sz_tmp);
tt_assert(evbuffer_get_length(evb) == sizeof(buffer) / 2);
evbuffer_validate(evb);
if (memcmp(evbuffer_pullup(
evb, -1), buffer, sizeof(buffer) / 2) != 0 ||
memcmp(evbuffer_pullup(
evb_two, -1), buffer, sizeof(buffer) != 0))
tt_abort_msg("Pullup did not preserve content");
evbuffer_validate(evb);
/* testing one-vector reserve and commit */
{
struct evbuffer_iovec v[1];
char *buf;
int i, j, r;
for (i = 0; i < 3; ++i) {
r = evbuffer_reserve_space(evb, 10000, v, 1);
tt_int_op(r, ==, 1);
tt_assert(v[0].iov_len >= 10000);
tt_assert(v[0].iov_base != NULL);
evbuffer_validate(evb);
buf = v[0].iov_base;
for (j = 0; j < 10000; ++j) {
buf[j] = j;
}
evbuffer_validate(evb);
tt_int_op(evbuffer_commit_space(evb, v, 1), ==, 0);
evbuffer_validate(evb);
tt_assert(evbuffer_get_length(evb) >= 10000);
evbuffer_drain(evb, j * 5000);
evbuffer_validate(evb);
}
}
end:
evbuffer_free(evb);
evbuffer_free(evb_two);
}
