granicus.if.org Git - libevent/blob - http.c

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