root/opal/mca/event/libevent2022/libevent/http.c

DEFINITIONS

1. fake_getnameinfo
2. strsep
3. html_replace
4. evhttp_htmlescape
5. evhttp_method
6. evhttp_response_needs_body
7. evhttp_add_event
8. evhttp_write_buffer
9. evhttp_send_continue_done
10. evhttp_send_continue
11. evhttp_connected
12. evhttp_make_header_request
13. evhttp_is_connection_close
14. evhttp_is_connection_keepalive
15. evhttp_maybe_add_date_header
16. evhttp_maybe_add_content_length_header
17. evhttp_make_header_response
18. evhttp_make_header
19. evhttp_connection_set_max_headers_size
20. evhttp_connection_set_max_body_size
21. evhttp_connection_incoming_fail
22. evhttp_connection_fail
23. evhttp_write_cb
24. evhttp_connection_done
25. evhttp_handle_chunked_read
26. evhttp_read_trailer
27. evhttp_read_body
28. evhttp_read_cb
29. evhttp_deferred_read_cb
30. evhttp_write_connectioncb
31. evhttp_connection_free
32. evhttp_connection_set_local_address
33. evhttp_connection_set_local_port
34. evhttp_request_dispatch
35. evhttp_connection_reset
36. evhttp_connection_start_detectclose
37. evhttp_connection_stop_detectclose
38. evhttp_connection_retry
39. evhttp_connection_cb_cleanup
40. evhttp_error_cb
41. evhttp_connection_cb
42. evhttp_valid_response_code
43. evhttp_parse_http_version
44. evhttp_parse_response_line
45. evhttp_parse_request_line
46. evhttp_find_header
47. evhttp_clear_headers
48. evhttp_remove_header
49. evhttp_header_is_valid_value
50. evhttp_add_header
51. evhttp_add_header_internal
52. evhttp_parse_firstline
53. evhttp_append_to_last_header
54. evhttp_parse_headers
55. evhttp_get_body_length
56. evhttp_method_may_have_body
57. evhttp_get_body
58. evhttp_read_firstline
59. evhttp_read_header
60. evhttp_connection_new
61. evhttp_connection_base_new
62. evhttp_connection_get_bufferevent
63. evhttp_connection_set_base
64. evhttp_connection_set_timeout
65. evhttp_connection_set_retries
66. evhttp_connection_set_closecb
67. evhttp_connection_get_peer
68. evhttp_connection_connect
69. evhttp_make_request
70. evhttp_cancel_request
71. evhttp_start_read
72. evhttp_send_done
73. evhttp_send_error
74. evhttp_send
75. evhttp_send_reply
76. evhttp_send_reply_start
77. evhttp_send_reply_chunk
78. evhttp_send_reply_end
79. evhttp_response_phrase_internal
80. evhttp_response_code
81. evhttp_send_page
82. evhttp_uriencode
83. evhttp_encode_uri
84. evhttp_decode_uri_internal
85. evhttp_decode_uri
86. evhttp_uridecode
87. evhttp_parse_query_impl
88. evhttp_parse_query
89. evhttp_parse_query_str
90. evhttp_dispatch_callback
91. prefix_suffix_match
92. evhttp_find_alias
93. evhttp_find_vhost
94. evhttp_handle_request
95. accept_socket_cb
96. evhttp_bind_socket
97. evhttp_bind_socket_with_handle
98. evhttp_accept_socket
99. evhttp_accept_socket_with_handle
100. evhttp_bind_listener
101. evhttp_bound_socket_get_fd
102. evhttp_bound_socket_get_listener
103. evhttp_del_accept_socket
104. evhttp_new_object
105. evhttp_new
106. evhttp_start
107. evhttp_free
108. evhttp_add_virtual_host
109. evhttp_remove_virtual_host
110. evhttp_add_server_alias
111. evhttp_remove_server_alias
112. evhttp_set_timeout
113. evhttp_set_max_headers_size
114. evhttp_set_max_body_size
115. evhttp_set_allowed_methods
116. evhttp_set_cb
117. evhttp_del_cb
118. evhttp_set_gencb
119. evhttp_request_new
120. evhttp_request_free
121. evhttp_request_own
122. evhttp_request_is_owned
123. evhttp_request_get_connection
124. evhttp_connection_get_base
125. evhttp_request_set_chunked_cb
126. evhttp_request_get_uri
127. evhttp_request_get_evhttp_uri
128. evhttp_request_get_host
129. evhttp_request_get_command
130. evhttp_request_get_response_code
131. evhttp_request_get_input_headers
132. evhttp_request_get_output_headers
133. evhttp_request_get_input_buffer
134. evhttp_request_get_output_buffer
135. evhttp_get_request_connection
136. evhttp_associate_new_request_with_connection
137. evhttp_get_request
138. name_from_addr
139. bind_socket_ai
140. make_addrinfo
141. bind_socket
142. evhttp_uri_new
143. evhttp_uri_set_flags
144. scheme_ok
145. userinfo_ok
146. regname_ok
147. parse_port
148. bracket_addr_ok
149. parse_authority
150. end_of_authority
151. end_of_path
152. path_matches_noscheme
153. evhttp_uri_parse
154. evhttp_uri_parse_with_flags
155. evhttp_uri_free
156. evhttp_uri_join
157. evhttp_uri_get_scheme
158. evhttp_uri_get_userinfo
159. evhttp_uri_get_host
160. evhttp_uri_get_port
161. evhttp_uri_get_path
162. evhttp_uri_get_query
163. evhttp_uri_get_fragment
164. evhttp_uri_set_scheme
165. evhttp_uri_set_userinfo
166. evhttp_uri_set_host
167. evhttp_uri_set_port
168. evhttp_uri_set_path
169. evhttp_uri_set_query
170. evhttp_uri_set_fragment

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