Lines Matching defs:req
156 #define REQ_VERSION_BEFORE(req, major_v, minor_v) \
157 ((req)->major < (major_v) || \
158 ((req)->major == (major_v) && (req)->minor < (minor_v)))
160 #define REQ_VERSION_ATLEAST(req, major_v, minor_v) \
161 ((req)->major > (major_v) || \
162 ((req)->major == (major_v) && (req)->minor >= (minor_v)))
181 struct evhttp_request *req);
183 struct evhttp_request *req);
345 evhttp_response_needs_body(struct evhttp_request *req)
347 return (req->response_code != HTTP_NOCONTENT &&
348 req->response_code != HTTP_NOTMODIFIED &&
349 (req->response_code < 100 || req->response_code >= 200) &&
350 req->type != EVHTTP_REQ_HEAD);
387 struct evhttp_request *req)
392 req->major, req->minor);
427 struct evhttp_request *req)
431 evhttp_remove_header(req->output_headers, "Proxy-Connection");
434 method = evhttp_method(req->type);
437 method, req->uri, req->major, req->minor);
440 if ((req->type == EVHTTP_REQ_POST || req->type == EVHTTP_REQ_PUT) &&
441 evhttp_find_header(req->output_headers, "Content-Length") == NULL){
444 EV_SIZE_ARG(evbuffer_get_length(req->output_buffer)));
445 evhttp_add_header(req->output_headers, "Content-Length", size);
514 * Create the headers needed for an HTTP reply in req->output_headers,
515 * and write the first HTTP response for req line to evcon.
519 struct evhttp_request *req)
521 int is_keepalive = evhttp_is_connection_keepalive(req->input_headers);
524 req->major, req->minor, req->response_code,
525 req->response_code_line);
527 if (req->major == 1) {
528 if (req->minor >= 1)
529 evhttp_maybe_add_date_header(req->output_headers);
535 if (req->minor == 0 && is_keepalive)
536 evhttp_add_header(req->output_headers,
539 if ((req->minor >= 1 || is_keepalive) &&
540 evhttp_response_needs_body(req)) {
547 req->output_headers,
548 evbuffer_get_length(req->output_buffer));
553 if (evhttp_response_needs_body(req)) {
554 if (evhttp_find_header(req->output_headers,
557 evhttp_add_header(req->output_headers,
564 if (evhttp_is_connection_close(req->flags, req->input_headers)) {
565 evhttp_remove_header(req->output_headers, "Connection");
566 if (!(req->flags & EVHTTP_PROXY_REQUEST))
567 evhttp_add_header(req->output_headers, "Connection", "close");
568 evhttp_remove_header(req->output_headers, "Proxy-Connection");
572 /** Generate all headers appropriate for sending the http request in req (or
574 * bufferevent. Also writes all data from req->output_buffer */
576 evhttp_make_header(struct evhttp_connection *evcon, struct evhttp_request *req)
585 if (req->kind == EVHTTP_REQUEST) {
586 evhttp_make_header_request(evcon, req);
588 evhttp_make_header_response(evcon, req);
591 TAILQ_FOREACH(header, req->output_headers, next) {
597 if (evbuffer_get_length(req->output_buffer) > 0) {
605 evbuffer_add_buffer(output, req->output_buffer);
629 evhttp_connection_incoming_fail(struct evhttp_request *req,
643 if (!req->userdone) {
645 TAILQ_REMOVE(&req->evcon->requests, req, next);
649 req->evcon = NULL;
658 if (req->uri) {
659 mm_free(req->uri);
660 req->uri = NULL;
662 if (req->uri_elems) {
663 evhttp_uri_free(req->uri_elems);
664 req->uri_elems = NULL;
671 (*req->cb)(req, req->cb_arg);
686 struct evhttp_request* req = TAILQ_FIRST(&evcon->requests);
691 EVUTIL_ASSERT(req != NULL);
704 if (evhttp_connection_incoming_fail(req, error) == -1)
709 error_cb = req->error_cb;
710 error_cb_arg = req->cb_arg;
714 cb = req->cb;
715 cb_arg = req->cb_arg;
725 TAILQ_REMOVE(&evcon->requests, req, next);
726 evhttp_request_free(req);
770 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
777 TAILQ_REMOVE(&evcon->requests, req, next);
778 req->evcon = NULL;
783 evhttp_is_connection_close(req->flags, req->input_headers)||
784 evhttp_is_connection_close(req->flags, req->output_headers);
821 (*req->cb)(req, req->cb_arg);
826 if (con_outgoing && ((req->flags & EVHTTP_USER_OWNED) == 0)) {
827 evhttp_request_free(req);
856 evhttp_handle_chunked_read(struct evhttp_request *req, struct evbuffer *buf)
858 if (req == NULL || buf == NULL) {
875 if (req->ntoread < 0) {
899 if ((ev_uint64_t)ntoread > EV_SIZE_MAX - req->body_size) {
903 if (req->body_size + (size_t)ntoread > req->evcon->max_body_size) {
909 req->body_size += (size_t)ntoread;
910 req->ntoread = ntoread;
911 if (req->ntoread == 0) {
918 /* req->ntoread is signed int64, len is ssize_t, based on arch,
920 if (req->ntoread > EV_SSIZE_MAX) {
925 if (req->ntoread > 0 && buflen < (ev_uint64_t)req->ntoread)
929 evbuffer_remove_buffer(buf, req->input_buffer, (size_t)req->ntoread);
930 req->ntoread = -1;
931 if (req->chunk_cb != NULL) {
932 req->flags |= EVHTTP_REQ_DEFER_FREE;
933 (*req->chunk_cb)(req, req->cb_arg);
934 evbuffer_drain(req->input_buffer,
935 evbuffer_get_length(req->input_buffer));
936 req->flags &= ~EVHTTP_REQ_DEFER_FREE;
937 if ((req->flags & EVHTTP_REQ_NEEDS_FREE) != 0) {
947 evhttp_read_trailer(struct evhttp_connection *evcon, struct evhttp_request *req)
951 switch (evhttp_parse_headers_(req, buf)) {
969 evhttp_read_body(struct evhttp_connection *evcon, struct evhttp_request *req)
973 if (req->chunked) {
974 switch (evhttp_handle_chunked_read(req, buf)) {
978 evhttp_read_trailer(evcon, req);
988 evhttp_request_free(req);
994 } else if (req->ntoread < 0) {
996 if ((size_t)(req->body_size + evbuffer_get_length(buf)) < req->body_size) {
1001 req->body_size += evbuffer_get_length(buf);
1002 evbuffer_add_buffer(req->input_buffer, buf);
1003 } else if (req->chunk_cb != NULL || evbuffer_get_length(buf) >= (size_t)req->ntoread) {
1009 if (n > (size_t) req->ntoread)
1010 n = (size_t) req->ntoread;
1011 req->ntoread -= n;
1012 req->body_size += n;
1013 evbuffer_remove_buffer(buf, req->input_buffer, n);
1016 if (req->body_size > req->evcon->max_body_size ||
1017 (!req->chunked && req->ntoread >= 0 &&
1018 (size_t)req->ntoread > req->evcon->max_body_size)) {
1027 if (evbuffer_get_length(req->input_buffer) > 0 && req->chunk_cb != NULL) {
1028 req->flags |= EVHTTP_REQ_DEFER_FREE;
1029 (*req->chunk_cb)(req, req->cb_arg);
1030 req->flags &= ~EVHTTP_REQ_DEFER_FREE;
1031 evbuffer_drain(req->input_buffer,
1032 evbuffer_get_length(req->input_buffer));
1033 if ((req->flags & EVHTTP_REQ_NEEDS_FREE) != 0) {
1034 evhttp_request_free(req);
1039 if (req->ntoread == 0) {
1061 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
1069 evhttp_read_firstline(evcon, req);
1074 evhttp_read_header(evcon, req);
1079 evhttp_read_body(evcon, req);
1084 evhttp_read_trailer(evcon, req);
1123 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
1124 EVUTIL_ASSERT(req != NULL);
1129 req->kind = EVHTTP_RESPONSE;
1141 struct evhttp_request *req;
1154 while ((req = TAILQ_FIRST(&evcon->requests)) != NULL) {
1155 TAILQ_REMOVE(&evcon->requests, req, next);
1156 evhttp_request_free(req);
1221 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
1224 if (req == NULL)
1236 evhttp_make_header(evcon, req);
1363 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
1381 if (!req->chunked && req->ntoread < 0
1540 evhttp_parse_http_version(const char *version, struct evhttp_request *req)
1547 __func__, version, req, req->remote_host));
1550 req->major = major;
1551 req->minor = minor;
1558 evhttp_parse_response_line(struct evhttp_request *req, char *line)
1571 if (evhttp_parse_http_version(protocol, req) < 0)
1574 req->response_code = atoi(number);
1575 if (!evhttp_valid_response_code(req->response_code)) {
1581 if ((req->response_code_line = mm_strdup(readable)) == NULL) {
1592 evhttp_parse_request_line(struct evhttp_request *req, char *line)
1723 __func__, method, req, req->remote_host));
1725 * we see that req->type is unsupported. */
1728 req->type = type;
1730 if (evhttp_parse_http_version(version, req) < 0)
1733 if ((req->uri = mm_strdup(uri)) == NULL) {
1738 if ((req->uri_elems = evhttp_uri_parse_with_flags(req->uri,
1746 scheme = evhttp_uri_get_scheme(req->uri_elems);
1747 hostname = evhttp_uri_get_host(req->uri_elems);
1751 !evhttp_find_vhost(req->evcon->http_server, NULL, hostname))
1752 req->flags |= EVHTTP_PROXY_REQUEST;
1884 evhttp_parse_firstline_(struct evhttp_request *req, struct evbuffer *buffer)
1893 if (req->evcon != NULL &&
1894 evbuffer_get_length(buffer) > req->evcon->max_headers_size)
1900 if (req->evcon != NULL &&
1901 line_length > req->evcon->max_headers_size) {
1906 req->headers_size = line_length;
1908 switch (req->kind) {
1910 if (evhttp_parse_request_line(req, line) == -1)
1914 if (evhttp_parse_response_line(req, line) == -1)
1956 evhttp_parse_headers_(struct evhttp_request *req, struct evbuffer* buffer)
1962 struct evkeyvalq* headers = req->input_headers;
1968 req->headers_size += line_length;
1970 if (req->evcon != NULL &&
1971 req->headers_size > req->evcon->max_headers_size) {
2006 if (req->evcon != NULL &&
2007 req->headers_size + evbuffer_get_length(buffer) > req->evcon->max_headers_size)
2019 evhttp_get_body_length(struct evhttp_request *req)
2021 struct evkeyvalq *headers = req->input_headers;
2029 req->ntoread = -1;
2038 req->ntoread = -1;
2047 req->ntoread = ntoread;
2051 __func__, EV_I64_ARG(req->ntoread),
2052 EV_SIZE_ARG(evbuffer_get_length(bufferevent_get_input(req->evcon->bufev)))));
2080 evhttp_get_body(struct evhttp_connection *evcon, struct evhttp_request *req)
2085 if (req->kind == EVHTTP_REQUEST &&
2086 !evhttp_method_may_have_body(req->type)) {
2091 xfer_enc = evhttp_find_header(req->input_headers, "Transfer-Encoding");
2093 req->chunked = 1;
2094 req->ntoread = -1;
2096 if (evhttp_get_body_length(req) == -1) {
2101 if (req->kind == EVHTTP_REQUEST && req->ntoread < 1) {
2110 if (req->kind == EVHTTP_REQUEST && REQ_VERSION_ATLEAST(req, 1, 1)) {
2113 expect = evhttp_find_header(req->input_headers, "Expect");
2122 if (req->ntoread > 0) {
2124 if ((req->evcon->max_body_size <= EV_INT64_MAX) && (ev_uint64_t)req->ntoread > req->evcon->max_body_size) {
2125 evhttp_send_error(req, HTTP_ENTITYTOOLARGE, NULL);
2130 evhttp_send_continue(evcon, req);
2132 evhttp_send_error(req, HTTP_EXPECTATIONFAILED,
2139 evhttp_read_body(evcon, req);
2145 struct evhttp_request *req)
2149 res = evhttp_parse_firstline_(req, bufferevent_get_input(evcon->bufev));
2162 evhttp_read_header(evcon, req);
2167 struct evhttp_request *req)
2172 res = evhttp_parse_headers_(req, bufferevent_get_input(evcon->bufev));
2188 if (req->header_cb != NULL) {
2189 if ((*req->header_cb)(req, req->cb_arg) < 0) {
2196 switch (req->kind) {
2200 evhttp_get_body(evcon, req);
2206 if (req->response_code == 100) {
2210 if (!evhttp_response_needs_body(req)) {
2212 __func__, req->response_code));
2217 __func__, req->remote_host, EV_SOCK_ARG(fd)));
2218 evhttp_get_body(evcon, req);
2486 struct evhttp_request *req,
2490 req->kind = EVHTTP_REQUEST;
2491 req->type = type;
2492 if (req->uri != NULL)
2493 mm_free(req->uri);
2494 if ((req->uri = mm_strdup(uri)) == NULL) {
2496 evhttp_request_free(req);
2501 if (!req->major && !req->minor) {
2502 req->major = 1;
2503 req->minor = 1;
2506 EVUTIL_ASSERT(req->evcon == NULL);
2507 req->evcon = evcon;
2508 EVUTIL_ASSERT(!(req->flags & EVHTTP_REQ_OWN_CONNECTION));
2510 TAILQ_INSERT_TAIL(&evcon->requests, req, next);
2516 * evhttp_connection_connect_(), assumes that req lies in
2520 TAILQ_REMOVE(&evcon->requests, req, next);
2530 if (TAILQ_FIRST(&evcon->requests) == req)
2537 evhttp_cancel_request(struct evhttp_request *req)
2539 struct evhttp_connection *evcon = req->evcon;
2542 if (TAILQ_FIRST(&evcon->requests) == req) {
2555 TAILQ_REMOVE(&evcon->requests, req, next);
2559 evhttp_request_free(req);
2593 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
2594 TAILQ_REMOVE(&evcon->requests, req, next);
2596 if (req->on_complete_cb != NULL) {
2597 req->on_complete_cb(req, req->on_complete_cb_arg);
2601 (REQ_VERSION_BEFORE(req, 1, 1) &&
2602 !evhttp_is_connection_keepalive(req->input_headers))||
2603 evhttp_is_connection_close(req->flags, req->input_headers) ||
2604 evhttp_is_connection_close(req->flags, req->output_headers);
2606 EVUTIL_ASSERT(req->flags & EVHTTP_REQ_OWN_CONNECTION);
2607 evhttp_request_free(req);
2625 evhttp_send_error(struct evhttp_request *req, int error, const char *reason)
2637 evhttp_connection_free(req->evcon);
2644 evhttp_response_code_(req, error, reason);
2648 evhttp_send_page_(req, buf);
2657 evhttp_send(struct evhttp_request *req, struct evbuffer *databuf)
2659 struct evhttp_connection *evcon = req->evcon;
2662 evhttp_request_free(req);
2666 EVUTIL_ASSERT(TAILQ_FIRST(&evcon->requests) == req);
2669 req->userdone = 1;
2673 evbuffer_add_buffer(req->output_buffer, databuf);
2676 evhttp_make_header(evcon, req);
2682 evhttp_send_reply(struct evhttp_request *req, int code, const char *reason,
2685 evhttp_response_code_(req, code, reason);
2687 evhttp_send(req, databuf);
2691 evhttp_send_reply_start(struct evhttp_request *req, int code,
2694 evhttp_response_code_(req, code, reason);
2695 if (evhttp_find_header(req->output_headers, "Content-Length") == NULL &&
2696 REQ_VERSION_ATLEAST(req, 1, 1) &&
2697 evhttp_response_needs_body(req)) {
2703 evhttp_add_header(req->output_headers, "Transfer-Encoding",
2705 req->chunked = 1;
2707 req->chunked = 0;
2709 evhttp_make_header(req->evcon, req);
2710 evhttp_write_buffer(req->evcon, NULL, NULL);
2714 evhttp_send_reply_chunk_with_cb(struct evhttp_request *req, struct evbuffer *databuf,
2717 struct evhttp_connection *evcon = req->evcon;
2727 if (!evhttp_response_needs_body(req))
2729 if (req->chunked) {
2734 if (req->chunked) {
2741 evhttp_send_reply_chunk(struct evhttp_request *req, struct evbuffer *databuf)
2743 evhttp_send_reply_chunk_with_cb(req, databuf, NULL, NULL);
2746 evhttp_send_reply_end(struct evhttp_request *req)
2748 struct evhttp_connection *evcon = req->evcon;
2752 evhttp_request_free(req);
2759 req->userdone = 1;
2761 if (req->chunked) {
2763 evhttp_write_buffer(req->evcon, evhttp_send_done, NULL);
2764 req->chunked = 0;
2866 evhttp_response_code_(struct evhttp_request *req, int code, const char *reason)
2868 req->kind = EVHTTP_RESPONSE;
2869 req->response_code = code;
2870 if (req->response_code_line != NULL)
2871 mm_free(req->response_code_line);
2874 req->response_code_line = mm_strdup(reason);
2875 if (req->response_code_line == NULL) {
2882 evhttp_send_page_(struct evhttp_request *req, struct evbuffer *databuf)
2884 if (!req->major || !req->minor) {
2885 req->major = 1;
2886 req->minor = 1;
2889 if (req->kind != EVHTTP_RESPONSE)
2890 evhttp_response_code_(req, 200, "OK");
2892 evhttp_clear_headers(req->output_headers);
2893 evhttp_add_header(req->output_headers, "Content-Type", "text/html");
2894 evhttp_add_header(req->output_headers, "Connection", "close");
2896 evhttp_send(req, databuf);
3131 evhttp_dispatch_callback(struct httpcbq *callbacks, struct evhttp_request *req)
3139 path = evhttp_uri_get_path(req->uri_elems);
3261 evhttp_handle_request(struct evhttp_request *req, void *arg)
3268 req->userdone = 0;
3270 if (req->type == 0 || req->uri == NULL) {
3271 evhttp_send_error(req, HTTP_BADREQUEST, NULL);
3275 if ((http->allowed_methods & req->type) == 0) {
3277 (unsigned)req->type, (unsigned)http->allowed_methods));
3278 evhttp_send_error(req, HTTP_NOTIMPLEMENTED, NULL);
3283 hostname = evhttp_request_get_host(req);
3288 if ((cb = evhttp_dispatch_callback(&http->callbacks, req)) != NULL) {
3289 (*cb->cb)(req, cb->cbarg);
3295 (*http->gencb)(req, http->gencbarg);
3309 if ((escaped_html = evhttp_htmlescape(req->uri)) == NULL) {
3310 evhttp_connection_free(req->evcon);
3316 evhttp_connection_free(req->evcon);
3320 evhttp_response_code_(req, HTTP_NOTFOUND, "Not Found");
3326 evhttp_send_page_(req, buf);
3762 struct evhttp_request *req = NULL;
3765 if ((req = mm_calloc(1, sizeof(struct evhttp_request))) == NULL) {
3770 req->headers_size = 0;
3771 req->body_size = 0;
3773 req->kind = EVHTTP_RESPONSE;
3774 req->input_headers = mm_calloc(1, sizeof(struct evkeyvalq));
3775 if (req->input_headers == NULL) {
3779 TAILQ_INIT(req->input_headers);
3781 req->output_headers = mm_calloc(1, sizeof(struct evkeyvalq));
3782 if (req->output_headers == NULL) {
3786 TAILQ_INIT(req->output_headers);
3788 if ((req->input_buffer = evbuffer_new()) == NULL) {
3793 if ((req->output_buffer = evbuffer_new()) == NULL) {
3798 req->cb = cb;
3799 req->cb_arg = arg;
3801 return (req);
3804 if (req != NULL)
3805 evhttp_request_free(req);
3810 evhttp_request_free(struct evhttp_request *req)
3812 if ((req->flags & EVHTTP_REQ_DEFER_FREE) != 0) {
3813 req->flags |= EVHTTP_REQ_NEEDS_FREE;
3817 if (req->remote_host != NULL)
3818 mm_free(req->remote_host);
3819 if (req->uri != NULL)
3820 mm_free(req->uri);
3821 if (req->uri_elems != NULL)
3822 evhttp_uri_free(req->uri_elems);
3823 if (req->response_code_line != NULL)
3824 mm_free(req->response_code_line);
3825 if (req->host_cache != NULL)
3826 mm_free(req->host_cache);
3828 evhttp_clear_headers(req->input_headers);
3829 mm_free(req->input_headers);
3831 evhttp_clear_headers(req->output_headers);
3832 mm_free(req->output_headers);
3834 if (req->input_buffer != NULL)
3835 evbuffer_free(req->input_buffer);
3837 if (req->output_buffer != NULL)
3838 evbuffer_free(req->output_buffer);
3840 mm_free(req);
3844 evhttp_request_own(struct evhttp_request *req)
3846 req->flags |= EVHTTP_USER_OWNED;
3850 evhttp_request_is_owned(struct evhttp_request *req)
3852 return (req->flags & EVHTTP_USER_OWNED) != 0;
3856 evhttp_request_get_connection(struct evhttp_request *req)
3858 return req->evcon;
3868 evhttp_request_set_chunked_cb(struct evhttp_request *req,
3871 req->chunk_cb = cb;
3875 evhttp_request_set_header_cb(struct evhttp_request *req,
3878 req->header_cb = cb;
3882 evhttp_request_set_error_cb(struct evhttp_request *req,
3885 req->error_cb = cb;
3889 evhttp_request_set_on_complete_cb(struct evhttp_request *req,
3892 req->on_complete_cb = cb;
3893 req->on_complete_cb_arg = cb_arg;
3901 evhttp_request_get_uri(const struct evhttp_request *req) {
3902 if (req->uri == NULL)
3903 event_debug(("%s: request %p has no uri\n", __func__, req));
3904 return (req->uri);
3908 evhttp_request_get_evhttp_uri(const struct evhttp_request *req) {
3909 if (req->uri_elems == NULL)
3911 __func__, req));
3912 return (req->uri_elems);
3916 evhttp_request_get_host(struct evhttp_request *req)
3920 if (req->host_cache)
3921 return req->host_cache;
3923 if (req->uri_elems)
3924 host = evhttp_uri_get_host(req->uri_elems);
3925 if (!host && req->input_headers) {
3929 host = evhttp_find_header(req->input_headers, "Host");
3938 req->host_cache = mm_malloc(len + 1);
3939 if (!req->host_cache) {
3943 memcpy(req->host_cache, host, len);
3944 req->host_cache[len] = '\0';
3945 host = req->host_cache;
3954 evhttp_request_get_command(const struct evhttp_request *req) {
3955 return (req->type);
3959 evhttp_request_get_response_code(const struct evhttp_request *req)
3961 return req->response_code;
3965 evhttp_request_get_response_code_line(const struct evhttp_request *req)
3967 return req->response_code_line;
3971 struct evkeyvalq *evhttp_request_get_input_headers(struct evhttp_request *req)
3973 return (req->input_headers);
3977 struct evkeyvalq *evhttp_request_get_output_headers(struct evhttp_request *req)
3979 return (req->output_headers);
3983 struct evbuffer *evhttp_request_get_input_buffer(struct evhttp_request *req)
3985 return (req->input_buffer);
3989 struct evbuffer *evhttp_request_get_output_buffer(struct evhttp_request *req)
3991 return (req->output_buffer);
4047 struct evhttp_request *req;
4048 if ((req = evhttp_request_new(evhttp_handle_request, http)) == NULL)
4051 if ((req->remote_host = mm_strdup(evcon->address)) == NULL) {
4053 evhttp_request_free(req);
4056 req->remote_port = evcon->port;
4058 req->evcon = evcon; /* the request ends up owning the connection */
4059 req->flags |= EVHTTP_REQ_OWN_CONNECTION;
4066 req->userdone = 1;
4068 TAILQ_INSERT_TAIL(&evcon->requests, req, next);
4070 req->kind = EVHTTP_REQUEST;