xref: /freebsd/contrib/libevent/http.c (revision 123af6ec70016f5556da5972d4d63c7d175c06d3)
1 /*
2  * Copyright (c) 2002-2007 Niels Provos <provos@citi.umich.edu>
3  * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
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.
15  *
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.
26  */
27 
28 #include "event2/event-config.h"
29 #include "evconfig-private.h"
30 
31 #ifdef EVENT__HAVE_SYS_PARAM_H
32 #include <sys/param.h>
33 #endif
34 #ifdef EVENT__HAVE_SYS_TYPES_H
35 #include <sys/types.h>
36 #endif
37 
38 #ifdef HAVE_SYS_IOCCOM_H
39 #include <sys/ioccom.h>
40 #endif
41 #ifdef EVENT__HAVE_SYS_RESOURCE_H
42 #include <sys/resource.h>
43 #endif
44 #ifdef EVENT__HAVE_SYS_TIME_H
45 #include <sys/time.h>
46 #endif
47 #ifdef EVENT__HAVE_SYS_WAIT_H
48 #include <sys/wait.h>
49 #endif
50 
51 #ifndef _WIN32
52 #include <sys/socket.h>
53 #include <sys/stat.h>
54 #else
55 #include <winsock2.h>
56 #include <ws2tcpip.h>
57 #endif
58 
59 #include <sys/queue.h>
60 
61 #ifdef EVENT__HAVE_NETINET_IN_H
62 #include <netinet/in.h>
63 #endif
64 #ifdef EVENT__HAVE_ARPA_INET_H
65 #include <arpa/inet.h>
66 #endif
67 #ifdef EVENT__HAVE_NETDB_H
68 #include <netdb.h>
69 #endif
70 
71 #ifdef _WIN32
72 #include <winsock2.h>
73 #endif
74 
75 #include <errno.h>
76 #include <stdio.h>
77 #include <stdlib.h>
78 #include <string.h>
79 #ifndef _WIN32
80 #include <syslog.h>
81 #endif
82 #include <signal.h>
83 #ifdef EVENT__HAVE_UNISTD_H
84 #include <unistd.h>
85 #endif
86 #ifdef EVENT__HAVE_FCNTL_H
87 #include <fcntl.h>
88 #endif
89 
90 #undef timeout_pending
91 #undef timeout_initialized
92 
93 #include "strlcpy-internal.h"
94 #include "event2/http.h"
95 #include "event2/event.h"
96 #include "event2/buffer.h"
97 #include "event2/bufferevent.h"
98 #include "event2/http_struct.h"
99 #include "event2/http_compat.h"
100 #include "event2/util.h"
101 #include "event2/listener.h"
102 #include "log-internal.h"
103 #include "util-internal.h"
104 #include "http-internal.h"
105 #include "mm-internal.h"
106 #include "bufferevent-internal.h"
107 
108 #ifndef EVENT__HAVE_GETNAMEINFO
109 #define NI_MAXSERV 32
110 #define NI_MAXHOST 1025
111 
112 #ifndef NI_NUMERICHOST
113 #define NI_NUMERICHOST 1
114 #endif
115 
116 #ifndef NI_NUMERICSERV
117 #define NI_NUMERICSERV 2
118 #endif
119 
120 static int
121 fake_getnameinfo(const struct sockaddr *sa, size_t salen, char *host,
122 	size_t hostlen, char *serv, size_t servlen, int flags)
123 {
124 	struct sockaddr_in *sin = (struct sockaddr_in *)sa;
125 
126 	if (serv != NULL) {
127 		char tmpserv[16];
128 		evutil_snprintf(tmpserv, sizeof(tmpserv),
129 		    "%d", ntohs(sin->sin_port));
130 		if (strlcpy(serv, tmpserv, servlen) >= servlen)
131 			return (-1);
132 	}
133 
134 	if (host != NULL) {
135 		if (flags & NI_NUMERICHOST) {
136 			if (strlcpy(host, inet_ntoa(sin->sin_addr),
137 			    hostlen) >= hostlen)
138 				return (-1);
139 			else
140 				return (0);
141 		} else {
142 			struct hostent *hp;
143 			hp = gethostbyaddr((char *)&sin->sin_addr,
144 			    sizeof(struct in_addr), AF_INET);
145 			if (hp == NULL)
146 				return (-2);
147 
148 			if (strlcpy(host, hp->h_name, hostlen) >= hostlen)
149 				return (-1);
150 			else
151 				return (0);
152 		}
153 	}
154 	return (0);
155 }
156 
157 #endif
158 
159 #define REQ_VERSION_BEFORE(req, major_v, minor_v)			\
160 	((req)->major < (major_v) ||					\
161 	    ((req)->major == (major_v) && (req)->minor < (minor_v)))
162 
163 #define REQ_VERSION_ATLEAST(req, major_v, minor_v)			\
164 	((req)->major > (major_v) ||					\
165 	    ((req)->major == (major_v) && (req)->minor >= (minor_v)))
166 
167 #ifndef MIN
168 #define MIN(a,b) (((a)<(b))?(a):(b))
169 #endif
170 
171 extern int debug;
172 
173 static evutil_socket_t bind_socket_ai(struct evutil_addrinfo *, int reuse);
174 static evutil_socket_t bind_socket(const char *, ev_uint16_t, int reuse);
175 static void name_from_addr(struct sockaddr *, ev_socklen_t, char **, char **);
176 static int evhttp_associate_new_request_with_connection(
177 	struct evhttp_connection *evcon);
178 static void evhttp_connection_start_detectclose(
179 	struct evhttp_connection *evcon);
180 static void evhttp_connection_stop_detectclose(
181 	struct evhttp_connection *evcon);
182 static void evhttp_request_dispatch(struct evhttp_connection* evcon);
183 static void evhttp_read_firstline(struct evhttp_connection *evcon,
184 				  struct evhttp_request *req);
185 static void evhttp_read_header(struct evhttp_connection *evcon,
186     struct evhttp_request *req);
187 static int evhttp_add_header_internal(struct evkeyvalq *headers,
188     const char *key, const char *value);
189 static const char *evhttp_response_phrase_internal(int code);
190 static void evhttp_get_request(struct evhttp *, evutil_socket_t, struct sockaddr *, ev_socklen_t);
191 static void evhttp_write_buffer(struct evhttp_connection *,
192     void (*)(struct evhttp_connection *, void *), void *);
193 static void evhttp_make_header(struct evhttp_connection *, struct evhttp_request *);
194 
195 /* callbacks for bufferevent */
196 static void evhttp_read_cb(struct bufferevent *, void *);
197 static void evhttp_write_cb(struct bufferevent *, void *);
198 static void evhttp_error_cb(struct bufferevent *bufev, short what, void *arg);
199 static int evhttp_find_vhost(struct evhttp *http, struct evhttp **outhttp,
200 		  const char *hostname);
201 
202 #ifndef EVENT__HAVE_STRSEP
203 /* strsep replacement for platforms that lack it.  Only works if
204  * del is one character long. */
205 static char *
206 strsep(char **s, const char *del)
207 {
208 	char *d, *tok;
209 	EVUTIL_ASSERT(strlen(del) == 1);
210 	if (!s || !*s)
211 		return NULL;
212 	tok = *s;
213 	d = strstr(tok, del);
214 	if (d) {
215 		*d = '\0';
216 		*s = d + 1;
217 	} else
218 		*s = NULL;
219 	return tok;
220 }
221 #endif
222 
223 static size_t
224 html_replace(const char ch, const char **escaped)
225 {
226 	switch (ch) {
227 	case '<':
228 		*escaped = "&lt;";
229 		return 4;
230 	case '>':
231 		*escaped = "&gt;";
232 		return 4;
233 	case '"':
234 		*escaped = "&quot;";
235 		return 6;
236 	case '\'':
237 		*escaped = "&#039;";
238 		return 6;
239 	case '&':
240 		*escaped = "&amp;";
241 		return 5;
242 	default:
243 		break;
244 	}
245 
246 	return 1;
247 }
248 
249 /*
250  * Replaces <, >, ", ' and & with &lt;, &gt;, &quot;,
251  * &#039; and &amp; correspondingly.
252  *
253  * The returned string needs to be freed by the caller.
254  */
255 
256 char *
257 evhttp_htmlescape(const char *html)
258 {
259 	size_t i;
260 	size_t new_size = 0, old_size = 0;
261 	char *escaped_html, *p;
262 
263 	if (html == NULL)
264 		return (NULL);
265 
266 	old_size = strlen(html);
267 	for (i = 0; i < old_size; ++i) {
268 		const char *replaced = NULL;
269 		const size_t replace_size = html_replace(html[i], &replaced);
270 		if (replace_size > EV_SIZE_MAX - new_size) {
271 			event_warn("%s: html_replace overflow", __func__);
272 			return (NULL);
273 		}
274 		new_size += replace_size;
275 	}
276 
277 	if (new_size == EV_SIZE_MAX)
278 		return (NULL);
279 	p = escaped_html = mm_malloc(new_size + 1);
280 	if (escaped_html == NULL) {
281 		event_warn("%s: malloc(%lu)", __func__,
282 		           (unsigned long)(new_size + 1));
283 		return (NULL);
284 	}
285 	for (i = 0; i < old_size; ++i) {
286 		const char *replaced = &html[i];
287 		const size_t len = html_replace(html[i], &replaced);
288 		memcpy(p, replaced, len);
289 		p += len;
290 	}
291 
292 	*p = '\0';
293 
294 	return (escaped_html);
295 }
296 
297 /** Given an evhttp_cmd_type, returns a constant string containing the
298  * equivalent HTTP command, or NULL if the evhttp_command_type is
299  * unrecognized. */
300 static const char *
301 evhttp_method(enum evhttp_cmd_type type)
302 {
303 	const char *method;
304 
305 	switch (type) {
306 	case EVHTTP_REQ_GET:
307 		method = "GET";
308 		break;
309 	case EVHTTP_REQ_POST:
310 		method = "POST";
311 		break;
312 	case EVHTTP_REQ_HEAD:
313 		method = "HEAD";
314 		break;
315 	case EVHTTP_REQ_PUT:
316 		method = "PUT";
317 		break;
318 	case EVHTTP_REQ_DELETE:
319 		method = "DELETE";
320 		break;
321 	case EVHTTP_REQ_OPTIONS:
322 		method = "OPTIONS";
323 		break;
324 	case EVHTTP_REQ_TRACE:
325 		method = "TRACE";
326 		break;
327 	case EVHTTP_REQ_CONNECT:
328 		method = "CONNECT";
329 		break;
330 	case EVHTTP_REQ_PATCH:
331 		method = "PATCH";
332 		break;
333 	default:
334 		method = NULL;
335 		break;
336 	}
337 
338 	return (method);
339 }
340 
341 /**
342  * Determines if a response should have a body.
343  * Follows the rules in RFC 2616 section 4.3.
344  * @return 1 if the response MUST have a body; 0 if the response MUST NOT have
345  *     a body.
346  */
347 static int
348 evhttp_response_needs_body(struct evhttp_request *req)
349 {
350 	return (req->response_code != HTTP_NOCONTENT &&
351 		req->response_code != HTTP_NOTMODIFIED &&
352 		(req->response_code < 100 || req->response_code >= 200) &&
353 		req->type != EVHTTP_REQ_HEAD);
354 }
355 
356 /** Helper: called after we've added some data to an evcon's bufferevent's
357  * output buffer.  Sets the evconn's writing-is-done callback, and puts
358  * the bufferevent into writing mode.
359  */
360 static void
361 evhttp_write_buffer(struct evhttp_connection *evcon,
362     void (*cb)(struct evhttp_connection *, void *), void *arg)
363 {
364 	event_debug(("%s: preparing to write buffer\n", __func__));
365 
366 	/* Set call back */
367 	evcon->cb = cb;
368 	evcon->cb_arg = arg;
369 
370 	/* Disable the read callback: we don't actually care about data;
371 	 * we only care about close detection.  (We don't disable reading,
372 	 * since we *do* want to learn about any close events.) */
373 	bufferevent_setcb(evcon->bufev,
374 	    NULL, /*read*/
375 	    evhttp_write_cb,
376 	    evhttp_error_cb,
377 	    evcon);
378 
379 	bufferevent_enable(evcon->bufev, EV_WRITE);
380 }
381 
382 static void
383 evhttp_send_continue_done(struct evhttp_connection *evcon, void *arg)
384 {
385 	bufferevent_disable(evcon->bufev, EV_WRITE);
386 }
387 
388 static void
389 evhttp_send_continue(struct evhttp_connection *evcon,
390 			struct evhttp_request *req)
391 {
392 	bufferevent_enable(evcon->bufev, EV_WRITE);
393 	evbuffer_add_printf(bufferevent_get_output(evcon->bufev),
394 			"HTTP/%d.%d 100 Continue\r\n\r\n",
395 			req->major, req->minor);
396 	evcon->cb = evhttp_send_continue_done;
397 	evcon->cb_arg = NULL;
398 	bufferevent_setcb(evcon->bufev,
399 	    evhttp_read_cb,
400 	    evhttp_write_cb,
401 	    evhttp_error_cb,
402 	    evcon);
403 }
404 
405 /** Helper: returns true iff evconn is in any connected state. */
406 static int
407 evhttp_connected(struct evhttp_connection *evcon)
408 {
409 	switch (evcon->state) {
410 	case EVCON_DISCONNECTED:
411 	case EVCON_CONNECTING:
412 		return (0);
413 	case EVCON_IDLE:
414 	case EVCON_READING_FIRSTLINE:
415 	case EVCON_READING_HEADERS:
416 	case EVCON_READING_BODY:
417 	case EVCON_READING_TRAILER:
418 	case EVCON_WRITING:
419 	default:
420 		return (1);
421 	}
422 }
423 
424 /* Create the headers needed for an outgoing HTTP request, adds them to
425  * the request's header list, and writes the request line to the
426  * connection's output buffer.
427  */
428 static void
429 evhttp_make_header_request(struct evhttp_connection *evcon,
430     struct evhttp_request *req)
431 {
432 	const char *method;
433 
434 	evhttp_remove_header(req->output_headers, "Proxy-Connection");
435 
436 	/* Generate request line */
437 	if (!(method = evhttp_method(req->type))) {
438 		method = "NULL";
439 	}
440 
441 	evbuffer_add_printf(bufferevent_get_output(evcon->bufev),
442 	    "%s %s HTTP/%d.%d\r\n",
443 	    method, req->uri, req->major, req->minor);
444 
445 	/* Add the content length on a post or put request if missing */
446 	if ((req->type == EVHTTP_REQ_POST || req->type == EVHTTP_REQ_PUT) &&
447 	    evhttp_find_header(req->output_headers, "Content-Length") == NULL){
448 		char size[22];
449 		evutil_snprintf(size, sizeof(size), EV_SIZE_FMT,
450 		    EV_SIZE_ARG(evbuffer_get_length(req->output_buffer)));
451 		evhttp_add_header(req->output_headers, "Content-Length", size);
452 	}
453 }
454 
455 /** Return true if the list of headers in 'headers', intepreted with respect
456  * to flags, means that we should send a "connection: close" when the request
457  * is done. */
458 static int
459 evhttp_is_connection_close(int flags, struct evkeyvalq* headers)
460 {
461 	if (flags & EVHTTP_PROXY_REQUEST) {
462 		/* proxy connection */
463 		const char *connection = evhttp_find_header(headers, "Proxy-Connection");
464 		return (connection == NULL || evutil_ascii_strcasecmp(connection, "keep-alive") != 0);
465 	} else {
466 		const char *connection = evhttp_find_header(headers, "Connection");
467 		return (connection != NULL && evutil_ascii_strcasecmp(connection, "close") == 0);
468 	}
469 }
470 static int
471 evhttp_is_request_connection_close(struct evhttp_request *req)
472 {
473 	return
474 		evhttp_is_connection_close(req->flags, req->input_headers) ||
475 		evhttp_is_connection_close(req->flags, req->output_headers);
476 }
477 
478 /* Return true iff 'headers' contains 'Connection: keep-alive' */
479 static int
480 evhttp_is_connection_keepalive(struct evkeyvalq* headers)
481 {
482 	const char *connection = evhttp_find_header(headers, "Connection");
483 	return (connection != NULL
484 	    && evutil_ascii_strncasecmp(connection, "keep-alive", 10) == 0);
485 }
486 
487 /* Add a correct "Date" header to headers, unless it already has one. */
488 static void
489 evhttp_maybe_add_date_header(struct evkeyvalq *headers)
490 {
491 	if (evhttp_find_header(headers, "Date") == NULL) {
492 		char date[50];
493 		if (sizeof(date) - evutil_date_rfc1123(date, sizeof(date), NULL) > 0) {
494 			evhttp_add_header(headers, "Date", date);
495 		}
496 	}
497 }
498 
499 /* Add a "Content-Length" header with value 'content_length' to headers,
500  * unless it already has a content-length or transfer-encoding header. */
501 static void
502 evhttp_maybe_add_content_length_header(struct evkeyvalq *headers,
503     size_t content_length)
504 {
505 	if (evhttp_find_header(headers, "Transfer-Encoding") == NULL &&
506 	    evhttp_find_header(headers,	"Content-Length") == NULL) {
507 		char len[22];
508 		evutil_snprintf(len, sizeof(len), EV_SIZE_FMT,
509 		    EV_SIZE_ARG(content_length));
510 		evhttp_add_header(headers, "Content-Length", len);
511 	}
512 }
513 
514 /*
515  * Create the headers needed for an HTTP reply in req->output_headers,
516  * and write the first HTTP response for req line to evcon.
517  */
518 static void
519 evhttp_make_header_response(struct evhttp_connection *evcon,
520     struct evhttp_request *req)
521 {
522 	int is_keepalive = evhttp_is_connection_keepalive(req->input_headers);
523 	evbuffer_add_printf(bufferevent_get_output(evcon->bufev),
524 	    "HTTP/%d.%d %d %s\r\n",
525 	    req->major, req->minor, req->response_code,
526 	    req->response_code_line);
527 
528 	if (req->major == 1) {
529 		if (req->minor >= 1)
530 			evhttp_maybe_add_date_header(req->output_headers);
531 
532 		/*
533 		 * if the protocol is 1.0; and the connection was keep-alive
534 		 * we need to add a keep-alive header, too.
535 		 */
536 		if (req->minor == 0 && is_keepalive)
537 			evhttp_add_header(req->output_headers,
538 			    "Connection", "keep-alive");
539 
540 		if ((req->minor >= 1 || is_keepalive) &&
541 		    evhttp_response_needs_body(req)) {
542 			/*
543 			 * we need to add the content length if the
544 			 * user did not give it, this is required for
545 			 * persistent connections to work.
546 			 */
547 			evhttp_maybe_add_content_length_header(
548 				req->output_headers,
549 				evbuffer_get_length(req->output_buffer));
550 		}
551 	}
552 
553 	/* Potentially add headers for unidentified content. */
554 	if (evhttp_response_needs_body(req)) {
555 		if (evhttp_find_header(req->output_headers,
556 			"Content-Type") == NULL
557 		    && evcon->http_server->default_content_type) {
558 			evhttp_add_header(req->output_headers,
559 			    "Content-Type",
560 			    evcon->http_server->default_content_type);
561 		}
562 	}
563 
564 	/* if the request asked for a close, we send a close, too */
565 	if (evhttp_is_connection_close(req->flags, req->input_headers)) {
566 		evhttp_remove_header(req->output_headers, "Connection");
567 		if (!(req->flags & EVHTTP_PROXY_REQUEST))
568 		    evhttp_add_header(req->output_headers, "Connection", "close");
569 		evhttp_remove_header(req->output_headers, "Proxy-Connection");
570 	}
571 }
572 
573 enum expect { NO, CONTINUE, OTHER };
574 static enum expect evhttp_have_expect(struct evhttp_request *req, int input)
575 {
576 	const char *expect;
577 	struct evkeyvalq *h = input ? req->input_headers : req->output_headers;
578 
579 	if (!(req->kind == EVHTTP_REQUEST) || !REQ_VERSION_ATLEAST(req, 1, 1))
580 		return NO;
581 
582 	expect = evhttp_find_header(h, "Expect");
583 	if (!expect)
584 		return NO;
585 
586 	return !evutil_ascii_strcasecmp(expect, "100-continue") ? CONTINUE : OTHER;
587 }
588 
589 
590 /** Generate all headers appropriate for sending the http request in req (or
591  * the response, if we're sending a response), and write them to evcon's
592  * bufferevent. Also writes all data from req->output_buffer */
593 static void
594 evhttp_make_header(struct evhttp_connection *evcon, struct evhttp_request *req)
595 {
596 	struct evkeyval *header;
597 	struct evbuffer *output = bufferevent_get_output(evcon->bufev);
598 
599 	/*
600 	 * Depending if this is a HTTP request or response, we might need to
601 	 * add some new headers or remove existing headers.
602 	 */
603 	if (req->kind == EVHTTP_REQUEST) {
604 		evhttp_make_header_request(evcon, req);
605 	} else {
606 		evhttp_make_header_response(evcon, req);
607 	}
608 
609 	TAILQ_FOREACH(header, req->output_headers, next) {
610 		evbuffer_add_printf(output, "%s: %s\r\n",
611 		    header->key, header->value);
612 	}
613 	evbuffer_add(output, "\r\n", 2);
614 
615 	if (evhttp_have_expect(req, 0) != CONTINUE &&
616 		evbuffer_get_length(req->output_buffer)) {
617 		/*
618 		 * For a request, we add the POST data, for a reply, this
619 		 * is the regular data.
620 		 */
621 		evbuffer_add_buffer(output, req->output_buffer);
622 	}
623 }
624 
625 void
626 evhttp_connection_set_max_headers_size(struct evhttp_connection *evcon,
627     ev_ssize_t new_max_headers_size)
628 {
629 	if (new_max_headers_size<0)
630 		evcon->max_headers_size = EV_SIZE_MAX;
631 	else
632 		evcon->max_headers_size = new_max_headers_size;
633 }
634 void
635 evhttp_connection_set_max_body_size(struct evhttp_connection* evcon,
636     ev_ssize_t new_max_body_size)
637 {
638 	if (new_max_body_size<0)
639 		evcon->max_body_size = EV_UINT64_MAX;
640 	else
641 		evcon->max_body_size = new_max_body_size;
642 }
643 
644 static int
645 evhttp_connection_incoming_fail(struct evhttp_request *req,
646     enum evhttp_request_error error)
647 {
648 	switch (error) {
649 		case EVREQ_HTTP_DATA_TOO_LONG:
650 			req->response_code = HTTP_ENTITYTOOLARGE;
651 			break;
652 		default:
653 			req->response_code = HTTP_BADREQUEST;
654 	}
655 
656 	switch (error) {
657 	case EVREQ_HTTP_TIMEOUT:
658 	case EVREQ_HTTP_EOF:
659 		/*
660 		 * these are cases in which we probably should just
661 		 * close the connection and not send a reply.  this
662 		 * case may happen when a browser keeps a persistent
663 		 * connection open and we timeout on the read.  when
664 		 * the request is still being used for sending, we
665 		 * need to disassociated it from the connection here.
666 		 */
667 		if (!req->userdone) {
668 			/* remove it so that it will not be freed */
669 			TAILQ_REMOVE(&req->evcon->requests, req, next);
670 			/* indicate that this request no longer has a
671 			 * connection object
672 			 */
673 			req->evcon = NULL;
674 		}
675 		return (-1);
676 	case EVREQ_HTTP_INVALID_HEADER:
677 	case EVREQ_HTTP_BUFFER_ERROR:
678 	case EVREQ_HTTP_REQUEST_CANCEL:
679 	case EVREQ_HTTP_DATA_TOO_LONG:
680 	default:	/* xxx: probably should just error on default */
681 		/* the callback looks at the uri to determine errors */
682 		if (req->uri) {
683 			mm_free(req->uri);
684 			req->uri = NULL;
685 		}
686 		if (req->uri_elems) {
687 			evhttp_uri_free(req->uri_elems);
688 			req->uri_elems = NULL;
689 		}
690 
691 		/*
692 		 * the callback needs to send a reply, once the reply has
693 		 * been send, the connection should get freed.
694 		 */
695 		(*req->cb)(req, req->cb_arg);
696 	}
697 
698 	return (0);
699 }
700 
701 /* Free connection ownership of which can be acquired by user using
702  * evhttp_request_own(). */
703 static inline void
704 evhttp_request_free_auto(struct evhttp_request *req)
705 {
706 	if (!(req->flags & EVHTTP_USER_OWNED))
707 		evhttp_request_free(req);
708 }
709 
710 static void
711 evhttp_request_free_(struct evhttp_connection *evcon, struct evhttp_request *req)
712 {
713 	TAILQ_REMOVE(&evcon->requests, req, next);
714 	evhttp_request_free_auto(req);
715 }
716 
717 /* Called when evcon has experienced a (non-recoverable? -NM) error, as
718  * given in error. If it's an outgoing connection, reset the connection,
719  * retry any pending requests, and inform the user.  If it's incoming,
720  * delegates to evhttp_connection_incoming_fail(). */
721 void
722 evhttp_connection_fail_(struct evhttp_connection *evcon,
723     enum evhttp_request_error error)
724 {
725 	const int errsave = EVUTIL_SOCKET_ERROR();
726 	struct evhttp_request* req = TAILQ_FIRST(&evcon->requests);
727 	void (*cb)(struct evhttp_request *, void *);
728 	void *cb_arg;
729 	void (*error_cb)(enum evhttp_request_error, void *);
730 	void *error_cb_arg;
731 	EVUTIL_ASSERT(req != NULL);
732 
733 	bufferevent_disable(evcon->bufev, EV_READ|EV_WRITE);
734 
735 	if (evcon->flags & EVHTTP_CON_INCOMING) {
736 		/*
737 		 * for incoming requests, there are two different
738 		 * failure cases.  it's either a network level error
739 		 * or an http layer error. for problems on the network
740 		 * layer like timeouts we just drop the connections.
741 		 * For HTTP problems, we might have to send back a
742 		 * reply before the connection can be freed.
743 		 */
744 		if (evhttp_connection_incoming_fail(req, error) == -1)
745 			evhttp_connection_free(evcon);
746 		return;
747 	}
748 
749 	error_cb = req->error_cb;
750 	error_cb_arg = req->cb_arg;
751 	/* when the request was canceled, the callback is not executed */
752 	if (error != EVREQ_HTTP_REQUEST_CANCEL) {
753 		/* save the callback for later; the cb might free our object */
754 		cb = req->cb;
755 		cb_arg = req->cb_arg;
756 	} else {
757 		cb = NULL;
758 		cb_arg = NULL;
759 	}
760 
761 	/* do not fail all requests; the next request is going to get
762 	 * send over a new connection.   when a user cancels a request,
763 	 * all other pending requests should be processed as normal
764 	 */
765 	evhttp_request_free_(evcon, req);
766 
767 	/* reset the connection */
768 	evhttp_connection_reset_(evcon);
769 
770 	/* We are trying the next request that was queued on us */
771 	if (TAILQ_FIRST(&evcon->requests) != NULL)
772 		evhttp_connection_connect_(evcon);
773 
774 	/* The call to evhttp_connection_reset_ overwrote errno.
775 	 * Let's restore the original errno, so that the user's
776 	 * callback can have a better idea of what the error was.
777 	 */
778 	EVUTIL_SET_SOCKET_ERROR(errsave);
779 
780 	/* inform the user */
781 	if (error_cb != NULL)
782 		error_cb(error, error_cb_arg);
783 	if (cb != NULL)
784 		(*cb)(NULL, cb_arg);
785 }
786 
787 /* Bufferevent callback: invoked when any data has been written from an
788  * http connection's bufferevent */
789 static void
790 evhttp_write_cb(struct bufferevent *bufev, void *arg)
791 {
792 	struct evhttp_connection *evcon = arg;
793 
794 	/* Activate our call back */
795 	if (evcon->cb != NULL)
796 		(*evcon->cb)(evcon, evcon->cb_arg);
797 }
798 
799 /**
800  * Advance the connection state.
801  * - If this is an outgoing connection, we've just processed the response;
802  *   idle or close the connection.
803  * - If this is an incoming connection, we've just processed the request;
804  *   respond.
805  */
806 static void
807 evhttp_connection_done(struct evhttp_connection *evcon)
808 {
809 	struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
810 	int con_outgoing = evcon->flags & EVHTTP_CON_OUTGOING;
811 	int free_evcon = 0;
812 
813 	if (con_outgoing) {
814 		/* idle or close the connection */
815 		int need_close = evhttp_is_request_connection_close(req);
816 		TAILQ_REMOVE(&evcon->requests, req, next);
817 		req->evcon = NULL;
818 
819 		evcon->state = EVCON_IDLE;
820 
821 		/* check if we got asked to close the connection */
822 		if (need_close)
823 			evhttp_connection_reset_(evcon);
824 
825 		if (TAILQ_FIRST(&evcon->requests) != NULL) {
826 			/*
827 			 * We have more requests; reset the connection
828 			 * and deal with the next request.
829 			 */
830 			if (!evhttp_connected(evcon))
831 				evhttp_connection_connect_(evcon);
832 			else
833 				evhttp_request_dispatch(evcon);
834 		} else if (!need_close) {
835 			/*
836 			 * The connection is going to be persistent, but we
837 			 * need to detect if the other side closes it.
838 			 */
839 			evhttp_connection_start_detectclose(evcon);
840 		} else if ((evcon->flags & EVHTTP_CON_AUTOFREE)) {
841 			/*
842 			 * If we have no more requests that need completion
843 			 * and we're not waiting for the connection to close
844 			 */
845 			 free_evcon = 1;
846 		}
847 	} else {
848 		/*
849 		 * incoming connection - we need to leave the request on the
850 		 * connection so that we can reply to it.
851 		 */
852 		evcon->state = EVCON_WRITING;
853 	}
854 
855 	/* notify the user of the request */
856 	(*req->cb)(req, req->cb_arg);
857 
858 	/* if this was an outgoing request, we own and it's done. so free it. */
859 	if (con_outgoing) {
860 		evhttp_request_free_auto(req);
861 	}
862 
863 	/* If this was the last request of an outgoing connection and we're
864 	 * not waiting to receive a connection close event and we want to
865 	 * automatically free the connection. We check to ensure our request
866 	 * list is empty one last time just in case our callback added a
867 	 * new request.
868 	 */
869 	if (free_evcon && TAILQ_FIRST(&evcon->requests) == NULL) {
870 		evhttp_connection_free(evcon);
871 	}
872 }
873 
874 /*
875  * Handles reading from a chunked request.
876  *   return ALL_DATA_READ:
877  *     all data has been read
878  *   return MORE_DATA_EXPECTED:
879  *     more data is expected
880  *   return DATA_CORRUPTED:
881  *     data is corrupted
882  *   return REQUEST_CANCELED:
883  *     request was canceled by the user calling evhttp_cancel_request
884  *   return DATA_TOO_LONG:
885  *     ran over the maximum limit
886  */
887 
888 static enum message_read_status
889 evhttp_handle_chunked_read(struct evhttp_request *req, struct evbuffer *buf)
890 {
891 	if (req == NULL || buf == NULL) {
892 	    return DATA_CORRUPTED;
893 	}
894 
895 	while (1) {
896 		size_t buflen;
897 
898 		if ((buflen = evbuffer_get_length(buf)) == 0) {
899 			break;
900 		}
901 
902 		/* evbuffer_get_length returns size_t, but len variable is ssize_t,
903 		 * check for overflow conditions */
904 		if (buflen > EV_SSIZE_MAX) {
905 			return DATA_CORRUPTED;
906 		}
907 
908 		if (req->ntoread < 0) {
909 			/* Read chunk size */
910 			ev_int64_t ntoread;
911 			char *p = evbuffer_readln(buf, NULL, EVBUFFER_EOL_CRLF);
912 			char *endp;
913 			int error;
914 			if (p == NULL)
915 				break;
916 			/* the last chunk is on a new line? */
917 			if (strlen(p) == 0) {
918 				mm_free(p);
919 				continue;
920 			}
921 			ntoread = evutil_strtoll(p, &endp, 16);
922 			error = (*p == '\0' ||
923 			    (*endp != '\0' && *endp != ' ') ||
924 			    ntoread < 0);
925 			mm_free(p);
926 			if (error) {
927 				/* could not get chunk size */
928 				return (DATA_CORRUPTED);
929 			}
930 
931 			/* ntoread is signed int64, body_size is unsigned size_t, check for under/overflow conditions */
932 			if ((ev_uint64_t)ntoread > EV_SIZE_MAX - req->body_size) {
933 			    return DATA_CORRUPTED;
934 			}
935 
936 			if (req->body_size + (size_t)ntoread > req->evcon->max_body_size) {
937 				/* failed body length test */
938 				event_debug(("Request body is too long"));
939 				return (DATA_TOO_LONG);
940 			}
941 
942 			req->body_size += (size_t)ntoread;
943 			req->ntoread = ntoread;
944 			if (req->ntoread == 0) {
945 				/* Last chunk */
946 				return (ALL_DATA_READ);
947 			}
948 			continue;
949 		}
950 
951 		/* req->ntoread is signed int64, len is ssize_t, based on arch,
952 		 * ssize_t could only be 32b, check for these conditions */
953 		if (req->ntoread > EV_SSIZE_MAX) {
954 			return DATA_CORRUPTED;
955 		}
956 
957 		/* don't have enough to complete a chunk; wait for more */
958 		if (req->ntoread > 0 && buflen < (ev_uint64_t)req->ntoread)
959 			return (MORE_DATA_EXPECTED);
960 
961 		/* Completed chunk */
962 		evbuffer_remove_buffer(buf, req->input_buffer, (size_t)req->ntoread);
963 		req->ntoread = -1;
964 		if (req->chunk_cb != NULL) {
965 			req->flags |= EVHTTP_REQ_DEFER_FREE;
966 			(*req->chunk_cb)(req, req->cb_arg);
967 			evbuffer_drain(req->input_buffer,
968 			    evbuffer_get_length(req->input_buffer));
969 			req->flags &= ~EVHTTP_REQ_DEFER_FREE;
970 			if ((req->flags & EVHTTP_REQ_NEEDS_FREE) != 0) {
971 				return (REQUEST_CANCELED);
972 			}
973 		}
974 	}
975 
976 	return (MORE_DATA_EXPECTED);
977 }
978 
979 static void
980 evhttp_read_trailer(struct evhttp_connection *evcon, struct evhttp_request *req)
981 {
982 	struct evbuffer *buf = bufferevent_get_input(evcon->bufev);
983 
984 	switch (evhttp_parse_headers_(req, buf)) {
985 	case DATA_CORRUPTED:
986 	case DATA_TOO_LONG:
987 		evhttp_connection_fail_(evcon, EVREQ_HTTP_DATA_TOO_LONG);
988 		break;
989 	case ALL_DATA_READ:
990 		bufferevent_disable(evcon->bufev, EV_READ);
991 		evhttp_connection_done(evcon);
992 		break;
993 	case MORE_DATA_EXPECTED:
994 	case REQUEST_CANCELED: /* ??? */
995 	default:
996 		break;
997 	}
998 }
999 
1000 static void
1001 evhttp_lingering_close(struct evhttp_connection *evcon,
1002 	struct evhttp_request *req)
1003 {
1004 	struct evbuffer *buf = bufferevent_get_input(evcon->bufev);
1005 
1006 	size_t n = evbuffer_get_length(buf);
1007 	if (n > (size_t) req->ntoread)
1008 		n = (size_t) req->ntoread;
1009 	req->ntoread -= n;
1010 	req->body_size += n;
1011 
1012 	event_debug(("Request body is too long, left " EV_I64_FMT,
1013 		EV_I64_ARG(req->ntoread)));
1014 
1015 	evbuffer_drain(buf, n);
1016 	if (!req->ntoread)
1017 		evhttp_connection_fail_(evcon, EVREQ_HTTP_DATA_TOO_LONG);
1018 }
1019 static void
1020 evhttp_lingering_fail(struct evhttp_connection *evcon,
1021 	struct evhttp_request *req)
1022 {
1023 	if (evcon->flags & EVHTTP_CON_LINGERING_CLOSE)
1024 		evhttp_lingering_close(evcon, req);
1025 	else
1026 		evhttp_connection_fail_(evcon, EVREQ_HTTP_DATA_TOO_LONG);
1027 }
1028 
1029 static void
1030 evhttp_read_body(struct evhttp_connection *evcon, struct evhttp_request *req)
1031 {
1032 	struct evbuffer *buf = bufferevent_get_input(evcon->bufev);
1033 
1034 	if (req->chunked) {
1035 		switch (evhttp_handle_chunked_read(req, buf)) {
1036 		case ALL_DATA_READ:
1037 			/* finished last chunk */
1038 			evcon->state = EVCON_READING_TRAILER;
1039 			evhttp_read_trailer(evcon, req);
1040 			return;
1041 		case DATA_CORRUPTED:
1042 		case DATA_TOO_LONG:
1043 			/* corrupted data */
1044 			evhttp_connection_fail_(evcon,
1045 			    EVREQ_HTTP_DATA_TOO_LONG);
1046 			return;
1047 		case REQUEST_CANCELED:
1048 			/* request canceled */
1049 			evhttp_request_free_auto(req);
1050 			return;
1051 		case MORE_DATA_EXPECTED:
1052 		default:
1053 			break;
1054 		}
1055 	} else if (req->ntoread < 0) {
1056 		/* Read until connection close. */
1057 		if ((size_t)(req->body_size + evbuffer_get_length(buf)) < req->body_size) {
1058 			evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
1059 			return;
1060 		}
1061 
1062 		req->body_size += evbuffer_get_length(buf);
1063 		evbuffer_add_buffer(req->input_buffer, buf);
1064 	} else if (req->chunk_cb != NULL || evbuffer_get_length(buf) >= (size_t)req->ntoread) {
1065 		/* XXX: the above get_length comparison has to be fixed for overflow conditions! */
1066 		/* We've postponed moving the data until now, but we're
1067 		 * about to use it. */
1068 		size_t n = evbuffer_get_length(buf);
1069 
1070 		if (n > (size_t) req->ntoread)
1071 			n = (size_t) req->ntoread;
1072 		req->ntoread -= n;
1073 		req->body_size += n;
1074 		evbuffer_remove_buffer(buf, req->input_buffer, n);
1075 	}
1076 
1077 	if (req->body_size > req->evcon->max_body_size ||
1078 	    (!req->chunked && req->ntoread >= 0 &&
1079 		(size_t)req->ntoread > req->evcon->max_body_size)) {
1080 		/* XXX: The above casted comparison must checked for overflow */
1081 		/* failed body length test */
1082 
1083 		evhttp_lingering_fail(evcon, req);
1084 		return;
1085 	}
1086 
1087 	if (evbuffer_get_length(req->input_buffer) > 0 && req->chunk_cb != NULL) {
1088 		req->flags |= EVHTTP_REQ_DEFER_FREE;
1089 		(*req->chunk_cb)(req, req->cb_arg);
1090 		req->flags &= ~EVHTTP_REQ_DEFER_FREE;
1091 		evbuffer_drain(req->input_buffer,
1092 		    evbuffer_get_length(req->input_buffer));
1093 		if ((req->flags & EVHTTP_REQ_NEEDS_FREE) != 0) {
1094 			evhttp_request_free_auto(req);
1095 			return;
1096 		}
1097 	}
1098 
1099 	if (!req->ntoread) {
1100 		bufferevent_disable(evcon->bufev, EV_READ);
1101 		/* Completed content length */
1102 		evhttp_connection_done(evcon);
1103 		return;
1104 	}
1105 }
1106 
1107 #define get_deferred_queue(evcon)		\
1108 	((evcon)->base)
1109 
1110 /*
1111  * Gets called when more data becomes available
1112  */
1113 
1114 static void
1115 evhttp_read_cb(struct bufferevent *bufev, void *arg)
1116 {
1117 	struct evhttp_connection *evcon = arg;
1118 	struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
1119 
1120 	/* Cancel if it's pending. */
1121 	event_deferred_cb_cancel_(get_deferred_queue(evcon),
1122 	    &evcon->read_more_deferred_cb);
1123 
1124 	switch (evcon->state) {
1125 	case EVCON_READING_FIRSTLINE:
1126 		evhttp_read_firstline(evcon, req);
1127 		/* note the request may have been freed in
1128 		 * evhttp_read_body */
1129 		break;
1130 	case EVCON_READING_HEADERS:
1131 		evhttp_read_header(evcon, req);
1132 		/* note the request may have been freed in
1133 		 * evhttp_read_body */
1134 		break;
1135 	case EVCON_READING_BODY:
1136 		evhttp_read_body(evcon, req);
1137 		/* note the request may have been freed in
1138 		 * evhttp_read_body */
1139 		break;
1140 	case EVCON_READING_TRAILER:
1141 		evhttp_read_trailer(evcon, req);
1142 		break;
1143 	case EVCON_IDLE:
1144 		{
1145 #ifdef USE_DEBUG
1146 			struct evbuffer *input;
1147 			size_t total_len;
1148 
1149 			input = bufferevent_get_input(evcon->bufev);
1150 			total_len = evbuffer_get_length(input);
1151 			event_debug(("%s: read "EV_SIZE_FMT
1152 				" bytes in EVCON_IDLE state,"
1153 				" resetting connection",
1154 				__func__, EV_SIZE_ARG(total_len)));
1155 #endif
1156 
1157 			evhttp_connection_reset_(evcon);
1158 		}
1159 		break;
1160 	case EVCON_DISCONNECTED:
1161 	case EVCON_CONNECTING:
1162 	case EVCON_WRITING:
1163 	default:
1164 		event_errx(1, "%s: illegal connection state %d",
1165 			   __func__, evcon->state);
1166 	}
1167 }
1168 
1169 static void
1170 evhttp_deferred_read_cb(struct event_callback *cb, void *data)
1171 {
1172 	struct evhttp_connection *evcon = data;
1173 	evhttp_read_cb(evcon->bufev, evcon);
1174 }
1175 
1176 static void
1177 evhttp_write_connectioncb(struct evhttp_connection *evcon, void *arg)
1178 {
1179 	/* This is after writing the request to the server */
1180 	struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
1181 	struct evbuffer *output = bufferevent_get_output(evcon->bufev);
1182 	EVUTIL_ASSERT(req != NULL);
1183 
1184 	EVUTIL_ASSERT(evcon->state == EVCON_WRITING);
1185 
1186 	/* We need to wait until we've written all of our output data before we can
1187 	 * continue */
1188 	if (evbuffer_get_length(output) > 0)
1189 		return;
1190 
1191 	/* We are done writing our header and are now expecting the response */
1192 	req->kind = EVHTTP_RESPONSE;
1193 
1194 	evhttp_start_read_(evcon);
1195 }
1196 
1197 /*
1198  * Clean up a connection object
1199  */
1200 
1201 void
1202 evhttp_connection_free(struct evhttp_connection *evcon)
1203 {
1204 	struct evhttp_request *req;
1205 
1206 	/* notify interested parties that this connection is going down */
1207 	if (evcon->fd != -1) {
1208 		if (evhttp_connected(evcon) && evcon->closecb != NULL)
1209 			(*evcon->closecb)(evcon, evcon->closecb_arg);
1210 	}
1211 
1212 	/* remove all requests that might be queued on this
1213 	 * connection.  for server connections, this should be empty.
1214 	 * because it gets dequeued either in evhttp_connection_done or
1215 	 * evhttp_connection_fail_.
1216 	 */
1217 	while ((req = TAILQ_FIRST(&evcon->requests)) != NULL) {
1218 		evhttp_request_free_(evcon, req);
1219 	}
1220 
1221 	if (evcon->http_server != NULL) {
1222 		struct evhttp *http = evcon->http_server;
1223 		TAILQ_REMOVE(&http->connections, evcon, next);
1224 	}
1225 
1226 	if (event_initialized(&evcon->retry_ev)) {
1227 		event_del(&evcon->retry_ev);
1228 		event_debug_unassign(&evcon->retry_ev);
1229 	}
1230 
1231 	if (evcon->bufev != NULL)
1232 		bufferevent_free(evcon->bufev);
1233 
1234 	event_deferred_cb_cancel_(get_deferred_queue(evcon),
1235 	    &evcon->read_more_deferred_cb);
1236 
1237 	if (evcon->fd == -1)
1238 		evcon->fd = bufferevent_getfd(evcon->bufev);
1239 
1240 	if (evcon->fd != -1) {
1241 		bufferevent_disable(evcon->bufev, EV_READ|EV_WRITE);
1242 		shutdown(evcon->fd, EVUTIL_SHUT_WR);
1243 		if (!(bufferevent_get_options_(evcon->bufev) & BEV_OPT_CLOSE_ON_FREE)) {
1244 			evutil_closesocket(evcon->fd);
1245 		}
1246 	}
1247 
1248 	if (evcon->bind_address != NULL)
1249 		mm_free(evcon->bind_address);
1250 
1251 	if (evcon->address != NULL)
1252 		mm_free(evcon->address);
1253 
1254 	mm_free(evcon);
1255 }
1256 
1257 void
1258 evhttp_connection_free_on_completion(struct evhttp_connection *evcon) {
1259 	evcon->flags |= EVHTTP_CON_AUTOFREE;
1260 }
1261 
1262 void
1263 evhttp_connection_set_local_address(struct evhttp_connection *evcon,
1264     const char *address)
1265 {
1266 	EVUTIL_ASSERT(evcon->state == EVCON_DISCONNECTED);
1267 	if (evcon->bind_address)
1268 		mm_free(evcon->bind_address);
1269 	if ((evcon->bind_address = mm_strdup(address)) == NULL)
1270 		event_warn("%s: strdup", __func__);
1271 }
1272 
1273 void
1274 evhttp_connection_set_local_port(struct evhttp_connection *evcon,
1275     ev_uint16_t port)
1276 {
1277 	EVUTIL_ASSERT(evcon->state == EVCON_DISCONNECTED);
1278 	evcon->bind_port = port;
1279 }
1280 
1281 static void
1282 evhttp_request_dispatch(struct evhttp_connection* evcon)
1283 {
1284 	struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
1285 
1286 	/* this should not usually happy but it's possible */
1287 	if (req == NULL)
1288 		return;
1289 
1290 	/* delete possible close detection events */
1291 	evhttp_connection_stop_detectclose(evcon);
1292 
1293 	/* we assume that the connection is connected already */
1294 	EVUTIL_ASSERT(evcon->state == EVCON_IDLE);
1295 
1296 	evcon->state = EVCON_WRITING;
1297 
1298 	/* Create the header from the store arguments */
1299 	evhttp_make_header(evcon, req);
1300 
1301 	evhttp_write_buffer(evcon, evhttp_write_connectioncb, NULL);
1302 }
1303 
1304 /* Reset our connection state: disables reading/writing, closes our fd (if
1305 * any), clears out buffers, and puts us in state DISCONNECTED. */
1306 void
1307 evhttp_connection_reset_(struct evhttp_connection *evcon)
1308 {
1309 	struct evbuffer *tmp;
1310 	int err;
1311 
1312 	/* XXXX This is not actually an optimal fix.  Instead we ought to have
1313 	   an API for "stop connecting", or use bufferevent_setfd to turn off
1314 	   connecting.  But for Libevent 2.0, this seems like a minimal change
1315 	   least likely to disrupt the rest of the bufferevent and http code.
1316 
1317 	   Why is this here?  If the fd is set in the bufferevent, and the
1318 	   bufferevent is connecting, then you can't actually stop the
1319 	   bufferevent from trying to connect with bufferevent_disable().  The
1320 	   connect will never trigger, since we close the fd, but the timeout
1321 	   might.  That caused an assertion failure in evhttp_connection_fail_.
1322 	*/
1323 	bufferevent_disable_hard_(evcon->bufev, EV_READ|EV_WRITE);
1324 
1325 	if (evcon->fd == -1)
1326 		evcon->fd = bufferevent_getfd(evcon->bufev);
1327 
1328 	if (evcon->fd != -1) {
1329 		/* inform interested parties about connection close */
1330 		if (evhttp_connected(evcon) && evcon->closecb != NULL)
1331 			(*evcon->closecb)(evcon, evcon->closecb_arg);
1332 
1333 		shutdown(evcon->fd, EVUTIL_SHUT_WR);
1334 		evutil_closesocket(evcon->fd);
1335 		evcon->fd = -1;
1336 	}
1337 	bufferevent_setfd(evcon->bufev, -1);
1338 
1339 	/* we need to clean up any buffered data */
1340 	tmp = bufferevent_get_output(evcon->bufev);
1341 	err = evbuffer_drain(tmp, -1);
1342 	EVUTIL_ASSERT(!err && "drain output");
1343 	tmp = bufferevent_get_input(evcon->bufev);
1344 	err = evbuffer_drain(tmp, -1);
1345 	EVUTIL_ASSERT(!err && "drain input");
1346 
1347 	evcon->flags &= ~EVHTTP_CON_READING_ERROR;
1348 
1349 	evcon->state = EVCON_DISCONNECTED;
1350 }
1351 
1352 static void
1353 evhttp_connection_start_detectclose(struct evhttp_connection *evcon)
1354 {
1355 	evcon->flags |= EVHTTP_CON_CLOSEDETECT;
1356 
1357 	bufferevent_enable(evcon->bufev, EV_READ);
1358 }
1359 
1360 static void
1361 evhttp_connection_stop_detectclose(struct evhttp_connection *evcon)
1362 {
1363 	evcon->flags &= ~EVHTTP_CON_CLOSEDETECT;
1364 
1365 	bufferevent_disable(evcon->bufev, EV_READ);
1366 }
1367 
1368 static void
1369 evhttp_connection_retry(evutil_socket_t fd, short what, void *arg)
1370 {
1371 	struct evhttp_connection *evcon = arg;
1372 
1373 	evcon->state = EVCON_DISCONNECTED;
1374 	evhttp_connection_connect_(evcon);
1375 }
1376 
1377 static void
1378 evhttp_connection_cb_cleanup(struct evhttp_connection *evcon)
1379 {
1380 	struct evcon_requestq requests;
1381 
1382 	evhttp_connection_reset_(evcon);
1383 	if (evcon->retry_max < 0 || evcon->retry_cnt < evcon->retry_max) {
1384 		struct timeval tv_retry = evcon->initial_retry_timeout;
1385 		int i;
1386 		evtimer_assign(&evcon->retry_ev, evcon->base, evhttp_connection_retry, evcon);
1387 		/* XXXX handle failure from evhttp_add_event */
1388 		for (i=0; i < evcon->retry_cnt; ++i) {
1389 			tv_retry.tv_usec *= 2;
1390 			if (tv_retry.tv_usec > 1000000) {
1391 				tv_retry.tv_usec -= 1000000;
1392 				tv_retry.tv_sec += 1;
1393 			}
1394 			tv_retry.tv_sec *= 2;
1395 			if (tv_retry.tv_sec > 3600) {
1396 				tv_retry.tv_sec = 3600;
1397 				tv_retry.tv_usec = 0;
1398 			}
1399 		}
1400 		event_add(&evcon->retry_ev, &tv_retry);
1401 		evcon->retry_cnt++;
1402 		return;
1403 	}
1404 
1405 	/*
1406 	 * User callback can do evhttp_make_request() on the same
1407 	 * evcon so new request will be added to evcon->requests.  To
1408 	 * avoid freeing it prematurely we iterate over the copy of
1409 	 * the queue.
1410 	 */
1411 	TAILQ_INIT(&requests);
1412 	while (TAILQ_FIRST(&evcon->requests) != NULL) {
1413 		struct evhttp_request *request = TAILQ_FIRST(&evcon->requests);
1414 		TAILQ_REMOVE(&evcon->requests, request, next);
1415 		TAILQ_INSERT_TAIL(&requests, request, next);
1416 	}
1417 
1418 	/* for now, we just signal all requests by executing their callbacks */
1419 	while (TAILQ_FIRST(&requests) != NULL) {
1420 		struct evhttp_request *request = TAILQ_FIRST(&requests);
1421 		TAILQ_REMOVE(&requests, request, next);
1422 		request->evcon = NULL;
1423 
1424 		/* we might want to set an error here */
1425 		request->cb(request, request->cb_arg);
1426 		evhttp_request_free_auto(request);
1427 	}
1428 }
1429 
1430 static void
1431 evhttp_connection_read_on_write_error(struct evhttp_connection *evcon,
1432     struct evhttp_request *req)
1433 {
1434 	struct evbuffer *buf;
1435 
1436 	/** Second time, we can't read anything */
1437 	if (evcon->flags & EVHTTP_CON_READING_ERROR) {
1438 		evcon->flags &= ~EVHTTP_CON_READING_ERROR;
1439 		evhttp_connection_fail_(evcon, EVREQ_HTTP_EOF);
1440 		return;
1441 	}
1442 
1443 	req->kind = EVHTTP_RESPONSE;
1444 
1445 	buf = bufferevent_get_output(evcon->bufev);
1446 	evbuffer_unfreeze(buf, 1);
1447 	evbuffer_drain(buf, evbuffer_get_length(buf));
1448 	evbuffer_freeze(buf, 1);
1449 
1450 	evhttp_start_read_(evcon);
1451 	evcon->flags |= EVHTTP_CON_READING_ERROR;
1452 }
1453 
1454 static void
1455 evhttp_error_cb(struct bufferevent *bufev, short what, void *arg)
1456 {
1457 	struct evhttp_connection *evcon = arg;
1458 	struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
1459 
1460 	if (evcon->fd == -1)
1461 		evcon->fd = bufferevent_getfd(bufev);
1462 
1463 	switch (evcon->state) {
1464 	case EVCON_CONNECTING:
1465 		if (what & BEV_EVENT_TIMEOUT) {
1466 			event_debug(("%s: connection timeout for \"%s:%d\" on "
1467 				EV_SOCK_FMT,
1468 				__func__, evcon->address, evcon->port,
1469 				EV_SOCK_ARG(evcon->fd)));
1470 			evhttp_connection_cb_cleanup(evcon);
1471 			return;
1472 		}
1473 		break;
1474 
1475 	case EVCON_READING_BODY:
1476 		if (!req->chunked && req->ntoread < 0
1477 		    && what == (BEV_EVENT_READING|BEV_EVENT_EOF)) {
1478 			/* EOF on read can be benign */
1479 			evhttp_connection_done(evcon);
1480 			return;
1481 		}
1482 		break;
1483 
1484 	case EVCON_DISCONNECTED:
1485 	case EVCON_IDLE:
1486 	case EVCON_READING_FIRSTLINE:
1487 	case EVCON_READING_HEADERS:
1488 	case EVCON_READING_TRAILER:
1489 	case EVCON_WRITING:
1490 	default:
1491 		break;
1492 	}
1493 
1494 	/* when we are in close detect mode, a read error means that
1495 	 * the other side closed their connection.
1496 	 */
1497 	if (evcon->flags & EVHTTP_CON_CLOSEDETECT) {
1498 		evcon->flags &= ~EVHTTP_CON_CLOSEDETECT;
1499 		EVUTIL_ASSERT(evcon->http_server == NULL);
1500 		/* For connections from the client, we just
1501 		 * reset the connection so that it becomes
1502 		 * disconnected.
1503 		 */
1504 		EVUTIL_ASSERT(evcon->state == EVCON_IDLE);
1505 		evhttp_connection_reset_(evcon);
1506 
1507 		/*
1508 		 * If we have no more requests that need completion
1509 		 * and we want to auto-free the connection when all
1510 		 * requests have been completed.
1511 		 */
1512 		if (TAILQ_FIRST(&evcon->requests) == NULL
1513 		  && (evcon->flags & EVHTTP_CON_OUTGOING)
1514 		  && (evcon->flags & EVHTTP_CON_AUTOFREE)) {
1515 			evhttp_connection_free(evcon);
1516 		}
1517 		return;
1518 	}
1519 
1520 	if (what & BEV_EVENT_TIMEOUT) {
1521 		evhttp_connection_fail_(evcon, EVREQ_HTTP_TIMEOUT);
1522 	} else if (what & (BEV_EVENT_EOF|BEV_EVENT_ERROR)) {
1523 		if (what & BEV_EVENT_WRITING &&
1524 			evcon->flags & EVHTTP_CON_READ_ON_WRITE_ERROR) {
1525 			evhttp_connection_read_on_write_error(evcon, req);
1526 			return;
1527 		}
1528 
1529 		evhttp_connection_fail_(evcon, EVREQ_HTTP_EOF);
1530 	} else if (what == BEV_EVENT_CONNECTED) {
1531 	} else {
1532 		evhttp_connection_fail_(evcon, EVREQ_HTTP_BUFFER_ERROR);
1533 	}
1534 }
1535 
1536 /*
1537  * Event callback for asynchronous connection attempt.
1538  */
1539 static void
1540 evhttp_connection_cb(struct bufferevent *bufev, short what, void *arg)
1541 {
1542 	struct evhttp_connection *evcon = arg;
1543 	int error;
1544 	ev_socklen_t errsz = sizeof(error);
1545 
1546 	if (evcon->fd == -1)
1547 		evcon->fd = bufferevent_getfd(bufev);
1548 
1549 	if (!(what & BEV_EVENT_CONNECTED)) {
1550 		/* some operating systems return ECONNREFUSED immediately
1551 		 * when connecting to a local address.  the cleanup is going
1552 		 * to reschedule this function call.
1553 		 */
1554 #ifndef _WIN32
1555 		if (errno == ECONNREFUSED)
1556 			goto cleanup;
1557 #endif
1558 		evhttp_error_cb(bufev, what, arg);
1559 		return;
1560 	}
1561 
1562 	if (evcon->fd == -1) {
1563 		event_debug(("%s: bufferevent_getfd returned -1",
1564 			__func__));
1565 		goto cleanup;
1566 	}
1567 
1568 	/* Check if the connection completed */
1569 	if (getsockopt(evcon->fd, SOL_SOCKET, SO_ERROR, (void*)&error,
1570 		       &errsz) == -1) {
1571 		event_debug(("%s: getsockopt for \"%s:%d\" on "EV_SOCK_FMT,
1572 			__func__, evcon->address, evcon->port,
1573 			EV_SOCK_ARG(evcon->fd)));
1574 		goto cleanup;
1575 	}
1576 
1577 	if (error) {
1578 		event_debug(("%s: connect failed for \"%s:%d\" on "
1579 			EV_SOCK_FMT": %s",
1580 			__func__, evcon->address, evcon->port,
1581 			EV_SOCK_ARG(evcon->fd),
1582 			evutil_socket_error_to_string(error)));
1583 		goto cleanup;
1584 	}
1585 
1586 	/* We are connected to the server now */
1587 	event_debug(("%s: connected to \"%s:%d\" on "EV_SOCK_FMT"\n",
1588 			__func__, evcon->address, evcon->port,
1589 			EV_SOCK_ARG(evcon->fd)));
1590 
1591 	/* Reset the retry count as we were successful in connecting */
1592 	evcon->retry_cnt = 0;
1593 	evcon->state = EVCON_IDLE;
1594 
1595 	/* reset the bufferevent cbs */
1596 	bufferevent_setcb(evcon->bufev,
1597 	    evhttp_read_cb,
1598 	    evhttp_write_cb,
1599 	    evhttp_error_cb,
1600 	    evcon);
1601 
1602 	if (!evutil_timerisset(&evcon->timeout)) {
1603 		const struct timeval read_tv = { HTTP_READ_TIMEOUT, 0 };
1604 		const struct timeval write_tv = { HTTP_WRITE_TIMEOUT, 0 };
1605 		bufferevent_set_timeouts(evcon->bufev, &read_tv, &write_tv);
1606 	} else {
1607 		bufferevent_set_timeouts(evcon->bufev, &evcon->timeout, &evcon->timeout);
1608 	}
1609 
1610 	/* try to start requests that have queued up on this connection */
1611 	evhttp_request_dispatch(evcon);
1612 	return;
1613 
1614  cleanup:
1615 	evhttp_connection_cb_cleanup(evcon);
1616 }
1617 
1618 /*
1619  * Check if we got a valid response code.
1620  */
1621 
1622 static int
1623 evhttp_valid_response_code(int code)
1624 {
1625 	if (code == 0)
1626 		return (0);
1627 
1628 	return (1);
1629 }
1630 
1631 static int
1632 evhttp_parse_http_version(const char *version, struct evhttp_request *req)
1633 {
1634 	int major, minor;
1635 	char ch;
1636 	int n = sscanf(version, "HTTP/%d.%d%c", &major, &minor, &ch);
1637 	if (n != 2 || major > 1) {
1638 		event_debug(("%s: bad version %s on message %p from %s",
1639 			__func__, version, req, req->remote_host));
1640 		return (-1);
1641 	}
1642 	req->major = major;
1643 	req->minor = minor;
1644 	return (0);
1645 }
1646 
1647 /* Parses the status line of a web server */
1648 
1649 static int
1650 evhttp_parse_response_line(struct evhttp_request *req, char *line)
1651 {
1652 	char *protocol;
1653 	char *number;
1654 	const char *readable = "";
1655 
1656 	protocol = strsep(&line, " ");
1657 	if (line == NULL)
1658 		return (-1);
1659 	number = strsep(&line, " ");
1660 	if (line != NULL)
1661 		readable = line;
1662 
1663 	if (evhttp_parse_http_version(protocol, req) < 0)
1664 		return (-1);
1665 
1666 	req->response_code = atoi(number);
1667 	if (!evhttp_valid_response_code(req->response_code)) {
1668 		event_debug(("%s: bad response code \"%s\"",
1669 			__func__, number));
1670 		return (-1);
1671 	}
1672 
1673 	if (req->response_code_line != NULL)
1674 		mm_free(req->response_code_line);
1675 	if ((req->response_code_line = mm_strdup(readable)) == NULL) {
1676 		event_warn("%s: strdup", __func__);
1677 		return (-1);
1678 	}
1679 
1680 	return (0);
1681 }
1682 
1683 /* Parse the first line of a HTTP request */
1684 
1685 static int
1686 evhttp_parse_request_line(struct evhttp_request *req, char *line)
1687 {
1688 	char *method;
1689 	char *uri;
1690 	char *version;
1691 	const char *hostname;
1692 	const char *scheme;
1693 	size_t method_len;
1694 	enum evhttp_cmd_type type;
1695 
1696 	/* Parse the request line */
1697 	method = strsep(&line, " ");
1698 	if (line == NULL)
1699 		return (-1);
1700 	uri = strsep(&line, " ");
1701 	if (line == NULL)
1702 		return (-1);
1703 	version = strsep(&line, " ");
1704 	if (line != NULL)
1705 		return (-1);
1706 
1707 	method_len = (uri - method) - 1;
1708 	type       = EVHTTP_REQ_UNKNOWN_;
1709 
1710 	/* First line */
1711 	switch (method_len) {
1712 	    case 3:
1713 		/* The length of the method string is 3, meaning it can only be one of two methods: GET or PUT */
1714 
1715 		/* Since both GET and PUT share the same character 'T' at the end,
1716 		 * if the string doesn't have 'T', we can immediately determine this
1717 		 * is an invalid HTTP method */
1718 
1719 		if (method[2] != 'T') {
1720 		    break;
1721 		}
1722 
1723 		switch (*method) {
1724 		    case 'G':
1725 			/* This first byte is 'G', so make sure the next byte is
1726 			 * 'E', if it isn't then this isn't a valid method */
1727 
1728 			if (method[1] == 'E') {
1729 			    type = EVHTTP_REQ_GET;
1730 			}
1731 
1732 			break;
1733 		    case 'P':
1734 			/* First byte is P, check second byte for 'U', if not,
1735 			 * we know it's an invalid method */
1736 			if (method[1] == 'U') {
1737 			    type = EVHTTP_REQ_PUT;
1738 			}
1739 			break;
1740 		    default:
1741 			break;
1742 		}
1743 		break;
1744 	    case 4:
1745 		/* The method length is 4 bytes, leaving only the methods "POST" and "HEAD" */
1746 		switch (*method) {
1747 		    case 'P':
1748 			if (method[3] == 'T' && method[2] == 'S' && method[1] == 'O') {
1749 			    type = EVHTTP_REQ_POST;
1750 			}
1751 			break;
1752 		    case 'H':
1753 			if (method[3] == 'D' && method[2] == 'A' && method[1] == 'E') {
1754 			    type = EVHTTP_REQ_HEAD;
1755 			}
1756 			break;
1757 		    default:
1758 			break;
1759 		}
1760 		break;
1761 	    case 5:
1762 		/* Method length is 5 bytes, which can only encompass PATCH and TRACE */
1763 		switch (*method) {
1764 		    case 'P':
1765 			if (method[4] == 'H' && method[3] == 'C' && method[2] == 'T' && method[1] == 'A') {
1766 			    type = EVHTTP_REQ_PATCH;
1767 			}
1768 			break;
1769 		    case 'T':
1770 			if (method[4] == 'E' && method[3] == 'C' && method[2] == 'A' && method[1] == 'R') {
1771 			    type = EVHTTP_REQ_TRACE;
1772 			}
1773 
1774 			break;
1775 		    default:
1776 			break;
1777 		}
1778 		break;
1779 	    case 6:
1780 		/* Method length is 6, only valid method 6 bytes in length is DELEte */
1781 
1782 		/* If the first byte isn't 'D' then it's invalid */
1783 		if (*method != 'D') {
1784 		    break;
1785 		}
1786 
1787 		if (method[5] == 'E' && method[4] == 'T' && method[3] == 'E' && method[2] == 'L' && method[1] == 'E') {
1788 		    type = EVHTTP_REQ_DELETE;
1789 		}
1790 
1791 		break;
1792 	    case 7:
1793 		/* Method length is 7, only valid methods are "OPTIONS" and "CONNECT" */
1794 		switch (*method) {
1795 		    case 'O':
1796 			if (method[6] == 'S' && method[5] == 'N' && method[4] == 'O' &&
1797 				method[3] == 'I' && method[2] == 'T' && method[1] == 'P') {
1798 			    type = EVHTTP_REQ_OPTIONS;
1799 			}
1800 
1801 		       	break;
1802 		    case 'C':
1803 			if (method[6] == 'T' && method[5] == 'C' && method[4] == 'E' &&
1804 				method[3] == 'N' && method[2] == 'N' && method[1] == 'O') {
1805 			    type = EVHTTP_REQ_CONNECT;
1806 			}
1807 
1808 			break;
1809 		    default:
1810 			break;
1811 		}
1812 		break;
1813 	} /* switch */
1814 
1815 	if ((int)type == EVHTTP_REQ_UNKNOWN_) {
1816 	        event_debug(("%s: bad method %s on request %p from %s",
1817 			__func__, method, req, req->remote_host));
1818                 /* No error yet; we'll give a better error later when
1819                  * we see that req->type is unsupported. */
1820 	}
1821 
1822 	req->type = type;
1823 
1824 	if (evhttp_parse_http_version(version, req) < 0)
1825 		return (-1);
1826 
1827 	if ((req->uri = mm_strdup(uri)) == NULL) {
1828 		event_debug(("%s: mm_strdup", __func__));
1829 		return (-1);
1830 	}
1831 
1832 	if ((req->uri_elems = evhttp_uri_parse_with_flags(req->uri,
1833 		    EVHTTP_URI_NONCONFORMANT)) == NULL) {
1834 		return -1;
1835 	}
1836 
1837 	/* If we have an absolute-URI, check to see if it is an http request
1838 	   for a known vhost or server alias. If we don't know about this
1839 	   host, we consider it a proxy request. */
1840 	scheme = evhttp_uri_get_scheme(req->uri_elems);
1841 	hostname = evhttp_uri_get_host(req->uri_elems);
1842 	if (scheme && (!evutil_ascii_strcasecmp(scheme, "http") ||
1843 		       !evutil_ascii_strcasecmp(scheme, "https")) &&
1844 	    hostname &&
1845 	    !evhttp_find_vhost(req->evcon->http_server, NULL, hostname))
1846 		req->flags |= EVHTTP_PROXY_REQUEST;
1847 
1848 	return (0);
1849 }
1850 
1851 const char *
1852 evhttp_find_header(const struct evkeyvalq *headers, const char *key)
1853 {
1854 	struct evkeyval *header;
1855 
1856 	TAILQ_FOREACH(header, headers, next) {
1857 		if (evutil_ascii_strcasecmp(header->key, key) == 0)
1858 			return (header->value);
1859 	}
1860 
1861 	return (NULL);
1862 }
1863 
1864 void
1865 evhttp_clear_headers(struct evkeyvalq *headers)
1866 {
1867 	struct evkeyval *header;
1868 
1869 	for (header = TAILQ_FIRST(headers);
1870 	    header != NULL;
1871 	    header = TAILQ_FIRST(headers)) {
1872 		TAILQ_REMOVE(headers, header, next);
1873 		mm_free(header->key);
1874 		mm_free(header->value);
1875 		mm_free(header);
1876 	}
1877 }
1878 
1879 /*
1880  * Returns 0,  if the header was successfully removed.
1881  * Returns -1, if the header could not be found.
1882  */
1883 
1884 int
1885 evhttp_remove_header(struct evkeyvalq *headers, const char *key)
1886 {
1887 	struct evkeyval *header;
1888 
1889 	TAILQ_FOREACH(header, headers, next) {
1890 		if (evutil_ascii_strcasecmp(header->key, key) == 0)
1891 			break;
1892 	}
1893 
1894 	if (header == NULL)
1895 		return (-1);
1896 
1897 	/* Free and remove the header that we found */
1898 	TAILQ_REMOVE(headers, header, next);
1899 	mm_free(header->key);
1900 	mm_free(header->value);
1901 	mm_free(header);
1902 
1903 	return (0);
1904 }
1905 
1906 static int
1907 evhttp_header_is_valid_value(const char *value)
1908 {
1909 	const char *p = value;
1910 
1911 	while ((p = strpbrk(p, "\r\n")) != NULL) {
1912 		/* we really expect only one new line */
1913 		p += strspn(p, "\r\n");
1914 		/* we expect a space or tab for continuation */
1915 		if (*p != ' ' && *p != '\t')
1916 			return (0);
1917 	}
1918 	return (1);
1919 }
1920 
1921 int
1922 evhttp_add_header(struct evkeyvalq *headers,
1923     const char *key, const char *value)
1924 {
1925 	event_debug(("%s: key: %s val: %s\n", __func__, key, value));
1926 
1927 	if (strchr(key, '\r') != NULL || strchr(key, '\n') != NULL) {
1928 		/* drop illegal headers */
1929 		event_debug(("%s: dropping illegal header key\n", __func__));
1930 		return (-1);
1931 	}
1932 
1933 	if (!evhttp_header_is_valid_value(value)) {
1934 		event_debug(("%s: dropping illegal header value\n", __func__));
1935 		return (-1);
1936 	}
1937 
1938 	return (evhttp_add_header_internal(headers, key, value));
1939 }
1940 
1941 static int
1942 evhttp_add_header_internal(struct evkeyvalq *headers,
1943     const char *key, const char *value)
1944 {
1945 	struct evkeyval *header = mm_calloc(1, sizeof(struct evkeyval));
1946 	if (header == NULL) {
1947 		event_warn("%s: calloc", __func__);
1948 		return (-1);
1949 	}
1950 	if ((header->key = mm_strdup(key)) == NULL) {
1951 		mm_free(header);
1952 		event_warn("%s: strdup", __func__);
1953 		return (-1);
1954 	}
1955 	if ((header->value = mm_strdup(value)) == NULL) {
1956 		mm_free(header->key);
1957 		mm_free(header);
1958 		event_warn("%s: strdup", __func__);
1959 		return (-1);
1960 	}
1961 
1962 	TAILQ_INSERT_TAIL(headers, header, next);
1963 
1964 	return (0);
1965 }
1966 
1967 /*
1968  * Parses header lines from a request or a response into the specified
1969  * request object given an event buffer.
1970  *
1971  * Returns
1972  *   DATA_CORRUPTED      on error
1973  *   MORE_DATA_EXPECTED  when we need to read more headers
1974  *   ALL_DATA_READ       when all headers have been read.
1975  */
1976 
1977 enum message_read_status
1978 evhttp_parse_firstline_(struct evhttp_request *req, struct evbuffer *buffer)
1979 {
1980 	char *line;
1981 	enum message_read_status status = ALL_DATA_READ;
1982 
1983 	size_t line_length;
1984 	/* XXX try */
1985 	line = evbuffer_readln(buffer, &line_length, EVBUFFER_EOL_CRLF);
1986 	if (line == NULL) {
1987 		if (req->evcon != NULL &&
1988 		    evbuffer_get_length(buffer) > req->evcon->max_headers_size)
1989 			return (DATA_TOO_LONG);
1990 		else
1991 			return (MORE_DATA_EXPECTED);
1992 	}
1993 
1994 	if (req->evcon != NULL &&
1995 	    line_length > req->evcon->max_headers_size) {
1996 		mm_free(line);
1997 		return (DATA_TOO_LONG);
1998 	}
1999 
2000 	req->headers_size = line_length;
2001 
2002 	switch (req->kind) {
2003 	case EVHTTP_REQUEST:
2004 		if (evhttp_parse_request_line(req, line) == -1)
2005 			status = DATA_CORRUPTED;
2006 		break;
2007 	case EVHTTP_RESPONSE:
2008 		if (evhttp_parse_response_line(req, line) == -1)
2009 			status = DATA_CORRUPTED;
2010 		break;
2011 	default:
2012 		status = DATA_CORRUPTED;
2013 	}
2014 
2015 	mm_free(line);
2016 	return (status);
2017 }
2018 
2019 static int
2020 evhttp_append_to_last_header(struct evkeyvalq *headers, char *line)
2021 {
2022 	struct evkeyval *header = TAILQ_LAST(headers, evkeyvalq);
2023 	char *newval;
2024 	size_t old_len, line_len;
2025 
2026 	if (header == NULL)
2027 		return (-1);
2028 
2029 	old_len = strlen(header->value);
2030 
2031 	/* Strip space from start and end of line. */
2032 	while (*line == ' ' || *line == '\t')
2033 		++line;
2034 	evutil_rtrim_lws_(line);
2035 
2036 	line_len = strlen(line);
2037 
2038 	newval = mm_realloc(header->value, old_len + line_len + 2);
2039 	if (newval == NULL)
2040 		return (-1);
2041 
2042 	newval[old_len] = ' ';
2043 	memcpy(newval + old_len + 1, line, line_len + 1);
2044 	header->value = newval;
2045 
2046 	return (0);
2047 }
2048 
2049 enum message_read_status
2050 evhttp_parse_headers_(struct evhttp_request *req, struct evbuffer* buffer)
2051 {
2052 	enum message_read_status errcode = DATA_CORRUPTED;
2053 	char *line;
2054 	enum message_read_status status = MORE_DATA_EXPECTED;
2055 
2056 	struct evkeyvalq* headers = req->input_headers;
2057 	size_t line_length;
2058 	while ((line = evbuffer_readln(buffer, &line_length, EVBUFFER_EOL_CRLF))
2059 	       != NULL) {
2060 		char *skey, *svalue;
2061 
2062 		req->headers_size += line_length;
2063 
2064 		if (req->evcon != NULL &&
2065 		    req->headers_size > req->evcon->max_headers_size) {
2066 			errcode = DATA_TOO_LONG;
2067 			goto error;
2068 		}
2069 
2070 		if (*line == '\0') { /* Last header - Done */
2071 			status = ALL_DATA_READ;
2072 			mm_free(line);
2073 			break;
2074 		}
2075 
2076 		/* Check if this is a continuation line */
2077 		if (*line == ' ' || *line == '\t') {
2078 			if (evhttp_append_to_last_header(headers, line) == -1)
2079 				goto error;
2080 			mm_free(line);
2081 			continue;
2082 		}
2083 
2084 		/* Processing of header lines */
2085 		svalue = line;
2086 		skey = strsep(&svalue, ":");
2087 		if (svalue == NULL)
2088 			goto error;
2089 
2090 		svalue += strspn(svalue, " ");
2091 		evutil_rtrim_lws_(svalue);
2092 
2093 		if (evhttp_add_header(headers, skey, svalue) == -1)
2094 			goto error;
2095 
2096 		mm_free(line);
2097 	}
2098 
2099 	if (status == MORE_DATA_EXPECTED) {
2100 		if (req->evcon != NULL &&
2101 		req->headers_size + evbuffer_get_length(buffer) > req->evcon->max_headers_size)
2102 			return (DATA_TOO_LONG);
2103 	}
2104 
2105 	return (status);
2106 
2107  error:
2108 	mm_free(line);
2109 	return (errcode);
2110 }
2111 
2112 static int
2113 evhttp_get_body_length(struct evhttp_request *req)
2114 {
2115 	struct evkeyvalq *headers = req->input_headers;
2116 	const char *content_length;
2117 	const char *connection;
2118 
2119 	content_length = evhttp_find_header(headers, "Content-Length");
2120 	connection = evhttp_find_header(headers, "Connection");
2121 
2122 	if (content_length == NULL && connection == NULL)
2123 		req->ntoread = -1;
2124 	else if (content_length == NULL &&
2125 	    evutil_ascii_strcasecmp(connection, "Close") != 0) {
2126 		/* Bad combination, we don't know when it will end */
2127 		event_warnx("%s: we got no content length, but the "
2128 		    "server wants to keep the connection open: %s.",
2129 		    __func__, connection);
2130 		return (-1);
2131 	} else if (content_length == NULL) {
2132 		req->ntoread = -1;
2133 	} else {
2134 		char *endp;
2135 		ev_int64_t ntoread = evutil_strtoll(content_length, &endp, 10);
2136 		if (*content_length == '\0' || *endp != '\0' || ntoread < 0) {
2137 			event_debug(("%s: illegal content length: %s",
2138 				__func__, content_length));
2139 			return (-1);
2140 		}
2141 		req->ntoread = ntoread;
2142 	}
2143 
2144 	event_debug(("%s: bytes to read: "EV_I64_FMT" (in buffer "EV_SIZE_FMT")\n",
2145 		__func__, EV_I64_ARG(req->ntoread),
2146 		EV_SIZE_ARG(evbuffer_get_length(bufferevent_get_input(req->evcon->bufev)))));
2147 
2148 	return (0);
2149 }
2150 
2151 static int
2152 evhttp_method_may_have_body(enum evhttp_cmd_type type)
2153 {
2154 	switch (type) {
2155 	case EVHTTP_REQ_POST:
2156 	case EVHTTP_REQ_PUT:
2157 	case EVHTTP_REQ_PATCH:
2158 		return 1;
2159 	case EVHTTP_REQ_TRACE:
2160 		return 0;
2161 	/* XXX May any of the below methods have a body? */
2162 	case EVHTTP_REQ_GET:
2163 	case EVHTTP_REQ_HEAD:
2164 	case EVHTTP_REQ_DELETE:
2165 	case EVHTTP_REQ_OPTIONS:
2166 	case EVHTTP_REQ_CONNECT:
2167 		return 0;
2168 	default:
2169 		return 0;
2170 	}
2171 }
2172 
2173 static void
2174 evhttp_get_body(struct evhttp_connection *evcon, struct evhttp_request *req)
2175 {
2176 	const char *xfer_enc;
2177 
2178 	/* If this is a request without a body, then we are done */
2179 	if (req->kind == EVHTTP_REQUEST &&
2180 	    !evhttp_method_may_have_body(req->type)) {
2181 		evhttp_connection_done(evcon);
2182 		return;
2183 	}
2184 	evcon->state = EVCON_READING_BODY;
2185 	xfer_enc = evhttp_find_header(req->input_headers, "Transfer-Encoding");
2186 	if (xfer_enc != NULL && evutil_ascii_strcasecmp(xfer_enc, "chunked") == 0) {
2187 		req->chunked = 1;
2188 		req->ntoread = -1;
2189 	} else {
2190 		if (evhttp_get_body_length(req) == -1) {
2191 			evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
2192 			return;
2193 		}
2194 		if (req->kind == EVHTTP_REQUEST && req->ntoread < 1) {
2195 			/* An incoming request with no content-length and no
2196 			 * transfer-encoding has no body. */
2197 			evhttp_connection_done(evcon);
2198 			return;
2199 		}
2200 	}
2201 
2202 	/* Should we send a 100 Continue status line? */
2203 	switch (evhttp_have_expect(req, 1)) {
2204 		case CONTINUE:
2205 				/* XXX It would be nice to do some sanity
2206 				   checking here. Does the resource exist?
2207 				   Should the resource accept post requests? If
2208 				   no, we should respond with an error. For
2209 				   now, just optimistically tell the client to
2210 				   send their message body. */
2211 				if (req->ntoread > 0) {
2212 					/* ntoread is ev_int64_t, max_body_size is ev_uint64_t */
2213 					if ((req->evcon->max_body_size <= EV_INT64_MAX) &&
2214 						(ev_uint64_t)req->ntoread > req->evcon->max_body_size) {
2215 						evhttp_lingering_fail(evcon, req);
2216 						return;
2217 					}
2218 				}
2219 				if (!evbuffer_get_length(bufferevent_get_input(evcon->bufev)))
2220 					evhttp_send_continue(evcon, req);
2221 			break;
2222 		case OTHER:
2223 			evhttp_send_error(req, HTTP_EXPECTATIONFAILED, NULL);
2224 			return;
2225 		case NO: break;
2226 	}
2227 
2228 	evhttp_read_body(evcon, req);
2229 	/* note the request may have been freed in evhttp_read_body */
2230 }
2231 
2232 static void
2233 evhttp_read_firstline(struct evhttp_connection *evcon,
2234 		      struct evhttp_request *req)
2235 {
2236 	enum message_read_status res;
2237 
2238 	res = evhttp_parse_firstline_(req, bufferevent_get_input(evcon->bufev));
2239 	if (res == DATA_CORRUPTED || res == DATA_TOO_LONG) {
2240 		/* Error while reading, terminate */
2241 		event_debug(("%s: bad header lines on "EV_SOCK_FMT"\n",
2242 			__func__, EV_SOCK_ARG(evcon->fd)));
2243 		evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
2244 		return;
2245 	} else if (res == MORE_DATA_EXPECTED) {
2246 		/* Need more header lines */
2247 		return;
2248 	}
2249 
2250 	evcon->state = EVCON_READING_HEADERS;
2251 	evhttp_read_header(evcon, req);
2252 }
2253 
2254 static void
2255 evhttp_read_header(struct evhttp_connection *evcon,
2256 		   struct evhttp_request *req)
2257 {
2258 	enum message_read_status res;
2259 	evutil_socket_t fd = evcon->fd;
2260 
2261 	res = evhttp_parse_headers_(req, bufferevent_get_input(evcon->bufev));
2262 	if (res == DATA_CORRUPTED || res == DATA_TOO_LONG) {
2263 		/* Error while reading, terminate */
2264 		event_debug(("%s: bad header lines on "EV_SOCK_FMT"\n",
2265 			__func__, EV_SOCK_ARG(fd)));
2266 		evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
2267 		return;
2268 	} else if (res == MORE_DATA_EXPECTED) {
2269 		/* Need more header lines */
2270 		return;
2271 	}
2272 
2273 	/* Callback can shut down connection with negative return value */
2274 	if (req->header_cb != NULL) {
2275 		if ((*req->header_cb)(req, req->cb_arg) < 0) {
2276 			evhttp_connection_fail_(evcon, EVREQ_HTTP_EOF);
2277 			return;
2278 		}
2279 	}
2280 
2281 	/* Done reading headers, do the real work */
2282 	switch (req->kind) {
2283 	case EVHTTP_REQUEST:
2284 		event_debug(("%s: checking for post data on "EV_SOCK_FMT"\n",
2285 			__func__, EV_SOCK_ARG(fd)));
2286 		evhttp_get_body(evcon, req);
2287 		/* note the request may have been freed in evhttp_get_body */
2288 		break;
2289 
2290 	case EVHTTP_RESPONSE:
2291 		/* Start over if we got a 100 Continue response. */
2292 		if (req->response_code == 100) {
2293 			struct evbuffer *output = bufferevent_get_output(evcon->bufev);
2294 			evbuffer_add_buffer(output, req->output_buffer);
2295 			evhttp_start_write_(evcon);
2296 			return;
2297 		}
2298 		if (!evhttp_response_needs_body(req)) {
2299 			event_debug(("%s: skipping body for code %d\n",
2300 					__func__, req->response_code));
2301 			evhttp_connection_done(evcon);
2302 		} else {
2303 			event_debug(("%s: start of read body for %s on "
2304 				EV_SOCK_FMT"\n",
2305 				__func__, req->remote_host, EV_SOCK_ARG(fd)));
2306 			evhttp_get_body(evcon, req);
2307 			/* note the request may have been freed in
2308 			 * evhttp_get_body */
2309 		}
2310 		break;
2311 
2312 	default:
2313 		event_warnx("%s: bad header on "EV_SOCK_FMT, __func__,
2314 		    EV_SOCK_ARG(fd));
2315 		evhttp_connection_fail_(evcon, EVREQ_HTTP_INVALID_HEADER);
2316 		break;
2317 	}
2318 	/* request may have been freed above */
2319 }
2320 
2321 /*
2322  * Creates a TCP connection to the specified port and executes a callback
2323  * when finished.  Failure or success is indicate by the passed connection
2324  * object.
2325  *
2326  * Although this interface accepts a hostname, it is intended to take
2327  * only numeric hostnames so that non-blocking DNS resolution can
2328  * happen elsewhere.
2329  */
2330 
2331 struct evhttp_connection *
2332 evhttp_connection_new(const char *address, ev_uint16_t port)
2333 {
2334 	return (evhttp_connection_base_new(NULL, NULL, address, port));
2335 }
2336 
2337 struct evhttp_connection *
2338 evhttp_connection_base_bufferevent_new(struct event_base *base, struct evdns_base *dnsbase, struct bufferevent* bev,
2339     const char *address, ev_uint16_t port)
2340 {
2341 	struct evhttp_connection *evcon = NULL;
2342 
2343 	event_debug(("Attempting connection to %s:%d\n", address, port));
2344 
2345 	if ((evcon = mm_calloc(1, sizeof(struct evhttp_connection))) == NULL) {
2346 		event_warn("%s: calloc failed", __func__);
2347 		goto error;
2348 	}
2349 
2350 	evcon->fd = -1;
2351 	evcon->port = port;
2352 
2353 	evcon->max_headers_size = EV_SIZE_MAX;
2354 	evcon->max_body_size = EV_SIZE_MAX;
2355 
2356 	evutil_timerclear(&evcon->timeout);
2357 	evcon->retry_cnt = evcon->retry_max = 0;
2358 
2359 	if ((evcon->address = mm_strdup(address)) == NULL) {
2360 		event_warn("%s: strdup failed", __func__);
2361 		goto error;
2362 	}
2363 
2364 	if (bev == NULL) {
2365 		if (!(bev = bufferevent_socket_new(base, -1, 0))) {
2366 			event_warn("%s: bufferevent_socket_new failed", __func__);
2367 			goto error;
2368 		}
2369 	}
2370 
2371 	bufferevent_setcb(bev, evhttp_read_cb, evhttp_write_cb, evhttp_error_cb, evcon);
2372 	evcon->bufev = bev;
2373 
2374 	evcon->state = EVCON_DISCONNECTED;
2375 	TAILQ_INIT(&evcon->requests);
2376 
2377 	evcon->initial_retry_timeout.tv_sec = 2;
2378 	evcon->initial_retry_timeout.tv_usec = 0;
2379 
2380 	if (base != NULL) {
2381 		evcon->base = base;
2382 		if (bufferevent_get_base(bev) != base)
2383 			bufferevent_base_set(base, evcon->bufev);
2384 	}
2385 
2386 	event_deferred_cb_init_(
2387 	    &evcon->read_more_deferred_cb,
2388 	    bufferevent_get_priority(bev),
2389 	    evhttp_deferred_read_cb, evcon);
2390 
2391 	evcon->dns_base = dnsbase;
2392 	evcon->ai_family = AF_UNSPEC;
2393 
2394 	return (evcon);
2395 
2396  error:
2397 	if (evcon != NULL)
2398 		evhttp_connection_free(evcon);
2399 	return (NULL);
2400 }
2401 
2402 struct bufferevent* evhttp_connection_get_bufferevent(struct evhttp_connection *evcon)
2403 {
2404 	return evcon->bufev;
2405 }
2406 
2407 struct evhttp *
2408 evhttp_connection_get_server(struct evhttp_connection *evcon)
2409 {
2410 	return evcon->http_server;
2411 }
2412 
2413 struct evhttp_connection *
2414 evhttp_connection_base_new(struct event_base *base, struct evdns_base *dnsbase,
2415     const char *address, ev_uint16_t port)
2416 {
2417 	return evhttp_connection_base_bufferevent_new(base, dnsbase, NULL, address, port);
2418 }
2419 
2420 void evhttp_connection_set_family(struct evhttp_connection *evcon,
2421 	int family)
2422 {
2423 	evcon->ai_family = family;
2424 }
2425 
2426 int evhttp_connection_set_flags(struct evhttp_connection *evcon,
2427 	int flags)
2428 {
2429 	int avail_flags = 0;
2430 	avail_flags |= EVHTTP_CON_REUSE_CONNECTED_ADDR;
2431 	avail_flags |= EVHTTP_CON_READ_ON_WRITE_ERROR;
2432 
2433 	if (flags & ~avail_flags || flags > EVHTTP_CON_PUBLIC_FLAGS_END)
2434 		return 1;
2435 	evcon->flags &= ~avail_flags;
2436 
2437 	evcon->flags |= flags;
2438 
2439 	return 0;
2440 }
2441 
2442 void
2443 evhttp_connection_set_base(struct evhttp_connection *evcon,
2444     struct event_base *base)
2445 {
2446 	EVUTIL_ASSERT(evcon->base == NULL);
2447 	EVUTIL_ASSERT(evcon->state == EVCON_DISCONNECTED);
2448 	evcon->base = base;
2449 	bufferevent_base_set(base, evcon->bufev);
2450 }
2451 
2452 void
2453 evhttp_connection_set_timeout(struct evhttp_connection *evcon,
2454     int timeout_in_secs)
2455 {
2456 	if (timeout_in_secs == -1)
2457 		evhttp_connection_set_timeout_tv(evcon, NULL);
2458 	else {
2459 		struct timeval tv;
2460 		tv.tv_sec = timeout_in_secs;
2461 		tv.tv_usec = 0;
2462 		evhttp_connection_set_timeout_tv(evcon, &tv);
2463 	}
2464 }
2465 
2466 void
2467 evhttp_connection_set_timeout_tv(struct evhttp_connection *evcon,
2468     const struct timeval* tv)
2469 {
2470 	if (tv) {
2471 		evcon->timeout = *tv;
2472 		bufferevent_set_timeouts(evcon->bufev, &evcon->timeout, &evcon->timeout);
2473 	} else {
2474 		const struct timeval read_tv = { HTTP_READ_TIMEOUT, 0 };
2475 		const struct timeval write_tv = { HTTP_WRITE_TIMEOUT, 0 };
2476 		evutil_timerclear(&evcon->timeout);
2477 		bufferevent_set_timeouts(evcon->bufev, &read_tv, &write_tv);
2478 	}
2479 }
2480 
2481 void
2482 evhttp_connection_set_initial_retry_tv(struct evhttp_connection *evcon,
2483     const struct timeval *tv)
2484 {
2485 	if (tv) {
2486 		evcon->initial_retry_timeout = *tv;
2487 	} else {
2488 		evutil_timerclear(&evcon->initial_retry_timeout);
2489 		evcon->initial_retry_timeout.tv_sec = 2;
2490 	}
2491 }
2492 
2493 void
2494 evhttp_connection_set_retries(struct evhttp_connection *evcon,
2495     int retry_max)
2496 {
2497 	evcon->retry_max = retry_max;
2498 }
2499 
2500 void
2501 evhttp_connection_set_closecb(struct evhttp_connection *evcon,
2502     void (*cb)(struct evhttp_connection *, void *), void *cbarg)
2503 {
2504 	evcon->closecb = cb;
2505 	evcon->closecb_arg = cbarg;
2506 }
2507 
2508 void
2509 evhttp_connection_get_peer(struct evhttp_connection *evcon,
2510     char **address, ev_uint16_t *port)
2511 {
2512 	*address = evcon->address;
2513 	*port = evcon->port;
2514 }
2515 
2516 const struct sockaddr*
2517 evhttp_connection_get_addr(struct evhttp_connection *evcon)
2518 {
2519 	return bufferevent_socket_get_conn_address_(evcon->bufev);
2520 }
2521 
2522 int
2523 evhttp_connection_connect_(struct evhttp_connection *evcon)
2524 {
2525 	int old_state = evcon->state;
2526 	const char *address = evcon->address;
2527 	const struct sockaddr *sa = evhttp_connection_get_addr(evcon);
2528 	int ret;
2529 
2530 	if (evcon->state == EVCON_CONNECTING)
2531 		return (0);
2532 
2533 	evhttp_connection_reset_(evcon);
2534 
2535 	EVUTIL_ASSERT(!(evcon->flags & EVHTTP_CON_INCOMING));
2536 	evcon->flags |= EVHTTP_CON_OUTGOING;
2537 
2538 	if (evcon->bind_address || evcon->bind_port) {
2539 		evcon->fd = bind_socket(
2540 			evcon->bind_address, evcon->bind_port, 0 /*reuse*/);
2541 		if (evcon->fd == -1) {
2542 			event_debug(("%s: failed to bind to \"%s\"",
2543 				__func__, evcon->bind_address));
2544 			return (-1);
2545 		}
2546 
2547 		bufferevent_setfd(evcon->bufev, evcon->fd);
2548 	} else {
2549 		bufferevent_setfd(evcon->bufev, -1);
2550 	}
2551 
2552 	/* Set up a callback for successful connection setup */
2553 	bufferevent_setcb(evcon->bufev,
2554 	    NULL /* evhttp_read_cb */,
2555 	    NULL /* evhttp_write_cb */,
2556 	    evhttp_connection_cb,
2557 	    evcon);
2558 	if (!evutil_timerisset(&evcon->timeout)) {
2559 		const struct timeval conn_tv = { HTTP_CONNECT_TIMEOUT, 0 };
2560 		bufferevent_set_timeouts(evcon->bufev, &conn_tv, &conn_tv);
2561 	} else {
2562 		bufferevent_set_timeouts(evcon->bufev, &evcon->timeout, &evcon->timeout);
2563 	}
2564 	/* make sure that we get a write callback */
2565 	bufferevent_enable(evcon->bufev, EV_WRITE);
2566 
2567 	evcon->state = EVCON_CONNECTING;
2568 
2569 	if (evcon->flags & EVHTTP_CON_REUSE_CONNECTED_ADDR &&
2570 		sa &&
2571 		(sa->sa_family == AF_INET || sa->sa_family == AF_INET6)) {
2572 		int socklen = sizeof(struct sockaddr_in);
2573 		if (sa->sa_family == AF_INET6) {
2574 			socklen = sizeof(struct sockaddr_in6);
2575 		}
2576 		ret = bufferevent_socket_connect(evcon->bufev, sa, socklen);
2577 	} else {
2578 		ret = bufferevent_socket_connect_hostname(evcon->bufev,
2579 				evcon->dns_base, evcon->ai_family, address, evcon->port);
2580 	}
2581 
2582 	if (ret < 0) {
2583 		evcon->state = old_state;
2584 		event_sock_warn(evcon->fd, "%s: connection to \"%s\" failed",
2585 		    __func__, evcon->address);
2586 		/* some operating systems return ECONNREFUSED immediately
2587 		 * when connecting to a local address.  the cleanup is going
2588 		 * to reschedule this function call.
2589 		 */
2590 		evhttp_connection_cb_cleanup(evcon);
2591 		return (0);
2592 	}
2593 
2594 	return (0);
2595 }
2596 
2597 /*
2598  * Starts an HTTP request on the provided evhttp_connection object.
2599  * If the connection object is not connected to the web server already,
2600  * this will start the connection.
2601  */
2602 
2603 int
2604 evhttp_make_request(struct evhttp_connection *evcon,
2605     struct evhttp_request *req,
2606     enum evhttp_cmd_type type, const char *uri)
2607 {
2608 	/* We are making a request */
2609 	req->kind = EVHTTP_REQUEST;
2610 	req->type = type;
2611 	if (req->uri != NULL)
2612 		mm_free(req->uri);
2613 	if ((req->uri = mm_strdup(uri)) == NULL) {
2614 		event_warn("%s: strdup", __func__);
2615 		evhttp_request_free_auto(req);
2616 		return (-1);
2617 	}
2618 
2619 	/* Set the protocol version if it is not supplied */
2620 	if (!req->major && !req->minor) {
2621 		req->major = 1;
2622 		req->minor = 1;
2623 	}
2624 
2625 	EVUTIL_ASSERT(req->evcon == NULL);
2626 	req->evcon = evcon;
2627 	EVUTIL_ASSERT(!(req->flags & EVHTTP_REQ_OWN_CONNECTION));
2628 
2629 	TAILQ_INSERT_TAIL(&evcon->requests, req, next);
2630 
2631 	/* If the connection object is not connected; make it so */
2632 	if (!evhttp_connected(evcon)) {
2633 		int res = evhttp_connection_connect_(evcon);
2634 		/* evhttp_connection_fail_(), which is called through
2635 		 * evhttp_connection_connect_(), assumes that req lies in
2636 		 * evcon->requests.  Thus, enqueue the request in advance and
2637 		 * remove it in the error case. */
2638 		if (res != 0)
2639 			TAILQ_REMOVE(&evcon->requests, req, next);
2640 
2641 		return res;
2642 	}
2643 
2644 	/*
2645 	 * If it's connected already and we are the first in the queue,
2646 	 * then we can dispatch this request immediately.  Otherwise, it
2647 	 * will be dispatched once the pending requests are completed.
2648 	 */
2649 	if (TAILQ_FIRST(&evcon->requests) == req)
2650 		evhttp_request_dispatch(evcon);
2651 
2652 	return (0);
2653 }
2654 
2655 void
2656 evhttp_cancel_request(struct evhttp_request *req)
2657 {
2658 	struct evhttp_connection *evcon = req->evcon;
2659 	if (evcon != NULL) {
2660 		/* We need to remove it from the connection */
2661 		if (TAILQ_FIRST(&evcon->requests) == req) {
2662 			/* it's currently being worked on, so reset
2663 			 * the connection.
2664 			 */
2665 			evhttp_connection_fail_(evcon,
2666 			    EVREQ_HTTP_REQUEST_CANCEL);
2667 
2668 			/* connection fail freed the request */
2669 			return;
2670 		} else {
2671 			/* otherwise, we can just remove it from the
2672 			 * queue
2673 			 */
2674 			TAILQ_REMOVE(&evcon->requests, req, next);
2675 		}
2676 	}
2677 
2678 	evhttp_request_free_auto(req);
2679 }
2680 
2681 /*
2682  * Reads data from file descriptor into request structure
2683  * Request structure needs to be set up correctly.
2684  */
2685 
2686 void
2687 evhttp_start_read_(struct evhttp_connection *evcon)
2688 {
2689 	bufferevent_disable(evcon->bufev, EV_WRITE);
2690 	bufferevent_enable(evcon->bufev, EV_READ);
2691 
2692 	evcon->state = EVCON_READING_FIRSTLINE;
2693 	/* Reset the bufferevent callbacks */
2694 	bufferevent_setcb(evcon->bufev,
2695 	    evhttp_read_cb,
2696 	    evhttp_write_cb,
2697 	    evhttp_error_cb,
2698 	    evcon);
2699 
2700 	/* If there's still data pending, process it next time through the
2701 	 * loop.  Don't do it now; that could get recusive. */
2702 	if (evbuffer_get_length(bufferevent_get_input(evcon->bufev))) {
2703 		event_deferred_cb_schedule_(get_deferred_queue(evcon),
2704 		    &evcon->read_more_deferred_cb);
2705 	}
2706 }
2707 
2708 void
2709 evhttp_start_write_(struct evhttp_connection *evcon)
2710 {
2711 	bufferevent_disable(evcon->bufev, EV_WRITE);
2712 	bufferevent_enable(evcon->bufev, EV_READ);
2713 
2714 	evcon->state = EVCON_WRITING;
2715 	evhttp_write_buffer(evcon, evhttp_write_connectioncb, NULL);
2716 }
2717 
2718 static void
2719 evhttp_send_done(struct evhttp_connection *evcon, void *arg)
2720 {
2721 	int need_close;
2722 	struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
2723 	TAILQ_REMOVE(&evcon->requests, req, next);
2724 
2725 	if (req->on_complete_cb != NULL) {
2726 		req->on_complete_cb(req, req->on_complete_cb_arg);
2727 	}
2728 
2729 	need_close =
2730 	    (REQ_VERSION_BEFORE(req, 1, 1) &&
2731 	    !evhttp_is_connection_keepalive(req->input_headers)) ||
2732 	    evhttp_is_request_connection_close(req);
2733 
2734 	EVUTIL_ASSERT(req->flags & EVHTTP_REQ_OWN_CONNECTION);
2735 	evhttp_request_free(req);
2736 
2737 	if (need_close) {
2738 		evhttp_connection_free(evcon);
2739 		return;
2740 	}
2741 
2742 	/* we have a persistent connection; try to accept another request. */
2743 	if (evhttp_associate_new_request_with_connection(evcon) == -1) {
2744 		evhttp_connection_free(evcon);
2745 	}
2746 }
2747 
2748 /*
2749  * Returns an error page.
2750  */
2751 
2752 void
2753 evhttp_send_error(struct evhttp_request *req, int error, const char *reason)
2754 {
2755 
2756 #define ERR_FORMAT "<HTML><HEAD>\n" \
2757 	    "<TITLE>%d %s</TITLE>\n" \
2758 	    "</HEAD><BODY>\n" \
2759 	    "<H1>%s</H1>\n" \
2760 	    "</BODY></HTML>\n"
2761 
2762 	struct evbuffer *buf = evbuffer_new();
2763 	if (buf == NULL) {
2764 		/* if we cannot allocate memory; we just drop the connection */
2765 		evhttp_connection_free(req->evcon);
2766 		return;
2767 	}
2768 	if (reason == NULL) {
2769 		reason = evhttp_response_phrase_internal(error);
2770 	}
2771 
2772 	evhttp_response_code_(req, error, reason);
2773 
2774 	evbuffer_add_printf(buf, ERR_FORMAT, error, reason, reason);
2775 
2776 	evhttp_send_page_(req, buf);
2777 
2778 	evbuffer_free(buf);
2779 #undef ERR_FORMAT
2780 }
2781 
2782 /* Requires that headers and response code are already set up */
2783 
2784 static inline void
2785 evhttp_send(struct evhttp_request *req, struct evbuffer *databuf)
2786 {
2787 	struct evhttp_connection *evcon = req->evcon;
2788 
2789 	if (evcon == NULL) {
2790 		evhttp_request_free(req);
2791 		return;
2792 	}
2793 
2794 	EVUTIL_ASSERT(TAILQ_FIRST(&evcon->requests) == req);
2795 
2796 	/* we expect no more calls form the user on this request */
2797 	req->userdone = 1;
2798 
2799 	/* xxx: not sure if we really should expose the data buffer this way */
2800 	if (databuf != NULL)
2801 		evbuffer_add_buffer(req->output_buffer, databuf);
2802 
2803 	/* Adds headers to the response */
2804 	evhttp_make_header(evcon, req);
2805 
2806 	evhttp_write_buffer(evcon, evhttp_send_done, NULL);
2807 }
2808 
2809 void
2810 evhttp_send_reply(struct evhttp_request *req, int code, const char *reason,
2811     struct evbuffer *databuf)
2812 {
2813 	evhttp_response_code_(req, code, reason);
2814 
2815 	evhttp_send(req, databuf);
2816 }
2817 
2818 void
2819 evhttp_send_reply_start(struct evhttp_request *req, int code,
2820     const char *reason)
2821 {
2822 	evhttp_response_code_(req, code, reason);
2823 	if (evhttp_find_header(req->output_headers, "Content-Length") == NULL &&
2824 	    REQ_VERSION_ATLEAST(req, 1, 1) &&
2825 	    evhttp_response_needs_body(req)) {
2826 		/*
2827 		 * prefer HTTP/1.1 chunked encoding to closing the connection;
2828 		 * note RFC 2616 section 4.4 forbids it with Content-Length:
2829 		 * and it's not necessary then anyway.
2830 		 */
2831 		evhttp_add_header(req->output_headers, "Transfer-Encoding",
2832 		    "chunked");
2833 		req->chunked = 1;
2834 	} else {
2835 		req->chunked = 0;
2836 	}
2837 	evhttp_make_header(req->evcon, req);
2838 	evhttp_write_buffer(req->evcon, NULL, NULL);
2839 }
2840 
2841 void
2842 evhttp_send_reply_chunk_with_cb(struct evhttp_request *req, struct evbuffer *databuf,
2843     void (*cb)(struct evhttp_connection *, void *), void *arg)
2844 {
2845 	struct evhttp_connection *evcon = req->evcon;
2846 	struct evbuffer *output;
2847 
2848 	if (evcon == NULL)
2849 		return;
2850 
2851 	output = bufferevent_get_output(evcon->bufev);
2852 
2853 	if (evbuffer_get_length(databuf) == 0)
2854 		return;
2855 	if (!evhttp_response_needs_body(req))
2856 		return;
2857 	if (req->chunked) {
2858 		evbuffer_add_printf(output, "%x\r\n",
2859 				    (unsigned)evbuffer_get_length(databuf));
2860 	}
2861 	evbuffer_add_buffer(output, databuf);
2862 	if (req->chunked) {
2863 		evbuffer_add(output, "\r\n", 2);
2864 	}
2865 	evhttp_write_buffer(evcon, cb, arg);
2866 }
2867 
2868 void
2869 evhttp_send_reply_chunk(struct evhttp_request *req, struct evbuffer *databuf)
2870 {
2871 	evhttp_send_reply_chunk_with_cb(req, databuf, NULL, NULL);
2872 }
2873 void
2874 evhttp_send_reply_end(struct evhttp_request *req)
2875 {
2876 	struct evhttp_connection *evcon = req->evcon;
2877 	struct evbuffer *output;
2878 
2879 	if (evcon == NULL) {
2880 		evhttp_request_free(req);
2881 		return;
2882 	}
2883 
2884 	output = bufferevent_get_output(evcon->bufev);
2885 
2886 	/* we expect no more calls form the user on this request */
2887 	req->userdone = 1;
2888 
2889 	if (req->chunked) {
2890 		evbuffer_add(output, "0\r\n\r\n", 5);
2891 		evhttp_write_buffer(req->evcon, evhttp_send_done, NULL);
2892 		req->chunked = 0;
2893 	} else if (evbuffer_get_length(output) == 0) {
2894 		/* let the connection know that we are done with the request */
2895 		evhttp_send_done(evcon, NULL);
2896 	} else {
2897 		/* make the callback execute after all data has been written */
2898 		evcon->cb = evhttp_send_done;
2899 		evcon->cb_arg = NULL;
2900 	}
2901 }
2902 
2903 static const char *informational_phrases[] = {
2904 	/* 100 */ "Continue",
2905 	/* 101 */ "Switching Protocols"
2906 };
2907 
2908 static const char *success_phrases[] = {
2909 	/* 200 */ "OK",
2910 	/* 201 */ "Created",
2911 	/* 202 */ "Accepted",
2912 	/* 203 */ "Non-Authoritative Information",
2913 	/* 204 */ "No Content",
2914 	/* 205 */ "Reset Content",
2915 	/* 206 */ "Partial Content"
2916 };
2917 
2918 static const char *redirection_phrases[] = {
2919 	/* 300 */ "Multiple Choices",
2920 	/* 301 */ "Moved Permanently",
2921 	/* 302 */ "Found",
2922 	/* 303 */ "See Other",
2923 	/* 304 */ "Not Modified",
2924 	/* 305 */ "Use Proxy",
2925 	/* 307 */ "Temporary Redirect"
2926 };
2927 
2928 static const char *client_error_phrases[] = {
2929 	/* 400 */ "Bad Request",
2930 	/* 401 */ "Unauthorized",
2931 	/* 402 */ "Payment Required",
2932 	/* 403 */ "Forbidden",
2933 	/* 404 */ "Not Found",
2934 	/* 405 */ "Method Not Allowed",
2935 	/* 406 */ "Not Acceptable",
2936 	/* 407 */ "Proxy Authentication Required",
2937 	/* 408 */ "Request Time-out",
2938 	/* 409 */ "Conflict",
2939 	/* 410 */ "Gone",
2940 	/* 411 */ "Length Required",
2941 	/* 412 */ "Precondition Failed",
2942 	/* 413 */ "Request Entity Too Large",
2943 	/* 414 */ "Request-URI Too Large",
2944 	/* 415 */ "Unsupported Media Type",
2945 	/* 416 */ "Requested range not satisfiable",
2946 	/* 417 */ "Expectation Failed"
2947 };
2948 
2949 static const char *server_error_phrases[] = {
2950 	/* 500 */ "Internal Server Error",
2951 	/* 501 */ "Not Implemented",
2952 	/* 502 */ "Bad Gateway",
2953 	/* 503 */ "Service Unavailable",
2954 	/* 504 */ "Gateway Time-out",
2955 	/* 505 */ "HTTP Version not supported"
2956 };
2957 
2958 struct response_class {
2959 	const char *name;
2960 	size_t num_responses;
2961 	const char **responses;
2962 };
2963 
2964 #ifndef MEMBERSOF
2965 #define MEMBERSOF(x) (sizeof(x)/sizeof(x[0]))
2966 #endif
2967 
2968 static const struct response_class response_classes[] = {
2969 	/* 1xx */ { "Informational", MEMBERSOF(informational_phrases), informational_phrases },
2970 	/* 2xx */ { "Success", MEMBERSOF(success_phrases), success_phrases },
2971 	/* 3xx */ { "Redirection", MEMBERSOF(redirection_phrases), redirection_phrases },
2972 	/* 4xx */ { "Client Error", MEMBERSOF(client_error_phrases), client_error_phrases },
2973 	/* 5xx */ { "Server Error", MEMBERSOF(server_error_phrases), server_error_phrases }
2974 };
2975 
2976 static const char *
2977 evhttp_response_phrase_internal(int code)
2978 {
2979 	int klass = code / 100 - 1;
2980 	int subcode = code % 100;
2981 
2982 	/* Unknown class - can't do any better here */
2983 	if (klass < 0 || klass >= (int) MEMBERSOF(response_classes))
2984 		return "Unknown Status Class";
2985 
2986 	/* Unknown sub-code, return class name at least */
2987 	if (subcode >= (int) response_classes[klass].num_responses)
2988 		return response_classes[klass].name;
2989 
2990 	return response_classes[klass].responses[subcode];
2991 }
2992 
2993 void
2994 evhttp_response_code_(struct evhttp_request *req, int code, const char *reason)
2995 {
2996 	req->kind = EVHTTP_RESPONSE;
2997 	req->response_code = code;
2998 	if (req->response_code_line != NULL)
2999 		mm_free(req->response_code_line);
3000 	if (reason == NULL)
3001 		reason = evhttp_response_phrase_internal(code);
3002 	req->response_code_line = mm_strdup(reason);
3003 	if (req->response_code_line == NULL) {
3004 		event_warn("%s: strdup", __func__);
3005 		/* XXX what else can we do? */
3006 	}
3007 }
3008 
3009 void
3010 evhttp_send_page_(struct evhttp_request *req, struct evbuffer *databuf)
3011 {
3012 	if (!req->major || !req->minor) {
3013 		req->major = 1;
3014 		req->minor = 1;
3015 	}
3016 
3017 	if (req->kind != EVHTTP_RESPONSE)
3018 		evhttp_response_code_(req, 200, "OK");
3019 
3020 	evhttp_clear_headers(req->output_headers);
3021 	evhttp_add_header(req->output_headers, "Content-Type", "text/html");
3022 	evhttp_add_header(req->output_headers, "Connection", "close");
3023 
3024 	evhttp_send(req, databuf);
3025 }
3026 
3027 static const char uri_chars[256] = {
3028 	/* 0 */
3029 	0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0,
3030 	0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0,
3031 	0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 1, 1, 0,
3032 	1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 0, 0, 0, 0, 0, 0,
3033 	/* 64 */
3034 	0, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,
3035 	1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 0, 0, 0, 0, 1,
3036 	0, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,
3037 	1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 0, 0, 0, 1, 0,
3038 	/* 128 */
3039 	0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0,
3040 	0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0,
3041 	0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0,
3042 	0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0,
3043 	/* 192 */
3044 	0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0,
3045 	0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0,
3046 	0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0,
3047 	0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0,
3048 };
3049 
3050 #define CHAR_IS_UNRESERVED(c)			\
3051 	(uri_chars[(unsigned char)(c)])
3052 
3053 /*
3054  * Helper functions to encode/decode a string for inclusion in a URI.
3055  * The returned string must be freed by the caller.
3056  */
3057 char *
3058 evhttp_uriencode(const char *uri, ev_ssize_t len, int space_as_plus)
3059 {
3060 	struct evbuffer *buf = evbuffer_new();
3061 	const char *p, *end;
3062 	char *result;
3063 
3064 	if (buf == NULL) {
3065 		return (NULL);
3066 	}
3067 
3068 
3069 	if (len >= 0) {
3070 		if (uri + len < uri) {
3071 			return (NULL);
3072 		}
3073 
3074 		end = uri + len;
3075 	} else {
3076 		size_t slen = strlen(uri);
3077 
3078 		if (slen >= EV_SSIZE_MAX) {
3079 			/* we don't want to mix signed and unsigned */
3080 			return (NULL);
3081 		}
3082 
3083 		if (uri + slen < uri) {
3084 			return (NULL);
3085 		}
3086 
3087 		end = uri + slen;
3088 	}
3089 
3090 	for (p = uri; p < end; p++) {
3091 		if (CHAR_IS_UNRESERVED(*p)) {
3092 			evbuffer_add(buf, p, 1);
3093 		} else if (*p == ' ' && space_as_plus) {
3094 			evbuffer_add(buf, "+", 1);
3095 		} else {
3096 			evbuffer_add_printf(buf, "%%%02X", (unsigned char)(*p));
3097 		}
3098 	}
3099 
3100 	evbuffer_add(buf, "", 1); /* NUL-terminator. */
3101 	result = mm_malloc(evbuffer_get_length(buf));
3102 
3103 	if (result)
3104 		evbuffer_remove(buf, result, evbuffer_get_length(buf));
3105 
3106 	evbuffer_free(buf);
3107 
3108 	return (result);
3109 }
3110 
3111 char *
3112 evhttp_encode_uri(const char *str)
3113 {
3114 	return evhttp_uriencode(str, -1, 0);
3115 }
3116 
3117 /*
3118  * @param decode_plus_ctl: if 1, we decode plus into space.  If 0, we don't.
3119  *     If -1, when true we transform plus to space only after we've seen
3120  *     a ?.  -1 is deprecated.
3121  * @return the number of bytes written to 'ret'.
3122  */
3123 int
3124 evhttp_decode_uri_internal(
3125 	const char *uri, size_t length, char *ret, int decode_plus_ctl)
3126 {
3127 	char c;
3128 	int j;
3129 	int decode_plus = (decode_plus_ctl == 1) ? 1: 0;
3130 	unsigned i;
3131 
3132 	for (i = j = 0; i < length; i++) {
3133 		c = uri[i];
3134 		if (c == '?') {
3135 			if (decode_plus_ctl < 0)
3136 				decode_plus = 1;
3137 		} else if (c == '+' && decode_plus) {
3138 			c = ' ';
3139 		} else if ((i + 2) < length && c == '%' &&
3140 			EVUTIL_ISXDIGIT_(uri[i+1]) && EVUTIL_ISXDIGIT_(uri[i+2])) {
3141 			char tmp[3];
3142 			tmp[0] = uri[i+1];
3143 			tmp[1] = uri[i+2];
3144 			tmp[2] = '\0';
3145 			c = (char)strtol(tmp, NULL, 16);
3146 			i += 2;
3147 		}
3148 		ret[j++] = c;
3149 	}
3150 	ret[j] = '\0';
3151 
3152 	return (j);
3153 }
3154 
3155 /* deprecated */
3156 char *
3157 evhttp_decode_uri(const char *uri)
3158 {
3159 	char *ret;
3160 
3161 	if ((ret = mm_malloc(strlen(uri) + 1)) == NULL) {
3162 		event_warn("%s: malloc(%lu)", __func__,
3163 			  (unsigned long)(strlen(uri) + 1));
3164 		return (NULL);
3165 	}
3166 
3167 	evhttp_decode_uri_internal(uri, strlen(uri),
3168 	    ret, -1 /*always_decode_plus*/);
3169 
3170 	return (ret);
3171 }
3172 
3173 char *
3174 evhttp_uridecode(const char *uri, int decode_plus, size_t *size_out)
3175 {
3176 	char *ret;
3177 	int n;
3178 
3179 	if ((ret = mm_malloc(strlen(uri) + 1)) == NULL) {
3180 		event_warn("%s: malloc(%lu)", __func__,
3181 			  (unsigned long)(strlen(uri) + 1));
3182 		return (NULL);
3183 	}
3184 
3185 	n = evhttp_decode_uri_internal(uri, strlen(uri),
3186 	    ret, !!decode_plus/*always_decode_plus*/);
3187 
3188 	if (size_out) {
3189 		EVUTIL_ASSERT(n >= 0);
3190 		*size_out = (size_t)n;
3191 	}
3192 
3193 	return (ret);
3194 }
3195 
3196 /*
3197  * Helper function to parse out arguments in a query.
3198  * The arguments are separated by key and value.
3199  */
3200 
3201 static int
3202 evhttp_parse_query_impl(const char *str, struct evkeyvalq *headers,
3203     int is_whole_uri)
3204 {
3205 	char *line=NULL;
3206 	char *argument;
3207 	char *p;
3208 	const char *query_part;
3209 	int result = -1;
3210 	struct evhttp_uri *uri=NULL;
3211 
3212 	TAILQ_INIT(headers);
3213 
3214 	if (is_whole_uri) {
3215 		uri = evhttp_uri_parse(str);
3216 		if (!uri)
3217 			goto error;
3218 		query_part = evhttp_uri_get_query(uri);
3219 	} else {
3220 		query_part = str;
3221 	}
3222 
3223 	/* No arguments - we are done */
3224 	if (!query_part || !strlen(query_part)) {
3225 		result = 0;
3226 		goto done;
3227 	}
3228 
3229 	if ((line = mm_strdup(query_part)) == NULL) {
3230 		event_warn("%s: strdup", __func__);
3231 		goto error;
3232 	}
3233 
3234 	p = argument = line;
3235 	while (p != NULL && *p != '\0') {
3236 		char *key, *value, *decoded_value;
3237 		argument = strsep(&p, "&");
3238 
3239 		value = argument;
3240 		key = strsep(&value, "=");
3241 		if (value == NULL || *key == '\0') {
3242 			goto error;
3243 		}
3244 
3245 		if ((decoded_value = mm_malloc(strlen(value) + 1)) == NULL) {
3246 			event_warn("%s: mm_malloc", __func__);
3247 			goto error;
3248 		}
3249 		evhttp_decode_uri_internal(value, strlen(value),
3250 		    decoded_value, 1 /*always_decode_plus*/);
3251 		event_debug(("Query Param: %s -> %s\n", key, decoded_value));
3252 		evhttp_add_header_internal(headers, key, decoded_value);
3253 		mm_free(decoded_value);
3254 	}
3255 
3256 	result = 0;
3257 	goto done;
3258 error:
3259 	evhttp_clear_headers(headers);
3260 done:
3261 	if (line)
3262 		mm_free(line);
3263 	if (uri)
3264 		evhttp_uri_free(uri);
3265 	return result;
3266 }
3267 
3268 int
3269 evhttp_parse_query(const char *uri, struct evkeyvalq *headers)
3270 {
3271 	return evhttp_parse_query_impl(uri, headers, 1);
3272 }
3273 int
3274 evhttp_parse_query_str(const char *uri, struct evkeyvalq *headers)
3275 {
3276 	return evhttp_parse_query_impl(uri, headers, 0);
3277 }
3278 
3279 static struct evhttp_cb *
3280 evhttp_dispatch_callback(struct httpcbq *callbacks, struct evhttp_request *req)
3281 {
3282 	struct evhttp_cb *cb;
3283 	size_t offset = 0;
3284 	char *translated;
3285 	const char *path;
3286 
3287 	/* Test for different URLs */
3288 	path = evhttp_uri_get_path(req->uri_elems);
3289 	offset = strlen(path);
3290 	if ((translated = mm_malloc(offset + 1)) == NULL)
3291 		return (NULL);
3292 	evhttp_decode_uri_internal(path, offset, translated,
3293 	    0 /* decode_plus */);
3294 
3295 	TAILQ_FOREACH(cb, callbacks, next) {
3296 		if (!strcmp(cb->what, translated)) {
3297 			mm_free(translated);
3298 			return (cb);
3299 		}
3300 	}
3301 
3302 	mm_free(translated);
3303 	return (NULL);
3304 }
3305 
3306 
3307 static int
3308 prefix_suffix_match(const char *pattern, const char *name, int ignorecase)
3309 {
3310 	char c;
3311 
3312 	while (1) {
3313 		switch (c = *pattern++) {
3314 		case '\0':
3315 			return *name == '\0';
3316 
3317 		case '*':
3318 			while (*name != '\0') {
3319 				if (prefix_suffix_match(pattern, name,
3320 					ignorecase))
3321 					return (1);
3322 				++name;
3323 			}
3324 			return (0);
3325 		default:
3326 			if (c != *name) {
3327 				if (!ignorecase ||
3328 				    EVUTIL_TOLOWER_(c) != EVUTIL_TOLOWER_(*name))
3329 					return (0);
3330 			}
3331 			++name;
3332 		}
3333 	}
3334 	/* NOTREACHED */
3335 }
3336 
3337 /*
3338    Search the vhost hierarchy beginning with http for a server alias
3339    matching hostname.  If a match is found, and outhttp is non-null,
3340    outhttp is set to the matching http object and 1 is returned.
3341 */
3342 
3343 static int
3344 evhttp_find_alias(struct evhttp *http, struct evhttp **outhttp,
3345 		  const char *hostname)
3346 {
3347 	struct evhttp_server_alias *alias;
3348 	struct evhttp *vhost;
3349 
3350 	TAILQ_FOREACH(alias, &http->aliases, next) {
3351 		/* XXX Do we need to handle IP addresses? */
3352 		if (!evutil_ascii_strcasecmp(alias->alias, hostname)) {
3353 			if (outhttp)
3354 				*outhttp = http;
3355 			return 1;
3356 		}
3357 	}
3358 
3359 	/* XXX It might be good to avoid recursion here, but I don't
3360 	   see a way to do that w/o a list. */
3361 	TAILQ_FOREACH(vhost, &http->virtualhosts, next_vhost) {
3362 		if (evhttp_find_alias(vhost, outhttp, hostname))
3363 			return 1;
3364 	}
3365 
3366 	return 0;
3367 }
3368 
3369 /*
3370    Attempts to find the best http object to handle a request for a hostname.
3371    All aliases for the root http object and vhosts are searched for an exact
3372    match. Then, the vhost hierarchy is traversed again for a matching
3373    pattern.
3374 
3375    If an alias or vhost is matched, 1 is returned, and outhttp, if non-null,
3376    is set with the best matching http object. If there are no matches, the
3377    root http object is stored in outhttp and 0 is returned.
3378 */
3379 
3380 static int
3381 evhttp_find_vhost(struct evhttp *http, struct evhttp **outhttp,
3382 		  const char *hostname)
3383 {
3384 	struct evhttp *vhost;
3385 	struct evhttp *oldhttp;
3386 	int match_found = 0;
3387 
3388 	if (evhttp_find_alias(http, outhttp, hostname))
3389 		return 1;
3390 
3391 	do {
3392 		oldhttp = http;
3393 		TAILQ_FOREACH(vhost, &http->virtualhosts, next_vhost) {
3394 			if (prefix_suffix_match(vhost->vhost_pattern,
3395 				hostname, 1 /* ignorecase */)) {
3396 				http = vhost;
3397 				match_found = 1;
3398 				break;
3399 			}
3400 		}
3401 	} while (oldhttp != http);
3402 
3403 	if (outhttp)
3404 		*outhttp = http;
3405 
3406 	return match_found;
3407 }
3408 
3409 static void
3410 evhttp_handle_request(struct evhttp_request *req, void *arg)
3411 {
3412 	struct evhttp *http = arg;
3413 	struct evhttp_cb *cb = NULL;
3414 	const char *hostname;
3415 
3416 	/* we have a new request on which the user needs to take action */
3417 	req->userdone = 0;
3418 
3419 	if (req->type == 0 || req->uri == NULL) {
3420 		evhttp_send_error(req, req->response_code, NULL);
3421 		return;
3422 	}
3423 
3424 	if ((http->allowed_methods & req->type) == 0) {
3425 		event_debug(("Rejecting disallowed method %x (allowed: %x)\n",
3426 			(unsigned)req->type, (unsigned)http->allowed_methods));
3427 		evhttp_send_error(req, HTTP_NOTIMPLEMENTED, NULL);
3428 		return;
3429 	}
3430 
3431 	/* handle potential virtual hosts */
3432 	hostname = evhttp_request_get_host(req);
3433 	if (hostname != NULL) {
3434 		evhttp_find_vhost(http, &http, hostname);
3435 	}
3436 
3437 	if ((cb = evhttp_dispatch_callback(&http->callbacks, req)) != NULL) {
3438 		(*cb->cb)(req, cb->cbarg);
3439 		return;
3440 	}
3441 
3442 	/* Generic call back */
3443 	if (http->gencb) {
3444 		(*http->gencb)(req, http->gencbarg);
3445 		return;
3446 	} else {
3447 		/* We need to send a 404 here */
3448 #define ERR_FORMAT "<html><head>" \
3449 		    "<title>404 Not Found</title>" \
3450 		    "</head><body>" \
3451 		    "<h1>Not Found</h1>" \
3452 		    "<p>The requested URL %s was not found on this server.</p>"\
3453 		    "</body></html>\n"
3454 
3455 		char *escaped_html;
3456 		struct evbuffer *buf;
3457 
3458 		if ((escaped_html = evhttp_htmlescape(req->uri)) == NULL) {
3459 			evhttp_connection_free(req->evcon);
3460 			return;
3461 		}
3462 
3463 		if ((buf = evbuffer_new()) == NULL) {
3464 			mm_free(escaped_html);
3465 			evhttp_connection_free(req->evcon);
3466 			return;
3467 		}
3468 
3469 		evhttp_response_code_(req, HTTP_NOTFOUND, "Not Found");
3470 
3471 		evbuffer_add_printf(buf, ERR_FORMAT, escaped_html);
3472 
3473 		mm_free(escaped_html);
3474 
3475 		evhttp_send_page_(req, buf);
3476 
3477 		evbuffer_free(buf);
3478 #undef ERR_FORMAT
3479 	}
3480 }
3481 
3482 /* Listener callback when a connection arrives at a server. */
3483 static void
3484 accept_socket_cb(struct evconnlistener *listener, evutil_socket_t nfd, struct sockaddr *peer_sa, int peer_socklen, void *arg)
3485 {
3486 	struct evhttp *http = arg;
3487 
3488 	evhttp_get_request(http, nfd, peer_sa, peer_socklen);
3489 }
3490 
3491 int
3492 evhttp_bind_socket(struct evhttp *http, const char *address, ev_uint16_t port)
3493 {
3494 	struct evhttp_bound_socket *bound =
3495 		evhttp_bind_socket_with_handle(http, address, port);
3496 	if (bound == NULL)
3497 		return (-1);
3498 	return (0);
3499 }
3500 
3501 struct evhttp_bound_socket *
3502 evhttp_bind_socket_with_handle(struct evhttp *http, const char *address, ev_uint16_t port)
3503 {
3504 	evutil_socket_t fd;
3505 	struct evhttp_bound_socket *bound;
3506 
3507 	if ((fd = bind_socket(address, port, 1 /*reuse*/)) == -1)
3508 		return (NULL);
3509 
3510 	if (listen(fd, 128) == -1) {
3511 		event_sock_warn(fd, "%s: listen", __func__);
3512 		evutil_closesocket(fd);
3513 		return (NULL);
3514 	}
3515 
3516 	bound = evhttp_accept_socket_with_handle(http, fd);
3517 
3518 	if (bound != NULL) {
3519 		event_debug(("Bound to port %d - Awaiting connections ... ",
3520 			port));
3521 		return (bound);
3522 	}
3523 
3524 	return (NULL);
3525 }
3526 
3527 int
3528 evhttp_accept_socket(struct evhttp *http, evutil_socket_t fd)
3529 {
3530 	struct evhttp_bound_socket *bound =
3531 		evhttp_accept_socket_with_handle(http, fd);
3532 	if (bound == NULL)
3533 		return (-1);
3534 	return (0);
3535 }
3536 
3537 void
3538 evhttp_foreach_bound_socket(struct evhttp *http,
3539                             evhttp_bound_socket_foreach_fn *function,
3540                             void *argument)
3541 {
3542 	struct evhttp_bound_socket *bound;
3543 
3544 	TAILQ_FOREACH(bound, &http->sockets, next)
3545 		function(bound, argument);
3546 }
3547 
3548 struct evhttp_bound_socket *
3549 evhttp_accept_socket_with_handle(struct evhttp *http, evutil_socket_t fd)
3550 {
3551 	struct evhttp_bound_socket *bound;
3552 	struct evconnlistener *listener;
3553 	const int flags =
3554 	    LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_EXEC|LEV_OPT_CLOSE_ON_FREE;
3555 
3556 	listener = evconnlistener_new(http->base, NULL, NULL,
3557 	    flags,
3558 	    0, /* Backlog is '0' because we already said 'listen' */
3559 	    fd);
3560 	if (!listener)
3561 		return (NULL);
3562 
3563 	bound = evhttp_bind_listener(http, listener);
3564 	if (!bound) {
3565 		evconnlistener_free(listener);
3566 		return (NULL);
3567 	}
3568 	return (bound);
3569 }
3570 
3571 struct evhttp_bound_socket *
3572 evhttp_bind_listener(struct evhttp *http, struct evconnlistener *listener)
3573 {
3574 	struct evhttp_bound_socket *bound;
3575 
3576 	bound = mm_malloc(sizeof(struct evhttp_bound_socket));
3577 	if (bound == NULL)
3578 		return (NULL);
3579 
3580 	bound->listener = listener;
3581 	TAILQ_INSERT_TAIL(&http->sockets, bound, next);
3582 
3583 	evconnlistener_set_cb(listener, accept_socket_cb, http);
3584 	return bound;
3585 }
3586 
3587 evutil_socket_t
3588 evhttp_bound_socket_get_fd(struct evhttp_bound_socket *bound)
3589 {
3590 	return evconnlistener_get_fd(bound->listener);
3591 }
3592 
3593 struct evconnlistener *
3594 evhttp_bound_socket_get_listener(struct evhttp_bound_socket *bound)
3595 {
3596 	return bound->listener;
3597 }
3598 
3599 void
3600 evhttp_del_accept_socket(struct evhttp *http, struct evhttp_bound_socket *bound)
3601 {
3602 	TAILQ_REMOVE(&http->sockets, bound, next);
3603 	evconnlistener_free(bound->listener);
3604 	mm_free(bound);
3605 }
3606 
3607 static struct evhttp*
3608 evhttp_new_object(void)
3609 {
3610 	struct evhttp *http = NULL;
3611 
3612 	if ((http = mm_calloc(1, sizeof(struct evhttp))) == NULL) {
3613 		event_warn("%s: calloc", __func__);
3614 		return (NULL);
3615 	}
3616 
3617 	evutil_timerclear(&http->timeout);
3618 	evhttp_set_max_headers_size(http, EV_SIZE_MAX);
3619 	evhttp_set_max_body_size(http, EV_SIZE_MAX);
3620 	evhttp_set_default_content_type(http, "text/html; charset=ISO-8859-1");
3621 	evhttp_set_allowed_methods(http,
3622 	    EVHTTP_REQ_GET |
3623 	    EVHTTP_REQ_POST |
3624 	    EVHTTP_REQ_HEAD |
3625 	    EVHTTP_REQ_PUT |
3626 	    EVHTTP_REQ_DELETE);
3627 
3628 	TAILQ_INIT(&http->sockets);
3629 	TAILQ_INIT(&http->callbacks);
3630 	TAILQ_INIT(&http->connections);
3631 	TAILQ_INIT(&http->virtualhosts);
3632 	TAILQ_INIT(&http->aliases);
3633 
3634 	return (http);
3635 }
3636 
3637 struct evhttp *
3638 evhttp_new(struct event_base *base)
3639 {
3640 	struct evhttp *http = NULL;
3641 
3642 	http = evhttp_new_object();
3643 	if (http == NULL)
3644 		return (NULL);
3645 	http->base = base;
3646 
3647 	return (http);
3648 }
3649 
3650 /*
3651  * Start a web server on the specified address and port.
3652  */
3653 
3654 struct evhttp *
3655 evhttp_start(const char *address, ev_uint16_t port)
3656 {
3657 	struct evhttp *http = NULL;
3658 
3659 	http = evhttp_new_object();
3660 	if (http == NULL)
3661 		return (NULL);
3662 	if (evhttp_bind_socket(http, address, port) == -1) {
3663 		mm_free(http);
3664 		return (NULL);
3665 	}
3666 
3667 	return (http);
3668 }
3669 
3670 void
3671 evhttp_free(struct evhttp* http)
3672 {
3673 	struct evhttp_cb *http_cb;
3674 	struct evhttp_connection *evcon;
3675 	struct evhttp_bound_socket *bound;
3676 	struct evhttp* vhost;
3677 	struct evhttp_server_alias *alias;
3678 
3679 	/* Remove the accepting part */
3680 	while ((bound = TAILQ_FIRST(&http->sockets)) != NULL) {
3681 		TAILQ_REMOVE(&http->sockets, bound, next);
3682 
3683 		evconnlistener_free(bound->listener);
3684 
3685 		mm_free(bound);
3686 	}
3687 
3688 	while ((evcon = TAILQ_FIRST(&http->connections)) != NULL) {
3689 		/* evhttp_connection_free removes the connection */
3690 		evhttp_connection_free(evcon);
3691 	}
3692 
3693 	while ((http_cb = TAILQ_FIRST(&http->callbacks)) != NULL) {
3694 		TAILQ_REMOVE(&http->callbacks, http_cb, next);
3695 		mm_free(http_cb->what);
3696 		mm_free(http_cb);
3697 	}
3698 
3699 	while ((vhost = TAILQ_FIRST(&http->virtualhosts)) != NULL) {
3700 		TAILQ_REMOVE(&http->virtualhosts, vhost, next_vhost);
3701 
3702 		evhttp_free(vhost);
3703 	}
3704 
3705 	if (http->vhost_pattern != NULL)
3706 		mm_free(http->vhost_pattern);
3707 
3708 	while ((alias = TAILQ_FIRST(&http->aliases)) != NULL) {
3709 		TAILQ_REMOVE(&http->aliases, alias, next);
3710 		mm_free(alias->alias);
3711 		mm_free(alias);
3712 	}
3713 
3714 	mm_free(http);
3715 }
3716 
3717 int
3718 evhttp_add_virtual_host(struct evhttp* http, const char *pattern,
3719     struct evhttp* vhost)
3720 {
3721 	/* a vhost can only be a vhost once and should not have bound sockets */
3722 	if (vhost->vhost_pattern != NULL ||
3723 	    TAILQ_FIRST(&vhost->sockets) != NULL)
3724 		return (-1);
3725 
3726 	vhost->vhost_pattern = mm_strdup(pattern);
3727 	if (vhost->vhost_pattern == NULL)
3728 		return (-1);
3729 
3730 	TAILQ_INSERT_TAIL(&http->virtualhosts, vhost, next_vhost);
3731 
3732 	return (0);
3733 }
3734 
3735 int
3736 evhttp_remove_virtual_host(struct evhttp* http, struct evhttp* vhost)
3737 {
3738 	if (vhost->vhost_pattern == NULL)
3739 		return (-1);
3740 
3741 	TAILQ_REMOVE(&http->virtualhosts, vhost, next_vhost);
3742 
3743 	mm_free(vhost->vhost_pattern);
3744 	vhost->vhost_pattern = NULL;
3745 
3746 	return (0);
3747 }
3748 
3749 int
3750 evhttp_add_server_alias(struct evhttp *http, const char *alias)
3751 {
3752 	struct evhttp_server_alias *evalias;
3753 
3754 	evalias = mm_calloc(1, sizeof(*evalias));
3755 	if (!evalias)
3756 		return -1;
3757 
3758 	evalias->alias = mm_strdup(alias);
3759 	if (!evalias->alias) {
3760 		mm_free(evalias);
3761 		return -1;
3762 	}
3763 
3764 	TAILQ_INSERT_TAIL(&http->aliases, evalias, next);
3765 
3766 	return 0;
3767 }
3768 
3769 int
3770 evhttp_remove_server_alias(struct evhttp *http, const char *alias)
3771 {
3772 	struct evhttp_server_alias *evalias;
3773 
3774 	TAILQ_FOREACH(evalias, &http->aliases, next) {
3775 		if (evutil_ascii_strcasecmp(evalias->alias, alias) == 0) {
3776 			TAILQ_REMOVE(&http->aliases, evalias, next);
3777 			mm_free(evalias->alias);
3778 			mm_free(evalias);
3779 			return 0;
3780 		}
3781 	}
3782 
3783 	return -1;
3784 }
3785 
3786 void
3787 evhttp_set_timeout(struct evhttp* http, int timeout_in_secs)
3788 {
3789 	if (timeout_in_secs == -1) {
3790 		evhttp_set_timeout_tv(http, NULL);
3791 	} else {
3792 		struct timeval tv;
3793 		tv.tv_sec = timeout_in_secs;
3794 		tv.tv_usec = 0;
3795 		evhttp_set_timeout_tv(http, &tv);
3796 	}
3797 }
3798 
3799 void
3800 evhttp_set_timeout_tv(struct evhttp* http, const struct timeval* tv)
3801 {
3802 	if (tv) {
3803 		http->timeout = *tv;
3804 	} else {
3805 		evutil_timerclear(&http->timeout);
3806 	}
3807 }
3808 
3809 int evhttp_set_flags(struct evhttp *http, int flags)
3810 {
3811 	int avail_flags = 0;
3812 	avail_flags |= EVHTTP_SERVER_LINGERING_CLOSE;
3813 
3814 	if (flags & ~avail_flags)
3815 		return 1;
3816 	http->flags &= ~avail_flags;
3817 
3818 	http->flags |= flags;
3819 
3820 	return 0;
3821 }
3822 
3823 void
3824 evhttp_set_max_headers_size(struct evhttp* http, ev_ssize_t max_headers_size)
3825 {
3826 	if (max_headers_size < 0)
3827 		http->default_max_headers_size = EV_SIZE_MAX;
3828 	else
3829 		http->default_max_headers_size = max_headers_size;
3830 }
3831 
3832 void
3833 evhttp_set_max_body_size(struct evhttp* http, ev_ssize_t max_body_size)
3834 {
3835 	if (max_body_size < 0)
3836 		http->default_max_body_size = EV_UINT64_MAX;
3837 	else
3838 		http->default_max_body_size = max_body_size;
3839 }
3840 
3841 void
3842 evhttp_set_default_content_type(struct evhttp *http,
3843 	const char *content_type) {
3844 	http->default_content_type = content_type;
3845 }
3846 
3847 void
3848 evhttp_set_allowed_methods(struct evhttp* http, ev_uint16_t methods)
3849 {
3850 	http->allowed_methods = methods;
3851 }
3852 
3853 int
3854 evhttp_set_cb(struct evhttp *http, const char *uri,
3855     void (*cb)(struct evhttp_request *, void *), void *cbarg)
3856 {
3857 	struct evhttp_cb *http_cb;
3858 
3859 	TAILQ_FOREACH(http_cb, &http->callbacks, next) {
3860 		if (strcmp(http_cb->what, uri) == 0)
3861 			return (-1);
3862 	}
3863 
3864 	if ((http_cb = mm_calloc(1, sizeof(struct evhttp_cb))) == NULL) {
3865 		event_warn("%s: calloc", __func__);
3866 		return (-2);
3867 	}
3868 
3869 	http_cb->what = mm_strdup(uri);
3870 	if (http_cb->what == NULL) {
3871 		event_warn("%s: strdup", __func__);
3872 		mm_free(http_cb);
3873 		return (-3);
3874 	}
3875 	http_cb->cb = cb;
3876 	http_cb->cbarg = cbarg;
3877 
3878 	TAILQ_INSERT_TAIL(&http->callbacks, http_cb, next);
3879 
3880 	return (0);
3881 }
3882 
3883 int
3884 evhttp_del_cb(struct evhttp *http, const char *uri)
3885 {
3886 	struct evhttp_cb *http_cb;
3887 
3888 	TAILQ_FOREACH(http_cb, &http->callbacks, next) {
3889 		if (strcmp(http_cb->what, uri) == 0)
3890 			break;
3891 	}
3892 	if (http_cb == NULL)
3893 		return (-1);
3894 
3895 	TAILQ_REMOVE(&http->callbacks, http_cb, next);
3896 	mm_free(http_cb->what);
3897 	mm_free(http_cb);
3898 
3899 	return (0);
3900 }
3901 
3902 void
3903 evhttp_set_gencb(struct evhttp *http,
3904     void (*cb)(struct evhttp_request *, void *), void *cbarg)
3905 {
3906 	http->gencb = cb;
3907 	http->gencbarg = cbarg;
3908 }
3909 
3910 void
3911 evhttp_set_bevcb(struct evhttp *http,
3912     struct bufferevent* (*cb)(struct event_base *, void *), void *cbarg)
3913 {
3914 	http->bevcb = cb;
3915 	http->bevcbarg = cbarg;
3916 }
3917 
3918 /*
3919  * Request related functions
3920  */
3921 
3922 struct evhttp_request *
3923 evhttp_request_new(void (*cb)(struct evhttp_request *, void *), void *arg)
3924 {
3925 	struct evhttp_request *req = NULL;
3926 
3927 	/* Allocate request structure */
3928 	if ((req = mm_calloc(1, sizeof(struct evhttp_request))) == NULL) {
3929 		event_warn("%s: calloc", __func__);
3930 		goto error;
3931 	}
3932 
3933 	req->headers_size = 0;
3934 	req->body_size = 0;
3935 
3936 	req->kind = EVHTTP_RESPONSE;
3937 	req->input_headers = mm_calloc(1, sizeof(struct evkeyvalq));
3938 	if (req->input_headers == NULL) {
3939 		event_warn("%s: calloc", __func__);
3940 		goto error;
3941 	}
3942 	TAILQ_INIT(req->input_headers);
3943 
3944 	req->output_headers = mm_calloc(1, sizeof(struct evkeyvalq));
3945 	if (req->output_headers == NULL) {
3946 		event_warn("%s: calloc", __func__);
3947 		goto error;
3948 	}
3949 	TAILQ_INIT(req->output_headers);
3950 
3951 	if ((req->input_buffer = evbuffer_new()) == NULL) {
3952 		event_warn("%s: evbuffer_new", __func__);
3953 		goto error;
3954 	}
3955 
3956 	if ((req->output_buffer = evbuffer_new()) == NULL) {
3957 		event_warn("%s: evbuffer_new", __func__);
3958 		goto error;
3959 	}
3960 
3961 	req->cb = cb;
3962 	req->cb_arg = arg;
3963 
3964 	return (req);
3965 
3966  error:
3967 	if (req != NULL)
3968 		evhttp_request_free(req);
3969 	return (NULL);
3970 }
3971 
3972 void
3973 evhttp_request_free(struct evhttp_request *req)
3974 {
3975 	if ((req->flags & EVHTTP_REQ_DEFER_FREE) != 0) {
3976 		req->flags |= EVHTTP_REQ_NEEDS_FREE;
3977 		return;
3978 	}
3979 
3980 	if (req->remote_host != NULL)
3981 		mm_free(req->remote_host);
3982 	if (req->uri != NULL)
3983 		mm_free(req->uri);
3984 	if (req->uri_elems != NULL)
3985 		evhttp_uri_free(req->uri_elems);
3986 	if (req->response_code_line != NULL)
3987 		mm_free(req->response_code_line);
3988 	if (req->host_cache != NULL)
3989 		mm_free(req->host_cache);
3990 
3991 	evhttp_clear_headers(req->input_headers);
3992 	mm_free(req->input_headers);
3993 
3994 	evhttp_clear_headers(req->output_headers);
3995 	mm_free(req->output_headers);
3996 
3997 	if (req->input_buffer != NULL)
3998 		evbuffer_free(req->input_buffer);
3999 
4000 	if (req->output_buffer != NULL)
4001 		evbuffer_free(req->output_buffer);
4002 
4003 	mm_free(req);
4004 }
4005 
4006 void
4007 evhttp_request_own(struct evhttp_request *req)
4008 {
4009 	req->flags |= EVHTTP_USER_OWNED;
4010 }
4011 
4012 int
4013 evhttp_request_is_owned(struct evhttp_request *req)
4014 {
4015 	return (req->flags & EVHTTP_USER_OWNED) != 0;
4016 }
4017 
4018 struct evhttp_connection *
4019 evhttp_request_get_connection(struct evhttp_request *req)
4020 {
4021 	return req->evcon;
4022 }
4023 
4024 struct event_base *
4025 evhttp_connection_get_base(struct evhttp_connection *conn)
4026 {
4027 	return conn->base;
4028 }
4029 
4030 void
4031 evhttp_request_set_chunked_cb(struct evhttp_request *req,
4032     void (*cb)(struct evhttp_request *, void *))
4033 {
4034 	req->chunk_cb = cb;
4035 }
4036 
4037 void
4038 evhttp_request_set_header_cb(struct evhttp_request *req,
4039     int (*cb)(struct evhttp_request *, void *))
4040 {
4041 	req->header_cb = cb;
4042 }
4043 
4044 void
4045 evhttp_request_set_error_cb(struct evhttp_request *req,
4046     void (*cb)(enum evhttp_request_error, void *))
4047 {
4048 	req->error_cb = cb;
4049 }
4050 
4051 void
4052 evhttp_request_set_on_complete_cb(struct evhttp_request *req,
4053     void (*cb)(struct evhttp_request *, void *), void *cb_arg)
4054 {
4055 	req->on_complete_cb = cb;
4056 	req->on_complete_cb_arg = cb_arg;
4057 }
4058 
4059 /*
4060  * Allows for inspection of the request URI
4061  */
4062 
4063 const char *
4064 evhttp_request_get_uri(const struct evhttp_request *req) {
4065 	if (req->uri == NULL)
4066 		event_debug(("%s: request %p has no uri\n", __func__, req));
4067 	return (req->uri);
4068 }
4069 
4070 const struct evhttp_uri *
4071 evhttp_request_get_evhttp_uri(const struct evhttp_request *req) {
4072 	if (req->uri_elems == NULL)
4073 		event_debug(("%s: request %p has no uri elems\n",
4074 			    __func__, req));
4075 	return (req->uri_elems);
4076 }
4077 
4078 const char *
4079 evhttp_request_get_host(struct evhttp_request *req)
4080 {
4081 	const char *host = NULL;
4082 
4083 	if (req->host_cache)
4084 		return req->host_cache;
4085 
4086 	if (req->uri_elems)
4087 		host = evhttp_uri_get_host(req->uri_elems);
4088 	if (!host && req->input_headers) {
4089 		const char *p;
4090 		size_t len;
4091 
4092 		host = evhttp_find_header(req->input_headers, "Host");
4093 		/* The Host: header may include a port. Remove it here
4094 		   to be consistent with uri_elems case above. */
4095 		if (host) {
4096 			p = host + strlen(host) - 1;
4097 			while (p > host && EVUTIL_ISDIGIT_(*p))
4098 				--p;
4099 			if (p > host && *p == ':') {
4100 				len = p - host;
4101 				req->host_cache = mm_malloc(len + 1);
4102 				if (!req->host_cache) {
4103 					event_warn("%s: malloc", __func__);
4104 					return NULL;
4105 				}
4106 				memcpy(req->host_cache, host, len);
4107 				req->host_cache[len] = '\0';
4108 				host = req->host_cache;
4109 			}
4110 		}
4111 	}
4112 
4113 	return host;
4114 }
4115 
4116 enum evhttp_cmd_type
4117 evhttp_request_get_command(const struct evhttp_request *req) {
4118 	return (req->type);
4119 }
4120 
4121 int
4122 evhttp_request_get_response_code(const struct evhttp_request *req)
4123 {
4124 	return req->response_code;
4125 }
4126 
4127 const char *
4128 evhttp_request_get_response_code_line(const struct evhttp_request *req)
4129 {
4130 	return req->response_code_line;
4131 }
4132 
4133 /** Returns the input headers */
4134 struct evkeyvalq *evhttp_request_get_input_headers(struct evhttp_request *req)
4135 {
4136 	return (req->input_headers);
4137 }
4138 
4139 /** Returns the output headers */
4140 struct evkeyvalq *evhttp_request_get_output_headers(struct evhttp_request *req)
4141 {
4142 	return (req->output_headers);
4143 }
4144 
4145 /** Returns the input buffer */
4146 struct evbuffer *evhttp_request_get_input_buffer(struct evhttp_request *req)
4147 {
4148 	return (req->input_buffer);
4149 }
4150 
4151 /** Returns the output buffer */
4152 struct evbuffer *evhttp_request_get_output_buffer(struct evhttp_request *req)
4153 {
4154 	return (req->output_buffer);
4155 }
4156 
4157 
4158 /*
4159  * Takes a file descriptor to read a request from.
4160  * The callback is executed once the whole request has been read.
4161  */
4162 
4163 static struct evhttp_connection*
4164 evhttp_get_request_connection(
4165 	struct evhttp* http,
4166 	evutil_socket_t fd, struct sockaddr *sa, ev_socklen_t salen)
4167 {
4168 	struct evhttp_connection *evcon;
4169 	char *hostname = NULL, *portname = NULL;
4170 	struct bufferevent* bev = NULL;
4171 
4172 	name_from_addr(sa, salen, &hostname, &portname);
4173 	if (hostname == NULL || portname == NULL) {
4174 		if (hostname) mm_free(hostname);
4175 		if (portname) mm_free(portname);
4176 		return (NULL);
4177 	}
4178 
4179 	event_debug(("%s: new request from %s:%s on "EV_SOCK_FMT"\n",
4180 		__func__, hostname, portname, EV_SOCK_ARG(fd)));
4181 
4182 	/* we need a connection object to put the http request on */
4183 	if (http->bevcb != NULL) {
4184 		bev = (*http->bevcb)(http->base, http->bevcbarg);
4185 	}
4186 	evcon = evhttp_connection_base_bufferevent_new(
4187 		http->base, NULL, bev, hostname, atoi(portname));
4188 	mm_free(hostname);
4189 	mm_free(portname);
4190 	if (evcon == NULL)
4191 		return (NULL);
4192 
4193 	evcon->max_headers_size = http->default_max_headers_size;
4194 	evcon->max_body_size = http->default_max_body_size;
4195 	if (http->flags & EVHTTP_SERVER_LINGERING_CLOSE)
4196 		evcon->flags |= EVHTTP_CON_LINGERING_CLOSE;
4197 
4198 	evcon->flags |= EVHTTP_CON_INCOMING;
4199 	evcon->state = EVCON_READING_FIRSTLINE;
4200 
4201 	evcon->fd = fd;
4202 
4203 	bufferevent_enable(evcon->bufev, EV_READ);
4204 	bufferevent_disable(evcon->bufev, EV_WRITE);
4205 	bufferevent_setfd(evcon->bufev, fd);
4206 
4207 	return (evcon);
4208 }
4209 
4210 static int
4211 evhttp_associate_new_request_with_connection(struct evhttp_connection *evcon)
4212 {
4213 	struct evhttp *http = evcon->http_server;
4214 	struct evhttp_request *req;
4215 	if ((req = evhttp_request_new(evhttp_handle_request, http)) == NULL)
4216 		return (-1);
4217 
4218 	if ((req->remote_host = mm_strdup(evcon->address)) == NULL) {
4219 		event_warn("%s: strdup", __func__);
4220 		evhttp_request_free(req);
4221 		return (-1);
4222 	}
4223 	req->remote_port = evcon->port;
4224 
4225 	req->evcon = evcon;	/* the request ends up owning the connection */
4226 	req->flags |= EVHTTP_REQ_OWN_CONNECTION;
4227 
4228 	/* We did not present the request to the user user yet, so treat it as
4229 	 * if the user was done with the request.  This allows us to free the
4230 	 * request on a persistent connection if the client drops it without
4231 	 * sending a request.
4232 	 */
4233 	req->userdone = 1;
4234 
4235 	TAILQ_INSERT_TAIL(&evcon->requests, req, next);
4236 
4237 	req->kind = EVHTTP_REQUEST;
4238 
4239 
4240 	evhttp_start_read_(evcon);
4241 
4242 	return (0);
4243 }
4244 
4245 static void
4246 evhttp_get_request(struct evhttp *http, evutil_socket_t fd,
4247     struct sockaddr *sa, ev_socklen_t salen)
4248 {
4249 	struct evhttp_connection *evcon;
4250 
4251 	evcon = evhttp_get_request_connection(http, fd, sa, salen);
4252 	if (evcon == NULL) {
4253 		event_sock_warn(fd, "%s: cannot get connection on "EV_SOCK_FMT,
4254 		    __func__, EV_SOCK_ARG(fd));
4255 		evutil_closesocket(fd);
4256 		return;
4257 	}
4258 
4259 	/* the timeout can be used by the server to close idle connections */
4260 	if (evutil_timerisset(&http->timeout))
4261 		evhttp_connection_set_timeout_tv(evcon, &http->timeout);
4262 
4263 	/*
4264 	 * if we want to accept more than one request on a connection,
4265 	 * we need to know which http server it belongs to.
4266 	 */
4267 	evcon->http_server = http;
4268 	TAILQ_INSERT_TAIL(&http->connections, evcon, next);
4269 
4270 	if (evhttp_associate_new_request_with_connection(evcon) == -1)
4271 		evhttp_connection_free(evcon);
4272 }
4273 
4274 
4275 /*
4276  * Network helper functions that we do not want to export to the rest of
4277  * the world.
4278  */
4279 
4280 static void
4281 name_from_addr(struct sockaddr *sa, ev_socklen_t salen,
4282     char **phost, char **pport)
4283 {
4284 	char ntop[NI_MAXHOST];
4285 	char strport[NI_MAXSERV];
4286 	int ni_result;
4287 
4288 #ifdef EVENT__HAVE_GETNAMEINFO
4289 	ni_result = getnameinfo(sa, salen,
4290 		ntop, sizeof(ntop), strport, sizeof(strport),
4291 		NI_NUMERICHOST|NI_NUMERICSERV);
4292 
4293 	if (ni_result != 0) {
4294 #ifdef EAI_SYSTEM
4295 		/* Windows doesn't have an EAI_SYSTEM. */
4296 		if (ni_result == EAI_SYSTEM)
4297 			event_err(1, "getnameinfo failed");
4298 		else
4299 #endif
4300 			event_errx(1, "getnameinfo failed: %s", gai_strerror(ni_result));
4301 		return;
4302 	}
4303 #else
4304 	ni_result = fake_getnameinfo(sa, salen,
4305 		ntop, sizeof(ntop), strport, sizeof(strport),
4306 		NI_NUMERICHOST|NI_NUMERICSERV);
4307 	if (ni_result != 0)
4308 			return;
4309 #endif
4310 
4311 	*phost = mm_strdup(ntop);
4312 	*pport = mm_strdup(strport);
4313 }
4314 
4315 /* Create a non-blocking socket and bind it */
4316 /* todo: rename this function */
4317 static evutil_socket_t
4318 bind_socket_ai(struct evutil_addrinfo *ai, int reuse)
4319 {
4320 	evutil_socket_t fd;
4321 
4322 	int on = 1, r;
4323 	int serrno;
4324 
4325 	/* Create listen socket */
4326 	fd = evutil_socket_(ai ? ai->ai_family : AF_INET,
4327 	    SOCK_STREAM|EVUTIL_SOCK_NONBLOCK|EVUTIL_SOCK_CLOEXEC, 0);
4328 	if (fd == -1) {
4329 			event_sock_warn(-1, "socket");
4330 			return (-1);
4331 	}
4332 
4333 	if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void *)&on, sizeof(on))<0)
4334 		goto out;
4335 	if (reuse) {
4336 		if (evutil_make_listen_socket_reuseable(fd) < 0)
4337 			goto out;
4338 	}
4339 
4340 	if (ai != NULL) {
4341 		r = bind(fd, ai->ai_addr, (ev_socklen_t)ai->ai_addrlen);
4342 		if (r == -1)
4343 			goto out;
4344 	}
4345 
4346 	return (fd);
4347 
4348  out:
4349 	serrno = EVUTIL_SOCKET_ERROR();
4350 	evutil_closesocket(fd);
4351 	EVUTIL_SET_SOCKET_ERROR(serrno);
4352 	return (-1);
4353 }
4354 
4355 static struct evutil_addrinfo *
4356 make_addrinfo(const char *address, ev_uint16_t port)
4357 {
4358 	struct evutil_addrinfo *ai = NULL;
4359 
4360 	struct evutil_addrinfo hints;
4361 	char strport[NI_MAXSERV];
4362 	int ai_result;
4363 
4364 	memset(&hints, 0, sizeof(hints));
4365 	hints.ai_family = AF_UNSPEC;
4366 	hints.ai_socktype = SOCK_STREAM;
4367 	/* turn NULL hostname into INADDR_ANY, and skip looking up any address
4368 	 * types we don't have an interface to connect to. */
4369 	hints.ai_flags = EVUTIL_AI_PASSIVE|EVUTIL_AI_ADDRCONFIG;
4370 	evutil_snprintf(strport, sizeof(strport), "%d", port);
4371 	if ((ai_result = evutil_getaddrinfo(address, strport, &hints, &ai))
4372 	    != 0) {
4373 		if (ai_result == EVUTIL_EAI_SYSTEM)
4374 			event_warn("getaddrinfo");
4375 		else
4376 			event_warnx("getaddrinfo: %s",
4377 			    evutil_gai_strerror(ai_result));
4378 		return (NULL);
4379 	}
4380 
4381 	return (ai);
4382 }
4383 
4384 static evutil_socket_t
4385 bind_socket(const char *address, ev_uint16_t port, int reuse)
4386 {
4387 	evutil_socket_t fd;
4388 	struct evutil_addrinfo *aitop = NULL;
4389 
4390 	/* just create an unbound socket */
4391 	if (address == NULL && port == 0)
4392 		return bind_socket_ai(NULL, 0);
4393 
4394 	aitop = make_addrinfo(address, port);
4395 
4396 	if (aitop == NULL)
4397 		return (-1);
4398 
4399 	fd = bind_socket_ai(aitop, reuse);
4400 
4401 	evutil_freeaddrinfo(aitop);
4402 
4403 	return (fd);
4404 }
4405 
4406 struct evhttp_uri {
4407 	unsigned flags;
4408 	char *scheme; /* scheme; e.g http, ftp etc */
4409 	char *userinfo; /* userinfo (typically username:pass), or NULL */
4410 	char *host; /* hostname, IP address, or NULL */
4411 	int port; /* port, or zero */
4412 	char *path; /* path, or "". */
4413 	char *query; /* query, or NULL */
4414 	char *fragment; /* fragment or NULL */
4415 };
4416 
4417 struct evhttp_uri *
4418 evhttp_uri_new(void)
4419 {
4420 	struct evhttp_uri *uri = mm_calloc(sizeof(struct evhttp_uri), 1);
4421 	if (uri)
4422 		uri->port = -1;
4423 	return uri;
4424 }
4425 
4426 void
4427 evhttp_uri_set_flags(struct evhttp_uri *uri, unsigned flags)
4428 {
4429 	uri->flags = flags;
4430 }
4431 
4432 /* Return true if the string starting at s and ending immediately before eos
4433  * is a valid URI scheme according to RFC3986
4434  */
4435 static int
4436 scheme_ok(const char *s, const char *eos)
4437 {
4438 	/* scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) */
4439 	EVUTIL_ASSERT(eos >= s);
4440 	if (s == eos)
4441 		return 0;
4442 	if (!EVUTIL_ISALPHA_(*s))
4443 		return 0;
4444 	while (++s < eos) {
4445 		if (! EVUTIL_ISALNUM_(*s) &&
4446 		    *s != '+' && *s != '-' && *s != '.')
4447 			return 0;
4448 	}
4449 	return 1;
4450 }
4451 
4452 #define SUBDELIMS "!$&'()*+,;="
4453 
4454 /* Return true iff [s..eos) is a valid userinfo */
4455 static int
4456 userinfo_ok(const char *s, const char *eos)
4457 {
4458 	while (s < eos) {
4459 		if (CHAR_IS_UNRESERVED(*s) ||
4460 		    strchr(SUBDELIMS, *s) ||
4461 		    *s == ':')
4462 			++s;
4463 		else if (*s == '%' && s+2 < eos &&
4464 		    EVUTIL_ISXDIGIT_(s[1]) &&
4465 		    EVUTIL_ISXDIGIT_(s[2]))
4466 			s += 3;
4467 		else
4468 			return 0;
4469 	}
4470 	return 1;
4471 }
4472 
4473 static int
4474 regname_ok(const char *s, const char *eos)
4475 {
4476 	while (s && s<eos) {
4477 		if (CHAR_IS_UNRESERVED(*s) ||
4478 		    strchr(SUBDELIMS, *s))
4479 			++s;
4480 		else if (*s == '%' &&
4481 		    EVUTIL_ISXDIGIT_(s[1]) &&
4482 		    EVUTIL_ISXDIGIT_(s[2]))
4483 			s += 3;
4484 		else
4485 			return 0;
4486 	}
4487 	return 1;
4488 }
4489 
4490 static int
4491 parse_port(const char *s, const char *eos)
4492 {
4493 	int portnum = 0;
4494 	while (s < eos) {
4495 		if (! EVUTIL_ISDIGIT_(*s))
4496 			return -1;
4497 		portnum = (portnum * 10) + (*s - '0');
4498 		if (portnum < 0)
4499 			return -1;
4500 		if (portnum > 65535)
4501 			return -1;
4502 		++s;
4503 	}
4504 	return portnum;
4505 }
4506 
4507 /* returns 0 for bad, 1 for ipv6, 2 for IPvFuture */
4508 static int
4509 bracket_addr_ok(const char *s, const char *eos)
4510 {
4511 	if (s + 3 > eos || *s != '[' || *(eos-1) != ']')
4512 		return 0;
4513 	if (s[1] == 'v') {
4514 		/* IPvFuture, or junk.
4515 		   "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" )
4516 		 */
4517 		s += 2; /* skip [v */
4518 		--eos;
4519 		if (!EVUTIL_ISXDIGIT_(*s)) /*require at least one*/
4520 			return 0;
4521 		while (s < eos && *s != '.') {
4522 			if (EVUTIL_ISXDIGIT_(*s))
4523 				++s;
4524 			else
4525 				return 0;
4526 		}
4527 		if (*s != '.')
4528 			return 0;
4529 		++s;
4530 		while (s < eos) {
4531 			if (CHAR_IS_UNRESERVED(*s) ||
4532 			    strchr(SUBDELIMS, *s) ||
4533 			    *s == ':')
4534 				++s;
4535 			else
4536 				return 0;
4537 		}
4538 		return 2;
4539 	} else {
4540 		/* IPv6, or junk */
4541 		char buf[64];
4542 		ev_ssize_t n_chars = eos-s-2;
4543 		struct in6_addr in6;
4544 		if (n_chars >= 64) /* way too long */
4545 			return 0;
4546 		memcpy(buf, s+1, n_chars);
4547 		buf[n_chars]='\0';
4548 		return (evutil_inet_pton(AF_INET6,buf,&in6)==1) ? 1 : 0;
4549 	}
4550 }
4551 
4552 static int
4553 parse_authority(struct evhttp_uri *uri, char *s, char *eos)
4554 {
4555 	char *cp, *port;
4556 	EVUTIL_ASSERT(eos);
4557 	if (eos == s) {
4558 		uri->host = mm_strdup("");
4559 		if (uri->host == NULL) {
4560 			event_warn("%s: strdup", __func__);
4561 			return -1;
4562 		}
4563 		return 0;
4564 	}
4565 
4566 	/* Optionally, we start with "userinfo@" */
4567 
4568 	cp = strchr(s, '@');
4569 	if (cp && cp < eos) {
4570 		if (! userinfo_ok(s,cp))
4571 			return -1;
4572 		*cp++ = '\0';
4573 		uri->userinfo = mm_strdup(s);
4574 		if (uri->userinfo == NULL) {
4575 			event_warn("%s: strdup", __func__);
4576 			return -1;
4577 		}
4578 	} else {
4579 		cp = s;
4580 	}
4581 	/* Optionally, we end with ":port" */
4582 	for (port=eos-1; port >= cp && EVUTIL_ISDIGIT_(*port); --port)
4583 		;
4584 	if (port >= cp && *port == ':') {
4585 		if (port+1 == eos) /* Leave port unspecified; the RFC allows a
4586 				    * nil port */
4587 			uri->port = -1;
4588 		else if ((uri->port = parse_port(port+1, eos))<0)
4589 			return -1;
4590 		eos = port;
4591 	}
4592 	/* Now, cp..eos holds the "host" port, which can be an IPv4Address,
4593 	 * an IP-Literal, or a reg-name */
4594 	EVUTIL_ASSERT(eos >= cp);
4595 	if (*cp == '[' && eos >= cp+2 && *(eos-1) == ']') {
4596 		/* IPv6address, IP-Literal, or junk. */
4597 		if (! bracket_addr_ok(cp, eos))
4598 			return -1;
4599 	} else {
4600 		/* Make sure the host part is ok. */
4601 		if (! regname_ok(cp,eos)) /* Match IPv4Address or reg-name */
4602 			return -1;
4603 	}
4604 	uri->host = mm_malloc(eos-cp+1);
4605 	if (uri->host == NULL) {
4606 		event_warn("%s: malloc", __func__);
4607 		return -1;
4608 	}
4609 	memcpy(uri->host, cp, eos-cp);
4610 	uri->host[eos-cp] = '\0';
4611 	return 0;
4612 
4613 }
4614 
4615 static char *
4616 end_of_authority(char *cp)
4617 {
4618 	while (*cp) {
4619 		if (*cp == '?' || *cp == '#' || *cp == '/')
4620 			return cp;
4621 		++cp;
4622 	}
4623 	return cp;
4624 }
4625 
4626 enum uri_part {
4627 	PART_PATH,
4628 	PART_QUERY,
4629 	PART_FRAGMENT
4630 };
4631 
4632 /* Return the character after the longest prefix of 'cp' that matches...
4633  *   *pchar / "/" if allow_qchars is false, or
4634  *   *(pchar / "/" / "?") if allow_qchars is true.
4635  */
4636 static char *
4637 end_of_path(char *cp, enum uri_part part, unsigned flags)
4638 {
4639 	if (flags & EVHTTP_URI_NONCONFORMANT) {
4640 		/* If NONCONFORMANT:
4641 		 *   Path is everything up to a # or ? or nul.
4642 		 *   Query is everything up a # or nul
4643 		 *   Fragment is everything up to a nul.
4644 		 */
4645 		switch (part) {
4646 		case PART_PATH:
4647 			while (*cp && *cp != '#' && *cp != '?')
4648 				++cp;
4649 			break;
4650 		case PART_QUERY:
4651 			while (*cp && *cp != '#')
4652 				++cp;
4653 			break;
4654 		case PART_FRAGMENT:
4655 			cp += strlen(cp);
4656 			break;
4657 		};
4658 		return cp;
4659 	}
4660 
4661 	while (*cp) {
4662 		if (CHAR_IS_UNRESERVED(*cp) ||
4663 		    strchr(SUBDELIMS, *cp) ||
4664 		    *cp == ':' || *cp == '@' || *cp == '/')
4665 			++cp;
4666 		else if (*cp == '%' && EVUTIL_ISXDIGIT_(cp[1]) &&
4667 		    EVUTIL_ISXDIGIT_(cp[2]))
4668 			cp += 3;
4669 		else if (*cp == '?' && part != PART_PATH)
4670 			++cp;
4671 		else
4672 			return cp;
4673 	}
4674 	return cp;
4675 }
4676 
4677 static int
4678 path_matches_noscheme(const char *cp)
4679 {
4680 	while (*cp) {
4681 		if (*cp == ':')
4682 			return 0;
4683 		else if (*cp == '/')
4684 			return 1;
4685 		++cp;
4686 	}
4687 	return 1;
4688 }
4689 
4690 struct evhttp_uri *
4691 evhttp_uri_parse(const char *source_uri)
4692 {
4693 	return evhttp_uri_parse_with_flags(source_uri, 0);
4694 }
4695 
4696 struct evhttp_uri *
4697 evhttp_uri_parse_with_flags(const char *source_uri, unsigned flags)
4698 {
4699 	char *readbuf = NULL, *readp = NULL, *token = NULL, *query = NULL;
4700 	char *path = NULL, *fragment = NULL;
4701 	int got_authority = 0;
4702 
4703 	struct evhttp_uri *uri = mm_calloc(1, sizeof(struct evhttp_uri));
4704 	if (uri == NULL) {
4705 		event_warn("%s: calloc", __func__);
4706 		goto err;
4707 	}
4708 	uri->port = -1;
4709 	uri->flags = flags;
4710 
4711 	readbuf = mm_strdup(source_uri);
4712 	if (readbuf == NULL) {
4713 		event_warn("%s: strdup", __func__);
4714 		goto err;
4715 	}
4716 
4717 	readp = readbuf;
4718 	token = NULL;
4719 
4720 	/* We try to follow RFC3986 here as much as we can, and match
4721 	   the productions
4722 
4723 	      URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
4724 
4725 	      relative-ref  = relative-part [ "?" query ] [ "#" fragment ]
4726 	 */
4727 
4728 	/* 1. scheme: */
4729 	token = strchr(readp, ':');
4730 	if (token && scheme_ok(readp,token)) {
4731 		*token = '\0';
4732 		uri->scheme = mm_strdup(readp);
4733 		if (uri->scheme == NULL) {
4734 			event_warn("%s: strdup", __func__);
4735 			goto err;
4736 		}
4737 		readp = token+1; /* eat : */
4738 	}
4739 
4740 	/* 2. Optionally, "//" then an 'authority' part. */
4741 	if (readp[0]=='/' && readp[1] == '/') {
4742 		char *authority;
4743 		readp += 2;
4744 		authority = readp;
4745 		path = end_of_authority(readp);
4746 		if (parse_authority(uri, authority, path) < 0)
4747 			goto err;
4748 		readp = path;
4749 		got_authority = 1;
4750 	}
4751 
4752 	/* 3. Query: path-abempty, path-absolute, path-rootless, or path-empty
4753 	 */
4754 	path = readp;
4755 	readp = end_of_path(path, PART_PATH, flags);
4756 
4757 	/* Query */
4758 	if (*readp == '?') {
4759 		*readp = '\0';
4760 		++readp;
4761 		query = readp;
4762 		readp = end_of_path(readp, PART_QUERY, flags);
4763 	}
4764 	/* fragment */
4765 	if (*readp == '#') {
4766 		*readp = '\0';
4767 		++readp;
4768 		fragment = readp;
4769 		readp = end_of_path(readp, PART_FRAGMENT, flags);
4770 	}
4771 	if (*readp != '\0') {
4772 		goto err;
4773 	}
4774 
4775 	/* These next two cases may be unreachable; I'm leaving them
4776 	 * in to be defensive. */
4777 	/* If you didn't get an authority, the path can't begin with "//" */
4778 	if (!got_authority && path[0]=='/' && path[1]=='/')
4779 		goto err;
4780 	/* If you did get an authority, the path must begin with "/" or be
4781 	 * empty. */
4782 	if (got_authority && path[0] != '/' && path[0] != '\0')
4783 		goto err;
4784 	/* (End of maybe-unreachable cases) */
4785 
4786 	/* If there was no scheme, the first part of the path (if any) must
4787 	 * have no colon in it. */
4788 	if (! uri->scheme && !path_matches_noscheme(path))
4789 		goto err;
4790 
4791 	EVUTIL_ASSERT(path);
4792 	uri->path = mm_strdup(path);
4793 	if (uri->path == NULL) {
4794 		event_warn("%s: strdup", __func__);
4795 		goto err;
4796 	}
4797 
4798 	if (query) {
4799 		uri->query = mm_strdup(query);
4800 		if (uri->query == NULL) {
4801 			event_warn("%s: strdup", __func__);
4802 			goto err;
4803 		}
4804 	}
4805 	if (fragment) {
4806 		uri->fragment = mm_strdup(fragment);
4807 		if (uri->fragment == NULL) {
4808 			event_warn("%s: strdup", __func__);
4809 			goto err;
4810 		}
4811 	}
4812 
4813 	mm_free(readbuf);
4814 
4815 	return uri;
4816 err:
4817 	if (uri)
4818 		evhttp_uri_free(uri);
4819 	if (readbuf)
4820 		mm_free(readbuf);
4821 	return NULL;
4822 }
4823 
4824 void
4825 evhttp_uri_free(struct evhttp_uri *uri)
4826 {
4827 #define URI_FREE_STR_(f)		\
4828 	if (uri->f) {			\
4829 		mm_free(uri->f);		\
4830 	}
4831 
4832 	URI_FREE_STR_(scheme);
4833 	URI_FREE_STR_(userinfo);
4834 	URI_FREE_STR_(host);
4835 	URI_FREE_STR_(path);
4836 	URI_FREE_STR_(query);
4837 	URI_FREE_STR_(fragment);
4838 
4839 	mm_free(uri);
4840 #undef URI_FREE_STR_
4841 }
4842 
4843 char *
4844 evhttp_uri_join(struct evhttp_uri *uri, char *buf, size_t limit)
4845 {
4846 	struct evbuffer *tmp = 0;
4847 	size_t joined_size = 0;
4848 	char *output = NULL;
4849 
4850 #define URI_ADD_(f)	evbuffer_add(tmp, uri->f, strlen(uri->f))
4851 
4852 	if (!uri || !buf || !limit)
4853 		return NULL;
4854 
4855 	tmp = evbuffer_new();
4856 	if (!tmp)
4857 		return NULL;
4858 
4859 	if (uri->scheme) {
4860 		URI_ADD_(scheme);
4861 		evbuffer_add(tmp, ":", 1);
4862 	}
4863 	if (uri->host) {
4864 		evbuffer_add(tmp, "//", 2);
4865 		if (uri->userinfo)
4866 			evbuffer_add_printf(tmp,"%s@", uri->userinfo);
4867 		URI_ADD_(host);
4868 		if (uri->port >= 0)
4869 			evbuffer_add_printf(tmp,":%d", uri->port);
4870 
4871 		if (uri->path && uri->path[0] != '/' && uri->path[0] != '\0')
4872 			goto err;
4873 	}
4874 
4875 	if (uri->path)
4876 		URI_ADD_(path);
4877 
4878 	if (uri->query) {
4879 		evbuffer_add(tmp, "?", 1);
4880 		URI_ADD_(query);
4881 	}
4882 
4883 	if (uri->fragment) {
4884 		evbuffer_add(tmp, "#", 1);
4885 		URI_ADD_(fragment);
4886 	}
4887 
4888 	evbuffer_add(tmp, "\0", 1); /* NUL */
4889 
4890 	joined_size = evbuffer_get_length(tmp);
4891 
4892 	if (joined_size > limit) {
4893 		/* It doesn't fit. */
4894 		evbuffer_free(tmp);
4895 		return NULL;
4896 	}
4897        	evbuffer_remove(tmp, buf, joined_size);
4898 
4899 	output = buf;
4900 err:
4901 	evbuffer_free(tmp);
4902 
4903 	return output;
4904 #undef URI_ADD_
4905 }
4906 
4907 const char *
4908 evhttp_uri_get_scheme(const struct evhttp_uri *uri)
4909 {
4910 	return uri->scheme;
4911 }
4912 const char *
4913 evhttp_uri_get_userinfo(const struct evhttp_uri *uri)
4914 {
4915 	return uri->userinfo;
4916 }
4917 const char *
4918 evhttp_uri_get_host(const struct evhttp_uri *uri)
4919 {
4920 	return uri->host;
4921 }
4922 int
4923 evhttp_uri_get_port(const struct evhttp_uri *uri)
4924 {
4925 	return uri->port;
4926 }
4927 const char *
4928 evhttp_uri_get_path(const struct evhttp_uri *uri)
4929 {
4930 	return uri->path;
4931 }
4932 const char *
4933 evhttp_uri_get_query(const struct evhttp_uri *uri)
4934 {
4935 	return uri->query;
4936 }
4937 const char *
4938 evhttp_uri_get_fragment(const struct evhttp_uri *uri)
4939 {
4940 	return uri->fragment;
4941 }
4942 
4943 #define URI_SET_STR_(f) do {					\
4944 	if (uri->f)						\
4945 		mm_free(uri->f);				\
4946 	if (f) {						\
4947 		if ((uri->f = mm_strdup(f)) == NULL) {		\
4948 			event_warn("%s: strdup()", __func__);	\
4949 			return -1;				\
4950 		}						\
4951 	} else {						\
4952 		uri->f = NULL;					\
4953 	}							\
4954 	} while(0)
4955 
4956 int
4957 evhttp_uri_set_scheme(struct evhttp_uri *uri, const char *scheme)
4958 {
4959 	if (scheme && !scheme_ok(scheme, scheme+strlen(scheme)))
4960 		return -1;
4961 
4962 	URI_SET_STR_(scheme);
4963 	return 0;
4964 }
4965 int
4966 evhttp_uri_set_userinfo(struct evhttp_uri *uri, const char *userinfo)
4967 {
4968 	if (userinfo && !userinfo_ok(userinfo, userinfo+strlen(userinfo)))
4969 		return -1;
4970 	URI_SET_STR_(userinfo);
4971 	return 0;
4972 }
4973 int
4974 evhttp_uri_set_host(struct evhttp_uri *uri, const char *host)
4975 {
4976 	if (host) {
4977 		if (host[0] == '[') {
4978 			if (! bracket_addr_ok(host, host+strlen(host)))
4979 				return -1;
4980 		} else {
4981 			if (! regname_ok(host, host+strlen(host)))
4982 				return -1;
4983 		}
4984 	}
4985 
4986 	URI_SET_STR_(host);
4987 	return 0;
4988 }
4989 int
4990 evhttp_uri_set_port(struct evhttp_uri *uri, int port)
4991 {
4992 	if (port < -1)
4993 		return -1;
4994 	uri->port = port;
4995 	return 0;
4996 }
4997 #define end_of_cpath(cp,p,f) \
4998 	((const char*)(end_of_path(((char*)(cp)), (p), (f))))
4999 
5000 int
5001 evhttp_uri_set_path(struct evhttp_uri *uri, const char *path)
5002 {
5003 	if (path && end_of_cpath(path, PART_PATH, uri->flags) != path+strlen(path))
5004 		return -1;
5005 
5006 	URI_SET_STR_(path);
5007 	return 0;
5008 }
5009 int
5010 evhttp_uri_set_query(struct evhttp_uri *uri, const char *query)
5011 {
5012 	if (query && end_of_cpath(query, PART_QUERY, uri->flags) != query+strlen(query))
5013 		return -1;
5014 	URI_SET_STR_(query);
5015 	return 0;
5016 }
5017 int
5018 evhttp_uri_set_fragment(struct evhttp_uri *uri, const char *fragment)
5019 {
5020 	if (fragment && end_of_cpath(fragment, PART_FRAGMENT, uri->flags) != fragment+strlen(fragment))
5021 		return -1;
5022 	URI_SET_STR_(fragment);
5023 	return 0;
5024 }
5025