Lines Matching defs:evcon
177 struct evhttp_connection *evcon);
179 struct evhttp_connection *evcon);
181 struct evhttp_connection *evcon);
182 static void evhttp_request_dispatch(struct evhttp_connection* evcon);
183 static void evhttp_read_firstline(struct evhttp_connection *evcon,
185 static void evhttp_read_header(struct evhttp_connection *evcon,
356 /** Helper: called after we've added some data to an evcon's bufferevent's
361 evhttp_write_buffer(struct evhttp_connection *evcon,
367 evcon->cb = cb;
368 evcon->cb_arg = arg;
373 bufferevent_setcb(evcon->bufev,
377 evcon);
379 bufferevent_enable(evcon->bufev, EV_WRITE);
383 evhttp_send_continue_done(struct evhttp_connection *evcon, void *arg)
385 bufferevent_disable(evcon->bufev, EV_WRITE);
389 evhttp_send_continue(struct evhttp_connection *evcon,
392 bufferevent_enable(evcon->bufev, EV_WRITE);
393 evbuffer_add_printf(bufferevent_get_output(evcon->bufev),
396 evcon->cb = evhttp_send_continue_done;
397 evcon->cb_arg = NULL;
398 bufferevent_setcb(evcon->bufev,
402 evcon);
407 evhttp_connected(struct evhttp_connection *evcon)
409 switch (evcon->state) {
429 evhttp_make_header_request(struct evhttp_connection *evcon,
441 evbuffer_add_printf(bufferevent_get_output(evcon->bufev),
516 * and write the first HTTP response for req line to evcon.
519 evhttp_make_header_response(struct evhttp_connection *evcon,
523 evbuffer_add_printf(bufferevent_get_output(evcon->bufev),
557 && evcon->http_server->default_content_type) {
560 evcon->http_server->default_content_type);
591 * the response, if we're sending a response), and write them to evcon's
594 evhttp_make_header(struct evhttp_connection *evcon, struct evhttp_request *req)
597 struct evbuffer *output = bufferevent_get_output(evcon->bufev);
604 evhttp_make_header_request(evcon, req);
606 evhttp_make_header_response(evcon, req);
626 evhttp_connection_set_max_headers_size(struct evhttp_connection *evcon,
630 evcon->max_headers_size = EV_SIZE_MAX;
632 evcon->max_headers_size = new_max_headers_size;
635 evhttp_connection_set_max_body_size(struct evhttp_connection* evcon,
639 evcon->max_body_size = EV_UINT64_MAX;
641 evcon->max_body_size = new_max_body_size;
669 TAILQ_REMOVE(&req->evcon->requests, req, next);
673 req->evcon = NULL;
711 evhttp_request_free_(struct evhttp_connection *evcon, struct evhttp_request *req)
713 TAILQ_REMOVE(&evcon->requests, req, next);
717 /* Called when evcon has experienced a (non-recoverable? -NM) error, as
722 evhttp_connection_fail_(struct evhttp_connection *evcon,
726 struct evhttp_request* req = TAILQ_FIRST(&evcon->requests);
733 bufferevent_disable(evcon->bufev, EV_READ|EV_WRITE);
735 if (evcon->flags & EVHTTP_CON_INCOMING) {
745 evhttp_connection_free(evcon);
765 evhttp_request_free_(evcon, req);
768 evhttp_connection_reset_(evcon);
771 if (TAILQ_FIRST(&evcon->requests) != NULL)
772 evhttp_connection_connect_(evcon);
792 struct evhttp_connection *evcon = arg;
795 if (evcon->cb != NULL)
796 (*evcon->cb)(evcon, evcon->cb_arg);
807 evhttp_connection_done(struct evhttp_connection *evcon)
809 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
810 int con_outgoing = evcon->flags & EVHTTP_CON_OUTGOING;
816 TAILQ_REMOVE(&evcon->requests, req, next);
817 req->evcon = NULL;
819 evcon->state = EVCON_IDLE;
823 evhttp_connection_reset_(evcon);
825 if (TAILQ_FIRST(&evcon->requests) != NULL) {
830 if (!evhttp_connected(evcon))
831 evhttp_connection_connect_(evcon);
833 evhttp_request_dispatch(evcon);
839 evhttp_connection_start_detectclose(evcon);
840 } else if ((evcon->flags & EVHTTP_CON_AUTOFREE)) {
852 evcon->state = EVCON_WRITING;
869 if (free_evcon && TAILQ_FIRST(&evcon->requests) == NULL) {
870 evhttp_connection_free(evcon);
936 if (req->body_size + (size_t)ntoread > req->evcon->max_body_size) {
980 evhttp_read_trailer(struct evhttp_connection *evcon, struct evhttp_request *req)
982 struct evbuffer *buf = bufferevent_get_input(evcon->bufev);
987 evhttp_connection_fail_(evcon, EVREQ_HTTP_DATA_TOO_LONG);
990 bufferevent_disable(evcon->bufev, EV_READ);
991 evhttp_connection_done(evcon);
1001 evhttp_lingering_close(struct evhttp_connection *evcon,
1004 struct evbuffer *buf = bufferevent_get_input(evcon->bufev);
1017 evhttp_connection_fail_(evcon, EVREQ_HTTP_DATA_TOO_LONG);
1020 evhttp_lingering_fail(struct evhttp_connection *evcon,
1023 if (evcon->flags & EVHTTP_CON_LINGERING_CLOSE)
1024 evhttp_lingering_close(evcon, req);
1026 evhttp_connection_fail_(evcon, EVREQ_HTTP_DATA_TOO_LONG);
1030 evhttp_read_body(struct evhttp_connection *evcon, struct evhttp_request *req)
1032 struct evbuffer *buf = bufferevent_get_input(evcon->bufev);
1038 evcon->state = EVCON_READING_TRAILER;
1039 evhttp_read_trailer(evcon, req);
1044 evhttp_connection_fail_(evcon,
1058 evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
1077 if (req->body_size > req->evcon->max_body_size ||
1079 (size_t)req->ntoread > req->evcon->max_body_size)) {
1083 evhttp_lingering_fail(evcon, req);
1100 bufferevent_disable(evcon->bufev, EV_READ);
1102 evhttp_connection_done(evcon);
1107 #define get_deferred_queue(evcon) \
1108 ((evcon)->base)
1117 struct evhttp_connection *evcon = arg;
1118 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
1121 event_deferred_cb_cancel_(get_deferred_queue(evcon),
1122 &evcon->read_more_deferred_cb);
1124 switch (evcon->state) {
1126 evhttp_read_firstline(evcon, req);
1131 evhttp_read_header(evcon, req);
1136 evhttp_read_body(evcon, req);
1141 evhttp_read_trailer(evcon, req);
1149 input = bufferevent_get_input(evcon->bufev);
1157 evhttp_connection_reset_(evcon);
1165 __func__, evcon->state);
1172 struct evhttp_connection *evcon = data;
1173 evhttp_read_cb(evcon->bufev, evcon);
1177 evhttp_write_connectioncb(struct evhttp_connection *evcon, void *arg)
1180 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
1181 struct evbuffer *output = bufferevent_get_output(evcon->bufev);
1184 EVUTIL_ASSERT(evcon->state == EVCON_WRITING);
1194 evhttp_start_read_(evcon);
1202 evhttp_connection_free(struct evhttp_connection *evcon)
1207 if (evcon->fd != -1) {
1208 if (evhttp_connected(evcon) && evcon->closecb != NULL)
1209 (*evcon->closecb)(evcon, evcon->closecb_arg);
1217 while ((req = TAILQ_FIRST(&evcon->requests)) != NULL) {
1218 evhttp_request_free_(evcon, req);
1221 if (evcon->http_server != NULL) {
1222 struct evhttp *http = evcon->http_server;
1223 TAILQ_REMOVE(&http->connections, evcon, next);
1226 if (event_initialized(&evcon->retry_ev)) {
1227 event_del(&evcon->retry_ev);
1228 event_debug_unassign(&evcon->retry_ev);
1231 if (evcon->bufev != NULL)
1232 bufferevent_free(evcon->bufev);
1234 event_deferred_cb_cancel_(get_deferred_queue(evcon),
1235 &evcon->read_more_deferred_cb);
1237 if (evcon->fd == -1)
1238 evcon->fd = bufferevent_getfd(evcon->bufev);
1240 if (evcon->fd != -1) {
1241 bufferevent_disable(evcon->bufev, EV_READ|EV_WRITE);
1242 shutdown(evcon->fd, EVUTIL_SHUT_WR);
1243 if (!(bufferevent_get_options_(evcon->bufev) & BEV_OPT_CLOSE_ON_FREE)) {
1244 evutil_closesocket(evcon->fd);
1248 if (evcon->bind_address != NULL)
1249 mm_free(evcon->bind_address);
1251 if (evcon->address != NULL)
1252 mm_free(evcon->address);
1254 mm_free(evcon);
1258 evhttp_connection_free_on_completion(struct evhttp_connection *evcon) {
1259 evcon->flags |= EVHTTP_CON_AUTOFREE;
1263 evhttp_connection_set_local_address(struct evhttp_connection *evcon,
1266 EVUTIL_ASSERT(evcon->state == EVCON_DISCONNECTED);
1267 if (evcon->bind_address)
1268 mm_free(evcon->bind_address);
1269 if ((evcon->bind_address = mm_strdup(address)) == NULL)
1274 evhttp_connection_set_local_port(struct evhttp_connection *evcon,
1277 EVUTIL_ASSERT(evcon->state == EVCON_DISCONNECTED);
1278 evcon->bind_port = port;
1282 evhttp_request_dispatch(struct evhttp_connection* evcon)
1284 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
1291 evhttp_connection_stop_detectclose(evcon);
1294 EVUTIL_ASSERT(evcon->state == EVCON_IDLE);
1296 evcon->state = EVCON_WRITING;
1299 evhttp_make_header(evcon, req);
1301 evhttp_write_buffer(evcon, evhttp_write_connectioncb, NULL);
1307 evhttp_connection_reset_(struct evhttp_connection *evcon)
1323 bufferevent_disable_hard_(evcon->bufev, EV_READ|EV_WRITE);
1325 if (evcon->fd == -1)
1326 evcon->fd = bufferevent_getfd(evcon->bufev);
1328 if (evcon->fd != -1) {
1330 if (evhttp_connected(evcon) && evcon->closecb != NULL)
1331 (*evcon->closecb)(evcon, evcon->closecb_arg);
1333 shutdown(evcon->fd, EVUTIL_SHUT_WR);
1334 evutil_closesocket(evcon->fd);
1335 evcon->fd = -1;
1337 bufferevent_setfd(evcon->bufev, -1);
1340 tmp = bufferevent_get_output(evcon->bufev);
1343 tmp = bufferevent_get_input(evcon->bufev);
1347 evcon->flags &= ~EVHTTP_CON_READING_ERROR;
1349 evcon->state = EVCON_DISCONNECTED;
1353 evhttp_connection_start_detectclose(struct evhttp_connection *evcon)
1355 evcon->flags |= EVHTTP_CON_CLOSEDETECT;
1357 bufferevent_enable(evcon->bufev, EV_READ);
1361 evhttp_connection_stop_detectclose(struct evhttp_connection *evcon)
1363 evcon->flags &= ~EVHTTP_CON_CLOSEDETECT;
1365 bufferevent_disable(evcon->bufev, EV_READ);
1371 struct evhttp_connection *evcon = arg;
1373 evcon->state = EVCON_DISCONNECTED;
1374 evhttp_connection_connect_(evcon);
1378 evhttp_connection_cb_cleanup(struct evhttp_connection *evcon)
1382 evhttp_connection_reset_(evcon);
1383 if (evcon->retry_max < 0 || evcon->retry_cnt < evcon->retry_max) {
1384 struct timeval tv_retry = evcon->initial_retry_timeout;
1386 evtimer_assign(&evcon->retry_ev, evcon->base, evhttp_connection_retry, evcon);
1388 for (i=0; i < evcon->retry_cnt; ++i) {
1400 event_add(&evcon->retry_ev, &tv_retry);
1401 evcon->retry_cnt++;
1407 * evcon so new request will be added to evcon->requests. To
1412 while (TAILQ_FIRST(&evcon->requests) != NULL) {
1413 struct evhttp_request *request = TAILQ_FIRST(&evcon->requests);
1414 TAILQ_REMOVE(&evcon->requests, request, next);
1422 request->evcon = NULL;
1431 evhttp_connection_read_on_write_error(struct evhttp_connection *evcon,
1437 if (evcon->flags & EVHTTP_CON_READING_ERROR) {
1438 evcon->flags &= ~EVHTTP_CON_READING_ERROR;
1439 evhttp_connection_fail_(evcon, EVREQ_HTTP_EOF);
1445 buf = bufferevent_get_output(evcon->bufev);
1450 evhttp_start_read_(evcon);
1451 evcon->flags |= EVHTTP_CON_READING_ERROR;
1457 struct evhttp_connection *evcon = arg;
1458 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
1460 if (evcon->fd == -1)
1461 evcon->fd = bufferevent_getfd(bufev);
1463 switch (evcon->state) {
1468 __func__, evcon->address, evcon->port,
1469 EV_SOCK_ARG(evcon->fd)));
1470 evhttp_connection_cb_cleanup(evcon);
1479 evhttp_connection_done(evcon);
1497 if (evcon->flags & EVHTTP_CON_CLOSEDETECT) {
1498 evcon->flags &= ~EVHTTP_CON_CLOSEDETECT;
1499 EVUTIL_ASSERT(evcon->http_server == NULL);
1504 EVUTIL_ASSERT(evcon->state == EVCON_IDLE);
1505 evhttp_connection_reset_(evcon);
1512 if (TAILQ_FIRST(&evcon->requests) == NULL
1513 && (evcon->flags & EVHTTP_CON_OUTGOING)
1514 && (evcon->flags & EVHTTP_CON_AUTOFREE)) {
1515 evhttp_connection_free(evcon);
1521 evhttp_connection_fail_(evcon, EVREQ_HTTP_TIMEOUT);
1524 evcon->flags & EVHTTP_CON_READ_ON_WRITE_ERROR) {
1525 evhttp_connection_read_on_write_error(evcon, req);
1529 evhttp_connection_fail_(evcon, EVREQ_HTTP_EOF);
1532 evhttp_connection_fail_(evcon, EVREQ_HTTP_BUFFER_ERROR);
1542 struct evhttp_connection *evcon = arg;
1546 if (evcon->fd == -1)
1547 evcon->fd = bufferevent_getfd(bufev);
1562 if (evcon->fd == -1) {
1569 if (getsockopt(evcon->fd, SOL_SOCKET, SO_ERROR, (void*)&error,
1572 __func__, evcon->address, evcon->port,
1573 EV_SOCK_ARG(evcon->fd)));
1580 __func__, evcon->address, evcon->port,
1581 EV_SOCK_ARG(evcon->fd),
1588 __func__, evcon->address, evcon->port,
1589 EV_SOCK_ARG(evcon->fd)));
1592 evcon->retry_cnt = 0;
1593 evcon->state = EVCON_IDLE;
1596 bufferevent_setcb(evcon->bufev,
1600 evcon);
1602 if (!evutil_timerisset(&evcon->timeout)) {
1605 bufferevent_set_timeouts(evcon->bufev, &read_tv, &write_tv);
1607 bufferevent_set_timeouts(evcon->bufev, &evcon->timeout, &evcon->timeout);
1611 evhttp_request_dispatch(evcon);
1615 evhttp_connection_cb_cleanup(evcon);
1845 !evhttp_find_vhost(req->evcon->http_server, NULL, hostname))
1987 if (req->evcon != NULL &&
1988 evbuffer_get_length(buffer) > req->evcon->max_headers_size)
1994 if (req->evcon != NULL &&
1995 line_length > req->evcon->max_headers_size) {
2064 if (req->evcon != NULL &&
2065 req->headers_size > req->evcon->max_headers_size) {
2100 if (req->evcon != NULL &&
2101 req->headers_size + evbuffer_get_length(buffer) > req->evcon->max_headers_size)
2146 EV_SIZE_ARG(evbuffer_get_length(bufferevent_get_input(req->evcon->bufev)))));
2174 evhttp_get_body(struct evhttp_connection *evcon, struct evhttp_request *req)
2181 evhttp_connection_done(evcon);
2184 evcon->state = EVCON_READING_BODY;
2191 evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
2197 evhttp_connection_done(evcon);
2213 if ((req->evcon->max_body_size <= EV_INT64_MAX) &&
2214 (ev_uint64_t)req->ntoread > req->evcon->max_body_size) {
2215 evhttp_lingering_fail(evcon, req);
2219 if (!evbuffer_get_length(bufferevent_get_input(evcon->bufev)))
2220 evhttp_send_continue(evcon, req);
2228 evhttp_read_body(evcon, req);
2233 evhttp_read_firstline(struct evhttp_connection *evcon,
2238 res = evhttp_parse_firstline_(req, bufferevent_get_input(evcon->bufev));
2242 __func__, EV_SOCK_ARG(evcon->fd)));
2243 evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
2250 evcon->state = EVCON_READING_HEADERS;
2251 evhttp_read_header(evcon, req);
2255 evhttp_read_header(struct evhttp_connection *evcon,
2259 evutil_socket_t fd = evcon->fd;
2261 res = evhttp_parse_headers_(req, bufferevent_get_input(evcon->bufev));
2266 evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
2276 evhttp_connection_fail_(evcon, EVREQ_HTTP_EOF);
2286 evhttp_get_body(evcon, req);
2293 struct evbuffer *output = bufferevent_get_output(evcon->bufev);
2295 evhttp_start_write_(evcon);
2301 evhttp_connection_done(evcon);
2306 evhttp_get_body(evcon, req);
2315 evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
2341 struct evhttp_connection *evcon = NULL;
2345 if ((evcon = mm_calloc(1, sizeof(struct evhttp_connection))) == NULL) {
2350 evcon->fd = -1;
2351 evcon->port = port;
2353 evcon->max_headers_size = EV_SIZE_MAX;
2354 evcon->max_body_size = EV_SIZE_MAX;
2356 evutil_timerclear(&evcon->timeout);
2357 evcon->retry_cnt = evcon->retry_max = 0;
2359 if ((evcon->address = mm_strdup(address)) == NULL) {
2371 bufferevent_setcb(bev, evhttp_read_cb, evhttp_write_cb, evhttp_error_cb, evcon);
2372 evcon->bufev = bev;
2374 evcon->state = EVCON_DISCONNECTED;
2375 TAILQ_INIT(&evcon->requests);
2377 evcon->initial_retry_timeout.tv_sec = 2;
2378 evcon->initial_retry_timeout.tv_usec = 0;
2381 evcon->base = base;
2383 bufferevent_base_set(base, evcon->bufev);
2387 &evcon->read_more_deferred_cb,
2389 evhttp_deferred_read_cb, evcon);
2391 evcon->dns_base = dnsbase;
2392 evcon->ai_family = AF_UNSPEC;
2394 return (evcon);
2397 if (evcon != NULL)
2398 evhttp_connection_free(evcon);
2402 struct bufferevent* evhttp_connection_get_bufferevent(struct evhttp_connection *evcon)
2404 return evcon->bufev;
2408 evhttp_connection_get_server(struct evhttp_connection *evcon)
2410 return evcon->http_server;
2420 void evhttp_connection_set_family(struct evhttp_connection *evcon,
2423 evcon->ai_family = family;
2426 int evhttp_connection_set_flags(struct evhttp_connection *evcon,
2435 evcon->flags &= ~avail_flags;
2437 evcon->flags |= flags;
2443 evhttp_connection_set_base(struct evhttp_connection *evcon,
2446 EVUTIL_ASSERT(evcon->base == NULL);
2447 EVUTIL_ASSERT(evcon->state == EVCON_DISCONNECTED);
2448 evcon->base = base;
2449 bufferevent_base_set(base, evcon->bufev);
2453 evhttp_connection_set_timeout(struct evhttp_connection *evcon,
2457 evhttp_connection_set_timeout_tv(evcon, NULL);
2462 evhttp_connection_set_timeout_tv(evcon, &tv);
2467 evhttp_connection_set_timeout_tv(struct evhttp_connection *evcon,
2471 evcon->timeout = *tv;
2472 bufferevent_set_timeouts(evcon->bufev, &evcon->timeout, &evcon->timeout);
2476 evutil_timerclear(&evcon->timeout);
2477 bufferevent_set_timeouts(evcon->bufev, &read_tv, &write_tv);
2482 evhttp_connection_set_initial_retry_tv(struct evhttp_connection *evcon,
2486 evcon->initial_retry_timeout = *tv;
2488 evutil_timerclear(&evcon->initial_retry_timeout);
2489 evcon->initial_retry_timeout.tv_sec = 2;
2494 evhttp_connection_set_retries(struct evhttp_connection *evcon,
2497 evcon->retry_max = retry_max;
2501 evhttp_connection_set_closecb(struct evhttp_connection *evcon,
2504 evcon->closecb = cb;
2505 evcon->closecb_arg = cbarg;
2509 evhttp_connection_get_peer(struct evhttp_connection *evcon,
2512 *address = evcon->address;
2513 *port = evcon->port;
2517 evhttp_connection_get_addr(struct evhttp_connection *evcon)
2519 return bufferevent_socket_get_conn_address_(evcon->bufev);
2523 evhttp_connection_connect_(struct evhttp_connection *evcon)
2525 int old_state = evcon->state;
2526 const char *address = evcon->address;
2527 const struct sockaddr *sa = evhttp_connection_get_addr(evcon);
2530 if (evcon->state == EVCON_CONNECTING)
2533 evhttp_connection_reset_(evcon);
2535 EVUTIL_ASSERT(!(evcon->flags & EVHTTP_CON_INCOMING));
2536 evcon->flags |= EVHTTP_CON_OUTGOING;
2538 if (evcon->bind_address || evcon->bind_port) {
2539 evcon->fd = bind_socket(
2540 evcon->bind_address, evcon->bind_port, 0 /*reuse*/);
2541 if (evcon->fd == -1) {
2543 __func__, evcon->bind_address));
2547 bufferevent_setfd(evcon->bufev, evcon->fd);
2549 bufferevent_setfd(evcon->bufev, -1);
2553 bufferevent_setcb(evcon->bufev,
2557 evcon);
2558 if (!evutil_timerisset(&evcon->timeout)) {
2560 bufferevent_set_timeouts(evcon->bufev, &conn_tv, &conn_tv);
2562 bufferevent_set_timeouts(evcon->bufev, &evcon->timeout, &evcon->timeout);
2565 bufferevent_enable(evcon->bufev, EV_WRITE);
2567 evcon->state = EVCON_CONNECTING;
2569 if (evcon->flags & EVHTTP_CON_REUSE_CONNECTED_ADDR &&
2576 ret = bufferevent_socket_connect(evcon->bufev, sa, socklen);
2578 ret = bufferevent_socket_connect_hostname(evcon->bufev,
2579 evcon->dns_base, evcon->ai_family, address, evcon->port);
2583 evcon->state = old_state;
2584 event_sock_warn(evcon->fd, "%s: connection to \"%s\" failed",
2585 __func__, evcon->address);
2590 evhttp_connection_cb_cleanup(evcon);
2604 evhttp_make_request(struct evhttp_connection *evcon,
2625 EVUTIL_ASSERT(req->evcon == NULL);
2626 req->evcon = evcon;
2629 TAILQ_INSERT_TAIL(&evcon->requests, req, next);
2632 if (!evhttp_connected(evcon)) {
2633 int res = evhttp_connection_connect_(evcon);
2636 * evcon->requests. Thus, enqueue the request in advance and
2639 TAILQ_REMOVE(&evcon->requests, req, next);
2649 if (TAILQ_FIRST(&evcon->requests) == req)
2650 evhttp_request_dispatch(evcon);
2658 struct evhttp_connection *evcon = req->evcon;
2659 if (evcon != NULL) {
2661 if (TAILQ_FIRST(&evcon->requests) == req) {
2665 evhttp_connection_fail_(evcon,
2674 TAILQ_REMOVE(&evcon->requests, req, next);
2687 evhttp_start_read_(struct evhttp_connection *evcon)
2689 bufferevent_disable(evcon->bufev, EV_WRITE);
2690 bufferevent_enable(evcon->bufev, EV_READ);
2692 evcon->state = EVCON_READING_FIRSTLINE;
2694 bufferevent_setcb(evcon->bufev,
2698 evcon);
2702 if (evbuffer_get_length(bufferevent_get_input(evcon->bufev))) {
2703 event_deferred_cb_schedule_(get_deferred_queue(evcon),
2704 &evcon->read_more_deferred_cb);
2709 evhttp_start_write_(struct evhttp_connection *evcon)
2711 bufferevent_disable(evcon->bufev, EV_WRITE);
2712 bufferevent_enable(evcon->bufev, EV_READ);
2714 evcon->state = EVCON_WRITING;
2715 evhttp_write_buffer(evcon, evhttp_write_connectioncb, NULL);
2719 evhttp_send_done(struct evhttp_connection *evcon, void *arg)
2722 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
2723 TAILQ_REMOVE(&evcon->requests, req, next);
2738 evhttp_connection_free(evcon);
2743 if (evhttp_associate_new_request_with_connection(evcon) == -1) {
2744 evhttp_connection_free(evcon);
2765 evhttp_connection_free(req->evcon);
2787 struct evhttp_connection *evcon = req->evcon;
2789 if (evcon == NULL) {
2794 EVUTIL_ASSERT(TAILQ_FIRST(&evcon->requests) == req);
2804 evhttp_make_header(evcon, req);
2806 evhttp_write_buffer(evcon, evhttp_send_done, NULL);
2837 evhttp_make_header(req->evcon, req);
2838 evhttp_write_buffer(req->evcon, NULL, NULL);
2845 struct evhttp_connection *evcon = req->evcon;
2848 if (evcon == NULL)
2851 output = bufferevent_get_output(evcon->bufev);
2865 evhttp_write_buffer(evcon, cb, arg);
2876 struct evhttp_connection *evcon = req->evcon;
2879 if (evcon == NULL) {
2884 output = bufferevent_get_output(evcon->bufev);
2891 evhttp_write_buffer(req->evcon, evhttp_send_done, NULL);
2895 evhttp_send_done(evcon, NULL);
2898 evcon->cb = evhttp_send_done;
2899 evcon->cb_arg = NULL;
3459 evhttp_connection_free(req->evcon);
3465 evhttp_connection_free(req->evcon);
3674 struct evhttp_connection *evcon;
3688 while ((evcon = TAILQ_FIRST(&http->connections)) != NULL) {
3690 evhttp_connection_free(evcon);
4021 return req->evcon;
4168 struct evhttp_connection *evcon;
4186 evcon = evhttp_connection_base_bufferevent_new(
4190 if (evcon == NULL)
4193 evcon->max_headers_size = http->default_max_headers_size;
4194 evcon->max_body_size = http->default_max_body_size;
4196 evcon->flags |= EVHTTP_CON_LINGERING_CLOSE;
4198 evcon->flags |= EVHTTP_CON_INCOMING;
4199 evcon->state = EVCON_READING_FIRSTLINE;
4201 evcon->fd = fd;
4203 bufferevent_enable(evcon->bufev, EV_READ);
4204 bufferevent_disable(evcon->bufev, EV_WRITE);
4205 bufferevent_setfd(evcon->bufev, fd);
4207 return (evcon);
4211 evhttp_associate_new_request_with_connection(struct evhttp_connection *evcon)
4213 struct evhttp *http = evcon->http_server;
4218 if ((req->remote_host = mm_strdup(evcon->address)) == NULL) {
4223 req->remote_port = evcon->port;
4225 req->evcon = evcon; /* the request ends up owning the connection */
4235 TAILQ_INSERT_TAIL(&evcon->requests, req, next);
4240 evhttp_start_read_(evcon);
4249 struct evhttp_connection *evcon;
4251 evcon = evhttp_get_request_connection(http, fd, sa, salen);
4252 if (evcon == NULL) {
4261 evhttp_connection_set_timeout_tv(evcon, &http->timeout);
4267 evcon->http_server = http;
4268 TAILQ_INSERT_TAIL(&http->connections, evcon, next);
4270 if (evhttp_associate_new_request_with_connection(evcon) == -1)
4271 evhttp_connection_free(evcon);