int bufferevent_write(struct bufferevent *bufev, const void *data, size_t size) { int res; res = evbuffer_add(bufev->output, data, size); if (res == -1) return (res); if (size > 0 && (bufev->enabled & EV_WRITE)) bufferevent_add(&bufev->ev_write, bufev->timeout_write); return (res); }
void buffered_on_read(struct bufferevent *bev, void *arg) { client_t *client = (client_t *)arg; char data[4096]; int nbytes; while (bev->input->off > 0) { nbytes = (bev->input->off > 4096) ? 4096 : bev->input->off; evbuffer_remove(bev->input, data, nbytes); evbuffer_add(client->output_buffer, data, nbytes); } if (bufferevent_write_buffer(bev, client->output_buffer)) { errorOut("Error sending data to client on fd %d\n", client->fd); closeClient(client); } }
void Subscriber::send_old_msgs(){ std::vector<std::string>::iterator it = channel->msg_list.end(); int msg_seq_min = channel->seq_next - channel->msg_list.size(); if (Channel::SEQ_GT(this->seq_next, channel->seq_next) || Channel::SEQ_LT(this->seq_next, msg_seq_min)) { this->seq_next = msg_seq_min; } log_info("send old msg:[%d, %d]", this->seq_next, channel->seq_next - 1); it -= (channel->seq_next - this->seq_next); struct evbuffer *buf = evbuffer_new(); if (this->type == POLL){ if (!this->callback.empty()){ evbuffer_add_printf(buf, "%s(", this->callback.c_str()); } evbuffer_add_printf(buf, "["); for (; it != channel->msg_list.end(); it++, this->seq_next++) { std::string &msg = *it; evbuffer_add_printf(buf, "{\"type\":\"data\",\"cname\":\"%s\",\"seq\":%d,\"content\":\"%s\"}", this->channel->name.c_str(), this->channel->seq_next, msg.c_str()); if (this->seq_next != channel->seq_next - 1) { evbuffer_add(buf, ",", 1); } } evbuffer_add_printf(buf, "]"); if (!this->callback.empty()) { evbuffer_add_printf(buf, ");"); } evbuffer_add_printf(buf, "\n"); evhttp_send_reply_chunk(this->req, buf); this->close(); } else if (this->type == IFRAME || this->type == STREAM){ for (; it != channel->msg_list.end(); it++, this->seq_next++) { std::string &msg = *it; this->send_chunk(this->seq_next, "data", msg.c_str()); } } evbuffer_free(buf); }
void SocketLibEvent::write(const char* data, size_t data_len) { if (closing_) return; auto output = bufferevent_get_output(bev_); auto retval = evbuffer_add(output, data, data_len); if (retval != 0) { onSocketClose(true); return; } if (evbuffer_get_length(output) > MAX_OUTPUT_BUFFER_SIZE) { /* LogApiSock("WsApiEnviar MAX_OUTPUT_BUFFER_SIZE"); */ onSocketClose(true); return; } }
static void nbd_old_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_old_handshake hdr = { .magic = htobe64(GAMMARAY_NBD_MAGIC), .protocol = htobe64(GAMMARAY_NBD_OLD_PROTOCOL), .size = htobe64( ((struct nbd_handle*) handle)->size), .flags = htobe32(NBD_FLAG_HAS_FLAGS | NBD_FLAG_SEND_FLUSH | NBD_FLAG_SEND_FUA | NBD_FLAG_SEND_TRIM), .zeros = {0} }; struct nbd_client* client = (struct nbd_client*) malloc(sizeof(struct nbd_client)); client->handle = handle; client->state = NBD_DATA_PUSHING; 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); } static void nbd_event_error(struct evconnlistener* conn, void* ptr) { struct event_base* eb = evconnlistener_get_base(conn); event_base_loopexit(eb, NULL); } void nbd_run_loop(struct nbd_handle* handle) { event_base_dispatch(handle->eb); }
void COnlineConnManager::SendPacketToClent(evutil_socket_t fd, const char* buf, int iBufSize) { if (!buf || iBufSize == 0 || iBufSize > emMaxBuffLen) { return; } Conn *pConn = GetConn(fd); if (pConn) { if (pConn->bufev) { struct evbuffer * output = bufferevent_get_output(pConn->bufev); evbuffer_add(output, buf, iBufSize); printf("LOGIN_SC_IN has send!\n"); } } }
void new_connection(struct config *conf) { struct conn_state *st = calloc(1, sizeof(struct conn_state)); st->state = WAIT_HELLO; st->conf = conf; st->sock = socket(AF_INET, SOCK_STREAM, 0); int optval = 1; setsockopt(st->sock, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)); evutil_make_socket_nonblocking(st->sock); struct bufferevent *bev; bev = bufferevent_socket_new(conf->base, st->sock, BEV_OPT_CLOSE_ON_FREE); // TODO: error check struct timeval read_to; read_to.tv_sec = TIMEOUT_SECS; read_to.tv_usec = 0; bufferevent_set_timeouts(bev, &read_to, &read_to); st->bev = bev; // Generate client random generate_nonce(conf, st->nonce); generate_client_random(conf->prev_block_hash, conf->merkle_root, st->nonce, st->client_random); // Generte client hello and send it uint8_t *client_hello; size_t client_hello_len = make_client_hello(st->client_random, &client_hello); evbuffer_add(bufferevent_get_output(bev), client_hello, client_hello_len); free(client_hello); bufferevent_setcb(bev, readcb, NULL, eventcb, st); // TODO: error check bufferevent_enable(bev, EV_READ | EV_WRITE); if (bufferevent_socket_connect(bev, (struct sockaddr *)&conf->sin, sizeof(conf->sin)) < 0) { perror("socket connected failed: "); printf("Run `sudo sysctl -w net.ipv4.tcp_tw_recycle=1`\n"); cleanup(st); } conf->num_connections++; }
// 参考sock_recv ssize_t sock_send(int fd, char *buf, size_t size) { coro_sock *sock = find_sock_by_fd(fd); if ( !sock ) { return -1; } sock->op = WRITING; ssize_t status = 0; uthread_t cur = coro_current_uthread(); if ( TEST_WAIT_WRITE(sock->status) ) { if ( TEST_EOF(sock->status) ) { status = -1; } else { set_pending_status(sock, keep_status, cur, set_wait_write_status); sock->writequeue->push(cur); status = coro_schedule_uthread(cur, 0); } } int ret = status; sock = find_sock_by_fd(fd); if ( status >= 0 && sock ) { // 1. 协程没有进行调度,那么肯定可写 // 2. 协程唤醒以后 // 1) 写事件成功,那么一定可写 // 2) 写事件失败,那么status < 0,不可写 // 这种情况下,一定执行过调度的环节 // 调度环节执行前已经设置了等待写状态 // 因此,status < 0的情况不需要设置了 SET_WRITE(sock->status); clear_pending_status(sock, cur); size_t cnt = 0; struct evbuffer *output; bufferevent * bev = sock->bev; output = bufferevent_get_output(bev); if ( sock->hwm ) { size_t buflen = evbuffer_get_length(output); cnt = sock->hwm - buflen; size = size > cnt ? cnt : size; } ret = evbuffer_add(output, buf, size); ret = !ret ? size : -1; } return ret; }
void HttpServer::readCb(bufferevent *bev, void *ctx) { size_t length = evbuffer_get_length(bufferevent_get_input(bev)); char *data = (char *) malloc(sizeof(char) * length); evbuffer_remove(bufferevent_get_input(bev), data, length); HttpRequestParser requestParser; HttpRequest request; HttpResponse response; requestParser.reset(); requestParser.parse(request, data, length); HttpRequestHandler requestHandler(rootDir_); requestHandler.handleRequest(&request, &response); evbuffer_add(bufferevent_get_output(bev), response.toString().c_str(), response.toString().length()); free(data); }
static void server_flush_compression(client_t *client) { if (!client->compress) return; char buf[1024]; client->strm.next_in = NULL; client->strm.avail_in = 0; do { client->strm.next_out = (unsigned char*)buf; client->strm.avail_out = sizeof(buf); if (deflate(&client->strm, Z_SYNC_FLUSH) != Z_OK) { fprintf(stderr, "urgh. deflate (Z_SYNC_FLUSH) didn't return Z_OK"); // XXX: handle } evbuffer_add(client->out_buf, buf, sizeof(buf) - client->strm.avail_out); } while (client->strm.avail_out == 0); }
static void loud_writecb(struct bufferevent *bev, void *ctx) { struct client_state *cs = ctx; struct evbuffer *output = bufferevent_get_output(bev); char buf[1024]; #ifdef _WIN32 int r = rand() % 256; #else int r = random() % 256; #endif memset(buf, r, sizeof(buf)); while (evbuffer_get_length(output) < 8192) { evbuffer_add(output, buf, sizeof(buf)); cs->queued += sizeof(buf); } }
int feed_consume(struct feed *feed, struct evbuffer *buf) { char input[1024]; int removed; if (!feed->header_sent) { evbuffer_add(feed->sink, HEADER, strlen(HEADER)); feed->header_sent++; } while ((removed = evbuffer_remove(buf, input, sizeof(input))) > 0) { XML_Parse(feed->parser, input, removed, 0); /* TODO: Handle error. */ } return 0; }
void write_chunk(uint64_t chunkid, struct evhttp_request *req) { DBG(); struct evbuffer *input; struct evbuffer *evb = evbuffer_new(); if (evhttp_request_get_command(req) != EVHTTP_REQ_POST) { reply_error(req, HTTP_BADREQUEST, "should call write with POST"); return; } uint64_t start = 0, end; const char *range = evhttp_find_header(req->input_headers, "Range"); logging(LOG_DEUBG, "write Range Header: %s", range); if (range) { sscanf(range, "bytes=%" SCNu64 "-%" SCNu64, &start, &end); } input = req->input_buffer; hdd_chunk *chunk = hdd_create_chunk(chunkid, 0); //TODO int fd = open(chunk->path, O_WRONLY | O_CREAT, 0755); logging(LOG_DEUBG, "write seek to : %" PRIu64 "", start); logging(LOG_DEUBG, "evbuffer_get_length(input) = %d", evbuffer_get_length(input)); lseek(fd, start, SEEK_SET); if (-1 == fd) { reply_error(req, HTTP_INTERNAL, "could not open file : %s", chunk->path); return; } int rst = 0; while (evbuffer_get_length(input) && (rst = evbuffer_write(input, fd)) > 0) { ; } /*evbuffer_write(input, fd); */ close(fd); evbuffer_add(evb, "success", strlen("success")); evhttp_send_reply(req, HTTP_OK, "OK", evb); evbuffer_free(evb); }
static void http_send_reply_ok(struct evhttp_request *r, struct evkeyvalq *headers, char *data, int len, int allow_compress) { #ifdef HAVE_LIBZ char *compr = NULL; /* Gzipping files below 150 bytes can actually make them larger. */ if (len > 150 && allow_compress) { /* Consider returning a compressed version */ int compr_type = http_check_req_compressed(r); /* if (compr_type) hlog(LOG_DEBUG, "http_send_reply_ok, client supports transfer-encoding: %s", compr_type_strings[compr_type]); */ if (compr_type == HTTP_COMPR_GZIP) { /* for small files it's possible that the output is actually * larger than the input */ int oblen = len + 60; compr = hmalloc(oblen); int olen = http_compress_gzip(data, len, compr, oblen); /* If compression succeeded, replace buffer with the compressed one and free the * uncompressed one. Add HTTP header to indicate compressed response. * If the file got larger, send uncompressed. */ if (olen > 0 && olen < len) { data = compr; len = olen; evhttp_add_header(headers, "Content-Encoding", "gzip"); } } } #endif struct evbuffer *buffer = evbuffer_new(); evbuffer_add(buffer, data, len); evhttp_send_reply(r, HTTP_OK, "OK", buffer); evbuffer_free(buffer); #ifdef HAVE_LIBZ if (compr) hfree(compr); #endif }
bool TestExtNetwork::test_get_http_request_size() { //because no g_context in unit test, //instead of testing f_get_http_request_size(), //we test relevant code directly evhttp_request* r=evhttp_request_new(nullptr, nullptr); char* buf = "buffer"; evbuffer_add(r->input_buffer, buf, strlen(buf)); r->type=EVHTTP_REQ_POST; evhttp_add_header(r->input_headers, "Host", "www.facebook.com"); r->uri = "/index.php"; r->major=1; r->minor=1; r->remote_host="127.0.0.1"; r->remote_port=1234; LibEventTransport t(nullptr, r,0); VERIFY(t.getRequestSize()==58); return Count(true); }
void test_set( const struct mem_server *server ) { int ret = 0; char data[] = "some string data"; struct store_item item; item._exp_time = 0; NEW_ITEM_DATA( item._item, "TestSet", 0 ); evbuffer_add( STORE_ITEM_BUF( item ), data, strlen( data ) ); ret = mem_set( server, &item, 1 ); if( ret == MEM_STORED ) { printf( "test_set : stored.\n" ); } DEL_ITEM_DATA( item._item ); }
void proxycb(struct evhttp_request *req, void *arg) { struct evbuffer *buf; if ((buf = evbuffer_new()) == NULL) { printf("failed to create response buffer"); } else { tbuf resp = {0, NULL}; zs_http_pass_req(&resp, req, host, port, req->uri, NULL); printf("resp: {%d, %p}\n", resp.len, resp.data); if (resp.data!=NULL) printf("%s\n", resp.data); evbuffer_add(buf, resp.data, resp.len); evhttp_send_reply(req, HTTP_OK, "OK", buf); evbuffer_free(buf); if (resp.data!=NULL) free(resp.data); } }
int main(int argc, char **argv) { struct evbuffer *buf = evbuffer_new(); size_t n; const char *line, *str = "GET / HTTP/1.1\r\n" "Host: hello.world\r\n" "\r\n"; evbuffer_add(buf, str, strlen(str)); while (1) { line = evbuffer_readln(buf, &n, EVBUFFER_EOL_CRLF); printf("line=[%s], address=[%#x], n=%d\n", line, (unsigned int)line, n); if (NULL == line) { break; } free(line); } return 0; }
static void web_pipeline_stream_trickle(int fd, short events, void *arg) { struct evbuffer *evb = NULL; struct chunk_req_state *state = static_cast<chunk_req_state*>(arg); struct timeval when = { 0, 0 }; long unsigned int outlen; unsigned char *outbuf; when.tv_usec = state->delay * 1000; if ( state->closed ) { // free ! state->stream->setInput(NULL); delete state->stream; free(state); return; } if ( !state->stream->copy() ) { event_once(-1, EV_TIMEOUT, web_pipeline_stream_trickle, state, &when); return; } if ( state->stream->output_buffer->nChannels == 3 ) cvCvtColor(state->stream->output_buffer, state->stream->output_buffer, CV_BGR2RGB); ipl2jpeg(state->stream->output_buffer, &outbuf, &outlen); evb = evbuffer_new(); evbuffer_add_printf(evb, "--mjpegstream\r\n"); evbuffer_add_printf(evb, "Content-Type: image/jpeg\r\n"); evbuffer_add_printf(evb, "Content-Length: %lu\r\n\r\n", outlen); evbuffer_add(evb, outbuf, outlen); evhttp_send_reply_chunk(state->req, evb); evbuffer_free(evb); free(outbuf); event_once(-1, EV_TIMEOUT, web_pipeline_stream_trickle, state, &when); /** evhttp_send_reply_end(state->req); free(state); **/ }
static void drone_interval_timer_cb(evutil_socket_t fd, short what, void *arg) { struct job *job = arg; Drone__JobIntervalResult *interval; u_int64_t throughtput_kbs; struct packet_header *ph; u_int8_t *data; u_int8_t *buffer; u_int64_t packet_size; u_int64_t data_size; if (job->client == NULL) return; interval = &(job->intervalresults[job->cur_interval]); throughtput_kbs = interval->total_bytes_read / (job->request->interval * 1024); printf("[%5d] Messages: %8" PRIu64 ", Bytes: %12" PRIu64 ", Throughtput(KB/sec): %5" PRIu64 ", Connections: %6" PRIu64 "\n", job->cur_interval + 1, interval->total_messages_read, interval->total_bytes_read, throughtput_kbs, interval->total_sessions); data_size = drone__job_interval_result__get_packed_size(interval); packet_size = data_size + sizeof(struct packet_header); buffer = malloc(packet_size); ph = (struct packet_header *) buffer; data = buffer + sizeof(struct packet_header); ph->size = htonl(data_size); ph->type = TYPE_INTERVAL_PACKET; drone__job_interval_result__pack(interval, data); evbuffer_add(bufferevent_get_output(job->client->bev), buffer, packet_size); free(buffer); if (job->cur_interval < (job->total_intervals - 1)) job->cur_interval++; }
static void upload_progress_cb(evhtp_request_t *req, void *arg) { const char *progress_id; const char *callback; Progress *progress; GString *buf; progress_id = evhtp_kv_find (req->uri->query, "X-Progress-ID"); if (!progress_id) { seaf_warning ("[get pg] Progress id not found in url.\n"); evhtp_send_reply (req, EVHTP_RES_BADREQ); return; } callback = evhtp_kv_find (req->uri->query, "callback"); if (!callback) { seaf_warning ("[get pg] callback not found in url.\n"); evhtp_send_reply (req, EVHTP_RES_BADREQ); return; } pthread_mutex_lock (&pg_lock); progress = g_hash_table_lookup (upload_progress, progress_id); pthread_mutex_unlock (&pg_lock); if (!progress) { /* seaf_warning ("[get pg] No progress found for %s.\n", progress_id); */ evhtp_send_reply (req, EVHTP_RES_BADREQ); return; } /* Return JSONP formated data. */ buf = g_string_new (NULL); g_string_append_printf (buf, "%s({\"uploaded\": %lld, \"length\": %lld});", callback, progress->uploaded, progress->size); evbuffer_add (req->buffer_out, buf->str, buf->len); seaf_debug ("JSONP: %s\n", buf->str); evhtp_send_reply (req, EVHTP_RES_OK); g_string_free (buf, TRUE); }
void fileio_simple_upload (Application *app, const gchar *fname, const char *str, mode_t mode, FileIO_simple_on_upload_cb on_upload_cb, gpointer ctx) { FileIOSimpleUpload *fsim; fsim = g_new0 (FileIOSimpleUpload, 1); fsim->write_buf = evbuffer_new (); evbuffer_add (fsim->write_buf, str, strlen (str)); fsim->fname = g_strdup_printf ("/%s", fname); fsim->on_upload_cb = on_upload_cb; fsim->ctx = ctx; fsim->mode = mode; if (!client_pool_get_client (application_get_write_client_pool (app), fileio_simple_upload_on_con_cb, fsim)) { LOG_err (FIO_LOG, "Failed to get HTTP client !"); fsim->on_upload_cb (ctx, FALSE); fileio_simple_upload_destroy (fsim); } }
void evhtp_send_reply_chunk(evhtp_request_t * request, evbuf_t * buf) { evbuf_t * output; output = bufferevent_get_output(request->conn->bev); if (evbuffer_get_length(buf) == 0) { return; } if (request->chunked) { evbuffer_add_printf(output, "%x\r\n", (unsigned)evbuffer_get_length(buf)); } evhtp_send_reply_body(request, buf); if (request->chunked) { evbuffer_add(output, "\r\n", 2); } bufferevent_flush(request->conn->bev, EV_WRITE, BEV_FLUSH); }
static int artwork_read(char *filename, struct evbuffer *evbuf) { uint8_t buf[4096]; struct stat sb; int fd; int ret; fd = open(filename, O_RDONLY); if (fd < 0) { DPRINTF(E_WARN, L_ART, "Could not open artwork file '%s': %s\n", filename, strerror(errno)); return -1; } ret = fstat(fd, &sb); if (ret < 0) { DPRINTF(E_WARN, L_ART, "Could not stat() artwork file '%s': %s\n", filename, strerror(errno)); goto out_fail; } ret = evbuffer_expand(evbuf, sb.st_size); if (ret < 0) { DPRINTF(E_LOG, L_ART, "Out of memory for artwork\n"); goto out_fail; } while ((ret = read(fd, buf, sizeof(buf))) > 0) evbuffer_add(evbuf, buf, ret); close(fd); return 0; out_fail: close(fd); return -1; }
static enum bufferevent_filter_result bufferevent_input_filter(struct evbuffer *src, struct evbuffer *dst, ev_ssize_t lim, enum bufferevent_flush_mode state, void *ctx) { const unsigned char *buffer; int i; buffer = evbuffer_pullup(src, evbuffer_get_length(src)); for (i = 0; i < evbuffer_get_length(src); i += 2) { assert(buffer[i] == 'x'); evbuffer_add(dst, buffer + i + 1, 1); if (i + 2 > evbuffer_get_length(src)) break; } evbuffer_drain(src, i); return (BEV_OK); }
static char* makeURL( tr_webseed * w, const tr_file * file ) { char * ret; struct evbuffer * out = evbuffer_new( ); const char * url = w->url; const size_t url_len = strlen( url ); evbuffer_add( out, url, url_len ); /* if url ends with a '/', add the torrent name */ if( url[url_len - 1] == '/' && file->name ) tr_http_escape( out, file->name, strlen(file->name), FALSE ); ret = tr_strndup( EVBUFFER_DATA( out ), EVBUFFER_LENGTH( out ) ); evbuffer_free( out ); return ret; }
int evbuffer_add_buffer (struct evbuffer *outbuf, struct evbuffer *inbuf) { int res; /* Short cut for better performance */ if (outbuf->off == 0) { struct evbuffer tmp; size_t oldoff = inbuf->off; /* Swap them directly */ SWAP (&tmp, outbuf); SWAP (outbuf, inbuf); SWAP (inbuf, &tmp); /* * Optimization comes with a price; we need to notify the * buffer if necessary of the changes. oldoff is the amount * of data that we transfered from inbuf to outbuf */ if (inbuf->off != oldoff && inbuf->cb != NULL) (*inbuf->cb) (inbuf, oldoff, inbuf->off, inbuf->cbarg); if (oldoff && outbuf->cb != NULL) (*outbuf->cb) (outbuf, 0, oldoff, outbuf->cbarg); return (0); } res = evbuffer_add (outbuf, inbuf->buffer, inbuf->off); if (res == 0) { /* We drain the input buffer on success */ evbuffer_drain (inbuf, inbuf->off); } return (res); }
static size_t request_cb(char *ptr, size_t size, size_t nmemb, void *userdata) { size_t realsize; struct https_client_ctx *ctx; int ret; realsize = size * nmemb; ctx = (struct https_client_ctx *)userdata; ret = evbuffer_add(ctx->data, ptr, realsize); if (ret < 0) { DPRINTF(E_LOG, L_LASTFM, "Error adding reply from LastFM to data buffer\n"); return 0; } return realsize; }
static int url_evbuffer_write(URLContext *h, unsigned char *buf, int size) { struct evbuffer *evbuf; int ret; evbuf = (struct evbuffer *)h->priv_data; if (!evbuf) { DPRINTF(E_LOG, L_FFMPEG, "Write called on evbuffer URL with priv_data = NULL!\n"); return -1; } ret = evbuffer_add(evbuf, buf, size); return (ret == 0) ? size : -1; }
void telnet_readcb(struct bufferevent *bev, void *parameter) { struct argument *arg = parameter; struct evbuffer *input = EVBUFFER_INPUT(bev); struct telnet_state *state = arg->a_state; DFPRINTF((stderr, "%s: called\n", __func__)); if (arg->a_flags == 0) { int res = telnet_makeconnect(bev, arg); if (res == -1) { evbuffer_add(input, "", 1); printres(arg, arg->a_ports[0].port, EVBUFFER_DATA(input)); scanhost_return(bev, arg, 0); return; } else if (res == 1) { arg->a_flags = TELNET_WAITING_CONNECT; bufferevent_disable(bev, EV_READ); } } else if (arg->a_flags & TELNET_READING_CONNECT) { if (evbuffer_find(input, state->connect_wait, strlen(state->connect_wait)) == NULL) return; evbuffer_drain(input, EVBUFFER_LENGTH(input)); arg->a_flags = TELNET_WRITING_COMMAND; bufferevent_disable(bev, EV_READ); http_makerequest(bev, arg, socks_getword(), 0); } else if (arg->a_flags & TELNET_WAITING_RESPONSE) { int res = http_bufferanalyse(bev, arg); if (res == -1) return; if (res == 1) { postres(arg, state->response); scanhost_return(bev, arg, 1); } } return; }