posix: upgrade libevent from 1.4.7 to 1.4.13

third_party/libevent/http.c

 /*
  * Copyright (c) 2002-2006 Niels Provos <provos@citi.umich.edu>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 70 matching lines @@
 
 #undef timeout_pending
 #undef timeout_initialized
 
 #include "strlcpy-internal.h"
 #include "event.h"
 #include "evhttp.h"
 #include "evutil.h"
 #include "log.h"
 #include "http-internal.h"
-#include "event-internal.h"
 
 #ifdef WIN32
 #define strcasecmp _stricmp
 #define strncasecmp _strnicmp
 #define strdup _strdup
 #endif
 
 #ifndef HAVE_GETNAMEINFO
 #define NI_MAXSERV 32
 #define NI_MAXHOST 1025
 
 #define NI_NUMERICHOST 1
 #define NI_NUMERICSERV 2
 
-int
+static int
 fake_getnameinfo(const struct sockaddr *sa, size_t salen, char *host, 
         size_t hostlen, char *serv, size_t servlen, int flags)
 {
         struct sockaddr_in *sin = (struct sockaddr_in *)sa;
         
         if (serv != NULL) {
                                 char tmpserv[16];
                                 evutil_snprintf(tmpserv, sizeof(tmpserv),
                                         "%d", ntohs(sin->sin_port));
                 if (strlcpy(serv, tmpserv, servlen) >= servlen)
@@ skipping 88 matching lines @@
         struct evhttp_connection *evcon);
 static void evhttp_connection_start_detectclose(
         struct evhttp_connection *evcon);
 static void evhttp_connection_stop_detectclose(
         struct evhttp_connection *evcon);
 static void evhttp_request_dispatch(struct evhttp_connection* evcon);
 static void evhttp_read_firstline(struct evhttp_connection *evcon,
                                   struct evhttp_request *req);
 static void evhttp_read_header(struct evhttp_connection *evcon,
     struct evhttp_request *req);
+static int evhttp_add_header_internal(struct evkeyvalq *headers,
+    const char *key, const char *value);
+static int evhttp_decode_uri_internal(const char *uri, size_t length,
+    char *ret, int always_decode_plus);
 
 void evhttp_read(int, short, void *);
 void evhttp_write(int, short, void *);
 
 #ifndef HAVE_STRSEP
 /* strsep replacement for platforms that lack it.  Only works if
  * del is one character long. */
 static char *
 strsep(char **s, const char *del)
 {
@@ skipping 137 matching lines @@
         case EVCON_READING_HEADERS:
         case EVCON_READING_BODY:
         case EVCON_READING_TRAILER:
         case EVCON_WRITING:
         default:
                 return (1);
         }
 }
 
 /*
- * Create the headers need for an HTTP request
+ * Create the headers needed for an HTTP request
  */
 static void
 evhttp_make_header_request(struct evhttp_connection *evcon,
     struct evhttp_request *req)
 {
-        char line[1024];
         const char *method;
         
-        evhttp_remove_header(req->output_headers, "Accept-Encoding");
         evhttp_remove_header(req->output_headers, "Proxy-Connection");
 
         /* Generate request line */
         method = evhttp_method(req->type);
-        evutil_snprintf(line, sizeof(line), "%s %s HTTP/%d.%d\r\n",
+        evbuffer_add_printf(evcon->output_buffer, "%s %s HTTP/%d.%d\r\n",
             method, req->uri, req->major, req->minor);
-        evbuffer_add(evcon->output_buffer, line, strlen(line));
 
         /* Add the content length on a post request if missing */
         if (req->type == EVHTTP_REQ_POST &&
             evhttp_find_header(req->output_headers, "Content-Length") == NULL){
                 char size[12];
                 evutil_snprintf(size, sizeof(size), "%ld",
                     (long)EVBUFFER_LENGTH(req->output_buffer));
                 evhttp_add_header(req->output_headers, "Content-Length", size);
         }
 }
@@ skipping 56 matching lines @@
 
 /*
  * Create the headers needed for an HTTP reply
  */
 
 static void
 evhttp_make_header_response(struct evhttp_connection *evcon,
     struct evhttp_request *req)
 {
         int is_keepalive = evhttp_is_connection_keepalive(req->input_headers);
-        char line[1024];
-        evutil_snprintf(line, sizeof(line), "HTTP/%d.%d %d %s\r\n",
+        evbuffer_add_printf(evcon->output_buffer, "HTTP/%d.%d %d %s\r\n",
             req->major, req->minor, req->response_code,
             req->response_code_line);
-        evbuffer_add(evcon->output_buffer, line, strlen(line));
 
         if (req->major == 1) {
                 if (req->minor == 1)
                         evhttp_maybe_add_date_header(req->output_headers);
 
                 /*
                  * if the protocol is 1.0; and the connection was keep-alive
                  * we need to add a keep-alive header, too.
                  */
                 if (req->minor == 0 && is_keepalive)
@@ skipping 26 matching lines @@
                 evhttp_remove_header(req->output_headers, "Connection");
                 if (!(req->flags & EVHTTP_PROXY_REQUEST))
                     evhttp_add_header(req->output_headers, "Connection", "close");
                 evhttp_remove_header(req->output_headers, "Proxy-Connection");
         }
 }
 
 void
 evhttp_make_header(struct evhttp_connection *evcon, struct evhttp_request *req)
 {
-        char line[1024];
         struct evkeyval *header;
 
         /*
          * Depending if this is a HTTP request or response, we might need to
          * add some new headers or remove existing headers.
          */
         if (req->kind == EVHTTP_REQUEST) {
                 evhttp_make_header_request(evcon, req);
         } else {
                 evhttp_make_header_response(evcon, req);
         }
 
         TAILQ_FOREACH(header, req->output_headers, next) {
-                evutil_snprintf(line, sizeof(line), "%s: %s\r\n",
+                evbuffer_add_printf(evcon->output_buffer, "%s: %s\r\n",
                     header->key, header->value);
-                evbuffer_add(evcon->output_buffer, line, strlen(line));
         }
         evbuffer_add(evcon->output_buffer, "\r\n", 2);
 
         if (EVBUFFER_LENGTH(req->output_buffer) > 0) {
                 /*
                  * For a request, we add the POST data, for a reply, this
                  * is the regular data.
                  */
                 evbuffer_add_buffer(evcon->output_buffer, req->output_buffer);
         }
@@ skipping 276 matching lines @@
                         }
                         continue;
                 }
 
                 /* don't have enough to complete a chunk; wait for more */
                 if (len < req->ntoread)
                         return (MORE_DATA_EXPECTED);
 
                 /* Completed chunk */
                 evbuffer_add(req->input_buffer,
-                    EVBUFFER_DATA(buf), req->ntoread);
-                evbuffer_drain(buf, req->ntoread);
+                    EVBUFFER_DATA(buf), (size_t)req->ntoread);
+                evbuffer_drain(buf, (size_t)req->ntoread);
                 req->ntoread = -1;
                 if (req->chunk_cb != NULL) {
                         (*req->chunk_cb)(req, req->cb_arg);
                         evbuffer_drain(req->input_buffer,
                             EVBUFFER_LENGTH(req->input_buffer));
                 }
         }
 
         return (MORE_DATA_EXPECTED);
 }
