Lines Matching defs:evcon
187 struct evhttp_connection *evcon);
189 struct evhttp_connection *evcon);
191 struct evhttp_connection *evcon);
192 static void evhttp_request_dispatch(struct evhttp_connection* evcon);
193 static void evhttp_read_firstline(struct evhttp_connection *evcon,
195 static void evhttp_read_header(struct evhttp_connection *evcon,
367 /** Helper: called after we've added some data to an evcon's bufferevent's
372 evhttp_write_buffer(struct evhttp_connection *evcon,
378 evcon->cb = cb;
379 evcon->cb_arg = arg;
384 bufferevent_setcb(evcon->bufev,
388 evcon);
390 bufferevent_enable(evcon->bufev, EV_READ|EV_WRITE);
394 evhttp_send_continue_done(struct evhttp_connection *evcon, void *arg)
396 bufferevent_disable(evcon->bufev, EV_WRITE);
400 evhttp_send_continue(struct evhttp_connection *evcon,
403 bufferevent_enable(evcon->bufev, EV_WRITE);
404 evbuffer_add_printf(bufferevent_get_output(evcon->bufev),
407 evcon->cb = evhttp_send_continue_done;
408 evcon->cb_arg = NULL;
409 bufferevent_setcb(evcon->bufev,
413 evcon);
418 evhttp_connected(struct evhttp_connection *evcon)
420 switch (evcon->state) {
440 evhttp_make_header_request(struct evhttp_connection *evcon,
452 evbuffer_add_printf(bufferevent_get_output(evcon->bufev),
530 * and write the first HTTP response for req line to evcon.
533 evhttp_make_header_response(struct evhttp_connection *evcon,
537 evbuffer_add_printf(bufferevent_get_output(evcon->bufev),
571 && evcon->http_server->default_content_type) {
574 evcon->http_server->default_content_type);
605 * the response, if we're sending a response), and write them to evcon's
608 evhttp_make_header(struct evhttp_connection *evcon, struct evhttp_request *req)
611 struct evbuffer *output = bufferevent_get_output(evcon->bufev);
618 evhttp_make_header_request(evcon, req);
620 evhttp_make_header_response(evcon, req);
640 evhttp_connection_set_max_headers_size(struct evhttp_connection *evcon,
644 evcon->max_headers_size = EV_SIZE_MAX;
646 evcon->max_headers_size = new_max_headers_size;
649 evhttp_connection_set_max_body_size(struct evhttp_connection* evcon,
653 evcon->max_body_size = EV_UINT64_MAX;
655 evcon->max_body_size = new_max_body_size;
683 TAILQ_REMOVE(&req->evcon->requests, req, next);
687 req->evcon = NULL;
725 evhttp_request_free_(struct evhttp_connection *evcon, struct evhttp_request *req)
727 TAILQ_REMOVE(&evcon->requests, req, next);
731 /* Called when evcon has experienced a (non-recoverable? -NM) error, as
736 evhttp_connection_fail_(struct evhttp_connection *evcon,
740 struct evhttp_request* req = TAILQ_FIRST(&evcon->requests);
747 bufferevent_disable(evcon->bufev, EV_READ|EV_WRITE);
749 if (evcon->flags & EVHTTP_CON_INCOMING) {
759 evhttp_connection_free(evcon);
779 evhttp_request_free_(evcon, req);
782 evhttp_connection_reset_(evcon);
785 if (TAILQ_FIRST(&evcon->requests) != NULL)
786 evhttp_connection_connect_(evcon);
788 if ((evcon->flags & EVHTTP_CON_OUTGOING) &&
789 (evcon->flags & EVHTTP_CON_AUTOFREE)) {
790 evhttp_connection_free(evcon);
811 struct evhttp_connection *evcon = arg;
814 if (evcon->cb != NULL)
815 (*evcon->cb)(evcon, evcon->cb_arg);
826 evhttp_connection_done(struct evhttp_connection *evcon)
828 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
829 int con_outgoing = evcon->flags & EVHTTP_CON_OUTGOING;
835 TAILQ_REMOVE(&evcon->requests, req, next);
836 req->evcon = NULL;
838 evcon->state = EVCON_IDLE;
842 evhttp_connection_reset_(evcon);
844 if (TAILQ_FIRST(&evcon->requests) != NULL) {
849 if (!evhttp_connected(evcon))
850 evhttp_connection_connect_(evcon);
852 evhttp_request_dispatch(evcon);
858 evhttp_connection_start_detectclose(evcon);
859 } else if ((evcon->flags & EVHTTP_CON_AUTOFREE)) {
871 evcon->state = EVCON_WRITING;
888 if (free_evcon && TAILQ_FIRST(&evcon->requests) == NULL) {
889 evhttp_connection_free(evcon);
955 if (req->body_size + (size_t)ntoread > req->evcon->max_body_size) {
999 evhttp_read_trailer(struct evhttp_connection *evcon, struct evhttp_request *req)
1001 struct evbuffer *buf = bufferevent_get_input(evcon->bufev);
1006 evhttp_connection_fail_(evcon, EVREQ_HTTP_DATA_TOO_LONG);
1009 bufferevent_disable(evcon->bufev, EV_READ);
1010 evhttp_connection_done(evcon);
1020 evhttp_lingering_close(struct evhttp_connection *evcon,
1023 struct evbuffer *buf = bufferevent_get_input(evcon->bufev);
1036 evhttp_connection_fail_(evcon, EVREQ_HTTP_DATA_TOO_LONG);
1039 evhttp_lingering_fail(struct evhttp_connection *evcon,
1042 if (evcon->flags & EVHTTP_CON_LINGERING_CLOSE)
1043 evhttp_lingering_close(evcon, req);
1045 evhttp_connection_fail_(evcon, EVREQ_HTTP_DATA_TOO_LONG);
1049 evhttp_read_body(struct evhttp_connection *evcon, struct evhttp_request *req)
1051 struct evbuffer *buf = bufferevent_get_input(evcon->bufev);
1057 evcon->state = EVCON_READING_TRAILER;
1058 evhttp_read_trailer(evcon, req);
1063 evhttp_connection_fail_(evcon,
1077 evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
1096 if (req->body_size > req->evcon->max_body_size ||
1098 (size_t)req->ntoread > req->evcon->max_body_size)) {
1102 evhttp_lingering_fail(evcon, req);
1119 bufferevent_disable(evcon->bufev, EV_READ);
1121 evhttp_connection_done(evcon);
1126 #define get_deferred_queue(evcon) \
1127 ((evcon)->base)
1136 struct evhttp_connection *evcon = arg;
1137 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
1140 event_deferred_cb_cancel_(get_deferred_queue(evcon),
1141 &evcon->read_more_deferred_cb);
1143 switch (evcon->state) {
1145 evhttp_read_firstline(evcon, req);
1150 evhttp_read_header(evcon, req);
1155 evhttp_read_body(evcon, req);
1160 evhttp_read_trailer(evcon, req);
1168 input = bufferevent_get_input(evcon->bufev);
1176 evhttp_connection_reset_(evcon);
1184 __func__, evcon->state);
1191 struct evhttp_connection *evcon = data;
1192 struct bufferevent *bev = evcon->bufev;
1194 (bev->readcb)(evcon->bufev, evcon);
1198 evhttp_write_connectioncb(struct evhttp_connection *evcon, void *arg)
1201 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
1202 struct evbuffer *output = bufferevent_get_output(evcon->bufev);
1205 EVUTIL_ASSERT(evcon->state == EVCON_WRITING);
1215 evhttp_start_read_(evcon);
1223 evhttp_connection_free(struct evhttp_connection *evcon)
1229 if (evcon->fd != -1) {
1230 if (evhttp_connected(evcon) && evcon->closecb != NULL)
1231 (*evcon->closecb)(evcon, evcon->closecb_arg);
1239 while ((req = TAILQ_FIRST(&evcon->requests)) != NULL) {
1240 evhttp_request_free_(evcon, req);
1243 if (evcon->http_server != NULL) {
1244 struct evhttp *http = evcon->http_server;
1245 TAILQ_REMOVE(&http->connections, evcon, next);
1248 if (event_initialized(&evcon->retry_ev)) {
1249 event_del(&evcon->retry_ev);
1250 event_debug_unassign(&evcon->retry_ev);
1253 event_deferred_cb_cancel_(get_deferred_queue(evcon),
1254 &evcon->read_more_deferred_cb);
1256 if (evcon->bufev != NULL) {
1258 !(bufferevent_get_options_(evcon->bufev) & BEV_OPT_CLOSE_ON_FREE);
1259 if (evcon->fd == -1)
1260 evcon->fd = bufferevent_getfd(evcon->bufev);
1262 bufferevent_free(evcon->bufev);
1265 if (evcon->fd != -1) {
1266 shutdown(evcon->fd, EVUTIL_SHUT_WR);
1268 evutil_closesocket(evcon->fd);
1271 if (evcon->bind_address != NULL)
1272 mm_free(evcon->bind_address);
1274 if (evcon->address != NULL)
1275 mm_free(evcon->address);
1277 mm_free(evcon);
1281 evhttp_connection_free_on_completion(struct evhttp_connection *evcon) {
1282 evcon->flags |= EVHTTP_CON_AUTOFREE;
1286 evhttp_connection_set_local_address(struct evhttp_connection *evcon,
1289 EVUTIL_ASSERT(evcon->state == EVCON_DISCONNECTED);
1290 if (evcon->bind_address)
1291 mm_free(evcon->bind_address);
1292 if ((evcon->bind_address = mm_strdup(address)) == NULL)
1297 evhttp_connection_set_local_port(struct evhttp_connection *evcon,
1300 EVUTIL_ASSERT(evcon->state == EVCON_DISCONNECTED);
1301 evcon->bind_port = port;
1305 evhttp_request_dispatch(struct evhttp_connection* evcon)
1307 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
1316 evhttp_connection_stop_detectclose(evcon);
1319 EVUTIL_ASSERT(evcon->state == EVCON_IDLE);
1321 evcon->state = EVCON_WRITING;
1324 evhttp_make_header(evcon, req);
1326 evhttp_write_buffer(evcon, evhttp_write_connectioncb, NULL);
1332 evhttp_connection_reset_(struct evhttp_connection *evcon)
1337 bufferevent_setcb(evcon->bufev, NULL, NULL, NULL, NULL);
1350 bufferevent_disable_hard_(evcon->bufev, EV_READ|EV_WRITE);
1352 if (evcon->fd == -1)
1353 evcon->fd = bufferevent_getfd(evcon->bufev);
1355 if (evcon->fd != -1) {
1357 if (evhttp_connected(evcon) && evcon->closecb != NULL)
1358 (*evcon->closecb)(evcon, evcon->closecb_arg);
1360 shutdown(evcon->fd, EVUTIL_SHUT_WR);
1361 evutil_closesocket(evcon->fd);
1362 evcon->fd = -1;
1364 err = bufferevent_setfd(evcon->bufev, -1);
1368 tmp = bufferevent_get_output(evcon->bufev);
1371 tmp = bufferevent_get_input(evcon->bufev);
1375 evcon->flags &= ~EVHTTP_CON_READING_ERROR;
1377 evcon->state = EVCON_DISCONNECTED;
1381 evhttp_connection_start_detectclose(struct evhttp_connection *evcon)
1383 evcon->flags |= EVHTTP_CON_CLOSEDETECT;
1384 bufferevent_enable(evcon->bufev, EV_READ);
1388 evhttp_connection_stop_detectclose(struct evhttp_connection *evcon)
1390 evcon->flags &= ~EVHTTP_CON_CLOSEDETECT;
1391 bufferevent_disable(evcon->bufev, EV_READ);
1397 struct evhttp_connection *evcon = arg;
1399 evcon->state = EVCON_DISCONNECTED;
1400 evhttp_connection_connect_(evcon);
1404 evhttp_connection_cb_cleanup(struct evhttp_connection *evcon)
1408 evhttp_connection_reset_(evcon);
1409 if (evcon->retry_max < 0 || evcon->retry_cnt < evcon->retry_max) {
1410 struct timeval tv_retry = evcon->initial_retry_timeout;
1412 evtimer_assign(&evcon->retry_ev, evcon->base, evhttp_connection_retry, evcon);
1414 for (i=0; i < evcon->retry_cnt; ++i) {
1426 event_add(&evcon->retry_ev, &tv_retry);
1427 evcon->retry_cnt++;
1433 * evcon so new request will be added to evcon->requests. To
1438 while (TAILQ_FIRST(&evcon->requests) != NULL) {
1439 struct evhttp_request *request = TAILQ_FIRST(&evcon->requests);
1440 TAILQ_REMOVE(&evcon->requests, request, next);
1448 request->evcon = NULL;
1457 evhttp_connection_read_on_write_error(struct evhttp_connection *evcon,
1463 if (evcon->flags & EVHTTP_CON_READING_ERROR) {
1464 evcon->flags &= ~EVHTTP_CON_READING_ERROR;
1465 evhttp_connection_fail_(evcon, EVREQ_HTTP_EOF);
1471 buf = bufferevent_get_output(evcon->bufev);
1476 evhttp_start_read_(evcon);
1477 evcon->flags |= EVHTTP_CON_READING_ERROR;
1483 struct evhttp_connection *evcon = arg;
1484 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
1486 if (evcon->fd == -1)
1487 evcon->fd = bufferevent_getfd(bufev);
1489 switch (evcon->state) {
1494 __func__, evcon->address, evcon->port,
1495 EV_SOCK_ARG(evcon->fd)));
1496 evhttp_connection_cb_cleanup(evcon);
1505 evhttp_connection_done(evcon);
1523 if (evcon->flags & EVHTTP_CON_CLOSEDETECT) {
1524 evcon->flags &= ~EVHTTP_CON_CLOSEDETECT;
1525 EVUTIL_ASSERT(evcon->http_server == NULL);
1530 EVUTIL_ASSERT(evcon->state == EVCON_IDLE);
1531 evhttp_connection_reset_(evcon);
1538 if (TAILQ_FIRST(&evcon->requests) == NULL
1539 && (evcon->flags & EVHTTP_CON_OUTGOING)
1540 && (evcon->flags & EVHTTP_CON_AUTOFREE)) {
1541 evhttp_connection_free(evcon);
1547 evhttp_connection_fail_(evcon, EVREQ_HTTP_TIMEOUT);
1550 evcon->flags & EVHTTP_CON_READ_ON_WRITE_ERROR) {
1551 evhttp_connection_read_on_write_error(evcon, req);
1556 evcon->flags & EVHTTP_CON_READ_ON_WRITE_ERROR &&
1558 event_deferred_cb_schedule_(get_deferred_queue(evcon),
1559 &evcon->read_more_deferred_cb);
1563 evhttp_connection_fail_(evcon, EVREQ_HTTP_EOF);
1566 evhttp_connection_fail_(evcon, EVREQ_HTTP_BUFFER_ERROR);
1576 struct evhttp_connection *evcon = arg;
1580 if (evcon->fd == -1)
1581 evcon->fd = bufferevent_getfd(bufev);
1596 if (evcon->fd == -1) {
1603 if (getsockopt(evcon->fd, SOL_SOCKET, SO_ERROR, (void*)&error,
1606 __func__, evcon->address, evcon->port,
1607 EV_SOCK_ARG(evcon->fd)));
1614 __func__, evcon->address, evcon->port,
1615 EV_SOCK_ARG(evcon->fd),
1622 __func__, evcon->address, evcon->port,
1623 EV_SOCK_ARG(evcon->fd)));
1626 evcon->retry_cnt = 0;
1627 evcon->state = EVCON_IDLE;
1630 bufferevent_setcb(evcon->bufev,
1634 evcon);
1636 if (!evutil_timerisset(&evcon->timeout)) {
1639 bufferevent_set_timeouts(evcon->bufev, &read_tv, &write_tv);
1641 bufferevent_set_timeouts(evcon->bufev, &evcon->timeout, &evcon->timeout);
1645 evhttp_request_dispatch(evcon);
1649 evhttp_connection_cb_cleanup(evcon);
1894 !evhttp_find_vhost(req->evcon->http_server, NULL, hostname))
2036 if (req->evcon != NULL &&
2037 evbuffer_get_length(buffer) > req->evcon->max_headers_size)
2043 if (req->evcon != NULL && len > req->evcon->max_headers_size) {
2112 if (req->evcon != NULL &&
2113 req->headers_size > req->evcon->max_headers_size) {
2148 if (req->evcon != NULL &&
2149 req->headers_size + evbuffer_get_length(buffer) > req->evcon->max_headers_size)
2190 EV_SIZE_ARG(evbuffer_get_length(bufferevent_get_input(req->evcon->bufev)))));
2217 evhttp_get_body(struct evhttp_connection *evcon, struct evhttp_request *req)
2224 evhttp_connection_done(evcon);
2227 evcon->state = EVCON_READING_BODY;
2234 evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
2240 evhttp_connection_done(evcon);
2256 if ((req->evcon->max_body_size <= EV_INT64_MAX) &&
2257 (ev_uint64_t)req->ntoread > req->evcon->max_body_size) {
2258 evhttp_lingering_fail(evcon, req);
2262 if (!evbuffer_get_length(bufferevent_get_input(evcon->bufev)))
2263 evhttp_send_continue(evcon, req);
2271 evhttp_read_body(evcon, req);
2276 evhttp_read_firstline(struct evhttp_connection *evcon,
2281 res = evhttp_parse_firstline_(req, bufferevent_get_input(evcon->bufev));
2285 __func__, EV_SOCK_ARG(evcon->fd)));
2286 evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
2293 evcon->state = EVCON_READING_HEADERS;
2294 evhttp_read_header(evcon, req);
2298 evhttp_read_header(struct evhttp_connection *evcon,
2302 evutil_socket_t fd = evcon->fd;
2304 res = evhttp_parse_headers_(req, bufferevent_get_input(evcon->bufev));
2309 evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
2319 evhttp_connection_fail_(evcon, EVREQ_HTTP_EOF);
2329 evhttp_get_body(evcon, req);
2336 struct evbuffer *output = bufferevent_get_output(evcon->bufev);
2338 evhttp_start_write_(evcon);
2344 evhttp_connection_done(evcon);
2349 evhttp_get_body(evcon, req);
2358 evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
2384 struct evhttp_connection *evcon = NULL;
2388 if ((evcon = mm_calloc(1, sizeof(struct evhttp_connection))) == NULL) {
2393 evcon->fd = -1;
2394 evcon->port = port;
2396 evcon->max_headers_size = EV_SIZE_MAX;
2397 evcon->max_body_size = EV_SIZE_MAX;
2399 evutil_timerclear(&evcon->timeout);
2400 evcon->retry_cnt = evcon->retry_max = 0;
2402 if ((evcon->address = mm_strdup(address)) == NULL) {
2414 bufferevent_setcb(bev, evhttp_read_cb, evhttp_write_cb, evhttp_error_cb, evcon);
2415 evcon->bufev = bev;
2417 evcon->state = EVCON_DISCONNECTED;
2418 TAILQ_INIT(&evcon->requests);
2420 evcon->initial_retry_timeout.tv_sec = 2;
2421 evcon->initial_retry_timeout.tv_usec = 0;
2424 evcon->base = base;
2426 bufferevent_base_set(base, evcon->bufev);
2430 &evcon->read_more_deferred_cb,
2432 evhttp_deferred_read_cb, evcon);
2434 evcon->dns_base = dnsbase;
2435 evcon->ai_family = AF_UNSPEC;
2437 return (evcon);
2440 if (evcon != NULL)
2441 evhttp_connection_free(evcon);
2445 struct bufferevent* evhttp_connection_get_bufferevent(struct evhttp_connection *evcon)
2447 return evcon->bufev;
2451 evhttp_connection_get_server(struct evhttp_connection *evcon)
2453 return evcon->http_server;
2463 evcon,
2466 evcon->ai_family = family;
2469 int evhttp_connection_set_flags(struct evhttp_connection *evcon,
2478 evcon->flags &= ~avail_flags;
2480 evcon->flags |= flags;
2486 evhttp_connection_set_base(struct evhttp_connection *evcon,
2489 EVUTIL_ASSERT(evcon->base == NULL);
2490 EVUTIL_ASSERT(evcon->state == EVCON_DISCONNECTED);
2491 evcon->base = base;
2492 bufferevent_base_set(base, evcon->bufev);
2496 evhttp_connection_set_timeout(struct evhttp_connection *evcon,
2500 evhttp_connection_set_timeout_tv(evcon, NULL);
2505 evhttp_connection_set_timeout_tv(evcon, &tv);
2510 evhttp_connection_set_timeout_tv(struct evhttp_connection *evcon,
2514 evcon->timeout = *tv;
2515 bufferevent_set_timeouts(evcon->bufev, &evcon->timeout, &evcon->timeout);
2519 evutil_timerclear(&evcon->timeout);
2520 bufferevent_set_timeouts(evcon->bufev, &read_tv, &write_tv);
2525 evhttp_connection_set_initial_retry_tv(struct evhttp_connection *evcon,
2529 evcon->initial_retry_timeout = *tv;
2531 evutil_timerclear(&evcon->initial_retry_timeout);
2532 evcon->initial_retry_timeout.tv_sec = 2;
2537 evhttp_connection_set_retries(struct evhttp_connection *evcon,
2540 evcon->retry_max = retry_max;
2544 evhttp_connection_set_closecb(struct evhttp_connection *evcon,
2547 evcon->closecb = cb;
2548 evcon->closecb_arg = cbarg;
2552 evhttp_connection_get_peer(struct evhttp_connection *evcon,
2555 *address = evcon->address;
2556 *port = evcon->port;
2560 evhttp_connection_get_addr(struct evhttp_connection *evcon)
2562 return bufferevent_socket_get_conn_address_(evcon->bufev);
2566 evhttp_connection_connect_(struct evhttp_connection *evcon)
2568 int old_state = evcon->state;
2569 const char *address = evcon->address;
2570 const struct sockaddr *sa = evhttp_connection_get_addr(evcon);
2573 if (evcon->state == EVCON_CONNECTING)
2576 evhttp_connection_reset_(evcon);
2578 EVUTIL_ASSERT(!(evcon->flags & EVHTTP_CON_INCOMING));
2579 evcon->flags |= EVHTTP_CON_OUTGOING;
2581 if (evcon->bind_address || evcon->bind_port) {
2582 evcon->fd = bind_socket(
2583 evcon->bind_address, evcon->bind_port, 0 /*reuse*/);
2584 if (evcon->fd == -1) {
2586 __func__, evcon->bind_address));
2590 if (bufferevent_setfd(evcon->bufev, evcon->fd))
2593 if (bufferevent_setfd(evcon->bufev, -1))
2598 bufferevent_setcb(evcon->bufev,
2602 evcon);
2603 if (!evutil_timerisset(&evcon->timeout)) {
2605 bufferevent_set_timeouts(evcon->bufev, &conn_tv, &conn_tv);
2607 bufferevent_set_timeouts(evcon->bufev, &evcon->timeout, &evcon->timeout);
2610 if (bufferevent_enable(evcon->bufev, EV_WRITE))
2613 evcon->state = EVCON_CONNECTING;
2615 if (evcon->flags & EVHTTP_CON_REUSE_CONNECTED_ADDR &&
2622 ret = bufferevent_socket_connect(evcon->bufev, sa, socklen);
2624 ret = bufferevent_socket_connect_hostname(evcon->bufev,
2625 evcon->dns_base, evcon->ai_family, address, evcon->port);
2629 evcon->state = old_state;
2630 event_sock_warn(evcon->fd, "%s: connection to \"%s\" failed",
2631 __func__, evcon->address);
2636 evhttp_connection_cb_cleanup(evcon);
2650 evhttp_make_request(struct evhttp_connection *evcon,
2671 EVUTIL_ASSERT(req->evcon == NULL);
2672 req->evcon = evcon;
2675 TAILQ_INSERT_TAIL(&evcon->requests, req, next);
2678 if (evcon->retry_cnt)
2682 if (!evhttp_connected(evcon)) {
2683 int res = evhttp_connection_connect_(evcon);
2686 * evcon->requests. Thus, enqueue the request in advance and
2689 TAILQ_REMOVE(&evcon->requests, req, next);
2699 if (TAILQ_FIRST(&evcon->requests) == req)
2700 evhttp_request_dispatch(evcon);
2708 struct evhttp_connection *evcon = req->evcon;
2709 if (evcon != NULL) {
2711 if (TAILQ_FIRST(&evcon->requests) == req) {
2715 evhttp_connection_fail_(evcon,
2724 TAILQ_REMOVE(&evcon->requests, req, next);
2737 evhttp_start_read_(struct evhttp_connection *evcon)
2739 bufferevent_disable(evcon->bufev, EV_WRITE);
2740 bufferevent_enable(evcon->bufev, EV_READ);
2742 evcon->state = EVCON_READING_FIRSTLINE;
2744 bufferevent_setcb(evcon->bufev,
2748 evcon);
2752 if (evbuffer_get_length(bufferevent_get_input(evcon->bufev))) {
2753 event_deferred_cb_schedule_(get_deferred_queue(evcon),
2754 &evcon->read_more_deferred_cb);
2759 evhttp_start_write_(struct evhttp_connection *evcon)
2761 bufferevent_disable(evcon->bufev, EV_WRITE);
2762 bufferevent_enable(evcon->bufev, EV_READ);
2764 evcon->state = EVCON_WRITING;
2765 evhttp_write_buffer(evcon, evhttp_write_connectioncb, NULL);
2769 evhttp_send_done(struct evhttp_connection *evcon, void *arg)
2772 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
2773 TAILQ_REMOVE(&evcon->requests, req, next);
2788 evhttp_connection_free(evcon);
2793 if (evhttp_associate_new_request_with_connection(evcon) == -1) {
2794 evhttp_connection_free(evcon);
2815 evhttp_connection_free(req->evcon);
2837 struct evhttp_connection *evcon = req->evcon;
2839 if (evcon == NULL) {
2844 EVUTIL_ASSERT(TAILQ_FIRST(&evcon->requests) == req);
2854 evhttp_make_header(evcon, req);
2856 evhttp_write_buffer(evcon, evhttp_send_done, NULL);
2874 if (req->evcon == NULL)
2891 evhttp_make_header(req->evcon, req);
2892 evhttp_write_buffer(req->evcon, NULL, NULL);
2899 struct evhttp_connection *evcon = req->evcon;
2902 if (evcon == NULL)
2905 output = bufferevent_get_output(evcon->bufev);
2919 evhttp_write_buffer(evcon, cb, arg);
2930 struct evhttp_connection *evcon = req->evcon;
2933 if (evcon == NULL) {
2938 output = bufferevent_get_output(evcon->bufev);
2945 evhttp_write_buffer(req->evcon, evhttp_send_done, NULL);
2949 evhttp_send_done(evcon, NULL);
2952 evcon->cb = evhttp_send_done;
2953 evcon->cb_arg = NULL;
3476 bufferevent_disable(req->evcon->bufev, EV_READ);
3518 evhttp_connection_free(req->evcon);
3524 evhttp_connection_free(req->evcon);
3736 struct evhttp_connection *evcon;
3750 while ((evcon = TAILQ_FIRST(&http->connections)) != NULL) {
3752 evhttp_connection_free(evcon);
4083 return req->evcon;
4230 struct evhttp_connection *evcon;
4255 evcon = evhttp_connection_base_bufferevent_new(
4259 if (evcon == NULL)
4262 evcon->max_headers_size = http->default_max_headers_size;
4263 evcon->max_body_size = http->default_max_body_size;
4265 evcon->flags |= EVHTTP_CON_LINGERING_CLOSE;
4267 evcon->flags |= EVHTTP_CON_INCOMING;
4268 evcon->state = EVCON_READING_FIRSTLINE;
4270 evcon->fd = fd;
4272 if (bufferevent_setfd(evcon->bufev, fd))
4274 if (bufferevent_enable(evcon->bufev, EV_READ))
4276 if (bufferevent_disable(evcon->bufev, EV_WRITE))
4278 bufferevent_socket_set_conn_address_(evcon->bufev, sa, salen);
4280 return (evcon);
4283 evhttp_connection_free(evcon);
4288 evhttp_associate_new_request_with_connection(struct evhttp_connection *evcon)
4290 struct evhttp *http = evcon->http_server;
4295 if ((req->remote_host = mm_strdup(evcon->address)) == NULL) {
4300 req->remote_port = evcon->port;
4302 req->evcon = evcon; /* the request ends up owning the connection */
4312 TAILQ_INSERT_TAIL(&evcon->requests, req, next);
4317 evhttp_start_read_(evcon);
4326 struct evhttp_connection *evcon;
4328 evcon = evhttp_get_request_connection(http, fd, sa, salen);
4329 if (evcon == NULL) {
4338 evhttp_connection_set_timeout_tv(evcon, &http->timeout);
4344 evcon->http_server = http;
4345 TAILQ_INSERT_TAIL(&http->connections, evcon, next);
4347 if (evhttp_associate_new_request_with_connection(evcon) == -1)
4348 evhttp_connection_free(evcon);
Indexes created Sun Mar 01 05:31:48 UTC 2026