2 * Copyright (c) 2002-2007 Niels Provos <provos@citi.umich.edu>
3 * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 #include "event2/event-config.h"
30 #ifdef _EVENT_HAVE_SYS_PARAM_H
31 #include <sys/param.h>
33 #ifdef _EVENT_HAVE_SYS_TYPES_H
34 #include <sys/types.h>
37 #ifdef _EVENT_HAVE_SYS_TIME_H
40 #ifdef HAVE_SYS_IOCCOM_H
41 #include <sys/ioccom.h>
45 #include <sys/resource.h>
46 #include <sys/socket.h>
54 #include <sys/queue.h>
56 #ifdef _EVENT_HAVE_NETINET_IN_H
57 #include <netinet/in.h>
59 #ifdef _EVENT_HAVE_ARPA_INET_H
60 #include <arpa/inet.h>
62 #ifdef _EVENT_HAVE_NETDB_H
79 #ifdef _EVENT_HAVE_UNISTD_H
82 #ifdef _EVENT_HAVE_FCNTL_H
86 #undef timeout_pending
87 #undef timeout_initialized
89 #include "strlcpy-internal.h"
90 #include "event2/http.h"
91 #include "event2/event.h"
92 #include "event2/buffer.h"
93 #include "event2/bufferevent.h"
94 #include "event2/bufferevent_compat.h"
95 #include "event2/http_struct.h"
96 #include "event2/http_compat.h"
97 #include "event2/util.h"
98 #include "event2/listener.h"
99 #include "log-internal.h"
100 #include "util-internal.h"
101 #include "http-internal.h"
102 #include "mm-internal.h"
103 #include "bufferevent-internal.h"
105 #ifndef _EVENT_HAVE_GETNAMEINFO
106 #define NI_MAXSERV 32
107 #define NI_MAXHOST 1025
109 #ifndef NI_NUMERICHOST
110 #define NI_NUMERICHOST 1
113 #ifndef NI_NUMERICSERV
114 #define NI_NUMERICSERV 2
118 fake_getnameinfo(const struct sockaddr
*sa
, size_t salen
, char *host
,
119 size_t hostlen
, char *serv
, size_t servlen
, int flags
)
121 struct sockaddr_in
*sin
= (struct sockaddr_in
*)sa
;
125 evutil_snprintf(tmpserv
, sizeof(tmpserv
),
126 "%d", ntohs(sin
->sin_port
));
127 if (strlcpy(serv
, tmpserv
, servlen
) >= servlen
)
132 if (flags
& NI_NUMERICHOST
) {
133 if (strlcpy(host
, inet_ntoa(sin
->sin_addr
),
140 hp
= gethostbyaddr((char *)&sin
->sin_addr
,
141 sizeof(struct in_addr
), AF_INET
);
145 if (strlcpy(host
, hp
->h_name
, hostlen
) >= hostlen
)
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)))
165 #define MIN(a,b) (((a)<(b))?(a):(b))
170 static evutil_socket_t
bind_socket_ai(struct evutil_addrinfo
*, int reuse
);
171 static evutil_socket_t
bind_socket(const char *, ev_uint16_t
, int reuse
);
172 static void name_from_addr(struct sockaddr
*, ev_socklen_t
, char **, char **);
173 static int evhttp_associate_new_request_with_connection(
174 struct evhttp_connection
*evcon
);
175 static void evhttp_connection_start_detectclose(
176 struct evhttp_connection
*evcon
);
177 static void evhttp_connection_stop_detectclose(
178 struct evhttp_connection
*evcon
);
179 static void evhttp_request_dispatch(struct evhttp_connection
* evcon
);
180 static void evhttp_read_firstline(struct evhttp_connection
*evcon
,
181 struct evhttp_request
*req
);
182 static void evhttp_read_header(struct evhttp_connection
*evcon
,
183 struct evhttp_request
*req
);
184 static int evhttp_add_header_internal(struct evkeyvalq
*headers
,
185 const char *key
, const char *value
);
186 static const char *evhttp_response_phrase_internal(int code
);
187 static void evhttp_get_request(struct evhttp
*, evutil_socket_t
, struct sockaddr
*, ev_socklen_t
);
188 static void evhttp_write_buffer(struct evhttp_connection
*,
189 void (*)(struct evhttp_connection
*, void *), void *);
190 static void evhttp_make_header(struct evhttp_connection
*, struct evhttp_request
*);
192 /* callbacks for bufferevent */
193 static void evhttp_read_cb(struct bufferevent
*, void *);
194 static void evhttp_write_cb(struct bufferevent
*, void *);
195 static void evhttp_error_cb(struct bufferevent
*bufev
, short what
, void *arg
);
196 static int evhttp_decode_uri_internal(const char *uri
, size_t length
,
197 char *ret
, int decode_plus
);
198 static int evhttp_find_vhost(struct evhttp
*http
, struct evhttp
**outhttp
,
199 const char *hostname
);
201 #ifndef _EVENT_HAVE_STRSEP
202 /* strsep replacement for platforms that lack it. Only works if
203 * del is one character long. */
205 strsep(char **s
, const char *del
)
208 EVUTIL_ASSERT(strlen(del
) == 1);
212 d
= strstr(tok
, del
);
223 html_replace(const char ch
, const char **escaped
)
249 * Replaces <, >, ", ' and & with <, >, ",
250 * ' and & correspondingly.
252 * The returned string needs to be freed by the caller.
256 evhttp_htmlescape(const char *html
)
259 size_t new_size
= 0, old_size
= 0;
260 char *escaped_html
, *p
;
265 old_size
= strlen(html
);
266 for (i
= 0; i
< old_size
; ++i
) {
267 const char *replaced
= NULL
;
268 const size_t replace_size
= html_replace(html
[i
], &replaced
);
269 if (replace_size
> EV_SIZE_MAX
- new_size
) {
270 event_warn("%s: html_replace overflow", __func__
);
273 new_size
+= replace_size
;
276 if (new_size
== EV_SIZE_MAX
)
278 p
= escaped_html
= mm_malloc(new_size
+ 1);
279 if (escaped_html
== NULL
) {
280 event_warn("%s: malloc(%lu)", __func__
,
281 (unsigned long)(new_size
+ 1));
284 for (i
= 0; i
< old_size
; ++i
) {
285 const char *replaced
= &html
[i
];
286 const size_t len
= html_replace(html
[i
], &replaced
);
287 memcpy(p
, replaced
, len
);
293 return (escaped_html
);
296 /** Given an evhttp_cmd_type, returns a constant string containing the
297 * equivalent HTTP command, or NULL if the evhttp_command_type is
300 evhttp_method(enum evhttp_cmd_type type
)
308 case EVHTTP_REQ_POST
:
311 case EVHTTP_REQ_HEAD
:
317 case EVHTTP_REQ_DELETE
:
320 case EVHTTP_REQ_OPTIONS
:
323 case EVHTTP_REQ_TRACE
:
326 case EVHTTP_REQ_CONNECT
:
329 case EVHTTP_REQ_PATCH
:
341 * Determines if a response should have a body.
342 * Follows the rules in RFC 2616 section 4.3.
343 * @return 1 if the response MUST have a body; 0 if the response MUST NOT have
347 evhttp_response_needs_body(struct evhttp_request
*req
)
349 return (req
->response_code
!= HTTP_NOCONTENT
&&
350 req
->response_code
!= HTTP_NOTMODIFIED
&&
351 (req
->response_code
< 100 || req
->response_code
>= 200) &&
352 req
->type
!= EVHTTP_REQ_HEAD
);
355 /** Helper: adds the event 'ev' with the timeout 'timeout', or with
356 * default_timeout if timeout is -1.
359 evhttp_add_event(struct event
*ev
, int timeout
, int default_timeout
)
364 evutil_timerclear(&tv
);
365 tv
.tv_sec
= timeout
!= -1 ? timeout
: default_timeout
;
366 return event_add(ev
, &tv
);
368 return event_add(ev
, NULL
);
372 /** Helper: called after we've added some data to an evcon's bufferevent's
373 * output buffer. Sets the evconn's writing-is-done callback, and puts
374 * the bufferevent into writing mode.
377 evhttp_write_buffer(struct evhttp_connection
*evcon
,
378 void (*cb
)(struct evhttp_connection
*, void *), void *arg
)
380 event_debug(("%s: preparing to write buffer\n", __func__
));
386 bufferevent_enable(evcon
->bufev
, EV_WRITE
);
388 /* Disable the read callback: we don't actually care about data;
389 * we only care about close detection. (We don't disable reading,
390 * since we *do* want to learn about any close events.) */
391 bufferevent_setcb(evcon
->bufev
,
399 evhttp_send_continue_done(struct evhttp_connection
*evcon
, void *arg
)
401 bufferevent_disable(evcon
->bufev
, EV_WRITE
);
405 evhttp_send_continue(struct evhttp_connection
*evcon
,
406 struct evhttp_request
*req
)
408 bufferevent_enable(evcon
->bufev
, EV_WRITE
);
409 evbuffer_add_printf(bufferevent_get_output(evcon
->bufev
),
410 "HTTP/%d.%d 100 Continue\r\n\r\n",
411 req
->major
, req
->minor
);
412 evcon
->cb
= evhttp_send_continue_done
;
413 evcon
->cb_arg
= NULL
;
414 bufferevent_setcb(evcon
->bufev
,
421 /** Helper: returns true iff evconn is in any connected state. */
423 evhttp_connected(struct evhttp_connection
*evcon
)
425 switch (evcon
->state
) {
426 case EVCON_DISCONNECTED
:
427 case EVCON_CONNECTING
:
430 case EVCON_READING_FIRSTLINE
:
431 case EVCON_READING_HEADERS
:
432 case EVCON_READING_BODY
:
433 case EVCON_READING_TRAILER
:
440 /* Create the headers needed for an outgoing HTTP request, adds them to
441 * the request's header list, and writes the request line to the
442 * connection's output buffer.
445 evhttp_make_header_request(struct evhttp_connection
*evcon
,
446 struct evhttp_request
*req
)
450 evhttp_remove_header(req
->output_headers
, "Proxy-Connection");
452 /* Generate request line */
453 method
= evhttp_method(req
->type
);
454 evbuffer_add_printf(bufferevent_get_output(evcon
->bufev
),
455 "%s %s HTTP/%d.%d\r\n",
456 method
, req
->uri
, req
->major
, req
->minor
);
458 /* Add the content length on a post or put request if missing */
459 if ((req
->type
== EVHTTP_REQ_POST
|| req
->type
== EVHTTP_REQ_PUT
) &&
460 evhttp_find_header(req
->output_headers
, "Content-Length") == NULL
){
462 evutil_snprintf(size
, sizeof(size
), EV_SIZE_FMT
,
463 EV_SIZE_ARG(evbuffer_get_length(req
->output_buffer
)));
464 evhttp_add_header(req
->output_headers
, "Content-Length", size
);
468 /** Return true if the list of headers in 'headers', intepreted with respect
469 * to flags, means that we should send a "connection: close" when the request
472 evhttp_is_connection_close(int flags
, struct evkeyvalq
* headers
)
474 if (flags
& EVHTTP_PROXY_REQUEST
) {
475 /* proxy connection */
476 const char *connection
= evhttp_find_header(headers
, "Proxy-Connection");
477 return (connection
== NULL
|| evutil_ascii_strcasecmp(connection
, "keep-alive") != 0);
479 const char *connection
= evhttp_find_header(headers
, "Connection");
480 return (connection
!= NULL
&& evutil_ascii_strcasecmp(connection
, "close") == 0);
484 /* Return true iff 'headers' contains 'Connection: keep-alive' */
486 evhttp_is_connection_keepalive(struct evkeyvalq
* headers
)
488 const char *connection
= evhttp_find_header(headers
, "Connection");
489 return (connection
!= NULL
490 && evutil_ascii_strncasecmp(connection
, "keep-alive", 10) == 0);
493 /* Add a correct "Date" header to headers, unless it already has one. */
495 evhttp_maybe_add_date_header(struct evkeyvalq
*headers
)
497 if (evhttp_find_header(headers
, "Date") == NULL
) {
503 time_t t
= time(NULL
);
510 if (strftime(date
, sizeof(date
),
511 "%a, %d %b %Y %H:%M:%S GMT", cur_p
) != 0) {
512 evhttp_add_header(headers
, "Date", date
);
517 /* Add a "Content-Length" header with value 'content_length' to headers,
518 * unless it already has a content-length or transfer-encoding header. */
520 evhttp_maybe_add_content_length_header(struct evkeyvalq
*headers
,
521 size_t content_length
)
523 if (evhttp_find_header(headers
, "Transfer-Encoding") == NULL
&&
524 evhttp_find_header(headers
, "Content-Length") == NULL
) {
526 evutil_snprintf(len
, sizeof(len
), EV_SIZE_FMT
,
527 EV_SIZE_ARG(content_length
));
528 evhttp_add_header(headers
, "Content-Length", len
);
533 * Create the headers needed for an HTTP reply in req->output_headers,
534 * and write the first HTTP response for req line to evcon.
537 evhttp_make_header_response(struct evhttp_connection
*evcon
,
538 struct evhttp_request
*req
)
540 int is_keepalive
= evhttp_is_connection_keepalive(req
->input_headers
);
541 evbuffer_add_printf(bufferevent_get_output(evcon
->bufev
),
542 "HTTP/%d.%d %d %s\r\n",
543 req
->major
, req
->minor
, req
->response_code
,
544 req
->response_code_line
);
546 if (req
->major
== 1) {
548 evhttp_maybe_add_date_header(req
->output_headers
);
551 * if the protocol is 1.0; and the connection was keep-alive
552 * we need to add a keep-alive header, too.
554 if (req
->minor
== 0 && is_keepalive
)
555 evhttp_add_header(req
->output_headers
,
556 "Connection", "keep-alive");
558 if ((req
->minor
>= 1 || is_keepalive
) &&
559 evhttp_response_needs_body(req
)) {
561 * we need to add the content length if the
562 * user did not give it, this is required for
563 * persistent connections to work.
565 evhttp_maybe_add_content_length_header(
567 evbuffer_get_length(req
->output_buffer
));
571 /* Potentially add headers for unidentified content. */
572 if (evhttp_response_needs_body(req
)) {
573 if (evhttp_find_header(req
->output_headers
,
574 "Content-Type") == NULL
) {
575 evhttp_add_header(req
->output_headers
,
576 "Content-Type", "text/html; charset=ISO-8859-1");
580 /* if the request asked for a close, we send a close, too */
581 if (evhttp_is_connection_close(req
->flags
, req
->input_headers
)) {
582 evhttp_remove_header(req
->output_headers
, "Connection");
583 if (!(req
->flags
& EVHTTP_PROXY_REQUEST
))
584 evhttp_add_header(req
->output_headers
, "Connection", "close");
585 evhttp_remove_header(req
->output_headers
, "Proxy-Connection");
589 /** Generate all headers appropriate for sending the http request in req (or
590 * the response, if we're sending a response), and write them to evcon's
591 * bufferevent. Also writes all data from req->output_buffer */
593 evhttp_make_header(struct evhttp_connection
*evcon
, struct evhttp_request
*req
)
595 struct evkeyval
*header
;
596 struct evbuffer
*output
= bufferevent_get_output(evcon
->bufev
);
599 * Depending if this is a HTTP request or response, we might need to
600 * add some new headers or remove existing headers.
602 if (req
->kind
== EVHTTP_REQUEST
) {
603 evhttp_make_header_request(evcon
, req
);
605 evhttp_make_header_response(evcon
, req
);
608 TAILQ_FOREACH(header
, req
->output_headers
, next
) {
609 evbuffer_add_printf(output
, "%s: %s\r\n",
610 header
->key
, header
->value
);
612 evbuffer_add(output
, "\r\n", 2);
614 if (evbuffer_get_length(req
->output_buffer
) > 0) {
616 * For a request, we add the POST data, for a reply, this
617 * is the regular data.
619 /* XXX We might want to support waiting (a limited amount of
620 time) for a continue status line from the server before
621 sending POST/PUT message bodies. */
622 evbuffer_add_buffer(output
, req
->output_buffer
);
627 evhttp_connection_set_max_headers_size(struct evhttp_connection
*evcon
,
628 ev_ssize_t new_max_headers_size
)
630 if (new_max_headers_size
<0)
631 evcon
->max_headers_size
= EV_SIZE_MAX
;
633 evcon
->max_headers_size
= new_max_headers_size
;
636 evhttp_connection_set_max_body_size(struct evhttp_connection
* evcon
,
637 ev_ssize_t new_max_body_size
)
639 if (new_max_body_size
<0)
640 evcon
->max_body_size
= EV_UINT64_MAX
;
642 evcon
->max_body_size
= new_max_body_size
;
646 evhttp_connection_incoming_fail(struct evhttp_request
*req
,
647 enum evhttp_connection_error error
)
650 case EVCON_HTTP_TIMEOUT
:
653 * these are cases in which we probably should just
654 * close the connection and not send a reply. this
655 * case may happen when a browser keeps a persistent
656 * connection open and we timeout on the read. when
657 * the request is still being used for sending, we
658 * need to disassociated it from the connection here.
660 if (!req
->userdone
) {
661 /* remove it so that it will not be freed */
662 TAILQ_REMOVE(&req
->evcon
->requests
, req
, next
);
663 /* indicate that this request no longer has a
669 case EVCON_HTTP_INVALID_HEADER
:
670 case EVCON_HTTP_BUFFER_ERROR
:
671 case EVCON_HTTP_REQUEST_CANCEL
:
672 default: /* xxx: probably should just error on default */
673 /* the callback looks at the uri to determine errors */
678 if (req
->uri_elems
) {
679 evhttp_uri_free(req
->uri_elems
);
680 req
->uri_elems
= NULL
;
684 * the callback needs to send a reply, once the reply has
685 * been send, the connection should get freed.
687 (*req
->cb
)(req
, req
->cb_arg
);
693 /* Called when evcon has experienced a (non-recoverable? -NM) error, as
694 * given in error. If it's an outgoing connection, reset the connection,
695 * retry any pending requests, and inform the user. If it's incoming,
696 * delegates to evhttp_connection_incoming_fail(). */
698 evhttp_connection_fail(struct evhttp_connection
*evcon
,
699 enum evhttp_connection_error error
)
701 struct evhttp_request
* req
= TAILQ_FIRST(&evcon
->requests
);
702 void (*cb
)(struct evhttp_request
*, void *);
704 EVUTIL_ASSERT(req
!= NULL
);
706 bufferevent_disable(evcon
->bufev
, EV_READ
|EV_WRITE
);
708 if (evcon
->flags
& EVHTTP_CON_INCOMING
) {
710 * for incoming requests, there are two different
711 * failure cases. it's either a network level error
712 * or an http layer error. for problems on the network
713 * layer like timeouts we just drop the connections.
714 * For HTTP problems, we might have to send back a
715 * reply before the connection can be freed.
717 if (evhttp_connection_incoming_fail(req
, error
) == -1)
718 evhttp_connection_free(evcon
);
722 /* when the request was canceled, the callback is not executed */
723 if (error
!= EVCON_HTTP_REQUEST_CANCEL
) {
724 /* save the callback for later; the cb might free our object */
726 cb_arg
= req
->cb_arg
;
732 /* do not fail all requests; the next request is going to get
733 * send over a new connection. when a user cancels a request,
734 * all other pending requests should be processed as normal
736 TAILQ_REMOVE(&evcon
->requests
, req
, next
);
737 evhttp_request_free(req
);
739 /* reset the connection */
740 evhttp_connection_reset(evcon
);
742 /* We are trying the next request that was queued on us */
743 if (TAILQ_FIRST(&evcon
->requests
) != NULL
)
744 evhttp_connection_connect(evcon
);
746 /* inform the user */
751 /* Bufferevent callback: invoked when any data has been written from an
752 * http connection's bufferevent */
754 evhttp_write_cb(struct bufferevent
*bufev
, void *arg
)
756 struct evhttp_connection
*evcon
= arg
;
758 /* Activate our call back */
759 if (evcon
->cb
!= NULL
)
760 (*evcon
->cb
)(evcon
, evcon
->cb_arg
);
764 * Advance the connection state.
765 * - If this is an outgoing connection, we've just processed the response;
766 * idle or close the connection.
767 * - If this is an incoming connection, we've just processed the request;
771 evhttp_connection_done(struct evhttp_connection
*evcon
)
773 struct evhttp_request
*req
= TAILQ_FIRST(&evcon
->requests
);
774 int con_outgoing
= evcon
->flags
& EVHTTP_CON_OUTGOING
;
777 /* idle or close the connection */
779 TAILQ_REMOVE(&evcon
->requests
, req
, next
);
782 evcon
->state
= EVCON_IDLE
;
785 evhttp_is_connection_close(req
->flags
, req
->input_headers
)||
786 evhttp_is_connection_close(req
->flags
, req
->output_headers
);
788 /* check if we got asked to close the connection */
790 evhttp_connection_reset(evcon
);
792 if (TAILQ_FIRST(&evcon
->requests
) != NULL
) {
794 * We have more requests; reset the connection
795 * and deal with the next request.
797 if (!evhttp_connected(evcon
))
798 evhttp_connection_connect(evcon
);
800 evhttp_request_dispatch(evcon
);
801 } else if (!need_close
) {
803 * The connection is going to be persistent, but we
804 * need to detect if the other side closes it.
806 evhttp_connection_start_detectclose(evcon
);
810 * incoming connection - we need to leave the request on the
811 * connection so that we can reply to it.
813 evcon
->state
= EVCON_WRITING
;
816 /* notify the user of the request */
817 (*req
->cb
)(req
, req
->cb_arg
);
819 /* if this was an outgoing request, we own and it's done. so free it.
820 * unless the callback specifically requested to own the request.
822 if (con_outgoing
&& ((req
->flags
& EVHTTP_USER_OWNED
) == 0)) {
823 evhttp_request_free(req
);
828 * Handles reading from a chunked request.
829 * return ALL_DATA_READ:
830 * all data has been read
831 * return MORE_DATA_EXPECTED:
832 * more data is expected
833 * return DATA_CORRUPTED:
835 * return REQUEST_CANCELED:
836 * request was canceled by the user calling evhttp_cancel_request
837 * return DATA_TOO_LONG:
838 * ran over the maximum limit
841 static enum message_read_status
842 evhttp_handle_chunked_read(struct evhttp_request
*req
, struct evbuffer
*buf
)
844 if (req
== NULL
|| buf
== NULL
) {
845 return DATA_CORRUPTED
;
851 if ((buflen
= evbuffer_get_length(buf
)) == 0) {
855 /* evbuffer_get_length returns size_t, but len variable is ssize_t,
856 * check for overflow conditions */
857 if (buflen
> EV_SSIZE_MAX
) {
858 return DATA_CORRUPTED
;
861 if (req
->ntoread
< 0) {
862 /* Read chunk size */
864 char *p
= evbuffer_readln(buf
, NULL
, EVBUFFER_EOL_CRLF
);
869 /* the last chunk is on a new line? */
870 if (strlen(p
) == 0) {
874 ntoread
= evutil_strtoll(p
, &endp
, 16);
875 error
= (*p
== '\0' ||
876 (*endp
!= '\0' && *endp
!= ' ') ||
880 /* could not get chunk size */
881 return (DATA_CORRUPTED
);
884 /* ntoread is signed int64, body_size is unsigned size_t, check for under/overflow conditions */
885 if ((ev_uint64_t
)ntoread
> EV_SIZE_MAX
- req
->body_size
) {
886 return DATA_CORRUPTED
;
889 if (req
->body_size
+ (size_t)ntoread
> req
->evcon
->max_body_size
) {
890 /* failed body length test */
891 event_debug(("Request body is too long"));
892 return (DATA_TOO_LONG
);
895 req
->body_size
+= (size_t)ntoread
;
896 req
->ntoread
= ntoread
;
897 if (req
->ntoread
== 0) {
899 return (ALL_DATA_READ
);
904 /* req->ntoread is signed int64, len is ssize_t, based on arch,
905 * ssize_t could only be 32b, check for these conditions */
906 if (req
->ntoread
> EV_SSIZE_MAX
) {
907 return DATA_CORRUPTED
;
910 /* don't have enough to complete a chunk; wait for more */
911 if (req
->ntoread
> 0 && buflen
< (ev_uint64_t
)req
->ntoread
)
912 return (MORE_DATA_EXPECTED
);
914 /* Completed chunk */
915 evbuffer_remove_buffer(buf
, req
->input_buffer
, (size_t)req
->ntoread
);
917 if (req
->chunk_cb
!= NULL
) {
918 req
->flags
|= EVHTTP_REQ_DEFER_FREE
;
919 (*req
->chunk_cb
)(req
, req
->cb_arg
);
920 evbuffer_drain(req
->input_buffer
,
921 evbuffer_get_length(req
->input_buffer
));
922 req
->flags
&= ~EVHTTP_REQ_DEFER_FREE
;
923 if ((req
->flags
& EVHTTP_REQ_NEEDS_FREE
) != 0) {
924 return (REQUEST_CANCELED
);
929 return (MORE_DATA_EXPECTED
);
933 evhttp_read_trailer(struct evhttp_connection
*evcon
, struct evhttp_request
*req
)
935 struct evbuffer
*buf
= bufferevent_get_input(evcon
->bufev
);
937 switch (evhttp_parse_headers(req
, buf
)) {
940 evhttp_connection_fail(evcon
, EVCON_HTTP_INVALID_HEADER
);
943 bufferevent_disable(evcon
->bufev
, EV_READ
);
944 evhttp_connection_done(evcon
);
946 case MORE_DATA_EXPECTED
:
947 case REQUEST_CANCELED
: /* ??? */
949 bufferevent_enable(evcon
->bufev
, EV_READ
);
955 evhttp_read_body(struct evhttp_connection
*evcon
, struct evhttp_request
*req
)
957 struct evbuffer
*buf
= bufferevent_get_input(evcon
->bufev
);
960 switch (evhttp_handle_chunked_read(req
, buf
)) {
962 /* finished last chunk */
963 evcon
->state
= EVCON_READING_TRAILER
;
964 evhttp_read_trailer(evcon
, req
);
967 case DATA_TOO_LONG
:/*separate error for this? XXX */
969 evhttp_connection_fail(evcon
,
970 EVCON_HTTP_INVALID_HEADER
);
972 case REQUEST_CANCELED
:
973 /* request canceled */
974 evhttp_request_free(req
);
976 case MORE_DATA_EXPECTED
:
980 } else if (req
->ntoread
< 0) {
981 /* Read until connection close. */
982 if ((size_t)(req
->body_size
+ evbuffer_get_length(buf
)) < req
->body_size
) {
983 evhttp_connection_fail(evcon
, EVCON_HTTP_INVALID_HEADER
);
987 req
->body_size
+= evbuffer_get_length(buf
);
988 evbuffer_add_buffer(req
->input_buffer
, buf
);
989 } else if (req
->chunk_cb
!= NULL
|| evbuffer_get_length(buf
) >= (size_t)req
->ntoread
) {
990 /* XXX: the above get_length comparison has to be fixed for overflow conditions! */
991 /* We've postponed moving the data until now, but we're
992 * about to use it. */
993 size_t n
= evbuffer_get_length(buf
);
995 if (n
> (size_t) req
->ntoread
)
996 n
= (size_t) req
->ntoread
;
999 evbuffer_remove_buffer(buf
, req
->input_buffer
, n
);
1002 if (req
->body_size
> req
->evcon
->max_body_size
||
1003 (!req
->chunked
&& req
->ntoread
>= 0 &&
1004 (size_t)req
->ntoread
> req
->evcon
->max_body_size
)) {
1005 /* XXX: The above casted comparison must checked for overflow */
1006 /* failed body length test */
1007 event_debug(("Request body is too long"));
1008 evhttp_connection_fail(evcon
,
1009 EVCON_HTTP_INVALID_HEADER
);
1013 if (evbuffer_get_length(req
->input_buffer
) > 0 && req
->chunk_cb
!= NULL
) {
1014 req
->flags
|= EVHTTP_REQ_DEFER_FREE
;
1015 (*req
->chunk_cb
)(req
, req
->cb_arg
);
1016 req
->flags
&= ~EVHTTP_REQ_DEFER_FREE
;
1017 evbuffer_drain(req
->input_buffer
,
1018 evbuffer_get_length(req
->input_buffer
));
1019 if ((req
->flags
& EVHTTP_REQ_NEEDS_FREE
) != 0) {
1020 evhttp_request_free(req
);
1025 if (req
->ntoread
== 0) {
1026 bufferevent_disable(evcon
->bufev
, EV_READ
);
1027 /* Completed content length */
1028 evhttp_connection_done(evcon
);
1033 bufferevent_enable(evcon
->bufev
, EV_READ
);
1036 #define get_deferred_queue(evcon) \
1037 (event_base_get_deferred_cb_queue((evcon)->base))
1040 * Gets called when more data becomes available
1044 evhttp_read_cb(struct bufferevent
*bufev
, void *arg
)
1046 struct evhttp_connection
*evcon
= arg
;
1047 struct evhttp_request
*req
= TAILQ_FIRST(&evcon
->requests
);
1049 /* Cancel if it's pending. */
1050 event_deferred_cb_cancel(get_deferred_queue(evcon
),
1051 &evcon
->read_more_deferred_cb
);
1053 switch (evcon
->state
) {
1054 case EVCON_READING_FIRSTLINE
:
1055 evhttp_read_firstline(evcon
, req
);
1056 /* note the request may have been freed in
1057 * evhttp_read_body */
1059 case EVCON_READING_HEADERS
:
1060 evhttp_read_header(evcon
, req
);
1061 /* note the request may have been freed in
1062 * evhttp_read_body */
1064 case EVCON_READING_BODY
:
1065 evhttp_read_body(evcon
, req
);
1066 /* note the request may have been freed in
1067 * evhttp_read_body */
1069 case EVCON_READING_TRAILER
:
1070 evhttp_read_trailer(evcon
, req
);
1075 struct evbuffer
*input
;
1078 input
= bufferevent_get_input(evcon
->bufev
);
1079 total_len
= evbuffer_get_length(input
);
1080 event_debug(("%s: read "EV_SIZE_FMT
1081 " bytes in EVCON_IDLE state,"
1082 " resetting connection",
1083 __func__
, EV_SIZE_ARG(total_len
)));
1086 evhttp_connection_reset(evcon
);
1089 case EVCON_DISCONNECTED
:
1090 case EVCON_CONNECTING
:
1093 event_errx(1, "%s: illegal connection state %d",
1094 __func__
, evcon
->state
);
1099 evhttp_deferred_read_cb(struct deferred_cb
*cb
, void *data
)
1101 struct evhttp_connection
*evcon
= data
;
1102 evhttp_read_cb(evcon
->bufev
, evcon
);
1106 evhttp_write_connectioncb(struct evhttp_connection
*evcon
, void *arg
)
1108 /* This is after writing the request to the server */
1109 struct evhttp_request
*req
= TAILQ_FIRST(&evcon
->requests
);
1110 EVUTIL_ASSERT(req
!= NULL
);
1112 EVUTIL_ASSERT(evcon
->state
== EVCON_WRITING
);
1114 /* We are done writing our header and are now expecting the response */
1115 req
->kind
= EVHTTP_RESPONSE
;
1117 evhttp_start_read(evcon
);
1121 * Clean up a connection object
1125 evhttp_connection_free(struct evhttp_connection
*evcon
)
1127 struct evhttp_request
*req
;
1129 /* notify interested parties that this connection is going down */
1130 if (evcon
->fd
!= -1) {
1131 if (evhttp_connected(evcon
) && evcon
->closecb
!= NULL
)
1132 (*evcon
->closecb
)(evcon
, evcon
->closecb_arg
);
1135 /* remove all requests that might be queued on this
1136 * connection. for server connections, this should be empty.
1137 * because it gets dequeued either in evhttp_connection_done or
1138 * evhttp_connection_fail.
1140 while ((req
= TAILQ_FIRST(&evcon
->requests
)) != NULL
) {
1141 TAILQ_REMOVE(&evcon
->requests
, req
, next
);
1142 evhttp_request_free(req
);
1145 if (evcon
->http_server
!= NULL
) {
1146 struct evhttp
*http
= evcon
->http_server
;
1147 TAILQ_REMOVE(&http
->connections
, evcon
, next
);
1150 if (event_initialized(&evcon
->retry_ev
)) {
1151 event_del(&evcon
->retry_ev
);
1152 event_debug_unassign(&evcon
->retry_ev
);
1155 if (evcon
->bufev
!= NULL
)
1156 bufferevent_free(evcon
->bufev
);
1158 event_deferred_cb_cancel(get_deferred_queue(evcon
),
1159 &evcon
->read_more_deferred_cb
);
1161 if (evcon
->fd
!= -1) {
1162 shutdown(evcon
->fd
, EVUTIL_SHUT_WR
);
1163 evutil_closesocket(evcon
->fd
);
1166 if (evcon
->bind_address
!= NULL
)
1167 mm_free(evcon
->bind_address
);
1169 if (evcon
->address
!= NULL
)
1170 mm_free(evcon
->address
);
1176 evhttp_connection_set_local_address(struct evhttp_connection
*evcon
,
1177 const char *address
)
1179 EVUTIL_ASSERT(evcon
->state
== EVCON_DISCONNECTED
);
1180 if (evcon
->bind_address
)
1181 mm_free(evcon
->bind_address
);
1182 if ((evcon
->bind_address
= mm_strdup(address
)) == NULL
)
1183 event_warn("%s: strdup", __func__
);
1187 evhttp_connection_set_local_port(struct evhttp_connection
*evcon
,
1190 EVUTIL_ASSERT(evcon
->state
== EVCON_DISCONNECTED
);
1191 evcon
->bind_port
= port
;
1195 evhttp_request_dispatch(struct evhttp_connection
* evcon
)
1197 struct evhttp_request
*req
= TAILQ_FIRST(&evcon
->requests
);
1199 /* this should not usually happy but it's possible */
1203 /* delete possible close detection events */
1204 evhttp_connection_stop_detectclose(evcon
);
1206 /* we assume that the connection is connected already */
1207 EVUTIL_ASSERT(evcon
->state
== EVCON_IDLE
);
1209 evcon
->state
= EVCON_WRITING
;
1211 /* Create the header from the store arguments */
1212 evhttp_make_header(evcon
, req
);
1214 evhttp_write_buffer(evcon
, evhttp_write_connectioncb
, NULL
);
1217 /* Reset our connection state: disables reading/writing, closes our fd (if
1218 * any), clears out buffers, and puts us in state DISCONNECTED. */
1220 evhttp_connection_reset(struct evhttp_connection
*evcon
)
1222 struct evbuffer
*tmp
;
1224 /* XXXX This is not actually an optimal fix. Instead we ought to have
1225 an API for "stop connecting", or use bufferevent_setfd to turn off
1226 connecting. But for Libevent 2.0, this seems like a minimal change
1227 least likely to disrupt the rest of the bufferevent and http code.
1229 Why is this here? If the fd is set in the bufferevent, and the
1230 bufferevent is connecting, then you can't actually stop the
1231 bufferevent from trying to connect with bufferevent_disable(). The
1232 connect will never trigger, since we close the fd, but the timeout
1233 might. That caused an assertion failure in evhttp_connection_fail.
1235 bufferevent_disable_hard(evcon
->bufev
, EV_READ
|EV_WRITE
);
1237 if (evcon
->fd
!= -1) {
1238 /* inform interested parties about connection close */
1239 if (evhttp_connected(evcon
) && evcon
->closecb
!= NULL
)
1240 (*evcon
->closecb
)(evcon
, evcon
->closecb_arg
);
1242 shutdown(evcon
->fd
, EVUTIL_SHUT_WR
);
1243 evutil_closesocket(evcon
->fd
);
1247 /* we need to clean up any buffered data */
1248 tmp
= bufferevent_get_output(evcon
->bufev
);
1249 evbuffer_drain(tmp
, evbuffer_get_length(tmp
));
1250 tmp
= bufferevent_get_input(evcon
->bufev
);
1251 evbuffer_drain(tmp
, evbuffer_get_length(tmp
));
1253 evcon
->state
= EVCON_DISCONNECTED
;
1257 evhttp_connection_start_detectclose(struct evhttp_connection
*evcon
)
1259 evcon
->flags
|= EVHTTP_CON_CLOSEDETECT
;
1261 bufferevent_enable(evcon
->bufev
, EV_READ
);
1265 evhttp_connection_stop_detectclose(struct evhttp_connection
*evcon
)
1267 evcon
->flags
&= ~EVHTTP_CON_CLOSEDETECT
;
1269 bufferevent_disable(evcon
->bufev
, EV_READ
);
1273 evhttp_connection_retry(evutil_socket_t fd
, short what
, void *arg
)
1275 struct evhttp_connection
*evcon
= arg
;
1277 evcon
->state
= EVCON_DISCONNECTED
;
1278 evhttp_connection_connect(evcon
);
1282 evhttp_connection_cb_cleanup(struct evhttp_connection
*evcon
)
1284 struct evcon_requestq requests
;
1286 if (evcon
->retry_max
< 0 || evcon
->retry_cnt
< evcon
->retry_max
) {
1287 evtimer_assign(&evcon
->retry_ev
, evcon
->base
, evhttp_connection_retry
, evcon
);
1288 /* XXXX handle failure from evhttp_add_event */
1289 evhttp_add_event(&evcon
->retry_ev
,
1290 MIN(3600, 2 << evcon
->retry_cnt
),
1291 HTTP_CONNECT_TIMEOUT
);
1295 evhttp_connection_reset(evcon
);
1298 * User callback can do evhttp_make_request() on the same
1299 * evcon so new request will be added to evcon->requests. To
1300 * avoid freeing it prematurely we iterate over the copy of
1303 TAILQ_INIT(&requests
);
1304 while (TAILQ_FIRST(&evcon
->requests
) != NULL
) {
1305 struct evhttp_request
*request
= TAILQ_FIRST(&evcon
->requests
);
1306 TAILQ_REMOVE(&evcon
->requests
, request
, next
);
1307 TAILQ_INSERT_TAIL(&requests
, request
, next
);
1310 /* for now, we just signal all requests by executing their callbacks */
1311 while (TAILQ_FIRST(&requests
) != NULL
) {
1312 struct evhttp_request
*request
= TAILQ_FIRST(&requests
);
1313 TAILQ_REMOVE(&requests
, request
, next
);
1314 request
->evcon
= NULL
;
1316 /* we might want to set an error here */
1317 request
->cb(request
, request
->cb_arg
);
1318 evhttp_request_free(request
);
1323 evhttp_error_cb(struct bufferevent
*bufev
, short what
, void *arg
)
1325 struct evhttp_connection
*evcon
= arg
;
1326 struct evhttp_request
*req
= TAILQ_FIRST(&evcon
->requests
);
1328 switch (evcon
->state
) {
1329 case EVCON_CONNECTING
:
1330 if (what
& BEV_EVENT_TIMEOUT
) {
1331 event_debug(("%s: connection timeout for \"%s:%d\" on %d",
1332 __func__
, evcon
->address
, evcon
->port
,
1334 evhttp_connection_cb_cleanup(evcon
);
1339 case EVCON_READING_BODY
:
1340 if (!req
->chunked
&& req
->ntoread
< 0
1341 && what
== (BEV_EVENT_READING
|BEV_EVENT_EOF
)) {
1342 /* EOF on read can be benign */
1343 evhttp_connection_done(evcon
);
1348 case EVCON_DISCONNECTED
:
1350 case EVCON_READING_FIRSTLINE
:
1351 case EVCON_READING_HEADERS
:
1352 case EVCON_READING_TRAILER
:
1358 /* when we are in close detect mode, a read error means that
1359 * the other side closed their connection.
1361 if (evcon
->flags
& EVHTTP_CON_CLOSEDETECT
) {
1362 evcon
->flags
&= ~EVHTTP_CON_CLOSEDETECT
;
1363 EVUTIL_ASSERT(evcon
->http_server
== NULL
);
1364 /* For connections from the client, we just
1365 * reset the connection so that it becomes
1368 EVUTIL_ASSERT(evcon
->state
== EVCON_IDLE
);
1369 evhttp_connection_reset(evcon
);
1373 if (what
& BEV_EVENT_TIMEOUT
) {
1374 evhttp_connection_fail(evcon
, EVCON_HTTP_TIMEOUT
);
1375 } else if (what
& (BEV_EVENT_EOF
|BEV_EVENT_ERROR
)) {
1376 evhttp_connection_fail(evcon
, EVCON_HTTP_EOF
);
1378 evhttp_connection_fail(evcon
, EVCON_HTTP_BUFFER_ERROR
);
1383 * Event callback for asynchronous connection attempt.
1386 evhttp_connection_cb(struct bufferevent
*bufev
, short what
, void *arg
)
1388 struct evhttp_connection
*evcon
= arg
;
1390 ev_socklen_t errsz
= sizeof(error
);
1392 if (!(what
& BEV_EVENT_CONNECTED
)) {
1393 /* some operating systems return ECONNREFUSED immediately
1394 * when connecting to a local address. the cleanup is going
1395 * to reschedule this function call.
1398 if (errno
== ECONNREFUSED
)
1401 evhttp_error_cb(bufev
, what
, arg
);
1405 /* Check if the connection completed */
1406 if (getsockopt(evcon
->fd
, SOL_SOCKET
, SO_ERROR
, (void*)&error
,
1408 event_debug(("%s: getsockopt for \"%s:%d\" on %d",
1409 __func__
, evcon
->address
, evcon
->port
, evcon
->fd
));
1414 event_debug(("%s: connect failed for \"%s:%d\" on %d: %s",
1415 __func__
, evcon
->address
, evcon
->port
, evcon
->fd
,
1416 evutil_socket_error_to_string(error
)));
1420 /* We are connected to the server now */
1421 event_debug(("%s: connected to \"%s:%d\" on %d\n",
1422 __func__
, evcon
->address
, evcon
->port
, evcon
->fd
));
1424 /* Reset the retry count as we were successful in connecting */
1425 evcon
->retry_cnt
= 0;
1426 evcon
->state
= EVCON_IDLE
;
1428 /* reset the bufferevent cbs */
1429 bufferevent_setcb(evcon
->bufev
,
1435 if (evcon
->timeout
== -1)
1436 bufferevent_settimeout(evcon
->bufev
,
1437 HTTP_READ_TIMEOUT
, HTTP_WRITE_TIMEOUT
);
1440 tv
.tv_sec
= evcon
->timeout
;
1442 bufferevent_set_timeouts(evcon
->bufev
, &tv
, &tv
);
1445 /* try to start requests that have queued up on this connection */
1446 evhttp_request_dispatch(evcon
);
1450 evhttp_connection_cb_cleanup(evcon
);
1454 * Check if we got a valid response code.
1458 evhttp_valid_response_code(int code
)
1467 evhttp_parse_http_version(const char *version
, struct evhttp_request
*req
)
1471 int n
= sscanf(version
, "HTTP/%d.%d%c", &major
, &minor
, &ch
);
1472 if (n
!= 2 || major
> 1) {
1473 event_debug(("%s: bad version %s on message %p from %s",
1474 __func__
, version
, req
, req
->remote_host
));
1482 /* Parses the status line of a web server */
1485 evhttp_parse_response_line(struct evhttp_request
*req
, char *line
)
1489 const char *readable
= "";
1491 protocol
= strsep(&line
, " ");
1494 number
= strsep(&line
, " ");
1498 if (evhttp_parse_http_version(protocol
, req
) < 0)
1501 req
->response_code
= atoi(number
);
1502 if (!evhttp_valid_response_code(req
->response_code
)) {
1503 event_debug(("%s: bad response code \"%s\"",
1508 if ((req
->response_code_line
= mm_strdup(readable
)) == NULL
) {
1509 event_warn("%s: strdup", __func__
);
1516 /* Parse the first line of a HTTP request */
1519 evhttp_parse_request_line(struct evhttp_request
*req
, char *line
)
1524 const char *hostname
;
1527 /* Parse the request line */
1528 method
= strsep(&line
, " ");
1531 uri
= strsep(&line
, " ");
1534 version
= strsep(&line
, " ");
1539 if (strcmp(method
, "GET") == 0) {
1540 req
->type
= EVHTTP_REQ_GET
;
1541 } else if (strcmp(method
, "POST") == 0) {
1542 req
->type
= EVHTTP_REQ_POST
;
1543 } else if (strcmp(method
, "HEAD") == 0) {
1544 req
->type
= EVHTTP_REQ_HEAD
;
1545 } else if (strcmp(method
, "PUT") == 0) {
1546 req
->type
= EVHTTP_REQ_PUT
;
1547 } else if (strcmp(method
, "DELETE") == 0) {
1548 req
->type
= EVHTTP_REQ_DELETE
;
1549 } else if (strcmp(method
, "OPTIONS") == 0) {
1550 req
->type
= EVHTTP_REQ_OPTIONS
;
1551 } else if (strcmp(method
, "TRACE") == 0) {
1552 req
->type
= EVHTTP_REQ_TRACE
;
1553 } else if (strcmp(method
, "PATCH") == 0) {
1554 req
->type
= EVHTTP_REQ_PATCH
;
1556 req
->type
= _EVHTTP_REQ_UNKNOWN
;
1557 event_debug(("%s: bad method %s on request %p from %s",
1558 __func__
, method
, req
, req
->remote_host
));
1559 /* No error yet; we'll give a better error later when
1560 * we see that req->type is unsupported. */
1563 if (evhttp_parse_http_version(version
, req
) < 0)
1566 if ((req
->uri
= mm_strdup(uri
)) == NULL
) {
1567 event_debug(("%s: mm_strdup", __func__
));
1571 if ((req
->uri_elems
= evhttp_uri_parse_with_flags(req
->uri
,
1572 EVHTTP_URI_NONCONFORMANT
)) == NULL
) {
1576 /* If we have an absolute-URI, check to see if it is an http request
1577 for a known vhost or server alias. If we don't know about this
1578 host, we consider it a proxy request. */
1579 scheme
= evhttp_uri_get_scheme(req
->uri_elems
);
1580 hostname
= evhttp_uri_get_host(req
->uri_elems
);
1581 if (scheme
&& (!evutil_ascii_strcasecmp(scheme
, "http") ||
1582 !evutil_ascii_strcasecmp(scheme
, "https")) &&
1584 !evhttp_find_vhost(req
->evcon
->http_server
, NULL
, hostname
))
1585 req
->flags
|= EVHTTP_PROXY_REQUEST
;
1591 evhttp_find_header(const struct evkeyvalq
*headers
, const char *key
)
1593 struct evkeyval
*header
;
1595 TAILQ_FOREACH(header
, headers
, next
) {
1596 if (evutil_ascii_strcasecmp(header
->key
, key
) == 0)
1597 return (header
->value
);
1604 evhttp_clear_headers(struct evkeyvalq
*headers
)
1606 struct evkeyval
*header
;
1608 for (header
= TAILQ_FIRST(headers
);
1610 header
= TAILQ_FIRST(headers
)) {
1611 TAILQ_REMOVE(headers
, header
, next
);
1612 mm_free(header
->key
);
1613 mm_free(header
->value
);
1619 * Returns 0, if the header was successfully removed.
1620 * Returns -1, if the header could not be found.
1624 evhttp_remove_header(struct evkeyvalq
*headers
, const char *key
)
1626 struct evkeyval
*header
;
1628 TAILQ_FOREACH(header
, headers
, next
) {
1629 if (evutil_ascii_strcasecmp(header
->key
, key
) == 0)
1636 /* Free and remove the header that we found */
1637 TAILQ_REMOVE(headers
, header
, next
);
1638 mm_free(header
->key
);
1639 mm_free(header
->value
);
1646 evhttp_header_is_valid_value(const char *value
)
1648 const char *p
= value
;
1650 while ((p
= strpbrk(p
, "\r\n")) != NULL
) {
1651 /* we really expect only one new line */
1652 p
+= strspn(p
, "\r\n");
1653 /* we expect a space or tab for continuation */
1654 if (*p
!= ' ' && *p
!= '\t')
1661 evhttp_add_header(struct evkeyvalq
*headers
,
1662 const char *key
, const char *value
)
1664 event_debug(("%s: key: %s val: %s\n", __func__
, key
, value
));
1666 if (strchr(key
, '\r') != NULL
|| strchr(key
, '\n') != NULL
) {
1667 /* drop illegal headers */
1668 event_debug(("%s: dropping illegal header key\n", __func__
));
1672 if (!evhttp_header_is_valid_value(value
)) {
1673 event_debug(("%s: dropping illegal header value\n", __func__
));
1677 return (evhttp_add_header_internal(headers
, key
, value
));
1681 evhttp_add_header_internal(struct evkeyvalq
*headers
,
1682 const char *key
, const char *value
)
1684 struct evkeyval
*header
= mm_calloc(1, sizeof(struct evkeyval
));
1685 if (header
== NULL
) {
1686 event_warn("%s: calloc", __func__
);
1689 if ((header
->key
= mm_strdup(key
)) == NULL
) {
1691 event_warn("%s: strdup", __func__
);
1694 if ((header
->value
= mm_strdup(value
)) == NULL
) {
1695 mm_free(header
->key
);
1697 event_warn("%s: strdup", __func__
);
1701 TAILQ_INSERT_TAIL(headers
, header
, next
);
1707 * Parses header lines from a request or a response into the specified
1708 * request object given an event buffer.
1711 * DATA_CORRUPTED on error
1712 * MORE_DATA_EXPECTED when we need to read more headers
1713 * ALL_DATA_READ when all headers have been read.
1716 enum message_read_status
1717 evhttp_parse_firstline(struct evhttp_request
*req
, struct evbuffer
*buffer
)
1720 enum message_read_status status
= ALL_DATA_READ
;
1724 line
= evbuffer_readln(buffer
, &line_length
, EVBUFFER_EOL_CRLF
);
1726 if (req
->evcon
!= NULL
&&
1727 evbuffer_get_length(buffer
) > req
->evcon
->max_headers_size
)
1728 return (DATA_TOO_LONG
);
1730 return (MORE_DATA_EXPECTED
);
1733 if (req
->evcon
!= NULL
&&
1734 line_length
> req
->evcon
->max_headers_size
) {
1736 return (DATA_TOO_LONG
);
1739 req
->headers_size
= line_length
;
1741 switch (req
->kind
) {
1742 case EVHTTP_REQUEST
:
1743 if (evhttp_parse_request_line(req
, line
) == -1)
1744 status
= DATA_CORRUPTED
;
1746 case EVHTTP_RESPONSE
:
1747 if (evhttp_parse_response_line(req
, line
) == -1)
1748 status
= DATA_CORRUPTED
;
1751 status
= DATA_CORRUPTED
;
1759 evhttp_append_to_last_header(struct evkeyvalq
*headers
, const char *line
)
1761 struct evkeyval
*header
= TAILQ_LAST(headers
, evkeyvalq
);
1763 size_t old_len
, line_len
;
1768 old_len
= strlen(header
->value
);
1769 line_len
= strlen(line
);
1771 newval
= mm_realloc(header
->value
, old_len
+ line_len
+ 1);
1775 memcpy(newval
+ old_len
, line
, line_len
+ 1);
1776 header
->value
= newval
;
1781 enum message_read_status
1782 evhttp_parse_headers(struct evhttp_request
*req
, struct evbuffer
* buffer
)
1784 enum message_read_status errcode
= DATA_CORRUPTED
;
1786 enum message_read_status status
= MORE_DATA_EXPECTED
;
1788 struct evkeyvalq
* headers
= req
->input_headers
;
1790 while ((line
= evbuffer_readln(buffer
, &line_length
, EVBUFFER_EOL_CRLF
))
1792 char *skey
, *svalue
;
1794 req
->headers_size
+= line_length
;
1796 if (req
->evcon
!= NULL
&&
1797 req
->headers_size
> req
->evcon
->max_headers_size
) {
1798 errcode
= DATA_TOO_LONG
;
1802 if (*line
== '\0') { /* Last header - Done */
1803 status
= ALL_DATA_READ
;
1808 /* Check if this is a continuation line */
1809 if (*line
== ' ' || *line
== '\t') {
1810 if (evhttp_append_to_last_header(headers
, line
) == -1)
1816 /* Processing of header lines */
1818 skey
= strsep(&svalue
, ":");
1822 svalue
+= strspn(svalue
, " ");
1824 if (evhttp_add_header(headers
, skey
, svalue
) == -1)
1830 if (status
== MORE_DATA_EXPECTED
) {
1831 if (req
->evcon
!= NULL
&&
1832 req
->headers_size
+ evbuffer_get_length(buffer
) > req
->evcon
->max_headers_size
)
1833 return (DATA_TOO_LONG
);
1844 evhttp_get_body_length(struct evhttp_request
*req
)
1846 struct evkeyvalq
*headers
= req
->input_headers
;
1847 const char *content_length
;
1848 const char *connection
;
1850 content_length
= evhttp_find_header(headers
, "Content-Length");
1851 connection
= evhttp_find_header(headers
, "Connection");
1853 if (content_length
== NULL
&& connection
== NULL
)
1855 else if (content_length
== NULL
&&
1856 evutil_ascii_strcasecmp(connection
, "Close") != 0) {
1857 /* Bad combination, we don't know when it will end */
1858 event_warnx("%s: we got no content length, but the "
1859 "server wants to keep the connection open: %s.",
1860 __func__
, connection
);
1862 } else if (content_length
== NULL
) {
1866 ev_int64_t ntoread
= evutil_strtoll(content_length
, &endp
, 10);
1867 if (*content_length
== '\0' || *endp
!= '\0' || ntoread
< 0) {
1868 event_debug(("%s: illegal content length: %s",
1869 __func__
, content_length
));
1872 req
->ntoread
= ntoread
;
1875 event_debug(("%s: bytes to read: "EV_I64_FMT
" (in buffer "EV_SIZE_FMT
")\n",
1876 __func__
, EV_I64_ARG(req
->ntoread
),
1877 EV_SIZE_ARG(evbuffer_get_length(bufferevent_get_input(req
->evcon
->bufev
)))));
1883 evhttp_method_may_have_body(enum evhttp_cmd_type type
)
1886 case EVHTTP_REQ_POST
:
1887 case EVHTTP_REQ_PUT
:
1888 case EVHTTP_REQ_PATCH
:
1890 case EVHTTP_REQ_TRACE
:
1892 /* XXX May any of the below methods have a body? */
1893 case EVHTTP_REQ_GET
:
1894 case EVHTTP_REQ_HEAD
:
1895 case EVHTTP_REQ_DELETE
:
1896 case EVHTTP_REQ_OPTIONS
:
1897 case EVHTTP_REQ_CONNECT
:
1905 evhttp_get_body(struct evhttp_connection
*evcon
, struct evhttp_request
*req
)
1907 const char *xfer_enc
;
1909 /* If this is a request without a body, then we are done */
1910 if (req
->kind
== EVHTTP_REQUEST
&&
1911 !evhttp_method_may_have_body(req
->type
)) {
1912 evhttp_connection_done(evcon
);
1915 evcon
->state
= EVCON_READING_BODY
;
1916 xfer_enc
= evhttp_find_header(req
->input_headers
, "Transfer-Encoding");
1917 if (xfer_enc
!= NULL
&& evutil_ascii_strcasecmp(xfer_enc
, "chunked") == 0) {
1921 if (evhttp_get_body_length(req
) == -1) {
1922 evhttp_connection_fail(evcon
,
1923 EVCON_HTTP_INVALID_HEADER
);
1926 if (req
->kind
== EVHTTP_REQUEST
&& req
->ntoread
< 1) {
1927 /* An incoming request with no content-length and no
1928 * transfer-encoding has no body. */
1929 evhttp_connection_done(evcon
);
1934 /* Should we send a 100 Continue status line? */
1935 if (req
->kind
== EVHTTP_REQUEST
&& REQ_VERSION_ATLEAST(req
, 1, 1)) {
1938 expect
= evhttp_find_header(req
->input_headers
, "Expect");
1940 if (!evutil_ascii_strcasecmp(expect
, "100-continue")) {
1941 /* XXX It would be nice to do some sanity
1942 checking here. Does the resource exist?
1943 Should the resource accept post requests? If
1944 no, we should respond with an error. For
1945 now, just optimistically tell the client to
1946 send their message body. */
1947 if (req
->ntoread
> 0) {
1948 /* ntoread is ev_int64_t, max_body_size is ev_uint64_t */
1949 if ((req
->evcon
->max_body_size
<= EV_INT64_MAX
) && (ev_uint64_t
)req
->ntoread
> req
->evcon
->max_body_size
) {
1950 evhttp_send_error(req
, HTTP_ENTITYTOOLARGE
, NULL
);
1954 if (!evbuffer_get_length(bufferevent_get_input(evcon
->bufev
)))
1955 evhttp_send_continue(evcon
, req
);
1957 evhttp_send_error(req
, HTTP_EXPECTATIONFAILED
,
1964 evhttp_read_body(evcon
, req
);
1965 /* note the request may have been freed in evhttp_read_body */
1969 evhttp_read_firstline(struct evhttp_connection
*evcon
,
1970 struct evhttp_request
*req
)
1972 enum message_read_status res
;
1974 res
= evhttp_parse_firstline(req
, bufferevent_get_input(evcon
->bufev
));
1975 if (res
== DATA_CORRUPTED
|| res
== DATA_TOO_LONG
) {
1976 /* Error while reading, terminate */
1977 event_debug(("%s: bad header lines on %d\n",
1978 __func__
, evcon
->fd
));
1979 evhttp_connection_fail(evcon
, EVCON_HTTP_INVALID_HEADER
);
1981 } else if (res
== MORE_DATA_EXPECTED
) {
1982 /* Need more header lines */
1986 evcon
->state
= EVCON_READING_HEADERS
;
1987 evhttp_read_header(evcon
, req
);
1991 evhttp_read_header(struct evhttp_connection
*evcon
,
1992 struct evhttp_request
*req
)
1994 enum message_read_status res
;
1995 evutil_socket_t fd
= evcon
->fd
;
1997 res
= evhttp_parse_headers(req
, bufferevent_get_input(evcon
->bufev
));
1998 if (res
== DATA_CORRUPTED
|| res
== DATA_TOO_LONG
) {
1999 /* Error while reading, terminate */
2000 event_debug(("%s: bad header lines on %d\n", __func__
, fd
));
2001 evhttp_connection_fail(evcon
, EVCON_HTTP_INVALID_HEADER
);
2003 } else if (res
== MORE_DATA_EXPECTED
) {
2004 /* Need more header lines */
2008 /* Disable reading for now */
2009 bufferevent_disable(evcon
->bufev
, EV_READ
);
2011 /* Done reading headers, do the real work */
2012 switch (req
->kind
) {
2013 case EVHTTP_REQUEST
:
2014 event_debug(("%s: checking for post data on %d\n",
2016 evhttp_get_body(evcon
, req
);
2017 /* note the request may have been freed in evhttp_get_body */
2020 case EVHTTP_RESPONSE
:
2021 /* Start over if we got a 100 Continue response. */
2022 if (req
->response_code
== 100) {
2023 evhttp_start_read(evcon
);
2026 if (!evhttp_response_needs_body(req
)) {
2027 event_debug(("%s: skipping body for code %d\n",
2028 __func__
, req
->response_code
));
2029 evhttp_connection_done(evcon
);
2031 event_debug(("%s: start of read body for %s on %d\n",
2032 __func__
, req
->remote_host
, fd
));
2033 evhttp_get_body(evcon
, req
);
2034 /* note the request may have been freed in
2035 * evhttp_get_body */
2040 event_warnx("%s: bad header on %d", __func__
, fd
);
2041 evhttp_connection_fail(evcon
, EVCON_HTTP_INVALID_HEADER
);
2044 /* request may have been freed above */
2048 * Creates a TCP connection to the specified port and executes a callback
2049 * when finished. Failure or success is indicate by the passed connection
2052 * Although this interface accepts a hostname, it is intended to take
2053 * only numeric hostnames so that non-blocking DNS resolution can
2057 struct evhttp_connection
*
2058 evhttp_connection_new(const char *address
, unsigned short port
)
2060 return (evhttp_connection_base_new(NULL
, NULL
, address
, port
));
2063 struct evhttp_connection
*
2064 evhttp_connection_base_new(struct event_base
*base
, struct evdns_base
*dnsbase
,
2065 const char *address
, unsigned short port
)
2067 struct evhttp_connection
*evcon
= NULL
;
2069 event_debug(("Attempting connection to %s:%d\n", address
, port
));
2071 if ((evcon
= mm_calloc(1, sizeof(struct evhttp_connection
))) == NULL
) {
2072 event_warn("%s: calloc failed", __func__
);
2079 evcon
->max_headers_size
= EV_SIZE_MAX
;
2080 evcon
->max_body_size
= EV_SIZE_MAX
;
2082 evcon
->timeout
= -1;
2083 evcon
->retry_cnt
= evcon
->retry_max
= 0;
2085 if ((evcon
->address
= mm_strdup(address
)) == NULL
) {
2086 event_warn("%s: strdup failed", __func__
);
2090 if ((evcon
->bufev
= bufferevent_new(-1,
2093 evhttp_error_cb
, evcon
)) == NULL
) {
2094 event_warn("%s: bufferevent_new failed", __func__
);
2098 evcon
->state
= EVCON_DISCONNECTED
;
2099 TAILQ_INIT(&evcon
->requests
);
2103 bufferevent_base_set(base
, evcon
->bufev
);
2107 event_deferred_cb_init(&evcon
->read_more_deferred_cb
,
2108 evhttp_deferred_read_cb
, evcon
);
2110 evcon
->dns_base
= dnsbase
;
2116 evhttp_connection_free(evcon
);
2120 struct bufferevent
*
2121 evhttp_connection_get_bufferevent(struct evhttp_connection
*evcon
)
2123 return evcon
->bufev
;
2127 evhttp_connection_set_base(struct evhttp_connection
*evcon
,
2128 struct event_base
*base
)
2130 EVUTIL_ASSERT(evcon
->base
== NULL
);
2131 EVUTIL_ASSERT(evcon
->state
== EVCON_DISCONNECTED
);
2133 bufferevent_base_set(base
, evcon
->bufev
);
2137 evhttp_connection_set_timeout(struct evhttp_connection
*evcon
,
2138 int timeout_in_secs
)
2140 evcon
->timeout
= timeout_in_secs
;
2142 if (evcon
->timeout
== -1)
2143 bufferevent_settimeout(evcon
->bufev
,
2144 HTTP_READ_TIMEOUT
, HTTP_WRITE_TIMEOUT
);
2146 bufferevent_settimeout(evcon
->bufev
,
2147 evcon
->timeout
, evcon
->timeout
);
2151 evhttp_connection_set_retries(struct evhttp_connection
*evcon
,
2154 evcon
->retry_max
= retry_max
;
2158 evhttp_connection_set_closecb(struct evhttp_connection
*evcon
,
2159 void (*cb
)(struct evhttp_connection
*, void *), void *cbarg
)
2161 evcon
->closecb
= cb
;
2162 evcon
->closecb_arg
= cbarg
;
2166 evhttp_connection_get_peer(struct evhttp_connection
*evcon
,
2167 char **address
, ev_uint16_t
*port
)
2169 *address
= evcon
->address
;
2170 *port
= evcon
->port
;
2174 evhttp_connection_connect(struct evhttp_connection
*evcon
)
2176 if (evcon
->state
== EVCON_CONNECTING
)
2179 evhttp_connection_reset(evcon
);
2181 EVUTIL_ASSERT(!(evcon
->flags
& EVHTTP_CON_INCOMING
));
2182 evcon
->flags
|= EVHTTP_CON_OUTGOING
;
2184 evcon
->fd
= bind_socket(
2185 evcon
->bind_address
, evcon
->bind_port
, 0 /*reuse*/);
2186 if (evcon
->fd
== -1) {
2187 event_debug(("%s: failed to bind to \"%s\"",
2188 __func__
, evcon
->bind_address
));
2192 /* Set up a callback for successful connection setup */
2193 bufferevent_setfd(evcon
->bufev
, evcon
->fd
);
2194 bufferevent_setcb(evcon
->bufev
,
2195 NULL
/* evhttp_read_cb */,
2196 NULL
/* evhttp_write_cb */,
2197 evhttp_connection_cb
,
2199 bufferevent_settimeout(evcon
->bufev
, 0,
2200 evcon
->timeout
!= -1 ? evcon
->timeout
: HTTP_CONNECT_TIMEOUT
);
2201 /* make sure that we get a write callback */
2202 bufferevent_enable(evcon
->bufev
, EV_WRITE
);
2204 if (bufferevent_socket_connect_hostname(evcon
->bufev
, evcon
->dns_base
,
2205 AF_UNSPEC
, evcon
->address
, evcon
->port
) < 0) {
2206 event_sock_warn(evcon
->fd
, "%s: connection to \"%s\" failed",
2207 __func__
, evcon
->address
);
2208 /* some operating systems return ECONNREFUSED immediately
2209 * when connecting to a local address. the cleanup is going
2210 * to reschedule this function call.
2212 evhttp_connection_cb_cleanup(evcon
);
2216 evcon
->state
= EVCON_CONNECTING
;
2222 * Starts an HTTP request on the provided evhttp_connection object.
2223 * If the connection object is not connected to the web server already,
2224 * this will start the connection.
2228 evhttp_make_request(struct evhttp_connection
*evcon
,
2229 struct evhttp_request
*req
,
2230 enum evhttp_cmd_type type
, const char *uri
)
2232 /* We are making a request */
2233 req
->kind
= EVHTTP_REQUEST
;
2235 if (req
->uri
!= NULL
)
2237 if ((req
->uri
= mm_strdup(uri
)) == NULL
) {
2238 event_warn("%s: strdup", __func__
);
2239 evhttp_request_free(req
);
2243 /* Set the protocol version if it is not supplied */
2244 if (!req
->major
&& !req
->minor
) {
2249 EVUTIL_ASSERT(req
->evcon
== NULL
);
2251 EVUTIL_ASSERT(!(req
->flags
& EVHTTP_REQ_OWN_CONNECTION
));
2253 TAILQ_INSERT_TAIL(&evcon
->requests
, req
, next
);
2255 /* If the connection object is not connected; make it so */
2256 if (!evhttp_connected(evcon
)) {
2257 int res
= evhttp_connection_connect(evcon
);
2258 /* evhttp_connection_fail(), which is called through
2259 * evhttp_connection_connect(), assumes that req lies in
2260 * evcon->requests. Thus, enqueue the request in advance and r
2261 * it in the error case. */
2263 TAILQ_REMOVE(&evcon
->requests
, req
, next
);
2269 * If it's connected already and we are the first in the queue,
2270 * then we can dispatch this request immediately. Otherwise, it
2271 * will be dispatched once the pending requests are completed.
2273 if (TAILQ_FIRST(&evcon
->requests
) == req
)
2274 evhttp_request_dispatch(evcon
);
2280 evhttp_cancel_request(struct evhttp_request
*req
)
2282 struct evhttp_connection
*evcon
= req
->evcon
;
2283 if (evcon
!= NULL
) {
2284 /* We need to remove it from the connection */
2285 if (TAILQ_FIRST(&evcon
->requests
) == req
) {
2286 /* it's currently being worked on, so reset
2289 evhttp_connection_fail(evcon
,
2290 EVCON_HTTP_REQUEST_CANCEL
);
2292 /* connection fail freed the request */
2295 /* otherwise, we can just remove it from the
2298 TAILQ_REMOVE(&evcon
->requests
, req
, next
);
2302 evhttp_request_free(req
);
2306 * Reads data from file descriptor into request structure
2307 * Request structure needs to be set up correctly.
2311 evhttp_start_read(struct evhttp_connection
*evcon
)
2313 /* Set up an event to read the headers */
2314 bufferevent_disable(evcon
->bufev
, EV_WRITE
);
2315 bufferevent_enable(evcon
->bufev
, EV_READ
);
2316 evcon
->state
= EVCON_READING_FIRSTLINE
;
2317 /* Reset the bufferevent callbacks */
2318 bufferevent_setcb(evcon
->bufev
,
2324 /* If there's still data pending, process it next time through the
2325 * loop. Don't do it now; that could get recusive. */
2326 if (evbuffer_get_length(bufferevent_get_input(evcon
->bufev
))) {
2327 event_deferred_cb_schedule(get_deferred_queue(evcon
),
2328 &evcon
->read_more_deferred_cb
);
2333 evhttp_send_done(struct evhttp_connection
*evcon
, void *arg
)
2336 struct evhttp_request
*req
= TAILQ_FIRST(&evcon
->requests
);
2337 TAILQ_REMOVE(&evcon
->requests
, req
, next
);
2340 (REQ_VERSION_BEFORE(req
, 1, 1) &&
2341 !evhttp_is_connection_keepalive(req
->input_headers
))||
2342 evhttp_is_connection_close(req
->flags
, req
->input_headers
) ||
2343 evhttp_is_connection_close(req
->flags
, req
->output_headers
);
2345 EVUTIL_ASSERT(req
->flags
& EVHTTP_REQ_OWN_CONNECTION
);
2346 evhttp_request_free(req
);
2349 evhttp_connection_free(evcon
);
2353 /* we have a persistent connection; try to accept another request. */
2354 if (evhttp_associate_new_request_with_connection(evcon
) == -1) {
2355 evhttp_connection_free(evcon
);
2360 * Returns an error page.
2364 evhttp_send_error(struct evhttp_request
*req
, int error
, const char *reason
)
2367 #define ERR_FORMAT "<HTML><HEAD>\n" \
2368 "<TITLE>%d %s</TITLE>\n" \
2373 struct evbuffer
*buf
= evbuffer_new();
2375 /* if we cannot allocate memory; we just drop the connection */
2376 evhttp_connection_free(req
->evcon
);
2379 if (reason
== NULL
) {
2380 reason
= evhttp_response_phrase_internal(error
);
2383 evhttp_response_code(req
, error
, reason
);
2385 evbuffer_add_printf(buf
, ERR_FORMAT
, error
, reason
, reason
);
2387 evhttp_send_page(req
, buf
);
2393 /* Requires that headers and response code are already set up */
2396 evhttp_send(struct evhttp_request
*req
, struct evbuffer
*databuf
)
2398 struct evhttp_connection
*evcon
= req
->evcon
;
2400 if (evcon
== NULL
) {
2401 evhttp_request_free(req
);
2405 EVUTIL_ASSERT(TAILQ_FIRST(&evcon
->requests
) == req
);
2407 /* we expect no more calls form the user on this request */
2410 /* xxx: not sure if we really should expose the data buffer this way */
2411 if (databuf
!= NULL
)
2412 evbuffer_add_buffer(req
->output_buffer
, databuf
);
2414 /* Adds headers to the response */
2415 evhttp_make_header(evcon
, req
);
2417 evhttp_write_buffer(evcon
, evhttp_send_done
, NULL
);
2421 evhttp_send_reply(struct evhttp_request
*req
, int code
, const char *reason
,
2422 struct evbuffer
*databuf
)
2424 evhttp_response_code(req
, code
, reason
);
2426 evhttp_send(req
, databuf
);
2430 evhttp_send_reply_start(struct evhttp_request
*req
, int code
,
2433 evhttp_response_code(req
, code
, reason
);
2434 if (evhttp_find_header(req
->output_headers
, "Content-Length") == NULL
&&
2435 REQ_VERSION_ATLEAST(req
, 1, 1) &&
2436 evhttp_response_needs_body(req
)) {
2438 * prefer HTTP/1.1 chunked encoding to closing the connection;
2439 * note RFC 2616 section 4.4 forbids it with Content-Length:
2440 * and it's not necessary then anyway.
2442 evhttp_add_header(req
->output_headers
, "Transfer-Encoding",
2448 evhttp_make_header(req
->evcon
, req
);
2449 evhttp_write_buffer(req
->evcon
, NULL
, NULL
);
2453 evhttp_send_reply_chunk(struct evhttp_request
*req
, struct evbuffer
*databuf
)
2455 struct evhttp_connection
*evcon
= req
->evcon
;
2456 struct evbuffer
*output
;
2461 output
= bufferevent_get_output(evcon
->bufev
);
2463 if (evbuffer_get_length(databuf
) == 0)
2465 if (!evhttp_response_needs_body(req
))
2468 evbuffer_add_printf(output
, "%x\r\n",
2469 (unsigned)evbuffer_get_length(databuf
));
2471 evbuffer_add_buffer(output
, databuf
);
2473 evbuffer_add(output
, "\r\n", 2);
2475 evhttp_write_buffer(evcon
, NULL
, NULL
);
2479 evhttp_send_reply_end(struct evhttp_request
*req
)
2481 struct evhttp_connection
*evcon
= req
->evcon
;
2482 struct evbuffer
*output
;
2484 if (evcon
== NULL
) {
2485 evhttp_request_free(req
);
2489 output
= bufferevent_get_output(evcon
->bufev
);
2491 /* we expect no more calls form the user on this request */
2495 evbuffer_add(output
, "0\r\n\r\n", 5);
2496 evhttp_write_buffer(req
->evcon
, evhttp_send_done
, NULL
);
2498 } else if (evbuffer_get_length(output
) == 0) {
2499 /* let the connection know that we are done with the request */
2500 evhttp_send_done(evcon
, NULL
);
2502 /* make the callback execute after all data has been written */
2503 evcon
->cb
= evhttp_send_done
;
2504 evcon
->cb_arg
= NULL
;
2508 static const char *informational_phrases
[] = {
2509 /* 100 */ "Continue",
2510 /* 101 */ "Switching Protocols"
2513 static const char *success_phrases
[] = {
2515 /* 201 */ "Created",
2516 /* 202 */ "Accepted",
2517 /* 203 */ "Non-Authoritative Information",
2518 /* 204 */ "No Content",
2519 /* 205 */ "Reset Content",
2520 /* 206 */ "Partial Content"
2523 static const char *redirection_phrases
[] = {
2524 /* 300 */ "Multiple Choices",
2525 /* 301 */ "Moved Permanently",
2527 /* 303 */ "See Other",
2528 /* 304 */ "Not Modified",
2529 /* 305 */ "Use Proxy",
2530 /* 307 */ "Temporary Redirect"
2533 static const char *client_error_phrases
[] = {
2534 /* 400 */ "Bad Request",
2535 /* 401 */ "Unauthorized",
2536 /* 402 */ "Payment Required",
2537 /* 403 */ "Forbidden",
2538 /* 404 */ "Not Found",
2539 /* 405 */ "Method Not Allowed",
2540 /* 406 */ "Not Acceptable",
2541 /* 407 */ "Proxy Authentication Required",
2542 /* 408 */ "Request Time-out",
2543 /* 409 */ "Conflict",
2545 /* 411 */ "Length Required",
2546 /* 412 */ "Precondition Failed",
2547 /* 413 */ "Request Entity Too Large",
2548 /* 414 */ "Request-URI Too Large",
2549 /* 415 */ "Unsupported Media Type",
2550 /* 416 */ "Requested range not satisfiable",
2551 /* 417 */ "Expectation Failed"
2554 static const char *server_error_phrases
[] = {
2555 /* 500 */ "Internal Server Error",
2556 /* 501 */ "Not Implemented",
2557 /* 502 */ "Bad Gateway",
2558 /* 503 */ "Service Unavailable",
2559 /* 504 */ "Gateway Time-out",
2560 /* 505 */ "HTTP Version not supported"
2563 struct response_class
{
2565 size_t num_responses
;
2566 const char **responses
;
2570 #define MEMBERSOF(x) (sizeof(x)/sizeof(x[0]))
2573 static const struct response_class response_classes
[] = {
2574 /* 1xx */ { "Informational", MEMBERSOF(informational_phrases
), informational_phrases
},
2575 /* 2xx */ { "Success", MEMBERSOF(success_phrases
), success_phrases
},
2576 /* 3xx */ { "Redirection", MEMBERSOF(redirection_phrases
), redirection_phrases
},
2577 /* 4xx */ { "Client Error", MEMBERSOF(client_error_phrases
), client_error_phrases
},
2578 /* 5xx */ { "Server Error", MEMBERSOF(server_error_phrases
), server_error_phrases
}
2582 evhttp_response_phrase_internal(int code
)
2584 int klass
= code
/ 100 - 1;
2585 int subcode
= code
% 100;
2587 /* Unknown class - can't do any better here */
2588 if (klass
< 0 || klass
>= (int) MEMBERSOF(response_classes
))
2589 return "Unknown Status Class";
2591 /* Unknown sub-code, return class name at least */
2592 if (subcode
>= (int) response_classes
[klass
].num_responses
)
2593 return response_classes
[klass
].name
;
2595 return response_classes
[klass
].responses
[subcode
];
2599 evhttp_response_code(struct evhttp_request
*req
, int code
, const char *reason
)
2601 req
->kind
= EVHTTP_RESPONSE
;
2602 req
->response_code
= code
;
2603 if (req
->response_code_line
!= NULL
)
2604 mm_free(req
->response_code_line
);
2606 reason
= evhttp_response_phrase_internal(code
);
2607 req
->response_code_line
= mm_strdup(reason
);
2608 if (req
->response_code_line
== NULL
) {
2609 event_warn("%s: strdup", __func__
);
2610 /* XXX what else can we do? */
2615 evhttp_send_page(struct evhttp_request
*req
, struct evbuffer
*databuf
)
2617 if (!req
->major
|| !req
->minor
) {
2622 if (req
->kind
!= EVHTTP_RESPONSE
)
2623 evhttp_response_code(req
, 200, "OK");
2625 evhttp_clear_headers(req
->output_headers
);
2626 evhttp_add_header(req
->output_headers
, "Content-Type", "text/html");
2627 evhttp_add_header(req
->output_headers
, "Connection", "close");
2629 evhttp_send(req
, databuf
);
2632 static const char uri_chars
[256] = {
2634 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2635 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2636 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0,
2637 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
2639 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2640 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,
2641 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2642 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0,
2644 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2645 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2646 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2647 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2649 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2650 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2651 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2652 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2655 #define CHAR_IS_UNRESERVED(c) \
2656 (uri_chars[(unsigned char)(c)])
2659 * Helper functions to encode/decode a string for inclusion in a URI.
2660 * The returned string must be freed by the caller.
2663 evhttp_uriencode(const char *uri
, ev_ssize_t len
, int space_as_plus
)
2665 struct evbuffer
*buf
= evbuffer_new();
2666 const char *p
, *end
;
2675 end
= uri
+strlen(uri
);
2677 for (p
= uri
; p
< end
; p
++) {
2678 if (CHAR_IS_UNRESERVED(*p
)) {
2679 evbuffer_add(buf
, p
, 1);
2680 } else if (*p
== ' ' && space_as_plus
) {
2681 evbuffer_add(buf
, "+", 1);
2683 evbuffer_add_printf(buf
, "%%%02X", (unsigned char)(*p
));
2686 evbuffer_add(buf
, "", 1); /* NUL-terminator. */
2687 result
= mm_malloc(evbuffer_get_length(buf
));
2689 evbuffer_remove(buf
, result
, evbuffer_get_length(buf
));
2696 evhttp_encode_uri(const char *str
)
2698 return evhttp_uriencode(str
, -1, 0);
2702 * @param decode_plus_ctl: if 1, we decode plus into space. If 0, we don't.
2703 * If -1, when true we transform plus to space only after we've seen
2704 * a ?. -1 is deprecated.
2705 * @return the number of bytes written to 'ret'.
2708 evhttp_decode_uri_internal(
2709 const char *uri
, size_t length
, char *ret
, int decode_plus_ctl
)
2713 int decode_plus
= (decode_plus_ctl
== 1) ? 1: 0;
2716 for (i
= j
= 0; i
< length
; i
++) {
2719 if (decode_plus_ctl
< 0)
2721 } else if (c
== '+' && decode_plus
) {
2723 } else if (c
== '%' && EVUTIL_ISXDIGIT(uri
[i
+1]) &&
2724 EVUTIL_ISXDIGIT(uri
[i
+2])) {
2729 c
= (char)strtol(tmp
, NULL
, 16);
2741 evhttp_decode_uri(const char *uri
)
2745 if ((ret
= mm_malloc(strlen(uri
) + 1)) == NULL
) {
2746 event_warn("%s: malloc(%lu)", __func__
,
2747 (unsigned long)(strlen(uri
) + 1));
2751 evhttp_decode_uri_internal(uri
, strlen(uri
),
2752 ret
, -1 /*always_decode_plus*/);
2758 evhttp_uridecode(const char *uri
, int decode_plus
, size_t *size_out
)
2763 if ((ret
= mm_malloc(strlen(uri
) + 1)) == NULL
) {
2764 event_warn("%s: malloc(%lu)", __func__
,
2765 (unsigned long)(strlen(uri
) + 1));
2769 n
= evhttp_decode_uri_internal(uri
, strlen(uri
),
2770 ret
, !!decode_plus
/*always_decode_plus*/);
2773 EVUTIL_ASSERT(n
>= 0);
2774 *size_out
= (size_t)n
;
2781 * Helper function to parse out arguments in a query.
2782 * The arguments are separated by key and value.
2786 evhttp_parse_query_impl(const char *str
, struct evkeyvalq
*headers
,
2792 const char *query_part
;
2794 struct evhttp_uri
*uri
=NULL
;
2796 TAILQ_INIT(headers
);
2799 uri
= evhttp_uri_parse(str
);
2802 query_part
= evhttp_uri_get_query(uri
);
2807 /* No arguments - we are done */
2808 if (!query_part
|| !strlen(query_part
)) {
2813 if ((line
= mm_strdup(query_part
)) == NULL
) {
2814 event_warn("%s: strdup", __func__
);
2818 p
= argument
= line
;
2819 while (p
!= NULL
&& *p
!= '\0') {
2820 char *key
, *value
, *decoded_value
;
2821 argument
= strsep(&p
, "&");
2824 key
= strsep(&value
, "=");
2825 if (value
== NULL
|| *key
== '\0') {
2829 if ((decoded_value
= mm_malloc(strlen(value
) + 1)) == NULL
) {
2830 event_warn("%s: mm_malloc", __func__
);
2833 evhttp_decode_uri_internal(value
, strlen(value
),
2834 decoded_value
, 1 /*always_decode_plus*/);
2835 event_debug(("Query Param: %s -> %s\n", key
, decoded_value
));
2836 evhttp_add_header_internal(headers
, key
, decoded_value
);
2837 mm_free(decoded_value
);
2843 evhttp_clear_headers(headers
);
2848 evhttp_uri_free(uri
);
2853 evhttp_parse_query(const char *uri
, struct evkeyvalq
*headers
)
2855 return evhttp_parse_query_impl(uri
, headers
, 1);
2858 evhttp_parse_query_str(const char *uri
, struct evkeyvalq
*headers
)
2860 return evhttp_parse_query_impl(uri
, headers
, 0);
2863 static struct evhttp_cb
*
2864 evhttp_dispatch_callback(struct httpcbq
*callbacks
, struct evhttp_request
*req
)
2866 struct evhttp_cb
*cb
;
2871 /* Test for different URLs */
2872 path
= evhttp_uri_get_path(req
->uri_elems
);
2873 offset
= strlen(path
);
2874 if ((translated
= mm_malloc(offset
+ 1)) == NULL
)
2876 evhttp_decode_uri_internal(path
, offset
, translated
,
2877 0 /* decode_plus */);
2879 TAILQ_FOREACH(cb
, callbacks
, next
) {
2880 if (!strcmp(cb
->what
, translated
)) {
2881 mm_free(translated
);
2886 mm_free(translated
);
2892 prefix_suffix_match(const char *pattern
, const char *name
, int ignorecase
)
2897 switch (c
= *pattern
++) {
2899 return *name
== '\0';
2902 while (*name
!= '\0') {
2903 if (prefix_suffix_match(pattern
, name
,
2912 EVUTIL_TOLOWER(c
) != EVUTIL_TOLOWER(*name
))
2922 Search the vhost hierarchy beginning with http for a server alias
2923 matching hostname. If a match is found, and outhttp is non-null,
2924 outhttp is set to the matching http object and 1 is returned.
2928 evhttp_find_alias(struct evhttp
*http
, struct evhttp
**outhttp
,
2929 const char *hostname
)
2931 struct evhttp_server_alias
*alias
;
2932 struct evhttp
*vhost
;
2934 TAILQ_FOREACH(alias
, &http
->aliases
, next
) {
2935 /* XXX Do we need to handle IP addresses? */
2936 if (!evutil_ascii_strcasecmp(alias
->alias
, hostname
)) {
2943 /* XXX It might be good to avoid recursion here, but I don't
2944 see a way to do that w/o a list. */
2945 TAILQ_FOREACH(vhost
, &http
->virtualhosts
, next_vhost
) {
2946 if (evhttp_find_alias(vhost
, outhttp
, hostname
))
2954 Attempts to find the best http object to handle a request for a hostname.
2955 All aliases for the root http object and vhosts are searched for an exact
2956 match. Then, the vhost hierarchy is traversed again for a matching
2959 If an alias or vhost is matched, 1 is returned, and outhttp, if non-null,
2960 is set with the best matching http object. If there are no matches, the
2961 root http object is stored in outhttp and 0 is returned.
2965 evhttp_find_vhost(struct evhttp
*http
, struct evhttp
**outhttp
,
2966 const char *hostname
)
2968 struct evhttp
*vhost
;
2969 struct evhttp
*oldhttp
;
2970 int match_found
= 0;
2972 if (evhttp_find_alias(http
, outhttp
, hostname
))
2977 TAILQ_FOREACH(vhost
, &http
->virtualhosts
, next_vhost
) {
2978 if (prefix_suffix_match(vhost
->vhost_pattern
,
2979 hostname
, 1 /* ignorecase */)) {
2985 } while (oldhttp
!= http
);
2994 evhttp_handle_request(struct evhttp_request
*req
, void *arg
)
2996 struct evhttp
*http
= arg
;
2997 struct evhttp_cb
*cb
= NULL
;
2998 const char *hostname
;
3000 /* we have a new request on which the user needs to take action */
3003 if (req
->type
== 0 || req
->uri
== NULL
) {
3004 evhttp_send_error(req
, HTTP_BADREQUEST
, NULL
);
3008 if ((http
->allowed_methods
& req
->type
) == 0) {
3009 event_debug(("Rejecting disallowed method %x (allowed: %x)\n",
3010 (unsigned)req
->type
, (unsigned)http
->allowed_methods
));
3011 evhttp_send_error(req
, HTTP_NOTIMPLEMENTED
, NULL
);
3015 /* handle potential virtual hosts */
3016 hostname
= evhttp_request_get_host(req
);
3017 if (hostname
!= NULL
) {
3018 evhttp_find_vhost(http
, &http
, hostname
);
3021 if ((cb
= evhttp_dispatch_callback(&http
->callbacks
, req
)) != NULL
) {
3022 (*cb
->cb
)(req
, cb
->cbarg
);
3026 /* Generic call back */
3028 (*http
->gencb
)(req
, http
->gencbarg
);
3031 /* We need to send a 404 here */
3032 #define ERR_FORMAT "<html><head>" \
3033 "<title>404 Not Found</title>" \
3035 "<h1>Not Found</h1>" \
3036 "<p>The requested URL %s was not found on this server.</p>"\
3040 struct evbuffer
*buf
;
3042 if ((escaped_html
= evhttp_htmlescape(req
->uri
)) == NULL
) {
3043 evhttp_connection_free(req
->evcon
);
3047 if ((buf
= evbuffer_new()) == NULL
) {
3048 mm_free(escaped_html
);
3049 evhttp_connection_free(req
->evcon
);
3053 evhttp_response_code(req
, HTTP_NOTFOUND
, "Not Found");
3055 evbuffer_add_printf(buf
, ERR_FORMAT
, escaped_html
);
3057 mm_free(escaped_html
);
3059 evhttp_send_page(req
, buf
);
3066 /* Listener callback when a connection arrives at a server. */
3068 accept_socket_cb(struct evconnlistener
*listener
, evutil_socket_t nfd
, struct sockaddr
*peer_sa
, int peer_socklen
, void *arg
)
3070 struct evhttp
*http
= arg
;
3072 evhttp_get_request(http
, nfd
, peer_sa
, peer_socklen
);
3076 evhttp_bind_socket(struct evhttp
*http
, const char *address
, ev_uint16_t port
)
3078 struct evhttp_bound_socket
*bound
=
3079 evhttp_bind_socket_with_handle(http
, address
, port
);
3085 struct evhttp_bound_socket
*
3086 evhttp_bind_socket_with_handle(struct evhttp
*http
, const char *address
, ev_uint16_t port
)
3089 struct evhttp_bound_socket
*bound
;
3091 if ((fd
= bind_socket(address
, port
, 1 /*reuse*/)) == -1)
3094 if (listen(fd
, 128) == -1) {
3095 event_sock_warn(fd
, "%s: listen", __func__
);
3096 evutil_closesocket(fd
);
3100 bound
= evhttp_accept_socket_with_handle(http
, fd
);
3102 if (bound
!= NULL
) {
3103 event_debug(("Bound to port %d - Awaiting connections ... ",
3112 evhttp_accept_socket(struct evhttp
*http
, evutil_socket_t fd
)
3114 struct evhttp_bound_socket
*bound
=
3115 evhttp_accept_socket_with_handle(http
, fd
);
3122 struct evhttp_bound_socket
*
3123 evhttp_accept_socket_with_handle(struct evhttp
*http
, evutil_socket_t fd
)
3125 struct evhttp_bound_socket
*bound
;
3126 struct evconnlistener
*listener
;
3128 LEV_OPT_REUSEABLE
|LEV_OPT_CLOSE_ON_EXEC
|LEV_OPT_CLOSE_ON_FREE
;
3130 listener
= evconnlistener_new(http
->base
, NULL
, NULL
,
3132 0, /* Backlog is '0' because we already said 'listen' */
3137 bound
= evhttp_bind_listener(http
, listener
);
3139 evconnlistener_free(listener
);
3145 struct evhttp_bound_socket
*
3146 evhttp_bind_listener(struct evhttp
*http
, struct evconnlistener
*listener
)
3148 struct evhttp_bound_socket
*bound
;
3150 bound
= mm_malloc(sizeof(struct evhttp_bound_socket
));
3154 bound
->listener
= listener
;
3155 TAILQ_INSERT_TAIL(&http
->sockets
, bound
, next
);
3157 evconnlistener_set_cb(listener
, accept_socket_cb
, http
);
3162 evhttp_bound_socket_get_fd(struct evhttp_bound_socket
*bound
)
3164 return evconnlistener_get_fd(bound
->listener
);
3167 struct evconnlistener
*
3168 evhttp_bound_socket_get_listener(struct evhttp_bound_socket
*bound
)
3170 return bound
->listener
;
3174 evhttp_del_accept_socket(struct evhttp
*http
, struct evhttp_bound_socket
*bound
)
3176 TAILQ_REMOVE(&http
->sockets
, bound
, next
);
3177 evconnlistener_free(bound
->listener
);
3181 static struct evhttp
*
3182 evhttp_new_object(void)
3184 struct evhttp
*http
= NULL
;
3186 if ((http
= mm_calloc(1, sizeof(struct evhttp
))) == NULL
) {
3187 event_warn("%s: calloc", __func__
);
3192 evhttp_set_max_headers_size(http
, EV_SIZE_MAX
);
3193 evhttp_set_max_body_size(http
, EV_SIZE_MAX
);
3194 evhttp_set_allowed_methods(http
,
3201 TAILQ_INIT(&http
->sockets
);
3202 TAILQ_INIT(&http
->callbacks
);
3203 TAILQ_INIT(&http
->connections
);
3204 TAILQ_INIT(&http
->virtualhosts
);
3205 TAILQ_INIT(&http
->aliases
);
3211 evhttp_new(struct event_base
*base
)
3213 struct evhttp
*http
= NULL
;
3215 http
= evhttp_new_object();
3224 * Start a web server on the specified address and port.
3228 evhttp_start(const char *address
, unsigned short port
)
3230 struct evhttp
*http
= NULL
;
3232 http
= evhttp_new_object();
3235 if (evhttp_bind_socket(http
, address
, port
) == -1) {
3244 evhttp_free(struct evhttp
* http
)
3246 struct evhttp_cb
*http_cb
;
3247 struct evhttp_connection
*evcon
;
3248 struct evhttp_bound_socket
*bound
;
3249 struct evhttp
* vhost
;
3250 struct evhttp_server_alias
*alias
;
3252 /* Remove the accepting part */
3253 while ((bound
= TAILQ_FIRST(&http
->sockets
)) != NULL
) {
3254 TAILQ_REMOVE(&http
->sockets
, bound
, next
);
3256 evconnlistener_free(bound
->listener
);
3261 while ((evcon
= TAILQ_FIRST(&http
->connections
)) != NULL
) {
3262 /* evhttp_connection_free removes the connection */
3263 evhttp_connection_free(evcon
);
3266 while ((http_cb
= TAILQ_FIRST(&http
->callbacks
)) != NULL
) {
3267 TAILQ_REMOVE(&http
->callbacks
, http_cb
, next
);
3268 mm_free(http_cb
->what
);
3272 while ((vhost
= TAILQ_FIRST(&http
->virtualhosts
)) != NULL
) {
3273 TAILQ_REMOVE(&http
->virtualhosts
, vhost
, next_vhost
);
3278 if (http
->vhost_pattern
!= NULL
)
3279 mm_free(http
->vhost_pattern
);
3281 while ((alias
= TAILQ_FIRST(&http
->aliases
)) != NULL
) {
3282 TAILQ_REMOVE(&http
->aliases
, alias
, next
);
3283 mm_free(alias
->alias
);
3291 evhttp_add_virtual_host(struct evhttp
* http
, const char *pattern
,
3292 struct evhttp
* vhost
)
3294 /* a vhost can only be a vhost once and should not have bound sockets */
3295 if (vhost
->vhost_pattern
!= NULL
||
3296 TAILQ_FIRST(&vhost
->sockets
) != NULL
)
3299 vhost
->vhost_pattern
= mm_strdup(pattern
);
3300 if (vhost
->vhost_pattern
== NULL
)
3303 TAILQ_INSERT_TAIL(&http
->virtualhosts
, vhost
, next_vhost
);
3309 evhttp_remove_virtual_host(struct evhttp
* http
, struct evhttp
* vhost
)
3311 if (vhost
->vhost_pattern
== NULL
)
3314 TAILQ_REMOVE(&http
->virtualhosts
, vhost
, next_vhost
);
3316 mm_free(vhost
->vhost_pattern
);
3317 vhost
->vhost_pattern
= NULL
;
3323 evhttp_add_server_alias(struct evhttp
*http
, const char *alias
)
3325 struct evhttp_server_alias
*evalias
;
3327 evalias
= mm_calloc(1, sizeof(*evalias
));
3331 evalias
->alias
= mm_strdup(alias
);
3332 if (!evalias
->alias
) {
3337 TAILQ_INSERT_TAIL(&http
->aliases
, evalias
, next
);
3343 evhttp_remove_server_alias(struct evhttp
*http
, const char *alias
)
3345 struct evhttp_server_alias
*evalias
;
3347 TAILQ_FOREACH(evalias
, &http
->aliases
, next
) {
3348 if (evutil_ascii_strcasecmp(evalias
->alias
, alias
) == 0) {
3349 TAILQ_REMOVE(&http
->aliases
, evalias
, next
);
3350 mm_free(evalias
->alias
);
3360 evhttp_set_timeout(struct evhttp
* http
, int timeout_in_secs
)
3362 http
->timeout
= timeout_in_secs
;
3366 evhttp_set_max_headers_size(struct evhttp
* http
, ev_ssize_t max_headers_size
)
3368 if (max_headers_size
< 0)
3369 http
->default_max_headers_size
= EV_SIZE_MAX
;
3371 http
->default_max_headers_size
= max_headers_size
;
3375 evhttp_set_max_body_size(struct evhttp
* http
, ev_ssize_t max_body_size
)
3377 if (max_body_size
< 0)
3378 http
->default_max_body_size
= EV_UINT64_MAX
;
3380 http
->default_max_body_size
= max_body_size
;
3384 evhttp_set_allowed_methods(struct evhttp
* http
, ev_uint16_t methods
)
3386 http
->allowed_methods
= methods
;
3390 evhttp_set_cb(struct evhttp
*http
, const char *uri
,
3391 void (*cb
)(struct evhttp_request
*, void *), void *cbarg
)
3393 struct evhttp_cb
*http_cb
;
3395 TAILQ_FOREACH(http_cb
, &http
->callbacks
, next
) {
3396 if (strcmp(http_cb
->what
, uri
) == 0)
3400 if ((http_cb
= mm_calloc(1, sizeof(struct evhttp_cb
))) == NULL
) {
3401 event_warn("%s: calloc", __func__
);
3405 http_cb
->what
= mm_strdup(uri
);
3406 if (http_cb
->what
== NULL
) {
3407 event_warn("%s: strdup", __func__
);
3412 http_cb
->cbarg
= cbarg
;
3414 TAILQ_INSERT_TAIL(&http
->callbacks
, http_cb
, next
);
3420 evhttp_del_cb(struct evhttp
*http
, const char *uri
)
3422 struct evhttp_cb
*http_cb
;
3424 TAILQ_FOREACH(http_cb
, &http
->callbacks
, next
) {
3425 if (strcmp(http_cb
->what
, uri
) == 0)
3428 if (http_cb
== NULL
)
3431 TAILQ_REMOVE(&http
->callbacks
, http_cb
, next
);
3432 mm_free(http_cb
->what
);
3439 evhttp_set_gencb(struct evhttp
*http
,
3440 void (*cb
)(struct evhttp_request
*, void *), void *cbarg
)
3443 http
->gencbarg
= cbarg
;
3447 * Request related functions
3450 struct evhttp_request
*
3451 evhttp_request_new(void (*cb
)(struct evhttp_request
*, void *), void *arg
)
3453 struct evhttp_request
*req
= NULL
;
3455 /* Allocate request structure */
3456 if ((req
= mm_calloc(1, sizeof(struct evhttp_request
))) == NULL
) {
3457 event_warn("%s: calloc", __func__
);
3461 req
->headers_size
= 0;
3464 req
->kind
= EVHTTP_RESPONSE
;
3465 req
->input_headers
= mm_calloc(1, sizeof(struct evkeyvalq
));
3466 if (req
->input_headers
== NULL
) {
3467 event_warn("%s: calloc", __func__
);
3470 TAILQ_INIT(req
->input_headers
);
3472 req
->output_headers
= mm_calloc(1, sizeof(struct evkeyvalq
));
3473 if (req
->output_headers
== NULL
) {
3474 event_warn("%s: calloc", __func__
);
3477 TAILQ_INIT(req
->output_headers
);
3479 if ((req
->input_buffer
= evbuffer_new()) == NULL
) {
3480 event_warn("%s: evbuffer_new", __func__
);
3484 if ((req
->output_buffer
= evbuffer_new()) == NULL
) {
3485 event_warn("%s: evbuffer_new", __func__
);
3496 evhttp_request_free(req
);
3501 evhttp_request_free(struct evhttp_request
*req
)
3503 if ((req
->flags
& EVHTTP_REQ_DEFER_FREE
) != 0) {
3504 req
->flags
|= EVHTTP_REQ_NEEDS_FREE
;
3508 if (req
->remote_host
!= NULL
)
3509 mm_free(req
->remote_host
);
3510 if (req
->uri
!= NULL
)
3512 if (req
->uri_elems
!= NULL
)
3513 evhttp_uri_free(req
->uri_elems
);
3514 if (req
->response_code_line
!= NULL
)
3515 mm_free(req
->response_code_line
);
3516 if (req
->host_cache
!= NULL
)
3517 mm_free(req
->host_cache
);
3519 evhttp_clear_headers(req
->input_headers
);
3520 mm_free(req
->input_headers
);
3522 evhttp_clear_headers(req
->output_headers
);
3523 mm_free(req
->output_headers
);
3525 if (req
->input_buffer
!= NULL
)
3526 evbuffer_free(req
->input_buffer
);
3528 if (req
->output_buffer
!= NULL
)
3529 evbuffer_free(req
->output_buffer
);
3535 evhttp_request_own(struct evhttp_request
*req
)
3537 req
->flags
|= EVHTTP_USER_OWNED
;
3541 evhttp_request_is_owned(struct evhttp_request
*req
)
3543 return (req
->flags
& EVHTTP_USER_OWNED
) != 0;
3546 struct evhttp_connection
*
3547 evhttp_request_get_connection(struct evhttp_request
*req
)
3553 evhttp_connection_get_base(struct evhttp_connection
*conn
)
3559 evhttp_request_set_chunked_cb(struct evhttp_request
*req
,
3560 void (*cb
)(struct evhttp_request
*, void *))
3566 * Allows for inspection of the request URI
3570 evhttp_request_get_uri(const struct evhttp_request
*req
) {
3571 if (req
->uri
== NULL
)
3572 event_debug(("%s: request %p has no uri\n", __func__
, req
));
3576 const struct evhttp_uri
*
3577 evhttp_request_get_evhttp_uri(const struct evhttp_request
*req
) {
3578 if (req
->uri_elems
== NULL
)
3579 event_debug(("%s: request %p has no uri elems\n",
3581 return (req
->uri_elems
);
3585 evhttp_request_get_host(struct evhttp_request
*req
)
3587 const char *host
= NULL
;
3589 if (req
->host_cache
)
3590 return req
->host_cache
;
3593 host
= evhttp_uri_get_host(req
->uri_elems
);
3594 if (!host
&& req
->input_headers
) {
3598 host
= evhttp_find_header(req
->input_headers
, "Host");
3599 /* The Host: header may include a port. Remove it here
3600 to be consistent with uri_elems case above. */
3602 p
= host
+ strlen(host
) - 1;
3603 while (p
> host
&& EVUTIL_ISDIGIT(*p
))
3605 if (p
> host
&& *p
== ':') {
3607 req
->host_cache
= mm_malloc(len
+ 1);
3608 if (!req
->host_cache
) {
3609 event_warn("%s: malloc", __func__
);
3612 memcpy(req
->host_cache
, host
, len
);
3613 req
->host_cache
[len
] = '\0';
3614 host
= req
->host_cache
;
3622 enum evhttp_cmd_type
3623 evhttp_request_get_command(const struct evhttp_request
*req
) {
3628 evhttp_request_get_response_code(const struct evhttp_request
*req
)
3630 return req
->response_code
;
3633 /** Returns the input headers */
3634 struct evkeyvalq
*evhttp_request_get_input_headers(struct evhttp_request
*req
)
3636 return (req
->input_headers
);
3639 /** Returns the output headers */
3640 struct evkeyvalq
*evhttp_request_get_output_headers(struct evhttp_request
*req
)
3642 return (req
->output_headers
);
3645 /** Returns the input buffer */
3646 struct evbuffer
*evhttp_request_get_input_buffer(struct evhttp_request
*req
)
3648 return (req
->input_buffer
);
3651 /** Returns the output buffer */
3652 struct evbuffer
*evhttp_request_get_output_buffer(struct evhttp_request
*req
)
3654 return (req
->output_buffer
);
3659 * Takes a file descriptor to read a request from.
3660 * The callback is executed once the whole request has been read.
3663 static struct evhttp_connection
*
3664 evhttp_get_request_connection(
3665 struct evhttp
* http
,
3666 evutil_socket_t fd
, struct sockaddr
*sa
, ev_socklen_t salen
)
3668 struct evhttp_connection
*evcon
;
3669 char *hostname
= NULL
, *portname
= NULL
;
3671 name_from_addr(sa
, salen
, &hostname
, &portname
);
3672 if (hostname
== NULL
|| portname
== NULL
) {
3673 if (hostname
) mm_free(hostname
);
3674 if (portname
) mm_free(portname
);
3678 event_debug(("%s: new request from %s:%s on %d\n",
3679 __func__
, hostname
, portname
, fd
));
3681 /* we need a connection object to put the http request on */
3682 evcon
= evhttp_connection_base_new(
3683 http
->base
, NULL
, hostname
, atoi(portname
));
3689 evcon
->max_headers_size
= http
->default_max_headers_size
;
3690 evcon
->max_body_size
= http
->default_max_body_size
;
3692 evcon
->flags
|= EVHTTP_CON_INCOMING
;
3693 evcon
->state
= EVCON_READING_FIRSTLINE
;
3697 bufferevent_setfd(evcon
->bufev
, fd
);
3703 evhttp_associate_new_request_with_connection(struct evhttp_connection
*evcon
)
3705 struct evhttp
*http
= evcon
->http_server
;
3706 struct evhttp_request
*req
;
3707 if ((req
= evhttp_request_new(evhttp_handle_request
, http
)) == NULL
)
3710 if ((req
->remote_host
= mm_strdup(evcon
->address
)) == NULL
) {
3711 event_warn("%s: strdup", __func__
);
3712 evhttp_request_free(req
);
3715 req
->remote_port
= evcon
->port
;
3717 req
->evcon
= evcon
; /* the request ends up owning the connection */
3718 req
->flags
|= EVHTTP_REQ_OWN_CONNECTION
;
3720 /* We did not present the request to the user user yet, so treat it as
3721 * if the user was done with the request. This allows us to free the
3722 * request on a persistent connection if the client drops it without
3723 * sending a request.
3727 TAILQ_INSERT_TAIL(&evcon
->requests
, req
, next
);
3729 req
->kind
= EVHTTP_REQUEST
;
3732 evhttp_start_read(evcon
);
3738 evhttp_get_request(struct evhttp
*http
, evutil_socket_t fd
,
3739 struct sockaddr
*sa
, ev_socklen_t salen
)
3741 struct evhttp_connection
*evcon
;
3743 evcon
= evhttp_get_request_connection(http
, fd
, sa
, salen
);
3744 if (evcon
== NULL
) {
3745 event_sock_warn(fd
, "%s: cannot get connection on %d", __func__
, fd
);
3746 evutil_closesocket(fd
);
3750 /* the timeout can be used by the server to close idle connections */
3751 if (http
->timeout
!= -1)
3752 evhttp_connection_set_timeout(evcon
, http
->timeout
);
3755 * if we want to accept more than one request on a connection,
3756 * we need to know which http server it belongs to.
3758 evcon
->http_server
= http
;
3759 TAILQ_INSERT_TAIL(&http
->connections
, evcon
, next
);
3761 if (evhttp_associate_new_request_with_connection(evcon
) == -1)
3762 evhttp_connection_free(evcon
);
3767 * Network helper functions that we do not want to export to the rest of
3772 name_from_addr(struct sockaddr
*sa
, ev_socklen_t salen
,
3773 char **phost
, char **pport
)
3775 char ntop
[NI_MAXHOST
];
3776 char strport
[NI_MAXSERV
];
3779 #ifdef _EVENT_HAVE_GETNAMEINFO
3780 ni_result
= getnameinfo(sa
, salen
,
3781 ntop
, sizeof(ntop
), strport
, sizeof(strport
),
3782 NI_NUMERICHOST
|NI_NUMERICSERV
);
3784 if (ni_result
!= 0) {
3786 /* Windows doesn't have an EAI_SYSTEM. */
3787 if (ni_result
== EAI_SYSTEM
)
3788 event_err(1, "getnameinfo failed");
3791 event_errx(1, "getnameinfo failed: %s", gai_strerror(ni_result
));
3795 ni_result
= fake_getnameinfo(sa
, salen
,
3796 ntop
, sizeof(ntop
), strport
, sizeof(strport
),
3797 NI_NUMERICHOST
|NI_NUMERICSERV
);
3802 *phost
= mm_strdup(ntop
);
3803 *pport
= mm_strdup(strport
);
3806 /* Create a non-blocking socket and bind it */
3807 /* todo: rename this function */
3808 static evutil_socket_t
3809 bind_socket_ai(struct evutil_addrinfo
*ai
, int reuse
)
3816 /* Create listen socket */
3817 fd
= socket(ai
? ai
->ai_family
: AF_INET
, SOCK_STREAM
, 0);
3819 event_sock_warn(-1, "socket");
3823 if (evutil_make_socket_nonblocking(fd
) < 0)
3825 if (evutil_make_socket_closeonexec(fd
) < 0)
3828 setsockopt(fd
, SOL_SOCKET
, SO_KEEPALIVE
, (void *)&on
, sizeof(on
));
3830 evutil_make_listen_socket_reuseable(fd
);
3833 r
= bind(fd
, ai
->ai_addr
, (ev_socklen_t
)ai
->ai_addrlen
);
3841 serrno
= EVUTIL_SOCKET_ERROR();
3842 evutil_closesocket(fd
);
3843 EVUTIL_SET_SOCKET_ERROR(serrno
);
3847 static struct evutil_addrinfo
*
3848 make_addrinfo(const char *address
, ev_uint16_t port
)
3850 struct evutil_addrinfo
*ai
= NULL
;
3852 struct evutil_addrinfo hints
;
3853 char strport
[NI_MAXSERV
];
3856 memset(&hints
, 0, sizeof(hints
));
3857 hints
.ai_family
= AF_UNSPEC
;
3858 hints
.ai_socktype
= SOCK_STREAM
;
3859 /* turn NULL hostname into INADDR_ANY, and skip looking up any address
3860 * types we don't have an interface to connect to. */
3861 hints
.ai_flags
= EVUTIL_AI_PASSIVE
|EVUTIL_AI_ADDRCONFIG
;
3862 evutil_snprintf(strport
, sizeof(strport
), "%d", port
);
3863 if ((ai_result
= evutil_getaddrinfo(address
, strport
, &hints
, &ai
))
3865 if (ai_result
== EVUTIL_EAI_SYSTEM
)
3866 event_warn("getaddrinfo");
3868 event_warnx("getaddrinfo: %s",
3869 evutil_gai_strerror(ai_result
));
3876 static evutil_socket_t
3877 bind_socket(const char *address
, ev_uint16_t port
, int reuse
)
3880 struct evutil_addrinfo
*aitop
= NULL
;
3882 /* just create an unbound socket */
3883 if (address
== NULL
&& port
== 0)
3884 return bind_socket_ai(NULL
, 0);
3886 aitop
= make_addrinfo(address
, port
);
3891 fd
= bind_socket_ai(aitop
, reuse
);
3893 evutil_freeaddrinfo(aitop
);
3900 char *scheme
; /* scheme; e.g http, ftp etc */
3901 char *userinfo
; /* userinfo (typically username:pass), or NULL */
3902 char *host
; /* hostname, IP address, or NULL */
3903 int port
; /* port, or zero */
3904 char *path
; /* path, or "". */
3905 char *query
; /* query, or NULL */
3906 char *fragment
; /* fragment or NULL */
3910 evhttp_uri_new(void)
3912 struct evhttp_uri
*uri
= mm_calloc(sizeof(struct evhttp_uri
), 1);
3919 evhttp_uri_set_flags(struct evhttp_uri
*uri
, unsigned flags
)
3924 /* Return true if the string starting at s and ending immediately before eos
3925 * is a valid URI scheme according to RFC3986
3928 scheme_ok(const char *s
, const char *eos
)
3930 /* scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) */
3931 EVUTIL_ASSERT(eos
>= s
);
3934 if (!EVUTIL_ISALPHA(*s
))
3937 if (! EVUTIL_ISALNUM(*s
) &&
3938 *s
!= '+' && *s
!= '-' && *s
!= '.')
3944 #define SUBDELIMS "!$&'()*+,;="
3946 /* Return true iff [s..eos) is a valid userinfo */
3948 userinfo_ok(const char *s
, const char *eos
)
3951 if (CHAR_IS_UNRESERVED(*s
) ||
3952 strchr(SUBDELIMS
, *s
) ||
3955 else if (*s
== '%' && s
+2 < eos
&&
3956 EVUTIL_ISXDIGIT(s
[1]) &&
3957 EVUTIL_ISXDIGIT(s
[2]))
3966 regname_ok(const char *s
, const char *eos
)
3968 while (s
&& s
<eos
) {
3969 if (CHAR_IS_UNRESERVED(*s
) ||
3970 strchr(SUBDELIMS
, *s
))
3972 else if (*s
== '%' &&
3973 EVUTIL_ISXDIGIT(s
[1]) &&
3974 EVUTIL_ISXDIGIT(s
[2]))
3983 parse_port(const char *s
, const char *eos
)
3987 if (! EVUTIL_ISDIGIT(*s
))
3989 portnum
= (portnum
* 10) + (*s
- '0');
3997 /* returns 0 for bad, 1 for ipv6, 2 for IPvFuture */
3999 bracket_addr_ok(const char *s
, const char *eos
)
4001 if (s
+ 3 > eos
|| *s
!= '[' || *(eos
-1) != ']')
4004 /* IPvFuture, or junk.
4005 "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" )
4007 s
+= 2; /* skip [v */
4009 if (!EVUTIL_ISXDIGIT(*s
)) /*require at least one*/
4011 while (s
< eos
&& *s
!= '.') {
4012 if (EVUTIL_ISXDIGIT(*s
))
4021 if (CHAR_IS_UNRESERVED(*s
) ||
4022 strchr(SUBDELIMS
, *s
) ||
4032 ev_ssize_t n_chars
= eos
-s
-2;
4033 struct in6_addr in6
;
4034 if (n_chars
>= 64) /* way too long */
4036 memcpy(buf
, s
+1, n_chars
);
4038 return (evutil_inet_pton(AF_INET6
,buf
,&in6
)==1) ? 1 : 0;
4043 parse_authority(struct evhttp_uri
*uri
, char *s
, char *eos
)
4048 uri
->host
= mm_strdup("");
4049 if (uri
->host
== NULL
) {
4050 event_warn("%s: strdup", __func__
);
4056 /* Optionally, we start with "userinfo@" */
4058 cp
= strchr(s
, '@');
4059 if (cp
&& cp
< eos
) {
4060 if (! userinfo_ok(s
,cp
))
4063 uri
->userinfo
= mm_strdup(s
);
4064 if (uri
->userinfo
== NULL
) {
4065 event_warn("%s: strdup", __func__
);
4071 /* Optionally, we end with ":port" */
4072 for (port
=eos
-1; port
>= cp
&& EVUTIL_ISDIGIT(*port
); --port
)
4074 if (port
>= cp
&& *port
== ':') {
4075 if (port
+1 == eos
) /* Leave port unspecified; the RFC allows a
4078 else if ((uri
->port
= parse_port(port
+1, eos
))<0)
4082 /* Now, cp..eos holds the "host" port, which can be an IPv4Address,
4083 * an IP-Literal, or a reg-name */
4084 EVUTIL_ASSERT(eos
>= cp
);
4085 if (*cp
== '[' && eos
>= cp
+2 && *(eos
-1) == ']') {
4086 /* IPv6address, IP-Literal, or junk. */
4087 if (! bracket_addr_ok(cp
, eos
))
4090 /* Make sure the host part is ok. */
4091 if (! regname_ok(cp
,eos
)) /* Match IPv4Address or reg-name */
4094 uri
->host
= mm_malloc(eos
-cp
+1);
4095 if (uri
->host
== NULL
) {
4096 event_warn("%s: malloc", __func__
);
4099 memcpy(uri
->host
, cp
, eos
-cp
);
4100 uri
->host
[eos
-cp
] = '\0';
4106 end_of_authority(char *cp
)
4109 if (*cp
== '?' || *cp
== '#' || *cp
== '/')
4122 /* Return the character after the longest prefix of 'cp' that matches...
4123 * *pchar / "/" if allow_qchars is false, or
4124 * *(pchar / "/" / "?") if allow_qchars is true.
4127 end_of_path(char *cp
, enum uri_part part
, unsigned flags
)
4129 if (flags
& EVHTTP_URI_NONCONFORMANT
) {
4130 /* If NONCONFORMANT:
4131 * Path is everything up to a # or ? or nul.
4132 * Query is everything up a # or nul
4133 * Fragment is everything up to a nul.
4137 while (*cp
&& *cp
!= '#' && *cp
!= '?')
4141 while (*cp
&& *cp
!= '#')
4152 if (CHAR_IS_UNRESERVED(*cp
) ||
4153 strchr(SUBDELIMS
, *cp
) ||
4154 *cp
== ':' || *cp
== '@' || *cp
== '/')
4156 else if (*cp
== '%' && EVUTIL_ISXDIGIT(cp
[1]) &&
4157 EVUTIL_ISXDIGIT(cp
[2]))
4159 else if (*cp
== '?' && part
!= PART_PATH
)
4168 path_matches_noscheme(const char *cp
)
4173 else if (*cp
== '/')
4181 evhttp_uri_parse(const char *source_uri
)
4183 return evhttp_uri_parse_with_flags(source_uri
, 0);
4187 evhttp_uri_parse_with_flags(const char *source_uri
, unsigned flags
)
4189 char *readbuf
= NULL
, *readp
= NULL
, *token
= NULL
, *query
= NULL
;
4190 char *path
= NULL
, *fragment
= NULL
;
4191 int got_authority
= 0;
4193 struct evhttp_uri
*uri
= mm_calloc(1, sizeof(struct evhttp_uri
));
4195 event_warn("%s: calloc", __func__
);
4201 readbuf
= mm_strdup(source_uri
);
4202 if (readbuf
== NULL
) {
4203 event_warn("%s: strdup", __func__
);
4210 /* We try to follow RFC3986 here as much as we can, and match
4213 URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
4215 relative-ref = relative-part [ "?" query ] [ "#" fragment ]
4219 token
= strchr(readp
, ':');
4220 if (token
&& scheme_ok(readp
,token
)) {
4222 uri
->scheme
= mm_strdup(readp
);
4223 if (uri
->scheme
== NULL
) {
4224 event_warn("%s: strdup", __func__
);
4227 readp
= token
+1; /* eat : */
4230 /* 2. Optionally, "//" then an 'authority' part. */
4231 if (readp
[0]=='/' && readp
[1] == '/') {
4235 path
= end_of_authority(readp
);
4236 if (parse_authority(uri
, authority
, path
) < 0)
4242 /* 3. Query: path-abempty, path-absolute, path-rootless, or path-empty
4245 readp
= end_of_path(path
, PART_PATH
, flags
);
4248 if (*readp
== '?') {
4252 readp
= end_of_path(readp
, PART_QUERY
, flags
);
4255 if (*readp
== '#') {
4259 readp
= end_of_path(readp
, PART_FRAGMENT
, flags
);
4261 if (*readp
!= '\0') {
4265 /* These next two cases may be unreachable; I'm leaving them
4266 * in to be defensive. */
4267 /* If you didn't get an authority, the path can't begin with "//" */
4268 if (!got_authority
&& path
[0]=='/' && path
[1]=='/')
4270 /* If you did get an authority, the path must begin with "/" or be
4272 if (got_authority
&& path
[0] != '/' && path
[0] != '\0')
4274 /* (End of maybe-unreachable cases) */
4276 /* If there was no scheme, the first part of the path (if any) must
4277 * have no colon in it. */
4278 if (! uri
->scheme
&& !path_matches_noscheme(path
))
4281 EVUTIL_ASSERT(path
);
4282 uri
->path
= mm_strdup(path
);
4283 if (uri
->path
== NULL
) {
4284 event_warn("%s: strdup", __func__
);
4289 uri
->query
= mm_strdup(query
);
4290 if (uri
->query
== NULL
) {
4291 event_warn("%s: strdup", __func__
);
4296 uri
->fragment
= mm_strdup(fragment
);
4297 if (uri
->fragment
== NULL
) {
4298 event_warn("%s: strdup", __func__
);
4308 evhttp_uri_free(uri
);
4315 evhttp_uri_free(struct evhttp_uri
*uri
)
4317 #define _URI_FREE_STR(f) \
4322 _URI_FREE_STR(scheme
);
4323 _URI_FREE_STR(userinfo
);
4324 _URI_FREE_STR(host
);
4325 _URI_FREE_STR(path
);
4326 _URI_FREE_STR(query
);
4327 _URI_FREE_STR(fragment
);
4330 #undef _URI_FREE_STR
4334 evhttp_uri_join(struct evhttp_uri
*uri
, char *buf
, size_t limit
)
4336 struct evbuffer
*tmp
= 0;
4337 size_t joined_size
= 0;
4338 char *output
= NULL
;
4340 #define _URI_ADD(f) evbuffer_add(tmp, uri->f, strlen(uri->f))
4342 if (!uri
|| !buf
|| !limit
)
4345 tmp
= evbuffer_new();
4351 evbuffer_add(tmp
, ":", 1);
4354 evbuffer_add(tmp
, "//", 2);
4356 evbuffer_add_printf(tmp
,"%s@", uri
->userinfo
);
4359 evbuffer_add_printf(tmp
,":%d", uri
->port
);
4361 if (uri
->path
&& uri
->path
[0] != '/' && uri
->path
[0] != '\0')
4369 evbuffer_add(tmp
, "?", 1);
4373 if (uri
->fragment
) {
4374 evbuffer_add(tmp
, "#", 1);
4378 evbuffer_add(tmp
, "\0", 1); /* NUL */
4380 joined_size
= evbuffer_get_length(tmp
);
4382 if (joined_size
> limit
) {
4383 /* It doesn't fit. */
4387 evbuffer_remove(tmp
, buf
, joined_size
);
4398 evhttp_uri_get_scheme(const struct evhttp_uri
*uri
)
4403 evhttp_uri_get_userinfo(const struct evhttp_uri
*uri
)
4405 return uri
->userinfo
;
4408 evhttp_uri_get_host(const struct evhttp_uri
*uri
)
4413 evhttp_uri_get_port(const struct evhttp_uri
*uri
)
4418 evhttp_uri_get_path(const struct evhttp_uri
*uri
)
4423 evhttp_uri_get_query(const struct evhttp_uri
*uri
)
4428 evhttp_uri_get_fragment(const struct evhttp_uri
*uri
)
4430 return uri
->fragment
;
4433 #define _URI_SET_STR(f) do { \
4437 if ((uri->f = mm_strdup(f)) == NULL) { \
4438 event_warn("%s: strdup()", __func__); \
4447 evhttp_uri_set_scheme(struct evhttp_uri
*uri
, const char *scheme
)
4449 if (scheme
&& !scheme_ok(scheme
, scheme
+strlen(scheme
)))
4452 _URI_SET_STR(scheme
);
4456 evhttp_uri_set_userinfo(struct evhttp_uri
*uri
, const char *userinfo
)
4458 if (userinfo
&& !userinfo_ok(userinfo
, userinfo
+strlen(userinfo
)))
4460 _URI_SET_STR(userinfo
);
4464 evhttp_uri_set_host(struct evhttp_uri
*uri
, const char *host
)
4467 if (host
[0] == '[') {
4468 if (! bracket_addr_ok(host
, host
+strlen(host
)))
4471 if (! regname_ok(host
, host
+strlen(host
)))
4480 evhttp_uri_set_port(struct evhttp_uri
*uri
, int port
)
4487 #define end_of_cpath(cp,p,f) \
4488 ((const char*)(end_of_path(((char*)(cp)), (p), (f))))
4491 evhttp_uri_set_path(struct evhttp_uri
*uri
, const char *path
)
4493 if (path
&& end_of_cpath(path
, PART_PATH
, uri
->flags
) != path
+strlen(path
))
4500 evhttp_uri_set_query(struct evhttp_uri
*uri
, const char *query
)
4502 if (query
&& end_of_cpath(query
, PART_QUERY
, uri
->flags
) != query
+strlen(query
))
4504 _URI_SET_STR(query
);
4508 evhttp_uri_set_fragment(struct evhttp_uri
*uri
, const char *fragment
)
4510 if (fragment
&& end_of_cpath(fragment
, PART_FRAGMENT
, uri
->flags
) != fragment
+strlen(fragment
))
4512 _URI_SET_STR(fragment
);