@@ skipping 43 matching lines @@
                 case MORE_DATA_EXPECTED:
                 default:
                         break;
                 }
         } else if (req->ntoread < 0) {
                 /* Read until connection close. */
                 evbuffer_add_buffer(req->input_buffer, buf);
         } else if (EVBUFFER_LENGTH(buf) >= req->ntoread) {
                 /* Completed content length */
                 evbuffer_add(req->input_buffer, EVBUFFER_DATA(buf),
-                    req->ntoread);
-                evbuffer_drain(buf, req->ntoread);
+                    (size_t)req->ntoread);
+                evbuffer_drain(buf, (size_t)req->ntoread);
                 req->ntoread = 0;
                 evhttp_connection_done(evcon);
                 return;
         }
         /* Read more! */
         event_set(&evcon->ev, evcon->fd, EV_READ, evhttp_read, evcon);
         EVHTTP_BASE_SET(evcon, &evcon->ev);
         evhttp_add_event(&evcon->ev, evcon->timeout, HTTP_READ_TIMEOUT);
 }
 
@@ skipping 127 matching lines @@
 evhttp_connection_set_local_address(struct evhttp_connection *evcon,
     const char *address)
 {
         assert(evcon->state == EVCON_DISCONNECTED);
         if (evcon->bind_address)
                 free(evcon->bind_address);
         if ((evcon->bind_address = strdup(address)) == NULL)
                 event_err(1, "%s: strdup", __func__);
 }
 
