Lines Matching refs:evcon
189 struct evhttp_connection *evcon);
191 struct evhttp_connection *evcon);
193 struct evhttp_connection *evcon);
194 static void evhttp_request_dispatch(struct evhttp_connection* evcon);
195 static void evhttp_read_firstline(struct evhttp_connection *evcon,
197 static void evhttp_read_header(struct evhttp_connection *evcon,
369 /** Helper: called after we've added some data to an evcon's bufferevent's
374 evhttp_write_buffer(struct evhttp_connection *evcon,
380 evcon->cb = cb;
381 evcon->cb_arg = arg;
386 bufferevent_setcb(evcon->bufev,
390 evcon);
392 bufferevent_enable(evcon->bufev, EV_READ|EV_WRITE);
396 evhttp_send_continue_done(struct evhttp_connection *evcon, void *arg)
398 bufferevent_disable(evcon->bufev, EV_WRITE);
402 evhttp_send_continue(struct evhttp_connection *evcon,
405 bufferevent_enable(evcon->bufev, EV_WRITE);
406 evbuffer_add_printf(bufferevent_get_output(evcon->bufev),
409 evcon->cb = evhttp_send_continue_done;
410 evcon->cb_arg = NULL;
411 bufferevent_setcb(evcon->bufev,
415 evcon);
420 evhttp_connected(struct evhttp_connection *evcon)
422 switch (evcon->state) {
442 evhttp_make_header_request(struct evhttp_connection *evcon,
454 evbuffer_add_printf(bufferevent_get_output(evcon->bufev),
532 * and write the first HTTP response for req line to evcon.
535 evhttp_make_header_response(struct evhttp_connection *evcon,
539 evbuffer_add_printf(bufferevent_get_output(evcon->bufev),
573 && evcon->http_server->default_content_type) {
576 evcon->http_server->default_content_type);
607 * the response, if we're sending a response), and write them to evcon's
610 evhttp_make_header(struct evhttp_connection *evcon, struct evhttp_request *req)
613 struct evbuffer *output = bufferevent_get_output(evcon->bufev);
620 evhttp_make_header_request(evcon, req);
622 evhttp_make_header_response(evcon, req);
642 evhttp_connection_set_max_headers_size(struct evhttp_connection *evcon,
646 evcon->max_headers_size = EV_SIZE_MAX;
648 evcon->max_headers_size = new_max_headers_size;
651 evhttp_connection_set_max_body_size(struct evhttp_connection* evcon,
655 evcon->max_body_size = EV_UINT64_MAX;
657 evcon->max_body_size = new_max_body_size;
685 TAILQ_REMOVE(&req->evcon->requests, req, next);
689 req->evcon = NULL;
727 evhttp_request_free_(struct evhttp_connection *evcon, struct evhttp_request *req)
729 TAILQ_REMOVE(&evcon->requests, req, next);
733 /* Called when evcon has experienced a (non-recoverable? -NM) error, as
738 evhttp_connection_fail_(struct evhttp_connection *evcon,
742 struct evhttp_request* req = TAILQ_FIRST(&evcon->requests);
749 bufferevent_disable(evcon->bufev, EV_READ|EV_WRITE);
751 if (evcon->flags & EVHTTP_CON_INCOMING) {
761 evhttp_connection_free(evcon);
781 evhttp_request_free_(evcon, req);
784 evhttp_connection_reset_(evcon);
787 if (TAILQ_FIRST(&evcon->requests) != NULL)
788 evhttp_connection_connect_(evcon);
790 if ((evcon->flags & EVHTTP_CON_OUTGOING) &&
791 (evcon->flags & EVHTTP_CON_AUTOFREE)) {
792 evhttp_connection_free(evcon);
813 struct evhttp_connection *evcon = arg;
816 if (evcon->cb != NULL)
817 (*evcon->cb)(evcon, evcon->cb_arg);
828 evhttp_connection_done(struct evhttp_connection *evcon)
830 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
831 int con_outgoing = evcon->flags & EVHTTP_CON_OUTGOING;
837 TAILQ_REMOVE(&evcon->requests, req, next);
838 req->evcon = NULL;
840 evcon->state = EVCON_IDLE;
844 evhttp_connection_reset_(evcon);
846 if (TAILQ_FIRST(&evcon->requests) != NULL) {
851 if (!evhttp_connected(evcon))
852 evhttp_connection_connect_(evcon);
854 evhttp_request_dispatch(evcon);
860 evhttp_connection_start_detectclose(evcon);
861 } else if ((evcon->flags & EVHTTP_CON_AUTOFREE)) {
873 evcon->state = EVCON_WRITING;
890 if (free_evcon && TAILQ_FIRST(&evcon->requests) == NULL) {
891 evhttp_connection_free(evcon);
957 if (req->body_size + (size_t)ntoread > req->evcon->max_body_size) {
1001 evhttp_read_trailer(struct evhttp_connection *evcon, struct evhttp_request *req)
1003 struct evbuffer *buf = bufferevent_get_input(evcon->bufev);
1008 evhttp_connection_fail_(evcon, EVREQ_HTTP_DATA_TOO_LONG);
1011 bufferevent_disable(evcon->bufev, EV_READ);
1012 evhttp_connection_done(evcon);
1022 evhttp_lingering_close(struct evhttp_connection *evcon,
1025 struct evbuffer *buf = bufferevent_get_input(evcon->bufev);
1038 evhttp_connection_fail_(evcon, EVREQ_HTTP_DATA_TOO_LONG);
1041 evhttp_lingering_fail(struct evhttp_connection *evcon,
1044 if (evcon->flags & EVHTTP_CON_LINGERING_CLOSE)
1045 evhttp_lingering_close(evcon, req);
1047 evhttp_connection_fail_(evcon, EVREQ_HTTP_DATA_TOO_LONG);
1051 evhttp_read_body(struct evhttp_connection *evcon, struct evhttp_request *req)
1053 struct evbuffer *buf = bufferevent_get_input(evcon->bufev);
1059 evcon->state = EVCON_READING_TRAILER;
1060 evhttp_read_trailer(evcon, req);
1065 evhttp_connection_fail_(evcon,
1079 evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
1098 if (req->body_size > req->evcon->max_body_size ||
1100 (size_t)req->ntoread > req->evcon->max_body_size)) {
1104 evhttp_lingering_fail(evcon, req);
1121 bufferevent_disable(evcon->bufev, EV_READ);
1123 evhttp_connection_done(evcon);
1128 #define get_deferred_queue(evcon) \
1129 ((evcon)->base)
1138 struct evhttp_connection *evcon = arg;
1139 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
1142 event_deferred_cb_cancel_(get_deferred_queue(evcon),
1143 &evcon->read_more_deferred_cb);
1145 switch (evcon->state) {
1147 evhttp_read_firstline(evcon, req);
1152 evhttp_read_header(evcon, req);
1157 evhttp_read_body(evcon, req);
1162 evhttp_read_trailer(evcon, req);
1170 input = bufferevent_get_input(evcon->bufev);
1178 evhttp_connection_reset_(evcon);
1186 evcon->state);
1193 struct evhttp_connection *evcon = data;
1194 struct bufferevent *bev = evcon->bufev;
1196 (bev->readcb)(evcon->bufev, evcon);
1200 evhttp_write_connectioncb(struct evhttp_connection *evcon, void *arg)
1203 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
1204 struct evbuffer *output = bufferevent_get_output(evcon->bufev);
1207 EVUTIL_ASSERT(evcon->state == EVCON_WRITING);
1217 evhttp_start_read_(evcon);
1225 evhttp_connection_free(struct evhttp_connection *evcon)
1231 if (evcon->fd != -1) {
1232 if (evhttp_connected(evcon) && evcon->closecb != NULL)
1233 (*evcon->closecb)(evcon, evcon->closecb_arg);
1241 while ((req = TAILQ_FIRST(&evcon->requests)) != NULL) {
1242 evhttp_request_free_(evcon, req);
1245 if (evcon->http_server != NULL) {
1246 struct evhttp *http = evcon->http_server;
1247 TAILQ_REMOVE(&http->connections, evcon, next);
1250 if (event_initialized(&evcon->retry_ev)) {
1251 event_del(&evcon->retry_ev);
1252 event_debug_unassign(&evcon->retry_ev);
1255 event_deferred_cb_cancel_(get_deferred_queue(evcon),
1256 &evcon->read_more_deferred_cb);
1258 if (evcon->bufev != NULL) {
1260 !(bufferevent_get_options_(evcon->bufev) & BEV_OPT_CLOSE_ON_FREE);
1261 if (evcon->fd == -1)
1262 evcon->fd = bufferevent_getfd(evcon->bufev);
1264 bufferevent_free(evcon->bufev);
1267 if (evcon->fd != -1) {
1268 shutdown(evcon->fd, EVUTIL_SHUT_WR);
1270 evutil_closesocket(evcon->fd);
1273 if (evcon->bind_address != NULL)
1274 mm_free(evcon->bind_address);
1276 if (evcon->address != NULL)
1277 mm_free(evcon->address);
1279 mm_free(evcon);
1283 evhttp_connection_free_on_completion(struct evhttp_connection *evcon) {
1284 evcon->flags |= EVHTTP_CON_AUTOFREE;
1288 evhttp_connection_set_local_address(struct evhttp_connection *evcon,
1291 EVUTIL_ASSERT(evcon->state == EVCON_DISCONNECTED);
1292 if (evcon->bind_address)
1293 mm_free(evcon->bind_address);
1294 if ((evcon->bind_address = mm_strdup(address)) == NULL)
1299 evhttp_connection_set_local_port(struct evhttp_connection *evcon,
1302 EVUTIL_ASSERT(evcon->state == EVCON_DISCONNECTED);
1303 evcon->bind_port = port;
1307 evhttp_request_dispatch(struct evhttp_connection* evcon)
1309 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
1318 evhttp_connection_stop_detectclose(evcon);
1321 EVUTIL_ASSERT(evcon->state == EVCON_IDLE);
1323 evcon->state = EVCON_WRITING;
1326 evhttp_make_header(evcon, req);
1328 evhttp_write_buffer(evcon, evhttp_write_connectioncb, NULL);
1334 evhttp_connection_reset_(struct evhttp_connection *evcon)
1339 bufferevent_setcb(evcon->bufev, NULL, NULL, NULL, NULL);
1352 bufferevent_disable_hard_(evcon->bufev, EV_READ|EV_WRITE);
1354 if (evcon->fd == -1)
1355 evcon->fd = bufferevent_getfd(evcon->bufev);
1357 if (evcon->fd != -1) {
1359 if (evhttp_connected(evcon) && evcon->closecb != NULL)
1360 (*evcon->closecb)(evcon, evcon->closecb_arg);
1362 shutdown(evcon->fd, EVUTIL_SHUT_WR);
1363 evutil_closesocket(evcon->fd);
1364 evcon->fd = -1;
1366 err = bufferevent_setfd(evcon->bufev, -1);
1370 tmp = bufferevent_get_output(evcon->bufev);
1373 tmp = bufferevent_get_input(evcon->bufev);
1377 evcon->flags &= ~EVHTTP_CON_READING_ERROR;
1379 evcon->state = EVCON_DISCONNECTED;
1383 evhttp_connection_start_detectclose(struct evhttp_connection *evcon)
1385 evcon->flags |= EVHTTP_CON_CLOSEDETECT;
1386 bufferevent_enable(evcon->bufev, EV_READ);
1390 evhttp_connection_stop_detectclose(struct evhttp_connection *evcon)
1392 evcon->flags &= ~EVHTTP_CON_CLOSEDETECT;
1393 bufferevent_disable(evcon->bufev, EV_READ);
1399 struct evhttp_connection *evcon = arg;
1401 evcon->state = EVCON_DISCONNECTED;
1402 evhttp_connection_connect_(evcon);
1406 evhttp_connection_cb_cleanup(struct evhttp_connection *evcon)
1410 evhttp_connection_reset_(evcon);
1411 if (evcon->retry_max < 0 || evcon->retry_cnt < evcon->retry_max) {
1412 struct timeval tv_retry = evcon->initial_retry_timeout;
1414 evtimer_assign(&evcon->retry_ev, evcon->base, evhttp_connection_retry, evcon);
1416 for (i=0; i < evcon->retry_cnt; ++i) {
1428 event_add(&evcon->retry_ev, &tv_retry);
1429 evcon->retry_cnt++;
1435 * evcon so new request will be added to evcon->requests. To
1440 while (TAILQ_FIRST(&evcon->requests) != NULL) {
1441 struct evhttp_request *request = TAILQ_FIRST(&evcon->requests);
1442 TAILQ_REMOVE(&evcon->requests, request, next);
1450 request->evcon = NULL;
1459 evhttp_connection_read_on_write_error(struct evhttp_connection *evcon,
1465 if (evcon->flags & EVHTTP_CON_READING_ERROR) {
1466 evcon->flags &= ~EVHTTP_CON_READING_ERROR;
1467 evhttp_connection_fail_(evcon, EVREQ_HTTP_EOF);
1473 buf = bufferevent_get_output(evcon->bufev);
1478 evhttp_start_read_(evcon);
1479 evcon->flags |= EVHTTP_CON_READING_ERROR;
1485 struct evhttp_connection *evcon = arg;
1486 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
1488 if (evcon->fd == -1)
1489 evcon->fd = bufferevent_getfd(bufev);
1491 switch (evcon->state) {
1496 __func__, evcon->address, evcon->port,
1497 EV_SOCK_ARG(evcon->fd)));
1498 evhttp_connection_cb_cleanup(evcon);
1507 evhttp_connection_done(evcon);
1525 if (evcon->flags & EVHTTP_CON_CLOSEDETECT) {
1526 evcon->flags &= ~EVHTTP_CON_CLOSEDETECT;
1527 EVUTIL_ASSERT(evcon->http_server == NULL);
1532 EVUTIL_ASSERT(evcon->state == EVCON_IDLE);
1533 evhttp_connection_reset_(evcon);
1540 if (TAILQ_FIRST(&evcon->requests) == NULL
1541 && (evcon->flags & EVHTTP_CON_OUTGOING)
1542 && (evcon->flags & EVHTTP_CON_AUTOFREE)) {
1543 evhttp_connection_free(evcon);
1549 evhttp_connection_fail_(evcon, EVREQ_HTTP_TIMEOUT);
1552 evcon->flags & EVHTTP_CON_READ_ON_WRITE_ERROR) {
1553 evhttp_connection_read_on_write_error(evcon, req);
1558 evcon->flags & EVHTTP_CON_READ_ON_WRITE_ERROR &&
1560 event_deferred_cb_schedule_(get_deferred_queue(evcon),
1561 &evcon->read_more_deferred_cb);
1565 evhttp_connection_fail_(evcon, EVREQ_HTTP_EOF);
1568 evhttp_connection_fail_(evcon, EVREQ_HTTP_BUFFER_ERROR);
1578 struct evhttp_connection *evcon = arg;
1582 if (evcon->fd == -1)
1583 evcon->fd = bufferevent_getfd(bufev);
1598 if (evcon->fd == -1) {
1605 if (getsockopt(evcon->fd, SOL_SOCKET, SO_ERROR, (void*)&error,
1608 __func__, evcon->address, evcon->port,
1609 EV_SOCK_ARG(evcon->fd)));
1616 __func__, evcon->address, evcon->port,
1617 EV_SOCK_ARG(evcon->fd),
1624 __func__, evcon->address, evcon->port,
1625 EV_SOCK_ARG(evcon->fd)));
1628 evcon->retry_cnt = 0;
1629 evcon->state = EVCON_IDLE;
1632 bufferevent_setcb(evcon->bufev,
1636 evcon);
1638 if (!evutil_timerisset(&evcon->timeout)) {
1641 bufferevent_set_timeouts(evcon->bufev, &read_tv, &write_tv);
1643 bufferevent_set_timeouts(evcon->bufev, &evcon->timeout, &evcon->timeout);
1647 evhttp_request_dispatch(evcon);
1651 evhttp_connection_cb_cleanup(evcon);
1896 !evhttp_find_vhost(req->evcon->http_server, NULL, hostname))
2038 if (req->evcon != NULL &&
2039 evbuffer_get_length(buffer) > req->evcon->max_headers_size)
2045 if (req->evcon != NULL && len > req->evcon->max_headers_size) {
2114 if (req->evcon != NULL &&
2115 req->headers_size > req->evcon->max_headers_size) {
2150 if (req->evcon != NULL &&
2151 req->headers_size + evbuffer_get_length(buffer) > req->evcon->max_headers_size)
2192 EV_SIZE_ARG(evbuffer_get_length(bufferevent_get_input(req->evcon->bufev)))));
2219 evhttp_get_body(struct evhttp_connection *evcon, struct evhttp_request *req)
2226 evhttp_connection_done(evcon);
2229 evcon->state = EVCON_READING_BODY;
2236 evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
2242 evhttp_connection_done(evcon);
2258 if ((req->evcon->max_body_size <= EV_INT64_MAX) &&
2259 (ev_uint64_t)req->ntoread > req->evcon->max_body_size) {
2260 evhttp_lingering_fail(evcon, req);
2264 if (!evbuffer_get_length(bufferevent_get_input(evcon->bufev)))
2265 evhttp_send_continue(evcon, req);
2273 evhttp_read_body(evcon, req);
2278 evhttp_read_firstline(struct evhttp_connection *evcon,
2283 res = evhttp_parse_firstline_(req, bufferevent_get_input(evcon->bufev));
2287 __func__, EV_SOCK_ARG(evcon->fd)));
2288 evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
2295 evcon->state = EVCON_READING_HEADERS;
2296 evhttp_read_header(evcon, req);
2300 evhttp_read_header(struct evhttp_connection *evcon,
2304 evutil_socket_t fd = evcon->fd;
2306 res = evhttp_parse_headers_(req, bufferevent_get_input(evcon->bufev));
2311 evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
2321 evhttp_connection_fail_(evcon, EVREQ_HTTP_EOF);
2331 evhttp_get_body(evcon, req);
2338 struct evbuffer *output = bufferevent_get_output(evcon->bufev);
2340 evhttp_start_write_(evcon);
2346 evhttp_connection_done(evcon);
2351 evhttp_get_body(evcon, req);
2360 evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
2386 struct evhttp_connection *evcon = NULL;
2390 if ((evcon = mm_calloc(1, sizeof(struct evhttp_connection))) == NULL) {
2395 evcon->fd = -1;
2396 evcon->port = port;
2398 evcon->max_headers_size = EV_SIZE_MAX;
2399 evcon->max_body_size = EV_SIZE_MAX;
2401 evutil_timerclear(&evcon->timeout);
2402 evcon->retry_cnt = evcon->retry_max = 0;
2404 if ((evcon->address = mm_strdup(address)) == NULL) {
2416 bufferevent_setcb(bev, evhttp_read_cb, evhttp_write_cb, evhttp_error_cb, evcon);
2417 evcon->bufev = bev;
2419 evcon->state = EVCON_DISCONNECTED;
2420 TAILQ_INIT(&evcon->requests);
2422 evcon->initial_retry_timeout.tv_sec = 2;
2423 evcon->initial_retry_timeout.tv_usec = 0;
2426 evcon->base = base;
2428 bufferevent_base_set(base, evcon->bufev);
2432 &evcon->read_more_deferred_cb,
2434 evhttp_deferred_read_cb, evcon);
2436 evcon->dns_base = dnsbase;
2437 evcon->ai_family = AF_UNSPEC;
2439 return (evcon);
2442 if (evcon != NULL)
2443 evhttp_connection_free(evcon);
2447 struct bufferevent* evhttp_connection_get_bufferevent(struct evhttp_connection *evcon)
2449 return evcon->bufev;
2453 evhttp_connection_get_server(struct evhttp_connection *evcon)
2455 return evcon->http_server;
2465 void evhttp_connection_set_family(struct evhttp_connection *evcon,
2468 evcon->ai_family = family;
2471 int evhttp_connection_set_flags(struct evhttp_connection *evcon,
2480 evcon->flags &= ~avail_flags;
2482 evcon->flags |= flags;
2488 evhttp_connection_set_base(struct evhttp_connection *evcon,
2491 EVUTIL_ASSERT(evcon->base == NULL);
2492 EVUTIL_ASSERT(evcon->state == EVCON_DISCONNECTED);
2493 evcon->base = base;
2494 bufferevent_base_set(base, evcon->bufev);
2498 evhttp_connection_set_timeout(struct evhttp_connection *evcon,
2502 evhttp_connection_set_timeout_tv(evcon, NULL);
2507 evhttp_connection_set_timeout_tv(evcon, &tv);
2512 evhttp_connection_set_timeout_tv(struct evhttp_connection *evcon,
2516 evcon->timeout = *tv;
2517 bufferevent_set_timeouts(evcon->bufev, &evcon->timeout, &evcon->timeout);
2521 evutil_timerclear(&evcon->timeout);
2522 bufferevent_set_timeouts(evcon->bufev, &read_tv, &write_tv);
2527 evhttp_connection_set_initial_retry_tv(struct evhttp_connection *evcon,
2531 evcon->initial_retry_timeout = *tv;
2533 evutil_timerclear(&evcon->initial_retry_timeout);
2534 evcon->initial_retry_timeout.tv_sec = 2;
2539 evhttp_connection_set_retries(struct evhttp_connection *evcon,
2542 evcon->retry_max = retry_max;
2546 evhttp_connection_set_closecb(struct evhttp_connection *evcon,
2549 evcon->closecb = cb;
2550 evcon->closecb_arg = cbarg;
2554 evhttp_connection_get_peer(struct evhttp_connection *evcon,
2557 *address = evcon->address;
2558 *port = evcon->port;
2562 evhttp_connection_get_addr(struct evhttp_connection *evcon)
2564 return bufferevent_socket_get_conn_address_(evcon->bufev);
2568 evhttp_connection_connect_(struct evhttp_connection *evcon)
2570 int old_state = evcon->state;
2571 const char *address = evcon->address;
2572 const struct sockaddr *sa = evhttp_connection_get_addr(evcon);
2575 if (evcon->state == EVCON_CONNECTING)
2578 evhttp_connection_reset_(evcon);
2580 EVUTIL_ASSERT(!(evcon->flags & EVHTTP_CON_INCOMING));
2581 evcon->flags |= EVHTTP_CON_OUTGOING;
2583 if (evcon->bind_address || evcon->bind_port) {
2584 evcon->fd = bind_socket(
2585 evcon->bind_address, evcon->bind_port, 0 /*reuse*/);
2586 if (evcon->fd == -1) {
2588 __func__, evcon->bind_address));
2592 if (bufferevent_setfd(evcon->bufev, evcon->fd))
2595 if (bufferevent_setfd(evcon->bufev, -1))
2600 bufferevent_setcb(evcon->bufev,
2604 evcon);
2605 if (!evutil_timerisset(&evcon->timeout)) {
2607 bufferevent_set_timeouts(evcon->bufev, &conn_tv, &conn_tv);
2609 bufferevent_set_timeouts(evcon->bufev, &evcon->timeout, &evcon->timeout);
2612 if (bufferevent_enable(evcon->bufev, EV_WRITE))
2615 evcon->state = EVCON_CONNECTING;
2617 if (evcon->flags & EVHTTP_CON_REUSE_CONNECTED_ADDR &&
2624 ret = bufferevent_socket_connect(evcon->bufev, sa, socklen);
2626 ret = bufferevent_socket_connect_hostname(evcon->bufev,
2627 evcon->dns_base, evcon->ai_family, address, evcon->port);
2631 evcon->state = old_state;
2632 event_sock_warn(evcon->fd, "%s: connection to \"%s\" failed",
2633 __func__, evcon->address);
2638 evhttp_connection_cb_cleanup(evcon);
2652 evhttp_make_request(struct evhttp_connection *evcon,
2673 EVUTIL_ASSERT(req->evcon == NULL);
2674 req->evcon = evcon;
2677 TAILQ_INSERT_TAIL(&evcon->requests, req, next);
2680 if (evcon->retry_cnt)
2684 if (!evhttp_connected(evcon)) {
2685 int res = evhttp_connection_connect_(evcon);
2688 * evcon->requests. Thus, enqueue the request in advance and
2691 TAILQ_REMOVE(&evcon->requests, req, next);
2701 if (TAILQ_FIRST(&evcon->requests) == req)
2702 evhttp_request_dispatch(evcon);
2710 struct evhttp_connection *evcon = req->evcon;
2711 if (evcon != NULL) {
2713 if (TAILQ_FIRST(&evcon->requests) == req) {
2717 evhttp_connection_fail_(evcon,
2726 TAILQ_REMOVE(&evcon->requests, req, next);
2739 evhttp_start_read_(struct evhttp_connection *evcon)
2741 bufferevent_disable(evcon->bufev, EV_WRITE);
2742 bufferevent_enable(evcon->bufev, EV_READ);
2744 evcon->state = EVCON_READING_FIRSTLINE;
2746 bufferevent_setcb(evcon->bufev,
2750 evcon);
2754 if (evbuffer_get_length(bufferevent_get_input(evcon->bufev))) {
2755 event_deferred_cb_schedule_(get_deferred_queue(evcon),
2756 &evcon->read_more_deferred_cb);
2761 evhttp_start_write_(struct evhttp_connection *evcon)
2763 bufferevent_disable(evcon->bufev, EV_WRITE);
2764 bufferevent_enable(evcon->bufev, EV_READ);
2766 evcon->state = EVCON_WRITING;
2767 evhttp_write_buffer(evcon, evhttp_write_connectioncb, NULL);
2771 evhttp_send_done(struct evhttp_connection *evcon, void *arg)
2774 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
2775 TAILQ_REMOVE(&evcon->requests, req, next);
2790 evhttp_connection_free(evcon);
2795 if (evhttp_associate_new_request_with_connection(evcon) == -1) {
2796 evhttp_connection_free(evcon);
2817 evhttp_connection_free(req->evcon);
2839 struct evhttp_connection *evcon = req->evcon;
2841 if (evcon == NULL) {
2846 EVUTIL_ASSERT(TAILQ_FIRST(&evcon->requests) == req);
2856 evhttp_make_header(evcon, req);
2858 evhttp_write_buffer(evcon, evhttp_send_done, NULL);
2876 if (req->evcon == NULL)
2893 evhttp_make_header(req->evcon, req);
2894 evhttp_write_buffer(req->evcon, NULL, NULL);
2901 struct evhttp_connection *evcon = req->evcon;
2904 if (evcon == NULL)
2907 output = bufferevent_get_output(evcon->bufev);
2921 evhttp_write_buffer(evcon, cb, arg);
2932 struct evhttp_connection *evcon = req->evcon;
2935 if (evcon == NULL) {
2940 output = bufferevent_get_output(evcon->bufev);
2947 evhttp_write_buffer(req->evcon, evhttp_send_done, NULL);
2951 evhttp_send_done(evcon, NULL);
2954 evcon->cb = evhttp_send_done;
2955 evcon->cb_arg = NULL;
3478 bufferevent_disable(req->evcon->bufev, EV_READ);
3520 evhttp_connection_free(req->evcon);
3526 evhttp_connection_free(req->evcon);
3738 struct evhttp_connection *evcon;
3752 while ((evcon = TAILQ_FIRST(&http->connections)) != NULL) {
3754 evhttp_connection_free(evcon);
4085 return req->evcon;
4232 struct evhttp_connection *evcon;
4257 evcon = evhttp_connection_base_bufferevent_new(
4261 if (evcon == NULL)
4264 evcon->max_headers_size = http->default_max_headers_size;
4265 evcon->max_body_size = http->default_max_body_size;
4267 evcon->flags |= EVHTTP_CON_LINGERING_CLOSE;
4269 evcon->flags |= EVHTTP_CON_INCOMING;
4270 evcon->state = EVCON_READING_FIRSTLINE;
4272 evcon->fd = fd;
4274 if (bufferevent_setfd(evcon->bufev, fd))
4276 if (bufferevent_enable(evcon->bufev, EV_READ))
4278 if (bufferevent_disable(evcon->bufev, EV_WRITE))
4280 bufferevent_socket_set_conn_address_(evcon->bufev, sa, salen);
4282 return (evcon);
4285 evhttp_connection_free(evcon);
4290 evhttp_associate_new_request_with_connection(struct evhttp_connection *evcon)
4292 struct evhttp *http = evcon->http_server;
4297 if ((req->remote_host = mm_strdup(evcon->address)) == NULL) {
4302 req->remote_port = evcon->port;
4304 req->evcon = evcon; /* the request ends up owning the connection */
4314 TAILQ_INSERT_TAIL(&evcon->requests, req, next);
4319 evhttp_start_read_(evcon);
4328 struct evhttp_connection *evcon;
4330 evcon = evhttp_get_request_connection(http, fd, sa, salen);
4331 if (evcon == NULL) {
4340 evhttp_connection_set_timeout_tv(evcon, &http->timeout);
4346 evcon->http_server = http;
4347 TAILQ_INSERT_TAIL(&http->connections, evcon, next);
4349 if (evhttp_associate_new_request_with_connection(evcon) == -1)
4350 evhttp_connection_free(evcon);
Indexes created Sat Feb 28 05:31:39 UTC 2026