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