+void
+evhttp_connection_set_local_port(struct evhttp_connection *evcon,
+    unsigned short port)
+{
+        assert(evcon->state == EVCON_DISCONNECTED);
+        evcon->bind_port = port;
+}
 
 static void
 evhttp_request_dispatch(struct evhttp_connection* evcon)
 {
         struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
         
         /* this should not usually happy but it's possible */
         if (req == NULL)
                 return;
 
@@ skipping 20 matching lines @@
 
         if (evcon->fd != -1) {
                 /* inform interested parties about connection close */
                 if (evhttp_connected(evcon) && evcon->closecb != NULL)
                         (*evcon->closecb)(evcon, evcon->closecb_arg);
 
                 EVUTIL_CLOSESOCKET(evcon->fd);
                 evcon->fd = -1;
         }
         evcon->state = EVCON_DISCONNECTED;
+
+        evbuffer_drain(evcon->input_buffer,
+            EVBUFFER_LENGTH(evcon->input_buffer));
+        evbuffer_drain(evcon->output_buffer,
+            EVBUFFER_LENGTH(evcon->output_buffer));
 }
 
 static void
 evhttp_detect_close_cb(int fd, short what, void *arg)
 {
         struct evhttp_connection *evcon = arg;
         evhttp_connection_reset(evcon);
 }
 
 static void
@@ skipping 252 matching lines @@
 
         /* Free and remove the header that we found */
         TAILQ_REMOVE(headers, header, next);
         free(header->key);
         free(header->value);
         free(header);
 
         return (0);
 }
 
+static int
+evhttp_header_is_valid_value(const char *value)
+{
+        const char *p = value;
+
+        while ((p = strpbrk(p, "\r\n")) != NULL) {
+                /* we really expect only one new line */
+                p += strspn(p, "\r\n");
+                /* we expect a space or tab for continuation */
+                if (*p != ' ' && *p != '\t')
+                        return (0);
+        }
+        return (1);
+}
+
 int
 evhttp_add_header(struct evkeyvalq *headers,
     const char *key, const char *value)
 {
-        struct evkeyval *header = NULL;
-
         event_debug(("%s: key: %s val: %s\n", __func__, key, value));
 
-        if (strchr(value, '\r') != NULL || strchr(value, '\n') != NULL ||
-            strchr(key, '\r') != NULL || strchr(key, '\n') != NULL) {
+        if (strchr(key, '\r') != NULL || strchr(key, '\n') != NULL) {
                 /* drop illegal headers */
-                event_debug(("%s: dropping illegal header\n", __func__));
+                event_debug(("%s: dropping illegal header key\n", __func__));
+                return (-1);
+        }
+        
+        if (!evhttp_header_is_valid_value(value)) {
+                event_debug(("%s: dropping illegal header value\n", __func__));
                 return (-1);
         }
 
-        header = calloc(1, sizeof(struct evkeyval));
+        return (evhttp_add_header_internal(headers, key, value));
+}
+
+static int
+evhttp_add_header_internal(struct evkeyvalq *headers,
+    const char *key, const char *value)
+{
+        struct evkeyval *header = calloc(1, sizeof(struct evkeyval));
         if (header == NULL) {
                 event_warn("%s: calloc", __func__);
                 return (-1);
         }
         if ((header->key = strdup(key)) == NULL) {
                 free(header);
                 event_warn("%s: strdup", __func__);
                 return (-1);
         }
         if ((header->value = strdup(value)) == NULL) {
@@ skipping 82 matching lines @@
                 if (*line == '\0') { /* Last header - Done */
                         status = ALL_DATA_READ;
                         free(line);
                         break;
                 }
 
                 /* Check if this is a continuation line */
                 if (*line == ' ' || *line == '\t') {
                         if (evhttp_append_to_last_header(headers, line) == -1)
                                 goto error;
+                        free(line);
                         continue;
                 }
 
                 /* Processing of header lines */
                 svalue = line;
                 skey = strsep(&svalue, ":");
                 if (svalue == NULL)
                         goto error;
 
                 svalue += strspn(svalue, " ");
@@ skipping 243 matching lines @@
 evhttp_connection_connect(struct evhttp_connection *evcon)
 {
         if (evcon->state == EVCON_CONNECTING)
                 return (0);
         
         evhttp_connection_reset(evcon);
 
         assert(!(evcon->flags & EVHTTP_CON_INCOMING));
         evcon->flags |= EVHTTP_CON_OUTGOING;
         
-        evcon->fd = bind_socket(evcon->bind_address, 0 /*port*/, 0 /*reuse*/);
+        evcon->fd = bind_socket(
+                evcon->bind_address, evcon->bind_port, 0 /*reuse*/);
         if (evcon->fd == -1) {
                 event_debug(("%s: failed to bind to \"%s\"",
                         __func__, evcon->bind_address));
                 return (-1);
         }
 
         if (socket_connect(evcon->fd, evcon->address, evcon->port) == -1) {
                 EVUTIL_CLOSESOCKET(evcon->fd); evcon->fd = -1;
                 return (-1);
         }
@@ skipping 146 matching lines @@
         /* Adds headers to the response */
         evhttp_make_header(evcon, req);
 
         evhttp_write_buffer(evcon, evhttp_send_done, NULL);
 }
 
 void
 evhttp_send_reply(struct evhttp_request *req, int code, const char *reason,
     struct evbuffer *databuf)
 {
-        /* set up to watch for client close */
-        evhttp_connection_start_detectclose(req->evcon);
         evhttp_response_code(req, code, reason);
         
         evhttp_send(req, databuf);
 }
 
 void
 evhttp_send_reply_start(struct evhttp_request *req, int code,
     const char *reason)
 {
-        /* set up to watch for client close */
-        evhttp_connection_start_detectclose(req->evcon);
         evhttp_response_code(req, code, reason);
         if (req->major == 1 && req->minor == 1) {
                 /* use chunked encoding for HTTP/1.1 */
                 evhttp_add_header(req->output_headers, "Transfer-Encoding",
                     "chunked");
                 req->chunked = 1;
         }
         evhttp_make_header(req->evcon, req);
         evhttp_write_buffer(req->evcon, NULL, NULL);
 }
@@ skipping 98 matching lines @@
                         evbuffer_add_printf(buf, "%%%02X", (u_char)(*p));
                 }
         }
         evbuffer_add(buf, "", 1);
         p = strdup((char *)EVBUFFER_DATA(buf));
         evbuffer_free(buf);
         
         return (p);
 }
 
