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