-char *
-evhttp_decode_uri(const char *uri)
+/*
+ * @param always_decode_plus: when true we transform plus to space even
+ *     if we have not seen a ?.
+ */
+static int
+evhttp_decode_uri_internal(
+        const char *uri, size_t length, char *ret, int always_decode_plus)
 {
-        char c, *ret;
-        int i, j, in_query = 0;
-        
-        ret = malloc(strlen(uri) + 1);
-        if (ret == NULL)
-                event_err(1, "%s: malloc(%lu)", __func__,
-                          (unsigned long)(strlen(uri) + 1));
+        char c;
+        int i, j, in_query = always_decode_plus;
         
         for (i = j = 0; uri[i] != '\0'; i++) {
                 c = uri[i];
                 if (c == '?') {
                         in_query = 1;
                 } else if (c == '+' && in_query) {
                         c = ' ';
                 } else if (c == '%' && isxdigit((unsigned char)uri[i+1]) &&
                     isxdigit((unsigned char)uri[i+2])) {
                         char tmp[] = { uri[i+1], uri[i+2], '\0' };
                         c = (char)strtol(tmp, NULL, 16);
                         i += 2;
                 }
                 ret[j++] = c;
         }
         ret[j] = '\0';
-        
+
+        return (j);
+}
+
+char *
+evhttp_decode_uri(const char *uri)
+{
+        char *ret;
+
+        if ((ret = malloc(strlen(uri) + 1)) == NULL)
+                event_err(1, "%s: malloc(%lu)", __func__,
+                          (unsigned long)(strlen(uri) + 1));
+
+        evhttp_decode_uri_internal(uri, strlen(uri),
+            ret, 0 /*always_decode_plus*/);
+
         return (ret);
 }
 
 /* 
  * Helper function to parse out arguments in a query.
  * The arguments are separated by key and value.
- * URI should already be decoded.
  */
 
 void
 evhttp_parse_query(const char *uri, struct evkeyvalq *headers)
 {
         char *line;
         char *argument;
         char *p;
 
         TAILQ_INIT(headers);
 
         /* No arguments - we are done */
         if (strchr(uri, '?') == NULL)
                 return;
 
         if ((line = strdup(uri)) == NULL)
                 event_err(1, "%s: strdup", __func__);
 
 
         argument = line;
 
         /* We already know that there has to be a ? */
         strsep(&argument, "?");
 
         p = argument;
         while (p != NULL && *p != '\0') {
-                char *key, *value;
+                char *key, *value, *decoded_value;
                 argument = strsep(&p, "&");
 
                 value = argument;
                 key = strsep(&value, "=");
                 if (value == NULL)
                         goto error;
 
-                value = evhttp_decode_uri(value);
-                event_debug(("Query Param: %s -> %s\n", key, value));
-                evhttp_add_header(headers, key, value);
-                free(value);
+                if ((decoded_value = malloc(strlen(value) + 1)) == NULL)
+                        event_err(1, "%s: malloc", __func__);
+
+                evhttp_decode_uri_internal(value, strlen(value),
+                    decoded_value, 1 /*always_decode_plus*/);
+                event_debug(("Query Param: %s -> %s\n", key, decoded_value));
+                evhttp_add_header_internal(headers, key, decoded_value);
+                free(decoded_value);
         }
 
  error:
         free(line);
 }
 
 static struct evhttp_cb *
 evhttp_dispatch_callback(struct httpcbq *callbacks, struct evhttp_request *req)
 {
         struct evhttp_cb *cb;
@@ skipping 366 matching lines @@
 
 static struct evhttp_connection*
 evhttp_get_request_connection(
         struct evhttp* http,
         int fd, struct sockaddr *sa, socklen_t salen)
 {
         struct evhttp_connection *evcon;
         char *hostname = NULL, *portname = NULL;
 
         name_from_addr(sa, salen, &hostname, &portname);
+        if (hostname == NULL || portname == NULL) {
+                if (hostname) free(hostname);
+                if (portname) free(portname);
+                return (NULL);
+        }
+
         event_debug(("%s: new request from %s:%s on %d\n",
                         __func__, hostname, portname, fd));
 
         /* we need a connection object to put the http request on */
-        if ((evcon = evhttp_connection_new(hostname, atoi(portname))) == NULL)
+        evcon = evhttp_connection_new(hostname, atoi(portname));
+        free(hostname);
+        free(portname);
+        if (evcon == NULL)
                 return (NULL);
 
         /* associate the base if we have one*/
         evhttp_connection_set_base(evcon, http->base);
 
         evcon->flags |= EVHTTP_CON_INCOMING;
         evcon->state = EVCON_READING_FIRSTLINE;
         
         evcon->fd = fd;
 
@@ skipping 101 matching lines @@
                         event_errx(1, "getnameinfo failed: %s", gai_strerror(ni_result));
                 return;
         }
 #else
         ni_result = fake_getnameinfo(sa, salen,
                 ntop, sizeof(ntop), strport, sizeof(strport),
                 NI_NUMERICHOST|NI_NUMERICSERV);
         if (ni_result != 0)
                         return;
 #endif
-        *phost = ntop;
-        *pport = strport;
+        *phost = strdup(ntop);
+        *pport = strdup(strport);
 }
 
-/* Either connect or bind */
-
+/* Create a non-blocking socket and bind it */
+/* todo: rename this function */
 static int
 bind_socket_ai(struct addrinfo *ai, int reuse)
 {
         int fd, on = 1, r;
         int serrno;
 
         /* Create listen socket */
         fd = socket(AF_INET, SOCK_STREAM, 0);
         if (fd == -1) {
                 event_warn("socket");
                 return (-1);
         }
 
         if (evutil_make_socket_nonblocking(fd) < 0)
                 goto out;
 
 #ifndef WIN32
         if (fcntl(fd, F_SETFD, 1) == -1) {
                 event_warn("fcntl(F_SETFD)");
                 goto out;
         }
 #endif
 
         setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void *)&on, sizeof(on));
         if (reuse) {
                 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
                     (void *)&on, sizeof(on));
         }
 
-        r = bind(fd, ai->ai_addr, ai->ai_addrlen);
-        if (r == -1)
-                goto out;
+        if (ai != NULL) {
+                r = bind(fd, ai->ai_addr, ai->ai_addrlen);
+                if (r == -1)
+                        goto out;
+        }
 
         return (fd);
 
  out:
         serrno = EVUTIL_SOCKET_ERROR();
         EVUTIL_CLOSESOCKET(fd);
         EVUTIL_SET_SOCKET_ERROR(serrno);
         return (-1);
 }
 
@@ skipping 32 matching lines @@
         ((struct sockaddr_in *) aitop->ai_addr)->sin_port = htons(port);
 #endif
 
         return (aitop);
 }
 
 static int
 bind_socket(const char *address, u_short port, int reuse)
 {
         int fd;
-        struct addrinfo *aitop = make_addrinfo(address, port);
+        struct addrinfo *aitop = NULL;
+
+        /* just create an unbound socket */
+        if (address == NULL && port == 0)
+                return bind_socket_ai(NULL, 0);
+                
+        aitop = make_addrinfo(address, port);
 
         if (aitop == NULL)
                 return (-1);
 
         fd = bind_socket_ai(aitop, reuse);
 
 #ifdef HAVE_GETADDRINFO
         freeaddrinfo(aitop);
 #else
         fake_freeaddrinfo(aitop);
@@ skipping 33 matching lines @@
 
 out:
 #ifdef HAVE_GETADDRINFO
         freeaddrinfo(ai);
 #else
         fake_freeaddrinfo(ai);
 #endif
 
         return (res);
 }